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