pytdb: Add support for tdb_enable_seqnum, tdb_get_seqnum and tdb_increment_seqnum_non...
[metze/ctdb/wip.git] / server / ctdb_logging.c
1 /* 
2    ctdb logging code
3
4    Copyright (C) Andrew Tridgell  2008
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 3 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
17    along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "lib/tevent/tevent.h"
22 #include "../include/ctdb_client.h"
23 #include "../include/ctdb_private.h"
24 #include "system/syslog.h"
25 #include "system/time.h"
26 #include "system/filesys.h"
27
28 struct syslog_message {
29         uint32_t level;
30         uint32_t len;
31         char message[1];
32 };
33
34
35 struct ctdb_syslog_state {
36         int syslog_fd;
37         int fd[2];
38 };
39
40 static int syslogd_is_started = 0;
41
42
43 /* called when child is finished
44  * this is for the syslog daemon, we can not use DEBUG here
45  */
46 static void ctdb_syslog_handler(struct event_context *ev, struct fd_event *fde, 
47                                       uint16_t flags, void *p)
48 {
49         struct ctdb_syslog_state *state = talloc_get_type(p, struct ctdb_syslog_state);
50
51         int count;
52         char str[65536];
53         struct syslog_message *msg;
54
55         if (state == NULL) {
56                 return;
57         }
58
59         count = recv(state->syslog_fd, str, sizeof(str), 0);
60         if (count < sizeof(struct syslog_message)) {
61                 return;
62         }
63         msg = (struct syslog_message *)str;
64
65         syslog(msg->level, "%s", msg->message);
66 }
67
68
69 /* called when the pipd from the main daemon has closed
70  * this is for the syslog daemon, we can not use DEBUG here
71  */
72 static void ctdb_syslog_terminate_handler(struct event_context *ev, struct fd_event *fde, 
73                                       uint16_t flags, void *p)
74 {
75         syslog(LOG_ERR, "Shutting down SYSLOG daemon with pid:%d", (int)getpid());
76         _exit(0);
77 }
78
79
80
81 /*
82  * this is for the syslog daemon, we can not use DEBUG here
83  */
84 int start_syslog_daemon(struct ctdb_context *ctdb)
85 {
86         struct sockaddr_in syslog_sin;
87         struct ctdb_syslog_state *state;
88         struct tevent_fd *fde;
89
90         state = talloc(ctdb, struct ctdb_syslog_state);
91         CTDB_NO_MEMORY(ctdb, state);
92
93         if (pipe(state->fd) != 0) {
94                 printf("Failed to create syslog pipe\n");
95                 talloc_free(state);
96                 return -1;
97         }
98         
99         ctdb->syslogd_pid = fork();
100         if (ctdb->syslogd_pid == (pid_t)-1) {
101                 printf("Failed to create syslog child process\n");
102                 close(state->fd[0]);
103                 close(state->fd[1]);
104                 talloc_free(state);
105                 return -1;
106         }
107
108         syslogd_is_started = 1;
109
110         if (ctdb->syslogd_pid != 0) {
111                 DEBUG(DEBUG_ERR,("Starting SYSLOG child process with pid:%d\n", (int)ctdb->syslogd_pid));
112
113                 close(state->fd[1]);
114                 set_close_on_exec(state->fd[0]);
115
116                 return 0;
117         }
118
119         debug_extra = talloc_asprintf(NULL, "syslogd:");
120         talloc_free(ctdb->ev);
121         ctdb->ev = event_context_init(NULL);
122         tevent_loop_allow_nesting(ctdb->ev);
123
124         syslog(LOG_ERR, "Starting SYSLOG daemon with pid:%d", (int)getpid());
125
126         close(state->fd[0]);
127         set_close_on_exec(state->fd[1]);
128         fde = event_add_fd(ctdb->ev, state, state->fd[1], EVENT_FD_READ,
129                      ctdb_syslog_terminate_handler, state);
130         tevent_fd_set_auto_close(fde);
131
132         state->syslog_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
133         if (state->syslog_fd == -1) {
134                 printf("Failed to create syslog socket\n");
135                 return -1;
136         }
137
138         set_close_on_exec(state->syslog_fd);
139
140         syslog_sin.sin_family = AF_INET;
141         syslog_sin.sin_port   = htons(CTDB_PORT);
142         syslog_sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);    
143
144         if (bind(state->syslog_fd, &syslog_sin, sizeof(syslog_sin)) == -1) {
145                 if (errno == EADDRINUSE) {
146                         /* this is ok, we already have a syslog daemon */
147                         _exit(0);
148                 }
149                 printf("syslog daemon failed to bind to socket. errno:%d(%s)\n", errno, strerror(errno));
150                 _exit(10);
151         }
152
153
154         fde = event_add_fd(ctdb->ev, state, state->syslog_fd, EVENT_FD_READ,
155                      ctdb_syslog_handler, state);
156         tevent_fd_set_auto_close(fde);
157
158         event_loop_wait(ctdb->ev);
159
160         /* this should not happen */
161         _exit(10);
162 }
163
164 struct ctdb_log_state {
165         struct ctdb_context *ctdb;
166         int fd, pfd;
167         char buf[1024];
168         uint16_t buf_used;
169         bool use_syslog;
170         void (*logfn)(const char *, uint16_t, void *);
171         void *logfn_private;
172 };
173
174 /* we need this global to keep the DEBUG() syntax */
175 static struct ctdb_log_state *log_state;
176
177 /*
178   syslog logging function
179  */
180 static void ctdb_syslog_log(const char *format, va_list ap)
181 {
182         struct syslog_message *msg;
183         int level = LOG_DEBUG;
184         char *s = NULL;
185         int len, ret;
186         int syslog_fd;
187         struct sockaddr_in syslog_sin;
188
189         ret = vasprintf(&s, format, ap);
190         if (ret == -1) {
191                 return;
192         }
193
194         switch (this_log_level) {
195         case DEBUG_EMERG: 
196                 level = LOG_EMERG; 
197                 break;
198         case DEBUG_ALERT: 
199                 level = LOG_ALERT; 
200                 break;
201         case DEBUG_CRIT: 
202                 level = LOG_CRIT; 
203                 break;
204         case DEBUG_ERR: 
205                 level = LOG_ERR; 
206                 break;
207         case DEBUG_WARNING: 
208                 level = LOG_WARNING; 
209                 break;
210         case DEBUG_NOTICE: 
211                 level = LOG_NOTICE;
212                 break;
213         case DEBUG_INFO: 
214                 level = LOG_INFO;
215                 break;
216         default:
217                 level = LOG_DEBUG;
218                 break;          
219         }
220
221         len = offsetof(struct syslog_message, message) + strlen(debug_extra) + strlen(s) + 1;
222         msg = malloc(len);
223         if (msg == NULL) {
224                 free(s);
225                 return;
226         }
227         msg->level = level;
228         msg->len   = strlen(debug_extra) + strlen(s);
229         strcpy(msg->message, debug_extra);
230         strcat(msg->message, s);
231
232         if (syslogd_is_started == 0) {
233                 syslog(msg->level, "%s", msg->message);
234         } else {
235                 syslog_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
236                 if (syslog_fd == -1) {
237                         printf("Failed to create syslog socket\n");
238                         free(s);
239                         free(msg);
240                         return;
241                 }
242
243                 syslog_sin.sin_family = AF_INET;
244                 syslog_sin.sin_port   = htons(CTDB_PORT);
245                 syslog_sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);    
246
247        
248                 ret = sendto(syslog_fd, msg, len, 0, &syslog_sin, sizeof(syslog_sin));
249                 /* no point in checking here since we cant log an error */
250
251                 close(syslog_fd);
252         }
253
254         free(s);
255         free(msg);
256 }
257
258
259 /*
260   log file logging function
261  */
262 static void ctdb_logfile_log(const char *format, va_list ap)
263 {
264         struct timeval t;
265         char *s = NULL;
266         struct tm *tm;
267         char tbuf[100];
268         char *s2 = NULL;
269         int ret;
270
271         ret = vasprintf(&s, format, ap);
272         if (ret == -1) {
273                 const char *errstr = "vasprintf failed\n";
274
275                 write(log_state->fd, errstr, strlen(errstr));
276                 return;
277         }
278
279         t = timeval_current();
280         tm = localtime(&t.tv_sec);
281
282         strftime(tbuf,sizeof(tbuf)-1,"%Y/%m/%d %H:%M:%S", tm);
283
284         ret = asprintf(&s2, "%s.%06u [%s%5u]: %s",
285                        tbuf, (unsigned)t.tv_usec,
286                        debug_extra, (unsigned)getpid(), s);
287         free(s);
288         if (ret == -1) {
289                 const char *errstr = "asprintf failed\n";
290                 write(log_state->fd, errstr, strlen(errstr));
291                 return;
292         }
293         if (s2) {
294                 write(log_state->fd, s2, strlen(s2));
295                 free(s2);
296         }
297 }
298
299 static void ctdb_logfile_log_add(const char *format, va_list ap)
300 {
301         char *s = NULL;
302         int ret;
303
304         ret = vasprintf(&s, format, ap);
305         if (ret == -1) {
306                 const char *errstr = "vasprintf failed\n";
307
308                 write(log_state->fd, errstr, strlen(errstr));
309                 return;
310         }
311
312         if (s) {
313                 write(log_state->fd, s, strlen(s));
314                 free(s);
315         }
316 }
317
318
319
320 /*
321   choose the logfile location
322 */
323 int ctdb_set_logfile(struct ctdb_context *ctdb, const char *logfile, bool use_syslog)
324 {
325         int ret;
326
327         ctdb->log = talloc_zero(ctdb, struct ctdb_log_state);
328         if (ctdb->log == NULL) {
329                 printf("talloc_zero failed\n");
330                 abort();
331         }
332
333         ctdb->log->ctdb = ctdb;
334         log_state = ctdb->log;
335
336         if (use_syslog) {
337                 do_debug_v = ctdb_syslog_log;
338                 do_debug_add_v = ctdb_syslog_log;
339                 ctdb->log->use_syslog = true;
340         } else if (logfile == NULL || strcmp(logfile, "-") == 0) {
341                 do_debug_v = ctdb_logfile_log;
342                 do_debug_add_v = ctdb_logfile_log_add;
343                 ctdb->log->fd = 1;
344                 /* also catch stderr of subcommands to stdout */
345                 ret = dup2(1, 2);
346                 if (ret == -1) {
347                         printf("dup2 failed: %s\n", strerror(errno));
348                         abort();
349                 }
350         } else {
351                 do_debug_v = ctdb_logfile_log;
352                 do_debug_add_v = ctdb_logfile_log_add;
353
354                 ctdb->log->fd = open(logfile, O_WRONLY|O_APPEND|O_CREAT, 0666);
355                 if (ctdb->log->fd == -1) {
356                         printf("Failed to open logfile %s\n", logfile);
357                         abort();
358                 }
359         }
360
361         return 0;
362 }
363
364 /* Note that do_debug always uses the global log state. */
365 static void write_to_log(struct ctdb_log_state *log,
366                          const char *buf, unsigned int len)
367 {
368         if (script_log_level <= LogLevel) {
369                 do_debug("%*.*s\n", len, len, buf);
370                 /* log it in the eventsystem as well */
371                 if (log->logfn)
372                         log->logfn(log->buf, len, log->logfn_private);
373         }
374 }
375
376 /*
377   called when log data comes in from a child process
378  */
379 static void ctdb_log_handler(struct event_context *ev, struct fd_event *fde, 
380                              uint16_t flags, void *private)
381 {
382         struct ctdb_log_state *log = talloc_get_type(private, struct ctdb_log_state);
383         char *p;
384         int n;
385
386         if (!(flags & EVENT_FD_READ)) {
387                 return;
388         }
389         
390         n = read(log->pfd, &log->buf[log->buf_used],
391                  sizeof(log->buf) - log->buf_used);
392         if (n > 0) {
393                 log->buf_used += n;
394         } else if (n == 0) {
395                 if (log != log_state) {
396                         talloc_free(log);
397                 }
398                 return;
399         }
400
401         this_log_level = script_log_level;
402
403         while (log->buf_used > 0 &&
404                (p = memchr(log->buf, '\n', log->buf_used)) != NULL) {
405                 int n1 = (p - log->buf)+1;
406                 int n2 = n1 - 1;
407                 /* swallow \r from child processes */
408                 if (n2 > 0 && log->buf[n2-1] == '\r') {
409                         n2--;
410                 }
411                 write_to_log(log, log->buf, n2);
412                 memmove(log->buf, p+1, sizeof(log->buf) - n1);
413                 log->buf_used -= n1;
414         }
415
416         /* the buffer could have completely filled - unfortunately we have
417            no choice but to dump it out straight away */
418         if (log->buf_used == sizeof(log->buf)) {
419                 write_to_log(log, log->buf, log->buf_used);
420                 log->buf_used = 0;
421         }
422 }
423
424 static int log_context_destructor(struct ctdb_log_state *log)
425 {
426         /* Flush buffer in case it wasn't \n-terminated. */
427         if (log->buf_used > 0) {
428                 this_log_level = script_log_level;
429                 write_to_log(log, log->buf, log->buf_used);
430         }
431         return 0;
432 }
433
434 /*
435    fork(), redirecting child output to logging and specified callback.
436 */
437 struct ctdb_log_state *ctdb_fork_with_logging(TALLOC_CTX *mem_ctx,
438                                               struct ctdb_context *ctdb,
439                                               void (*logfn)(const char *, uint16_t, void *),
440                                               void *logfn_private, pid_t *pid)
441 {
442         int p[2];
443         struct ctdb_log_state *log;
444         struct tevent_fd *fde;
445
446         log = talloc_zero(mem_ctx, struct ctdb_log_state);
447         CTDB_NO_MEMORY_NULL(ctdb, log);
448         log->ctdb = ctdb;
449         log->logfn = logfn;
450         log->logfn_private = (void *)logfn_private;
451
452         if (pipe(p) != 0) {
453                 DEBUG(DEBUG_ERR,(__location__ " Failed to setup for child logging pipe\n"));
454                 goto free_log;
455         }
456
457         *pid = fork();
458
459         /* Child? */
460         if (*pid == 0) {
461                 close(STDOUT_FILENO);
462                 close(STDERR_FILENO);
463                 dup2(p[1], STDOUT_FILENO);
464                 dup2(p[1], STDERR_FILENO);
465                 close(p[0]);
466                 close(p[1]);
467                 return log;
468         }
469         close(p[1]);
470
471         /* We failed? */
472         if (*pid < 0) {
473                 DEBUG(DEBUG_ERR, (__location__ " fork failed for child process\n"));
474                 close(p[0]);
475                 goto free_log;
476         }
477
478         log->pfd = p[0];
479         set_close_on_exec(log->pfd);
480         talloc_set_destructor(log, log_context_destructor);
481         fde = event_add_fd(ctdb->ev, log, log->pfd,
482                            EVENT_FD_READ, ctdb_log_handler, log);
483         tevent_fd_set_auto_close(fde);
484
485         return log;
486
487 free_log:
488         talloc_free(log);
489         return NULL;
490 }
491
492 /*
493   setup for logging of child process stdout
494 */
495 int ctdb_set_child_logging(struct ctdb_context *ctdb)
496 {
497         int p[2];
498         int old_stdout, old_stderr;
499         struct tevent_fd *fde;
500
501         if (ctdb->log->fd == STDOUT_FILENO) {
502                 /* not needed for stdout logging */
503                 return 0;
504         }
505
506         /* setup a pipe to catch IO from subprocesses */
507         if (pipe(p) != 0) {
508                 DEBUG(DEBUG_ERR,(__location__ " Failed to setup for child logging pipe\n"));
509                 return -1;
510         }
511
512         /* We'll fail if stderr/stdout not already open; it's simpler. */
513         old_stdout = dup(STDOUT_FILENO);
514         old_stderr = dup(STDERR_FILENO);
515         if (dup2(p[1], STDOUT_FILENO) < 0 || dup2(p[1], STDERR_FILENO) < 0) {
516                 int saved_errno = errno;
517                 dup2(old_stdout, STDOUT_FILENO);
518                 dup2(old_stderr, STDERR_FILENO);
519                 close(old_stdout);
520                 close(old_stderr);
521                 close(p[0]);
522                 close(p[1]);
523                 errno = saved_errno;
524
525                 printf(__location__ " dup2 failed: %s\n",
526                         strerror(errno));
527                 return -1;
528         }
529         close(p[1]);
530         close(old_stdout);
531         close(old_stderr);
532
533         /* Is this correct for STDOUT and STDERR ? */
534         set_close_on_exec(STDOUT_FILENO);
535         set_close_on_exec(STDERR_FILENO);
536         set_close_on_exec(p[0]);
537
538         fde = event_add_fd(ctdb->ev, ctdb->log, p[0],
539                            EVENT_FD_READ, ctdb_log_handler, ctdb->log);
540         tevent_fd_set_auto_close(fde);
541
542         ctdb->log->pfd = p[0];
543
544         DEBUG(DEBUG_DEBUG, (__location__ " Created PIPE FD:%d for logging\n", p[0]));
545
546         return 0;
547 }
548
549
550 /*
551  * set up a log handler to catch logging from TEVENT
552  */
553 static void ctdb_tevent_logging(void *private_data,
554                                 enum tevent_debug_level level,
555                                 const char *fmt,
556                                 va_list ap)
557 {
558         enum debug_level lvl = DEBUG_EMERG;
559
560         switch (level) {
561         case TEVENT_DEBUG_FATAL:
562                 lvl = DEBUG_EMERG;
563                 break;
564         case TEVENT_DEBUG_ERROR:
565                 lvl = DEBUG_ERR;
566                 break;
567         case TEVENT_DEBUG_WARNING:
568                 lvl = DEBUG_WARNING;
569                 break;
570         case TEVENT_DEBUG_TRACE:
571                 lvl = DEBUG_DEBUG;
572                 break;
573         }
574
575         if (lvl <= LogLevel) {
576                 this_log_level = lvl;
577                 do_debug_v(fmt, ap);
578         }
579 }
580
581 int ctdb_init_tevent_logging(struct ctdb_context *ctdb)
582 {
583         int ret;
584
585         ret = tevent_set_debug(ctdb->ev,
586                         ctdb_tevent_logging,
587                         ctdb);
588         return ret;
589 }
590
591
592