help.c

   1 /*
   2  *  innduct
   3  *  tailing reliable realtime streaming feeder for inn
   4  *  help.c - logging and utility functions
   5  *
   6  *  Copyright (C) 2010 Ian Jackson <ijackson@chiark.greenend.org.uk>
   7  *
   8  *  This program is free software: you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation, either version 3 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  *
  21  *  (I believe that when you compile and link this as part of the inn2
  22  *  build, with the Makefile runes I have provided, all the libraries
  23  *  and files which end up included in innduct are licence-compatible
  24  *  with GPLv3.  If not then please let me know.  -Ian Jackson.)
  25  */
  26
  27 #include "innduct.h"
  28
  29
  30 /* for logging, simulation, debugging, etc. */
  31 int simulate_flush= -1;
  32 int logv_use_syslog;
  33 const char *logv_prefix="";
  34
  35 /*========== logging ==========*/
  36
  37 static void logcore(int sysloglevel, const char *fmt, ...) PRINTF(2,3);
  38 static void logcore(int sysloglevel, const char *fmt, ...) {
  39   VA;
  40   if (logv_use_syslog) {
  41     vsyslog(sysloglevel,fmt,al);
  42   } else {
  43     if (self_pid) fprintf(stderr,"[%lu] ",(unsigned long)self_pid);
  44     vfprintf(stderr,fmt,al);
  45     putc('\n',stderr);
  46   }
  47   va_end(al);
  48 }
  49
  50 void logv(int sysloglevel, const char *pfx, int errnoval,
  51           const char *fmt, va_list al) {
  52   char msgbuf[1024]; /* NB do not call xvasprintf here or you'll recurse */
  53   vsnprintf(msgbuf,sizeof(msgbuf), fmt,al);
  54   msgbuf[sizeof(msgbuf)-1]= 0;
  55
  56   if (sysloglevel >= LOG_ERR && (errnoval==EACCES || errnoval==EPERM))
  57     sysloglevel= LOG_ERR; /* run by wrong user, probably */
  58
  59   logcore(sysloglevel, "%s%s: %s%s%s",
  60           logv_prefix, pfx, msgbuf,
  61           errnoval>=0 ? ": " : "",
  62           errnoval>=0 ? strerror(errnoval) : "");
  63 }
  64
  65 #define DEFFATAL(fn, pfx, sysloglevel, err, estatus)    \
  66   void fn(const char *fmt, ...) {                       \
  67     preterminate();                                     \
  68     VA;                                                 \
  69     logv(sysloglevel, pfx, err, fmt, al);               \
  70     exit(estatus);                                      \
  71   }
  72
  73 #define DEFLOG(fn, pfx, sysloglevel, err)       \
  74   void fn(const char *fmt, ...) {               \
  75     VA;                                         \
  76     logv(sysloglevel, pfx, err, fmt, al);       \
  77     va_end(al);                                 \
  78   }
  79
  80 #define INNLOGSET_DEFINE(fn, pfx, sysloglevel)                          \
  81   void duct_log_##fn(int l, const char *fmt, va_list al, int errval) {  \
  82     logv(sysloglevel, pfx, errval ? errval : -1, fmt, al);              \
  83   }
  84
  85
  86 /* We want to extend the set of logging functions from inn, and we
  87  * want to prepend the site name to all our messages. */
  88
  89 DEFFATAL(syscrash,    "critical", LOG_CRIT,    errno, 16);
  90 DEFFATAL(crash,       "critical", LOG_CRIT,    -1,    16);
  91
  92 INNLOGSETS(INNLOGSET_DEFINE)
  93
  94 DEFLOG(info,          "info",     LOG_INFO,    -1)
  95 DEFLOG(dbg,           "debug",    LOG_DEBUG,   -1)
  96
  97
  98 /*========== utility functions etc. ==========*/
  99
 100 char *xvasprintf(const char *fmt, va_list al) {
 101   char *str;
 102   int rc= vasprintf(&str,fmt,al);
 103   if (rc<0) sysdie("vasprintf(\"%s\",...) failed", fmt);
 104   return str;
 105 }
 106
 107 char *xasprintf(const char *fmt, ...) {
 108   VA;
 109   char *str= xvasprintf(fmt,al);
 110   va_end(al);
 111   return str;
 112 }
 113
 114 int close_perhaps(int *fd) {
 115   if (*fd <= 0) return 0;
 116   int r= close(*fd);
 117   *fd=0;
 118   return r;
 119 }
 120 void xclose(int fd, const char *what, const char *what2) {
 121   int r= close(fd);
 122   if (r) syscrash("close %s%s",what,what2?what2:"");
 123 }
 124 void xclose_perhaps(int *fd, const char *what, const char *what2) {
 125   if (*fd <= 0) return;
 126   xclose(*fd,what,what2);
 127   *fd=0;
 128 }
 129
 130 pid_t xfork(const char *what) {
 131   pid_t child;
 132
 133   child= fork();
 134   if (child==-1) sysdie("cannot fork for %s",what);
 135   dbg("forked %s %ld", what, (unsigned long)child);
 136   if (!child) postfork();
 137   return child;
 138 }
 139
 140 void on_fd_read_except(int fd, oop_call_fd callback) {
 141   loop->on_fd(loop, fd, OOP_READ,      callback, 0);
 142   loop->on_fd(loop, fd, OOP_EXCEPTION, callback, 0);
 143 }
 144 void cancel_fd_read_except(int fd) {
 145   loop->cancel_fd(loop, fd, OOP_READ);
 146   loop->cancel_fd(loop, fd, OOP_EXCEPTION);
 147 }
 148
 149 void report_child_status(const char *what, int status) {
 150   if (WIFEXITED(status)) {
 151     int es= WEXITSTATUS(status);
 152     if (es)
 153       warn("%s: child died with error exit status %d", what, es);
 154   } else if (WIFSIGNALED(status)) {
 155     int sig= WTERMSIG(status);
 156     const char *sigstr= strsignal(sig);
 157     const char *coredump= WCOREDUMP(status) ? " (core dumped)" : "";
 158     if (sigstr)
 159       warn("%s: child died due to fatal signal %s%s", what, sigstr, coredump);
 160     else
 161       warn("%s: child died due to unknown fatal signal %d%s",
 162            what, sig, coredump);
 163   } else {
 164     warn("%s: child died with unknown wait status %d", what,status);
 165   }
 166 }
 167
 168 int xwaitpid(pid_t *pid, const char *what) {
 169   int status;
 170
 171   int r= kill(*pid, SIGKILL);
 172   if (r) syscrash("cannot kill %s child", what);
 173
 174   pid_t got= waitpid(*pid, &status, 0);
 175   if (got==-1) syscrash("cannot reap %s child", what);
 176   if (got==0) crash("cannot reap %s child", what);
 177
 178   *pid= 0;
 179
 180   return status;
 181 }
 182
 183 void *zxmalloc(size_t sz) {
 184   void *p= xmalloc(sz);
 185   memset(p,0,sz);
 186   return p;
 187 }
 188
 189 void xunlink(const char *path, const char *what) {
 190   int r= unlink(path);
 191   if (r) syscrash("can't unlink %s %s", path, what);
 192 }
 193
 194 time_t xtime(void) {
 195   time_t now= time(0);
 196   if (now==-1) syscrash("time(2) failed");
 197   return now;
 198 }
 199
 200 void xsigaction(int signo, const struct sigaction *sa) {
 201   int r= sigaction(signo,sa,0);
 202   if (r) syscrash("sigaction failed for \"%s\"", strsignal(signo));
 203 }
 204 void xsigsetdefault(int signo) {
 205   struct sigaction sa;
 206   memset(&sa,0,sizeof(sa));
 207   sa.sa_handler= SIG_DFL;
 208   xsigaction(signo,&sa);
 209 }
 210 void raise_default(int signo) {
 211   xsigsetdefault(signo);
 212   raise(signo);
 213   abort();
 214 }
 215
 216 void xgettimeofday(struct timeval *tv_r) {
 217   int r= gettimeofday(tv_r,0);
 218   if (r) syscrash("gettimeofday(2) failed");
 219 }
 220 void xsetnonblock(int fd, int nonb) {
 221   int errnoval= oop_fd_nonblock(fd, nonb);
 222   if (errnoval) { errno= errnoval; syscrash("setnonblocking"); }
 223 }
 224
 225 void check_isreg(const struct stat *stab, const char *path,
 226                  const char *what) {
 227   if (!S_ISREG(stab->st_mode))
 228     crash("%s %s not a plain file (mode 0%lo)",
 229           what, path, (unsigned long)stab->st_mode);
 230 }
 231
 232 void xfstat(int fd, struct stat *stab_r, const char *what) {
 233   int r= fstat(fd, stab_r);
 234   if (r) syscrash("could not fstat %s", what);
 235 }
 236
 237 void xfstat_isreg(int fd, struct stat *stab_r,
 238                   const char *path, const char *what) {
 239   xfstat(fd, stab_r, what);
 240   check_isreg(stab_r, path, what);
 241 }
 242
 243 void xlstat_isreg(const char *path, struct stat *stab,
 244                   int *enoent_r /* 0 means ENOENT is fatal */,
 245                   const char *what) {
 246   int r= lstat(path, stab);
 247   if (r) {
 248     if (errno==ENOENT && enoent_r) { *enoent_r=1; return; }
 249     syscrash("could not lstat %s %s", what, path);
 250   }
 251   if (enoent_r) *enoent_r= 0;
 252   check_isreg(stab, path, what);
 253 }
 254
 255 int samefile(const struct stat *a, const struct stat *b) {
 256   assert(S_ISREG(a->st_mode));
 257   assert(S_ISREG(b->st_mode));
 258   return (a->st_ino == b->st_ino &&
 259           a->st_dev == b->st_dev);
 260 }
 261
 262 char *sanitise(const char *input, int len) {
 263   static char sanibuf[100]; /* returns pointer to this buffer! */
 264
 265   const char *p= input;
 266   const char *endp= len>=0 ? input+len : 0;
 267   char *q= sanibuf;
 268   *q++= '`';
 269   for (;;) {
 270     if (q > sanibuf+sizeof(sanibuf)-8) { strcpy(q,"'.."); break; }
 271     int c= (!endp || p<endp) ? *p++ : 0;
 272     if (!c) { *q++= '\''; *q=0; break; }
 273     if (c>=' ' && c<=126 && c!='\\') { *q++= c; continue; }
 274     sprintf(q,"\\x%02x",c);
 275     q += 4;
 276   }
 277   return sanibuf;
 278 }