| /* | |
| * 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; | |
| } |