util.c

   1 #include <stdint.h>
   2 #include <stdlib.h>
   3 #include <errno.h>
   4 #include <stdio.h>
   5 #include <string.h>
   6 #include <stdarg.h>
   7 #include "sd-daemon.h"
   8 #include "dat.h"
   9
  10 const char *progname;
  11
  12 static void
  13 vwarnx(const char *err, const char *fmt, va_list args)
  14 __attribute__((format(printf, 2, 0)));
  15
  16 static void
  17 vwarnx(const char *err, const char *fmt, va_list args)
  18 {
  19     fprintf(stderr, "%s: ", progname);
  20     if (fmt) {
  21         vfprintf(stderr, fmt, args);
  22         if (err) fprintf(stderr, ": %s", err);
  23     }
  24     fputc('\n', stderr);
  25 }
  26
  27 void
  28 warn(const char *fmt, ...)
  29 {
  30     char *err = strerror(errno); /* must be done first thing */
  31     va_list args;
  32
  33     va_start(args, fmt);
  34     vwarnx(err, fmt, args);
  35     va_end(args);
  36 }
  37
  38 void
  39 warnx(const char *fmt, ...)
  40 {
  41     va_list args;
  42     va_start(args, fmt);
  43     vwarnx(NULL, fmt, args);
  44     va_end(args);
  45 }
  46
  47
  48 char*
  49 fmtalloc(char *fmt, ...)
  50 {
  51     int n;
  52     char *buf;
  53     va_list ap;
  54
  55     // find out how much space is needed
  56     va_start(ap, fmt);
  57     n = vsnprintf(0, 0, fmt, ap) + 1; // include space for trailing NUL
  58     va_end(ap);
  59
  60     buf = malloc(n);
  61     if (buf) {
  62         va_start(ap, fmt);
  63         vsnprintf(buf, n, fmt, ap);
  64         va_end(ap);
  65     }
  66     return buf;
  67 }
  68
  69
  70 // Zalloc allocates n bytes of zeroed memory and
  71 // returns a pointer to it.
  72 // If insufficient memory is available, zalloc returns 0.
  73 void*
  74 zalloc(int n)
  75 {
  76     void *p;
  77
  78     p = malloc(n);
  79     if (p) {
  80         memset(p, 0, n);
  81     }
  82     return p;
  83 }
  84
  85
  86 static void
  87 warn_systemd_ignored_option(char *opt, char *arg)
  88 {
  89     if (sd_listen_fds(0) > 0) {
  90         warnx("inherited listen fd; ignoring option: %s %s", opt, arg);
  91     }
  92 }
  93
  94
  95 static void usage(int code) __attribute__ ((noreturn));
  96 static void
  97 usage(int code)
  98 {
  99     fprintf(stderr, "Use: %s [OPTIONS]\n"
 100             "\n"
 101             "Options:\n"
 102             " -b DIR   write-ahead log directory\n"
 103             " -f MS    fsync at most once every MS milliseconds"
 104                        " (use -f0 for \"always fsync\")\n"
 105             " -F       never fsync (default)\n"
 106             " -l ADDR  listen on address (default is 0.0.0.0)\n"
 107             " -p PORT  listen on port (default is " Portdef ")\n"
 108             " -u USER  become user and group\n"
 109             " -z BYTES set the maximum job size in bytes (default is %d)\n"
 110             " -s BYTES set the size of each write-ahead log file (default is %d)\n"
 111             "            (will be rounded up to a multiple of 512 bytes)\n"
 112             " -c       compact the binlog (default)\n"
 113             " -n       do not compact the binlog\n"
 114             " -v       show version information\n"
 115             " -V       increase verbosity\n"
 116             " -h       show this help\n",
 117             progname, JOB_DATA_SIZE_LIMIT_DEFAULT, Filesizedef);
 118     exit(code);
 119 }
 120
 121
 122 static char *flagusage(char *flag) __attribute__ ((noreturn));
 123 static char *
 124 flagusage(char *flag)
 125 {
 126     warnx("flag requires an argument: %s", flag);
 127     usage(5);
 128 }
 129
 130
 131 static size_t
 132 parse_size_t(char *str)
 133 {
 134     char r, x;
 135     size_t size;
 136
 137     r = sscanf(str, "%zu%c", &size, &x);
 138     if (1 != r) {
 139         warnx("invalid size: %s", str);
 140         usage(5);
 141     }
 142     return size;
 143 }
 144
 145
 146 void
 147 optparse(Server *s, char **argv)
 148 {
 149     int64 ms;
 150     char *arg, c, *tmp;
 151 #   define EARGF(x) (*arg ? (tmp=arg,arg="",tmp) : *argv ? *argv++ : (x))
 152
 153     while ((arg = *argv++) && *arg++ == '-' && *arg) {
 154         while ((c = *arg++)) {
 155             switch (c) {
 156                 case 'p':
 157                     s->port = EARGF(flagusage("-p"));
 158                     warn_systemd_ignored_option("-p", s->port);
 159                     break;
 160                 case 'l':
 161                     s->addr = EARGF(flagusage("-l"));
 162                     warn_systemd_ignored_option("-l", s->addr);
 163                     break;
 164                 case 'z':
 165                     job_data_size_limit = parse_size_t(EARGF(flagusage("-z")));
 166                     break;
 167                 case 's':
 168                     s->wal.filesize = parse_size_t(EARGF(flagusage("-s")));
 169                     break;
 170                 case 'c':
 171                     s->wal.nocomp = 0;
 172                     break;
 173                 case 'n':
 174                     s->wal.nocomp = 1;
 175                     break;
 176                 case 'f':
 177                     ms = (int64)parse_size_t(EARGF(flagusage("-f")));
 178                     s->wal.syncrate = ms * 1000000;
 179                     s->wal.wantsync = 1;
 180                     break;
 181                 case 'F':
 182                     s->wal.wantsync = 0;
 183                     break;
 184                 case 'u':
 185                     s->user = EARGF(flagusage("-u"));
 186                     break;
 187                 case 'b':
 188                     s->wal.dir = EARGF(flagusage("-b"));
 189                     s->wal.use = 1;
 190                     break;
 191                 case 'h':
 192                     usage(0);
 193                 case 'v':
 194                     printf("beanstalkd %s\n", version);
 195                     exit(0);
 196                 case 'V':
 197                     verbose++;
 198                     break;
 199                 default:
 200                     warnx("unknown flag: %s", arg-2);
 201                     usage(5);
 202             }
 203         }
 204     }
 205     if (arg) {
 206         warnx("unknown argument: %s", arg-1);
 207         usage(5);
 208     }
 209 }