OpenBSD has a proper tap device.
[tinc] / src / logger.c
1 /*
2     logger.c -- logging code
3     Copyright (C) 2004-2017 Guus Sliepen <guus@tinc-vpn.org>
4                   2004-2005 Ivo Timmermans
5
6     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License along
17     with this program; if not, write to the Free Software Foundation, Inc.,
18     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 */
20
21 #include "system.h"
22
23 #include "conf.h"
24 #include "meta.h"
25 #include "names.h"
26 #include "logger.h"
27 #include "connection.h"
28 #include "control_common.h"
29 #include "process.h"
30 #include "sptps.h"
31
32 int debug_level = DEBUG_NOTHING;
33 static logmode_t logmode = LOGMODE_STDERR;
34 static pid_t logpid;
35 static FILE *logfile = NULL;
36 #ifdef HAVE_MINGW
37 static HANDLE loghandle = NULL;
38 #endif
39 static const char *logident = NULL;
40 bool logcontrol = false;
41 int umbilical = 0;
42
43 static void real_logger(int level, int priority, const char *message) {
44         char timestr[32] = "";
45         static bool suppress = false;
46
47         // Bail out early if there is nothing to do.
48         if(suppress) {
49                 return;
50         }
51
52         if(!logcontrol && (level > debug_level || logmode == LOGMODE_NULL)) {
53                 return;
54         }
55
56         if(level <= debug_level) {
57                 switch(logmode) {
58                 case LOGMODE_STDERR:
59                         fprintf(stderr, "%s\n", message);
60                         fflush(stderr);
61                         break;
62
63                 case LOGMODE_FILE:
64                         if(!now.tv_sec) {
65                                 gettimeofday(&now, NULL);
66                         }
67
68                         time_t now_sec = now.tv_sec;
69                         strftime(timestr, sizeof(timestr), "%Y-%m-%d %H:%M:%S", localtime(&now_sec));
70                         fprintf(logfile, "%s %s[%ld]: %s\n", timestr, logident, (long)logpid, message);
71                         fflush(logfile);
72                         break;
73
74                 case LOGMODE_SYSLOG:
75 #ifdef HAVE_MINGW
76                         {
77                                 const char *messages[] = {message};
78                                 ReportEvent(loghandle, priority, 0, 0, NULL, 1, 0, messages, NULL);
79                         }
80
81 #else
82 #ifdef HAVE_SYSLOG_H
83                         syslog(priority, "%s", message);
84 #endif
85 #endif
86                         break;
87
88                 case LOGMODE_NULL:
89                         break;
90                 }
91
92                 if(umbilical && do_detach) {
93                         write(umbilical, message, strlen(message));
94                         write(umbilical, "\n", 1);
95                 }
96         }
97
98         if(logcontrol) {
99                 suppress = true;
100                 logcontrol = false;
101
102                 for list_each(connection_t, c, connection_list) {
103                         if(!c->status.log) {
104                                 continue;
105                         }
106
107                         logcontrol = true;
108
109                         if(level > (c->outcompression >= 0 ? c->outcompression : debug_level)) {
110                                 continue;
111                         }
112
113                         int len = strlen(message);
114
115                         if(send_request(c, "%d %d %d", CONTROL, REQ_LOG, len)) {
116                                 send_meta(c, message, len);
117                         }
118                 }
119
120                 suppress = false;
121         }
122 }
123
124 void logger(int level, int priority, const char *format, ...) {
125         va_list ap;
126         char message[1024] = "";
127
128         va_start(ap, format);
129         int len = vsnprintf(message, sizeof(message), format, ap);
130         message[sizeof(message) - 1] = 0;
131         va_end(ap);
132
133         if(len > 0 && (size_t)len < sizeof(message) - 1 && message[len - 1] == '\n') {
134                 message[len - 1] = 0;
135         }
136
137         real_logger(level, priority, message);
138 }
139
140 static void sptps_logger(sptps_t *s, int s_errno, const char *format, va_list ap) {
141         (void)s_errno;
142         char message[1024];
143         size_t msglen = sizeof(message);
144
145         int len = vsnprintf(message, msglen, format, ap);
146         message[sizeof(message) - 1] = 0;
147
148         if(len > 0 && (size_t)len < sizeof(message) - 1) {
149                 if(message[len - 1] == '\n') {
150                         message[--len] = 0;
151                 }
152
153                 // WARNING: s->handle can point to a connection_t or a node_t,
154                 // but both types have the name and hostname fields at the same offsets.
155                 connection_t *c = s->handle;
156
157                 if(c) {
158                         snprintf(message + len, sizeof(message) - len, " from %s (%s)", c->name, c->hostname);
159                 }
160         }
161
162         real_logger(DEBUG_ALWAYS, LOG_ERR, message);
163 }
164
165 void openlogger(const char *ident, logmode_t mode) {
166         logident = ident;
167         logmode = mode;
168
169         switch(mode) {
170         case LOGMODE_STDERR:
171                 logpid = getpid();
172                 break;
173
174         case LOGMODE_FILE:
175                 logpid = getpid();
176                 logfile = fopen(logfilename, "a");
177
178                 if(!logfile) {
179                         fprintf(stderr, "Could not open log file %s: %s\n", logfilename, strerror(errno));
180                         logmode = LOGMODE_NULL;
181                 }
182
183                 break;
184
185         case LOGMODE_SYSLOG:
186 #ifdef HAVE_MINGW
187                 loghandle = RegisterEventSource(NULL, logident);
188
189                 if(!loghandle) {
190                         fprintf(stderr, "Could not open log handle!\n");
191                         logmode = LOGMODE_NULL;
192                 }
193
194                 break;
195 #else
196 #ifdef HAVE_SYSLOG_H
197                 openlog(logident, LOG_CONS | LOG_PID, LOG_DAEMON);
198                 break;
199 #endif
200 #endif
201
202         case LOGMODE_NULL:
203                 break;
204         }
205
206         if(logmode != LOGMODE_NULL) {
207                 sptps_log = sptps_logger;
208         } else {
209                 sptps_log = sptps_log_quiet;
210         }
211 }
212
213 void reopenlogger() {
214         if(logmode != LOGMODE_FILE) {
215                 return;
216         }
217
218         fflush(logfile);
219         FILE *newfile = fopen(logfilename, "a");
220
221         if(!newfile) {
222                 logger(DEBUG_ALWAYS, LOG_ERR, "Unable to reopen log file %s: %s", logfilename, strerror(errno));
223                 return;
224         }
225
226         fclose(logfile);
227         logfile = newfile;
228 }
229
230
231 void closelogger(void) {
232         switch(logmode) {
233         case LOGMODE_FILE:
234                 fclose(logfile);
235                 break;
236
237         case LOGMODE_SYSLOG:
238 #ifdef HAVE_MINGW
239                 DeregisterEventSource(loghandle);
240                 break;
241 #else
242 #ifdef HAVE_SYSLOG_H
243                 closelog();
244                 break;
245 #endif
246 #endif
247
248         case LOGMODE_NULL:
249         case LOGMODE_STDERR:
250                 break;
251         }
252 }