ccan/oserver/oserver.c

   1 #include <ccan/oserver/oserver.h>
   2 #include <ccan/oserver/oserver_types.h>
   3 #include <ccan/oserver/oserver_cdump.h>
   4 #include <ccan/read_write_all/read_write_all.h>
   5 #include <ccan/opt/opt.h>
   6 #include <ccan/tevent/tevent.h>
   7 #include <ccan/array_size/array_size.h>
   8 #include <ccan/grab_file/grab_file.h>
   9 #include <sys/types.h>
  10 #include <sys/socket.h>
  11 #include <netinet/in.h>
  12 #include <netinet/tcp.h>
  13 #include <err.h>
  14 #include <stdio.h>
  15 #include <unistd.h>
  16 #include <ctype.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <errno.h>
  20 #include <signal.h>
  21 #include <assert.h>
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <fcntl.h>
  25
  26 static uint16_t state_flag_map[] = {
  27         [SENDING_GREETING]              = TEVENT_FD_WRITE,
  28         [RECEIVING_USER_QUESTION]       = TEVENT_FD_READ,
  29         [SENDING_OTHER_QUESTION_PREFIX] = TEVENT_FD_WRITE,
  30         [SENDING_OTHER_QUESTION]        = TEVENT_FD_WRITE,
  31         [RECEIVING_OTHER_ANSWER]        = TEVENT_FD_READ,
  32         [SENDING_ANSWER_PREFIX]         = TEVENT_FD_WRITE,
  33         [SENDING_ANSWER]                = TEVENT_FD_WRITE,
  34         [FINISHED]                      = 0
  35 };
  36
  37 static ssize_t write_string(int fd, const char *str)
  38 {
  39         return write(fd, str, strlen(str));
  40 }
  41
  42 static ssize_t read_string(int fd, char **buf)
  43 {
  44         ssize_t ret, len, maxlen;
  45
  46         len = strlen(*buf);
  47         maxlen = talloc_array_length(*buf);
  48
  49         if (maxlen < len + 100) {
  50                 maxlen += 100;
  51                 *buf = talloc_realloc(NULL, *buf, char, maxlen);
  52         }
  53
  54         ret = read(fd, *buf + len, maxlen - len - 1);
  55         if (ret >= 0)
  56                 (*buf)[len + ret] = '\0';
  57         return ret;
  58 }
  59
  60 static bool input_finished(const char *str)
  61 {
  62         return strchr(str, '\n');
  63 }
  64
  65 /* Update state, and set our READ/WRITE flags appropriately. */
  66 static void set_state(struct client *c, enum state state)
  67 {
  68         c->state = state;
  69         tevent_fd_set_flags(c->fde, state_flag_map[state]);
  70 }
  71
  72 /* Returns false on error, increments state on finishing string. */
  73 static bool send_string(struct client *c, const char *str)
  74 {
  75         ssize_t len = write_string(c->fd, str + c->bytes_sent);
  76         if (len < 0)
  77                 return false;
  78         c->bytes_sent += len;
  79         if (c->bytes_sent == strlen(str)) {
  80                 c->bytes_sent = 0;
  81                 set_state(c, c->state+1);
  82         }
  83         return true;
  84 }
  85
  86 static bool get_subclient(struct client *me)
  87 {
  88         unsigned int i;
  89
  90         for (i = 0; i < ARRAY_SIZE(me->oserver->clients); i++) {
  91                 struct client *c = me->oserver->clients[i];
  92                 if (!c || c == me)
  93                         continue;
  94                 if (c->oracle == -1 && input_finished(c->question)) {
  95                         me->subclient = c->id;
  96                         c->oracle = me->id;
  97                         return true;
  98                 }
  99         }
 100         return false;
 101 }
 102
 103 static bool get_oracle(struct client *me)
 104 {
 105         unsigned int i;
 106
 107         for (i = 0; i < ARRAY_SIZE(me->oserver->clients); i++) {
 108                 struct client *c = me->oserver->clients[i];
 109                 if (!c || c == me)
 110                         continue;
 111                 if (c->subclient == -1 && input_finished(c->question)) {
 112                         me->oracle = c->id;
 113                         c->subclient = me->id;
 114                         return true;
 115                 }
 116         }
 117         return false;
 118 }
 119
 120 static void wakeup(struct client *c)
 121 {
 122         tevent_fd_set_flags(c->fde, state_flag_map[c->state]);
 123 }
 124
 125 static void service_client(struct tevent_context *ev,
 126                            struct tevent_fd *fde, uint16_t flags, void *_c)
 127 {
 128         struct client *c = _c;
 129         ssize_t len;
 130
 131         switch (c->state) {
 132         case SENDING_GREETING:
 133                 if (!send_string(c, "Welcome.  Please ask your question.\n"))
 134                         goto fail;
 135                 break;
 136         case RECEIVING_USER_QUESTION:
 137                 len = read_string(c->fd, &c->question);
 138                 if (len <= 0)
 139                         goto fail;
 140                 if (input_finished(c->question))
 141                         set_state(c, SENDING_OTHER_QUESTION_PREFIX);
 142                 break;
 143         case SENDING_OTHER_QUESTION_PREFIX:
 144                 if (c->subclient == -1)
 145                         goto need_subclient;
 146                 if (!send_string(c, "While the Oracle ponders,"
 147                                  " please answer the following question:\n"))
 148                         goto fail;
 149                 break;
 150         case SENDING_OTHER_QUESTION:
 151                 if (c->subclient == -1)
 152                         goto need_subclient;
 153                 if (!send_string(c,
 154                                  c->oserver->clients[c->subclient]->question))
 155                         goto fail;
 156                 break;
 157         case RECEIVING_OTHER_ANSWER:
 158                 if (c->subclient == -1)
 159                         goto need_subclient;
 160                 len = read_string(c->fd,
 161                                   &c->oserver->clients[c->subclient]->answer);
 162                 if (len <= 0)
 163                         goto fail;
 164                 if (input_finished(c->oserver->clients[c->subclient]->answer)) {
 165                         set_state(c, SENDING_ANSWER_PREFIX);
 166                         wakeup(c->oserver->clients[c->subclient]);
 167                 }
 168                 break;
 169         case SENDING_ANSWER_PREFIX:
 170                 if (!input_finished(c->answer))
 171                         goto need_answer;
 172                 if (!send_string(c, "The Oracle spake thus:\n"))
 173                         goto fail;
 174                 break;
 175         case SENDING_ANSWER:
 176                 if (!send_string(c, c->answer))
 177                         goto fail;
 178                 break;
 179         default:
 180                 goto fail;
 181         }
 182
 183         if (c->state != FINISHED)
 184                 return;
 185 fail:
 186         talloc_free(c);
 187         return;
 188
 189 need_subclient:
 190         if (!get_subclient(c)) {
 191                 /* We can't get one: go to sleep until someone find_oracle() */
 192                 tevent_fd_set_flags(c->fde, 0);
 193         } else
 194                 /* In case they are waiting... */
 195                 wakeup(c->oserver->clients[c->subclient]);
 196         return;
 197
 198 need_answer:
 199         /* If we don't have an oracle and find one, that's OK. */
 200         if (c->oracle == -1 && get_oracle(c)) {
 201                 /* In case they are waiting... */
 202                 wakeup(c->oserver->clients[c->oracle]);
 203                 return;
 204         }
 205
 206         /* Either our oracle is not finished, or we don't have one: sleep. */
 207         tevent_fd_set_flags(c->fde, 0);
 208 }
 209
 210 static int cleanup_client(struct client *client)
 211 {
 212
 213         /* We were an oracle? */
 214         if (client->subclient >= 0)
 215                 client->oserver->clients[client->subclient]->oracle = -1;
 216
 217         /* We had an oracle? */
 218         if (client->oracle >= 0)
 219                 client->oserver->clients[client->oracle]->subclient = -1;
 220
 221         assert(client->oserver->clients[client->id] == client);
 222         client->oserver->clients[client->id] = NULL;
 223         return 0;
 224 }
 225
 226 static unsigned int max_client(struct client *clients[5])
 227 {
 228         unsigned int i, ret = 0;
 229
 230         for (i = 0; i < 5; i++) {
 231                 if (clients[i])
 232                         ret = i+1;
 233         }
 234         return ret;
 235 }
 236
 237 static void add_client(struct tevent_context *ev,
 238                        struct tevent_fd *fde, uint16_t flags, void *_oserver)
 239 {
 240         struct oserver *oserver = _oserver;
 241         struct client *client;
 242
 243         client = talloc(oserver, struct client);
 244         client->fd = accept(oserver->fd, NULL, 0);
 245         if (client->fd < 0)
 246                 err(1, "Accepting client connection");
 247
 248         client->state = SENDING_GREETING;
 249         client->bytes_sent = 0;
 250         client->question = talloc_strdup(client, "");
 251         client->oserver = oserver;
 252         client->oracle = -1;
 253         client->subclient = -1;
 254         client->answer = talloc_strdup(client, "");
 255         client->fde = tevent_add_fd(ev, client, client->fd,
 256                                     state_flag_map[client->state],
 257                                     service_client, client);
 258         tevent_fd_set_auto_close(client->fde);
 259
 260         /* Find empty slot in array for this client. */
 261         for (client->id = 0; oserver->clients[client->id]; client->id++);
 262         oserver->clients[client->id] = client;
 263         talloc_set_destructor(client, cleanup_client);
 264
 265         /* Full?  Stop listening... */
 266         if (client->id == ARRAY_SIZE(oserver->clients)-1)
 267                 tevent_fd_set_flags(oserver->fde, 0);
 268         oserver->max_clients = max_client(oserver->clients);
 269 }
 270
 271 static void clear_clients(struct oserver *oserver)
 272 {
 273         memset(oserver->clients, 0,
 274                ARRAY_SIZE(oserver->clients) * sizeof(oserver->clients[0]));
 275 }
 276
 277 static int destroy_oserver(struct oserver *oserver)
 278 {
 279         close(oserver->fd);
 280         return 0;
 281 }
 282
 283 static void talloc_dump(struct tevent_context *ev,
 284                         struct tevent_signal *se,
 285                         int signum,
 286                         int count,
 287                         void *siginfo,
 288                         void *_oserver)
 289 {
 290         struct oserver *oserver = _oserver;
 291         FILE *f;
 292
 293         /* Fork off a child for the report, so we aren't stopped. */
 294         if (fork() == 0) {
 295                 f = fopen("/var/run/oserver/talloc.dump", "w");
 296                 if (f) {
 297                         talloc_report_full(oserver, f);
 298                         fclose(f);
 299                 }
 300                 _exit(0);
 301         }
 302 }
 303
 304 static void dump(struct tevent_context *ev,
 305                  struct tevent_signal *se,
 306                  int signum,
 307                  int count,
 308                  void *siginfo,
 309                  void *_oserver)
 310 {
 311         struct oserver *oserver = _oserver;
 312         char *str;
 313         int fd;
 314
 315         str = cdump_bundle(ev, cdump_struct_oserver, oserver);
 316         fd = open(oserver->dumpfile, O_CREAT|O_TRUNC|O_WRONLY, 0600);
 317         write(fd, str, strlen(str));
 318         close(fd);
 319         talloc_free(str);
 320         if (oserver->argv)
 321                 execvp(oserver->argv[0], oserver->argv);
 322 }
 323
 324 static bool load_file(struct oserver *oserver, const char *file)
 325 {
 326         char *str;
 327
 328         if (!file)
 329                 return false;
 330
 331         str = grab_file(oserver, file, NULL);
 332         if (!str)
 333                 return false;
 334
 335         if (!cdump_unbundle(oserver, cdump_struct_oserver, oserver, str)) {
 336                 talloc_free(str);
 337                 return false;
 338         }
 339         talloc_free(str);
 340         return true;
 341 }
 342
 343 static bool complete_server(struct tevent_context *ev,
 344                             struct oserver *oserver, const char *dumpfile)
 345 {
 346         oserver->max_clients = max_client(oserver->clients);
 347
 348         /* Re-set this even if restored from file, in case it changed. */
 349         oserver->dumpfile = dumpfile;
 350         if (oserver->dumpfile)
 351                 tevent_add_signal(ev, oserver, SIGHUP, SA_RESTART,
 352                                   dump, oserver);
 353
 354         /* Don't kill us if client dies. */
 355         signal(SIGPIPE, SIG_IGN);
 356
 357         /* Show talloc tree on SIGUSR1. */
 358         tevent_add_signal(ev, oserver, SIGUSR1, SA_RESTART,
 359                           talloc_dump, oserver);
 360
 361         oserver->fde = tevent_add_fd(ev, oserver, oserver->fd,
 362                                      TEVENT_FD_READ, add_client, oserver);
 363         if (!oserver->fde)
 364                 return false;
 365         return true;
 366 }
 367
 368 struct oserver *oserver_restore(struct tevent_context *ev, const char *dumpfile)
 369 {
 370         unsigned int i;
 371         struct oserver *oserver = talloc(ev, struct oserver);
 372         if (!load_file(oserver, dumpfile)) {
 373                 talloc_free(oserver);
 374                 return NULL;
 375         }
 376
 377         /* Restore ignored fields in clients, and talloc hierarchy. */
 378         for (i = 0; i < ARRAY_SIZE(oserver->clients); i++) {
 379                 struct client *client = oserver->clients[i];
 380                 if (!client)
 381                         continue;
 382                 /* These two were marked CDUMP_IGNORE. */
 383                 client->oserver = oserver;
 384                 client->fde = tevent_add_fd(ev, client, client->fd,
 385                                             state_flag_map[client->state],
 386                                             service_client, client);
 387                 tevent_fd_set_auto_close(client->fde);
 388                 /* cdump knows nothing of talloc. */
 389                 talloc_steal(oserver, client);
 390                 talloc_steal(client, client->question);
 391                 talloc_steal(client, client->answer);
 392                 talloc_set_destructor(client, cleanup_client);
 393         }
 394
 395         talloc_set_destructor(oserver, destroy_oserver);
 396         if (!complete_server(ev, oserver, dumpfile)) {
 397                 talloc_free(oserver);
 398                 return NULL;
 399         }
 400         return oserver;
 401 }
 402
 403 struct oserver *oserver_setup(struct tevent_context *ev, unsigned short port,
 404                               const char *dumpfile, char *argv[])
 405 {
 406         struct oserver *oserver;
 407         int one = 1;
 408         union {
 409                 struct sockaddr addr;
 410                 struct sockaddr_in in;
 411         } u;
 412
 413         oserver = talloc(ev, struct oserver);
 414         oserver->argv = argv;
 415         if (argv) {
 416                 /* Count the terminal NULL in argv_len. */
 417                 for (oserver->argv_len = 1;
 418                      argv[oserver->argv_len - 1];
 419                      oserver->argv_len++);
 420         } else
 421                 oserver->argv_len = 0;
 422         clear_clients(oserver);
 423         oserver->fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 424         if (oserver->fd < 0) {
 425                 talloc_free(oserver);
 426                 return NULL;
 427         }
 428
 429         talloc_set_destructor(oserver, destroy_oserver);
 430
 431         if (setsockopt(oserver->fd, SOL_SOCKET, SO_REUSEADDR,
 432                        &one, sizeof(one)))
 433                 warn("Setting socket reuse");
 434
 435         u.in.sin_family = AF_INET;
 436         u.in.sin_port = htons(port);
 437         u.in.sin_addr.s_addr = INADDR_ANY;
 438         if (bind(oserver->fd, &u.addr, sizeof(u.in)) == -1) {
 439                 talloc_free(oserver);
 440                 return NULL;
 441         }
 442
 443         if (listen(oserver->fd, 0) != 0) {
 444                 talloc_free(oserver);
 445                 return NULL;
 446         }
 447
 448         if (!complete_server(ev, oserver, dumpfile)) {
 449                 talloc_free(oserver);
 450                 return NULL;
 451         }
 452
 453         return oserver;
 454 }