/*
  *  OpenVPN -- An application to securely tunnel IP networks
  *             over a single TCP/UDP port, with support for SSL/TLS-based
  *             session authentication and key exchange,
  *             packet encryption, packet authentication, and
  *             packet compression.
  *

  *  Copyright (C) 2002-2018 OpenVPN Inc <sales@openvpn.net>

  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2
  *  as published by the Free Software Foundation.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *

  *  You should have received a copy of the GNU General Public License along
  *  with this program; if not, write to the Free Software Foundation, Inc.,
  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

  */
 

 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #elif defined(_MSC_VER)
 #include "config-msvc.h"
 #endif
 

 #include "syshead.h"
 
 #include "status.h"
 #include "perf.h"

 #include "misc.h"

 #include "fdmisc.h"

 
 #include "memdbg.h"
 
 /*
  * printf-style interface for outputting status info
  */
 
 static const char *

 print_status_mode(unsigned int flags)

 {

     switch (flags)

     {

         case STATUS_OUTPUT_WRITE:
             return "WRITE";
 
         case STATUS_OUTPUT_READ:
             return "READ";
 
         case STATUS_OUTPUT_READ|STATUS_OUTPUT_WRITE:
             return "READ/WRITE";
 
         default:
             return "UNDEF";

     }
 }
 
 struct status_output *

 status_open(const char *filename,
             const int refresh_freq,
             const int msglevel,
             const struct virtual_output *vout,
             const unsigned int flags)

 {

     struct status_output *so = NULL;
     if (filename || msglevel >= 0 || vout)

     {

         ALLOC_OBJ_CLEAR(so, struct status_output);
         so->flags = flags;
         so->msglevel = msglevel;
         so->vout = vout;
         so->fd = -1;
         buf_reset(&so->read_buf);
         event_timeout_clear(&so->et);
         if (filename)

         {

             switch (so->flags)
             {
                 case STATUS_OUTPUT_WRITE:
                     so->fd = platform_open(filename,
                                            O_CREAT | O_TRUNC | O_WRONLY,
                                            S_IRUSR | S_IWUSR);
                     break;
 
                 case STATUS_OUTPUT_READ:
                     so->fd = platform_open(filename,
                                            O_RDONLY,
                                            S_IRUSR | S_IWUSR);
                     break;
 
                 case STATUS_OUTPUT_READ|STATUS_OUTPUT_WRITE:
                     so->fd = platform_open(filename,
                                            O_CREAT | O_RDWR,
                                            S_IRUSR | S_IWUSR);
                     break;
 
                 default:
                     ASSERT(0);
             }
             if (so->fd >= 0)
             {
                 so->filename = string_alloc(filename, NULL);
                 set_cloexec(so->fd);
 
                 /* allocate read buffer */
                 if (so->flags & STATUS_OUTPUT_READ)
                 {
                     so->read_buf = alloc_buf(512);
                 }
             }
             else

             {

                 msg(M_WARN, "Note: cannot open %s for %s", filename, print_status_mode(so->flags));
                 so->errors = true;

             }

         }
         else
         {
             so->flags = STATUS_OUTPUT_WRITE;
         }
 
         if ((so->flags & STATUS_OUTPUT_WRITE) && refresh_freq > 0)
         {
             event_timeout_init(&so->et, refresh_freq, 0);
         }

     }

     return so;

 }
 
 bool

 status_trigger(struct status_output *so)

 {

     if (so)

     {

         struct timeval null;
         CLEAR(null);
         return event_timeout_trigger(&so->et, &null, ETT_DEFAULT);
     }
     else
     {
         return false;

     }
 }
 
 bool

 status_trigger_tv(struct status_output *so, struct timeval *tv)

 {

     if (so)
     {
         return event_timeout_trigger(&so->et, tv, ETT_DEFAULT);
     }
     else
     {
         return false;
     }

 }
 
 void

 status_reset(struct status_output *so)

 {

     if (so && so->fd >= 0)
     {
         lseek(so->fd, (off_t)0, SEEK_SET);
     }

 }
 
 void

 status_flush(struct status_output *so)

 {

     if (so && so->fd >= 0 && (so->flags & STATUS_OUTPUT_WRITE))

     {
 #if defined(HAVE_FTRUNCATE)

         {
             const off_t off = lseek(so->fd, (off_t)0, SEEK_CUR);
             if (ftruncate(so->fd, off) != 0)
             {

                 msg(M_WARN | M_ERRNO, "Failed to truncate status file");

             }
         }

 #elif defined(HAVE_CHSIZE)

         {
             const long off = (long) lseek(so->fd, (off_t)0, SEEK_CUR);
             chsize(so->fd, off);
         }
 #else  /* if defined(HAVE_FTRUNCATE) */

 #warning both ftruncate and chsize functions appear to be missing from this OS
 #endif
 

         /* clear read buffer */
         if (buf_defined(&so->read_buf))
         {
             ASSERT(buf_init(&so->read_buf, 0));
         }

     }
 }
 
 /* return false if error occurred */
 bool

 status_close(struct status_output *so)

 {

     bool ret = true;
     if (so)

     {

         if (so->errors)
         {
             ret = false;
         }
         if (so->fd >= 0)
         {
             if (close(so->fd) < 0)
             {
                 ret = false;
             }
         }
         if (so->filename)
         {
             free(so->filename);
         }
         if (buf_defined(&so->read_buf))
         {
             free_buf(&so->read_buf);
         }
         free(so);
     }
     else
     {
         ret = false;

     }

     return ret;

 }
 

 #define STATUS_PRINTF_MAXLEN 512

 
 void

 status_printf(struct status_output *so, const char *format, ...)

 {

     if (so && (so->flags & STATUS_OUTPUT_WRITE))

     {

         char buf[STATUS_PRINTF_MAXLEN+2]; /* leave extra bytes for CR, LF */
         va_list arglist;
         int stat;
 
         va_start(arglist, format);
         stat = vsnprintf(buf, STATUS_PRINTF_MAXLEN, format, arglist);
         va_end(arglist);
         buf[STATUS_PRINTF_MAXLEN - 1] = 0;
 
         if (stat < 0 || stat >= STATUS_PRINTF_MAXLEN)
         {
             so->errors = true;
         }
 
         if (so->msglevel >= 0 && !so->errors)
         {
             msg(so->msglevel, "%s", buf);
         }
 
         if (so->fd >= 0 && !so->errors)
         {
             int len;
             strcat(buf, "\n");
             len = strlen(buf);
             if (len > 0)
             {
                 if (write(so->fd, buf, len) != len)
                 {
                     so->errors = true;
                 }
             }
         }
 
         if (so->vout && !so->errors)
         {
             chomp(buf);
             (*so->vout->func)(so->vout->arg, so->vout->flags_default, buf);
         }

     }
 }
 
 bool

 status_read(struct status_output *so, struct buffer *buf)

 {

     bool ret = false;

     if (so && so->fd >= 0 && (so->flags & STATUS_OUTPUT_READ))

     {

         ASSERT(buf_defined(&so->read_buf));
         ASSERT(buf_defined(buf));
         while (true)
         {
             const int c = buf_read_u8(&so->read_buf);

             /* read more of file into buffer */
             if (c == -1)
             {
                 int len;

                 ASSERT(buf_init(&so->read_buf, 0));
                 len = read(so->fd, BPTR(&so->read_buf), BCAP(&so->read_buf));
                 if (len <= 0)
                 {
                     break;
                 }

                 ASSERT(buf_inc_len(&so->read_buf, len));
                 continue;
             }

             ret = true;

             if (c == '\r')
             {
                 continue;
             }

             if (c == '\n')
             {
                 break;
             }

             buf_write_u8(buf, c);
         }

         buf_null_terminate(buf);

     }
 

     return ret;

 }