ccan/oserver/oserver.c

   1 #include <ccan/oserver/oserver.h>
   2 #include <ccan/read_write_all/read_write_all.h>
   3 #include <ccan/opt/opt.h>
   4 #include <ccan/tevent/tevent.h>
   5 #include <ccan/array_size/array_size.h>
   6 #include <sys/types.h>
   7 #include <sys/socket.h>
   8 #include <netinet/in.h>
   9 #include <netinet/tcp.h>
  10 #include <err.h>
  11 #include <stdio.h>
  12 #include <unistd.h>
  13 #include <ctype.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <errno.h>
  17 #include <signal.h>
  18
  19 enum state {
  20         RECEIVING_USER_QUESTION,
  21         SENDING_ANSWER,
  22         FINISHED
  23 };
  24
  25 static uint16_t state_flag_map[] = {
  26         [RECEIVING_USER_QUESTION]       = TEVENT_FD_READ,
  27         [SENDING_ANSWER]                = TEVENT_FD_WRITE,
  28         [FINISHED]                      = 0
  29 };
  30
  31 struct client {
  32         /* What are we doing today, brain? */
  33         enum state state;
  34         /* Our event info, and the file descriptor. */
  35         struct tevent_fd *fde;
  36         int fd;
  37         /* The question we read from client. */
  38         char *question;
  39         /* How many bytes of the reply we sent so far. */
  40         size_t bytes_sent;
  41         /* Our server. */
  42         struct oserver *oserver;
  43 };
  44
  45 struct oserver {
  46         /* 5 clients should be enough for anybody! */
  47         struct client *clients[5];
  48         int fd;
  49         struct tevent_fd *fde;
  50 };
  51
  52 static ssize_t write_string(int fd, const char *str)
  53 {
  54         return write(fd, str, strlen(str));
  55 }
  56
  57 static ssize_t read_string(int fd, char **buf)
  58 {
  59         ssize_t ret, len, maxlen;
  60
  61         len = strlen(*buf);
  62         maxlen = talloc_array_length(*buf);
  63
  64         if (maxlen < len + 100) {
  65                 maxlen += 100;
  66                 *buf = talloc_realloc(NULL, *buf, char, maxlen);
  67         }
  68
  69         ret = read(fd, *buf + len, maxlen - len - 1);
  70         if (ret >= 0)
  71                 (*buf)[len + ret] = '\0';
  72         return ret;
  73 }
  74
  75 static bool input_finished(const char *str)
  76 {
  77         return strchr(str, '\n');
  78 }
  79
  80 /* Update state, and set our READ/WRITE flags appropriately. */
  81 static void set_state(struct client *c, enum state state)
  82 {
  83         c->state = state;
  84         tevent_fd_set_flags(c->fde, state_flag_map[state]);
  85 }
  86
  87 /* Returns false on error, increments state on finishing string. */
  88 static bool send_string(struct client *c, const char *str)
  89 {
  90         ssize_t len = write_string(c->fd, str + c->bytes_sent);
  91         if (len < 0)
  92                 return false;
  93         c->bytes_sent += len;
  94         if (c->bytes_sent == strlen(str)) {
  95                 c->bytes_sent = 0;
  96                 set_state(c, c->state+1);
  97         }
  98         return true;
  99 }
 100
 101 static void service_client(struct tevent_context *ev,
 102                            struct tevent_fd *fde, uint16_t flags, void *_c)
 103 {
 104         struct client *c = _c;
 105         ssize_t len;
 106
 107         switch (c->state) {
 108         case RECEIVING_USER_QUESTION:
 109                 len = read_string(c->fd, &c->question);
 110                 if (len <= 0)
 111                         goto fail;
 112                 if (input_finished(c->question)) {
 113                         unsigned int i;
 114
 115                         for (i = 0; c->question[i]; i++)
 116                                 c->question[i] = toupper(c->question[i]);
 117                         set_state(c, SENDING_ANSWER);
 118                 }
 119                 break;
 120         case SENDING_ANSWER:
 121                 if (!send_string(c, c->question))
 122                         goto fail;
 123                 break;
 124         default:
 125                 goto fail;
 126         }
 127
 128         if (c->state != FINISHED)
 129                 return;
 130
 131 fail:
 132         talloc_free(c);
 133 }
 134
 135 static int cleanup_client(struct client *client)
 136 {
 137         unsigned int i;
 138
 139         for (i = 0; i < ARRAY_SIZE(client->oserver->clients); i++) {
 140                 if (client->oserver->clients[i] == client) {
 141                         client->oserver->clients[i] = NULL;
 142                         tevent_fd_set_flags(client->oserver->fde,
 143                                             TEVENT_FD_READ);
 144                         return 0;
 145                 }
 146         }
 147         abort();
 148 }
 149
 150 static void add_client(struct tevent_context *ev,
 151                        struct tevent_fd *fde, uint16_t flags, void *_oserver)
 152 {
 153         struct oserver *oserver = _oserver;
 154         struct client *client;
 155         unsigned int i;
 156
 157         client = talloc(oserver, struct client);
 158         client->fd = accept(oserver->fd, NULL, 0);
 159         if (client->fd < 0)
 160                 err(1, "Accepting client connection");
 161
 162         client->state = RECEIVING_USER_QUESTION;
 163         client->bytes_sent = 0;
 164         client->question = talloc_strdup(client, "");
 165         client->oserver = oserver;
 166         client->fde = tevent_add_fd(ev, client, client->fd,
 167                                     state_flag_map[client->state],
 168                                     service_client, client);
 169         tevent_fd_set_auto_close(client->fde);
 170
 171         /* Find empty slot in array for this client. */
 172         for (i = 0; oserver->clients[i]; i++);
 173         oserver->clients[i] = client;
 174         talloc_set_destructor(client, cleanup_client);
 175
 176         /* Full?  Stop listening... */
 177         if (i == ARRAY_SIZE(oserver->clients)-1)
 178                 tevent_fd_set_flags(oserver->fde, 0);
 179 }
 180
 181 static int destroy_oserver(struct oserver *oserver)
 182 {
 183         close(oserver->fd);
 184         return 0;
 185 }
 186
 187 struct oserver *oserver_setup(struct tevent_context *ev, unsigned short port)
 188 {
 189         struct oserver *oserver;
 190         int one = 1;
 191         union {
 192                 struct sockaddr addr;
 193                 struct sockaddr_in in;
 194         } u;
 195
 196         oserver = talloc(ev, struct oserver);
 197
 198         oserver->fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 199         if (oserver->fd < 0) {
 200                 talloc_free(oserver);
 201                 return NULL;
 202         }
 203         talloc_set_destructor(oserver, destroy_oserver);
 204
 205         if (setsockopt(oserver->fd, SOL_SOCKET, SO_REUSEADDR,
 206                        &one, sizeof(one)))
 207                 warn("Setting socket reuse");
 208
 209         u.in.sin_family = AF_INET;
 210         u.in.sin_port = htons(port);
 211         u.in.sin_addr.s_addr = INADDR_ANY;
 212         if (bind(oserver->fd, &u.addr, sizeof(u.in)) == -1) {
 213                 talloc_free(oserver);
 214                 return NULL;
 215         }
 216
 217         if (listen(oserver->fd, 0) != 0) {
 218                 talloc_free(oserver);
 219                 return NULL;
 220         }
 221
 222         oserver->fde = tevent_add_fd(ev, oserver, oserver->fd,
 223                                      TEVENT_FD_READ, add_client, oserver);
 224         if (!oserver->fde) {
 225                 talloc_free(oserver);
 226                 return NULL;
 227         }
 228
 229         /* Don't kill us if client dies. */
 230         signal(SIGPIPE, SIG_IGN);
 231
 232         return oserver;
 233 }