ccan/oserver/oserver.c

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