+enum state {
+ SENDING_GREETING,
+ RECEIVING_USER_QUESTION,
+ AWAITING_A_SUBCLIENT,
+ SENDING_OTHER_QUESTION_PREFIX,
+ SENDING_OTHER_QUESTION,
+ RECEIVING_OTHER_ANSWER,
+ AWAITING_OUR_ORACLE,
+ SENDING_ANSWER_PREFIX,
+ SENDING_ANSWER,
+ FINISHED
+};
+
+static uint16_t state_flag_map[] = {
+ [SENDING_GREETING] = TEVENT_FD_WRITE,
+ [RECEIVING_USER_QUESTION] = TEVENT_FD_READ,
+ [AWAITING_A_SUBCLIENT] = 0,
+ [SENDING_OTHER_QUESTION_PREFIX] = TEVENT_FD_WRITE,
+ [SENDING_OTHER_QUESTION] = TEVENT_FD_WRITE,
+ [RECEIVING_OTHER_ANSWER] = TEVENT_FD_READ,
+ [AWAITING_OUR_ORACLE] = 0,
+ [SENDING_ANSWER_PREFIX] = TEVENT_FD_WRITE,
+ [SENDING_ANSWER] = TEVENT_FD_WRITE,
+ [FINISHED] = 0
+};
+
+struct client {
+ /* What are we doing today, brain? */
+ enum state state;
+ /* Our event info, and the file descriptor. */
+ struct tevent_fd *fde;
+ int fd;
+ /* The question we read from client. */
+ char *question;
+ /* The answer to the client. */
+ char *answer;
+ /* How many bytes of the reply we sent so far. */
+ size_t bytes_sent;
+ /* Our server. */
+ struct oserver *oserver;
+ /* Whose question this client is answering. */
+ struct client *subclient;
+ /* Who is answering our question. */
+ struct client *oracle;
+};
+
+struct oserver {
+ /* 5 clients should be enough for anybody! */
+ struct client *clients[5];
+ int fd;
+ struct tevent_fd *fde;
+};
+
+static ssize_t write_string(int fd, const char *str)
+{
+ return write(fd, str, strlen(str));
+}
+
+static ssize_t read_string(int fd, char **buf)
+{
+ ssize_t ret, len, maxlen;
+
+ len = strlen(*buf);
+ maxlen = talloc_array_length(*buf);
+
+ if (maxlen < len + 100) {
+ maxlen += 100;
+ *buf = talloc_realloc(NULL, *buf, char, maxlen);
+ }
+
+ ret = read(fd, *buf + len, maxlen - len - 1);
+ if (ret >= 0)
+ (*buf)[len + ret] = '\0';
+ return ret;
+}
+
+static bool input_finished(const char *str)
+{
+ return strchr(str, '\n');
+}
+
+/* Update state, and set our READ/WRITE flags appropriately. */
+static void set_state(struct client *c, enum state state)
+{
+ c->state = state;
+ tevent_fd_set_flags(c->fde, state_flag_map[state]);
+}
+
+/* Returns false on error, increments state on finishing string. */
+static bool send_string(struct client *c, const char *str)
+{
+ ssize_t len = write_string(c->fd, str + c->bytes_sent);
+ if (len < 0)
+ return false;
+ c->bytes_sent += len;
+ if (c->bytes_sent == strlen(str)) {
+ c->bytes_sent = 0;
+ set_state(c, c->state+1);
+ }
+ return true;
+}
+
+static bool get_subclient(struct client *me)
+{
+ unsigned int i;
+
+ for (i = 0; i < ARRAY_SIZE(me->oserver->clients); i++) {
+ struct client *c = me->oserver->clients[i];
+ if (!c || c == me)
+ continue;
+ if (c->oracle == NULL && input_finished(c->question)) {
+ me->subclient = c;
+ c->oracle = me;
+ return true;
+ }
+ }
+ return false;
+}
+
+static bool get_oracle(struct client *me)
+{
+ unsigned int i;
+
+ for (i = 0; i < ARRAY_SIZE(me->oserver->clients); i++) {
+ struct client *c = me->oserver->clients[i];
+ if (!c || c == me)
+ continue;
+ if (c->subclient == NULL && input_finished(c->question)) {
+ me->oracle = c;
+ c->subclient = me;
+ return true;
+ }
+ }
+ return false;
+}
+
+static void service_client(struct tevent_context *ev,
+ struct tevent_fd *fde, uint16_t flags, void *_c)
+{
+ struct client *c = _c;
+ ssize_t len;
+
+ switch (c->state) {
+ case SENDING_GREETING:
+ if (!send_string(c, "Welcome. Please ask your question.\n"))
+ goto fail;
+ break;
+ case RECEIVING_USER_QUESTION:
+ len = read_string(c->fd, &c->question);
+ if (len <= 0)
+ goto fail;
+ if (input_finished(c->question)) {
+ /* Look for someone to be oracle to. */
+ if (get_subclient(c)) {
+ set_state(c, SENDING_OTHER_QUESTION_PREFIX);
+ } else {
+ /* We sit here until someone find_oracles us */
+ set_state(c, AWAITING_A_SUBCLIENT);
+ }
+
+ /* Look for an oracle for ourselves. */
+ if (get_oracle(c)) {
+ assert(c->oracle->state
+ == AWAITING_A_SUBCLIENT);
+ set_state(c->oracle,
+ SENDING_OTHER_QUESTION_PREFIX);
+ }
+ }
+ break;
+ case SENDING_OTHER_QUESTION_PREFIX:
+ if (!send_string(c, "While the Oracle ponders,"
+ " please answer the following question:\n"))
+ goto fail;
+ break;
+ case SENDING_OTHER_QUESTION:
+ if (!send_string(c, c->subclient->question))
+ goto fail;
+ break;
+ case RECEIVING_OTHER_ANSWER:
+ len = read_string(c->fd, &c->subclient->answer);
+ if (len <= 0)
+ goto fail;
+ if (input_finished(c->subclient->answer)) {
+ /* Did our oracle answer for us already? */
+ if (input_finished(c->answer))
+ set_state(c, SENDING_ANSWER_PREFIX);
+ else
+ set_state(c, AWAITING_OUR_ORACLE);
+
+ /* If they were waiting for an answer, move them. */
+ if (c->subclient->state == AWAITING_OUR_ORACLE)
+ set_state(c->subclient, SENDING_ANSWER_PREFIX);
+ }
+ break;
+ case SENDING_ANSWER_PREFIX:
+ if (!send_string(c, "The Oracle spake thus:\n"))
+ goto fail;
+ break;
+ case SENDING_ANSWER:
+ if (!send_string(c, c->answer))
+ goto fail;
+ break;
+ default:
+ goto fail;
+ }
+
+ if (c->state != FINISHED)
+ return;
+
+fail:
+ talloc_free(c);
+}
+
+static int cleanup_client(struct client *client)