]> rtime.felk.cvut.cz Git - coffee/mt-apps.git/blobdiff - mt_server.c
queue improved
[coffee/mt-apps.git] / mt_server.c
index fb5eb1b22410382748a95519bdf1bc88ff7619c6..dc70aab33fd6d65e5e2ab271c7409b7d25e300a9 100644 (file)
@@ -3,13 +3,91 @@
 #include <string.h>
 
 #include "mt_server.h"
-#include "ev_signal_exit.h"
+#include "signal_exit.h"
+
+char *new_line()
+{
+    char *line = (char *)malloc((LWS_PRE + INPUT_LINE_LENGTH)*sizeof(char));
+    if (!line) {
+        perror("malloc");
+    }
+    return line + LWS_PRE;
+}
+
+char *copy_line(char *line) {
+    char *copy = new_line();
+    if (!copy) {
+        return NULL;
+    }
+    strcpy(copy, line);
+}
+
+void free_line(char *line)
+{
+    free(line - LWS_PRE);
+}
+
+node *node_init(char *line)
+{
+    node *res = (node *)malloc(sizeof(node));
+    if (!res) {
+        perror("malloc");
+        return res;
+    }
+    res->line = line;;
+    res->next = NULL;
+    return res;
+}
+
+list *list_init()
+{
+    list *res = (list *)calloc(1, sizeof(list));
+    if (!res) {
+        perror("malloc");
+    }
+    return res;
+}
+
+int list_add(list *in, char *line)
+{
+    node *new = node_init(line);
+    if (!new) {
+        return -1;
+    }
+    if (!in->first) {
+        in->first = new;
+    } else {
+        in->last->next = new;
+    }
+    in->last = new;
+    return 0;
+}
+
+void list_remove(list *in)
+{
+    node *tmp = in->first;
+    if (tmp) {
+        in->first = tmp->next;
+        if (!tmp->next) {
+            in->last = NULL;
+        }
+        free_line(tmp->line);
+        free(tmp);
+    }
+}
+
+void list_deinit(list *in)
+{
+    while (in->first) {
+        list_remove(in);
+    }
+}
 
 static const struct lws_http_mount mount = {
     /* .mount_next */            NULL,         /* linked-list "next" */
-    /* .mountpoint */            "/",          /* mountpoint URL */
-    /* .origin */                "/usr/share/mt-server", /* serve from dir */
-    /* .def */                   "index.html", /* default filename */
+    /* .mountpoint */            HTTP_MOUNTPOINT,
+    /* .origin */                HTTP_ORIGIN,  /* serve from dir */
+    /* .def */                   HTTP_DEFAULT, /* default filename */
     /* .protocol */              NULL,
     /* .cgienv */                NULL,
     /* .extra_mimetypes */       NULL,
@@ -25,21 +103,17 @@ static const struct lws_http_mount mount = {
     /* .basic_auth_login_file */ NULL,
 };
 
-typedef struct per_vhost_data__dumb_increment {
+typedef struct per_vhost_data__merica_terminal {
     struct lws_context *context;
     struct lws_vhost *vhost;
     const struct lws_protocols *protocol;
-} per_vhost_data__dumb_increment;
+} per_vhost_data__merica_terminal;
 
-typedef struct per_session_data__dumb_increment {
-    uint8_t card_type;
-    uint8_t sak;
-    uint8_t uid_size;
-    char *uid;
+/*
+typedef struct per_session_data__merica_terminal {
     int number;
-} per_session_data__dumb_increment;
-
-#define JSON_EMPTY "{\"type\":\"empty\"}"
+} per_session_data__merica_terminal;
+*/
 
 enum protocols {
     PROTOCOL_HTTP = 0, // always first
@@ -50,21 +124,17 @@ static int callback_merica_terminal(struct lws *wsi,
                                     enum lws_callback_reasons reason,
                                     void *user, void *in, size_t len);
 
-/* list of supported protocols and callbacks */
-
+// list of supported protocols and callbacks
 static struct lws_protocols protocols[] = {
-    /* first protocol must always be HTTP handler */
+    // first protocol must always be HTTP handler
     {"http", lws_callback_http_dummy, 0, 0},
     {
-        "dumb-increment-protocol",
+        "merica-terminal-protocol",
         callback_merica_terminal,
-        sizeof(struct per_session_data__dumb_increment),
-        128, /* rx buf size must be >= permessage-deflate rx size
-             * dumb-increment only sends very small packets, so we set
-             * this accordingly.  If your protocol will send bigger
-             * things, adjust this to match */
+        0, //sizeof(struct per_session_data__merica_terminal),
+        MT_PROTOCOL_RX_BUFFER_SIZE
     },
-    {NULL, NULL, 0, 0} /* terminator */
+    {NULL, NULL, 0, 0} // terminator
 };
 
 static int callback_merica_terminal(struct lws *wsi,
@@ -73,21 +143,24 @@ static int callback_merica_terminal(struct lws *wsi,
 {
     struct lws_vhost *vhost = lws_get_vhost(wsi);
     const struct lws_protocols *prot = lws_get_protocol(wsi);
-    per_session_data__dumb_increment *pss =
-        (per_session_data__dumb_increment *)user;
-    per_vhost_data__dumb_increment *vhd =
-        (per_vhost_data__dumb_increment *)
+    /*
+    per_session_data__merica_terminal *pss =
+        (per_session_data__merica_terminal *)user;
+    */
+    per_vhost_data__merica_terminal *vhd =
+        (per_vhost_data__merica_terminal *)
         lws_protocol_vh_priv_get(vhost, prot);
 
     int n, m;
 
-    char *line = (char *)prot->user;
+    list *lines = (list *)prot->user;
+    char *line;
 
     switch (reason) {
         case LWS_CALLBACK_PROTOCOL_INIT:
             vhd = lws_protocol_vh_priv_zalloc(
                       vhost, prot,
-                      sizeof(struct per_vhost_data__dumb_increment)
+                      sizeof(struct per_vhost_data__merica_terminal)
                   );
             vhd->context = lws_get_context(wsi);
             vhd->protocol = prot;
@@ -104,21 +177,31 @@ static int callback_merica_terminal(struct lws *wsi,
             break;
 
         case LWS_CALLBACK_SERVER_WRITEABLE:
+            line = lines->first->line;
             n = strlen(line);
-            m = lws_write(wsi, line, n, LWS_WRITE_TEXT);
+            m = lws_write(wsi, (unsigned char *)line, n, LWS_WRITE_TEXT);
+            if (lines->first->next != NULL) {
+                list_remove(lines);
+                lws_callback_on_writable_all_protocol(lws_get_context(wsi),
+                    &protocols[PROTOCOL_MERICA_TERMINAL]);
+            }
             if (m < n) {
-                printf("ERROR %d writing to di socket\n", n);
+                fprintf(stderr, "ERROR %d writing to di socket\n", n);
                 return -1;
             }
             break;
 
         case LWS_CALLBACK_RECEIVE:
             if (strcmp((const char *)in, "reset") == 0) {
-                strcpy(line, JSON_EMPTY);
-                lws_callback_on_writable_all_protocol(lws_get_context(wsi),
-                                                      &protocols[PROTOCOL_MERICA_TERMINAL]);
+                line = copy_line(JSON_EMPTY);
+                if (line) {
+                    if (list_add(lines, line) == 0) {
+                        lws_callback_on_writable_all_protocol(lws_get_context(wsi),
+                            &protocols[PROTOCOL_MERICA_TERMINAL]);
+                    }
+                }
             } else if (strcmp((const char *)in, "close") == 0) {
-                printf("dumb_inc: closing as requested\n");
+                fprintf(stderr, "closing websocket\n");
                 lws_close_reason(wsi, LWS_CLOSE_STATUS_GOINGAWAY,
                                  (unsigned char *)"seeya", 5);
                 return -1;
@@ -132,13 +215,6 @@ static int callback_merica_terminal(struct lws *wsi,
     return 0;
 }
 
-/*static void ev_timeout_cb(EV_P_ ev_timer *w, int revents)
-{
-    lws_callback_on_writable_all_protocol(context,
-                                          &protocols[PROTOCOL_MERICA_TERMINAL]);
-}*/
-
-
 static void fd_cb(EV_P_ ev_io *w_, int revents)
 {
     ev_io_ws *w = (ev_io_ws *)w_;
@@ -147,13 +223,20 @@ static void fd_cb(EV_P_ ev_io *w_, int revents)
 
     read(w->w.fd, pos, 1);
 
-    if (*pos == '\n') {
+    if (*pos == '\n' || (w->pos - w->text) == INPUT_LINE_LENGTH) {
         *pos = 0;
-        w->pos = w->text;
-        lws_callback_on_writable_all_protocol(w->context,
-                                              &protocols[PROTOCOL_MERICA_TERMINAL]);
+        if (list_add(w->lines, w->text) == 0) {
+            char *line = new_line();
+            if (line) {
+                w->text = line;
+                w->pos = w->text;
+                lws_callback_on_writable_all_protocol(w->context,
+                    &protocols[PROTOCOL_MERICA_TERMINAL]);
+                return;
+            }
+        }
+        fprintf(stderr, "cannot malloc new line\n");
     }
-
 }
 
 int mt_server_init(mt_server_t *self, struct ev_loop *loop, int fd)
@@ -161,7 +244,7 @@ int mt_server_init(mt_server_t *self, struct ev_loop *loop, int fd)
     struct lws_context_creation_info info;
 
     memset(&info, 0, sizeof(info));
-    info.port = 80;
+    info.port = HTTP_PORT;
     info.mounts = &mount;
     info.protocols = protocols;
     info.max_http_header_pool = 1;
@@ -177,14 +260,27 @@ int mt_server_init(mt_server_t *self, struct ev_loop *loop, int fd)
 
     ev_io_ws *w = &(self->fd_watcher);
     w->context = context;
-    w->text = (char *)malloc(512*sizeof(char));
-    if (!w->text) {
-        perror("malloc");
+    char *line = copy_line(JSON_EMPTY);
+    if (!line) {
         return -1;
     }
-    strcpy(w->text, JSON_EMPTY);
+    w->lines = list_init();
+    if (!w->lines) {
+        free_line(line);
+        return -1;
+    }
+    if (list_add(w->lines, line) != 0) {
+        list_deinit(w->lines);
+        return -1;
+    }
+    protocols[PROTOCOL_MERICA_TERMINAL].user = (void *)w->lines;
+    line = new_line();
+    if (!line) {
+        list_deinit(w->lines);
+        return -1;
+    }
+    w->text = line;
     w->pos = w->text;
-    protocols[PROTOCOL_MERICA_TERMINAL].user = (void *)w->text;
     ev_io_init(&(w->w), fd_cb, fd, EV_READ);
     ev_io_start(loop, (ev_io *)w);
 
@@ -193,27 +289,22 @@ int mt_server_init(mt_server_t *self, struct ev_loop *loop, int fd)
 
 void mt_server_deinit(mt_server_t *self)
 {
-    //free(self->fd_watcher.text);
-    //protocols[PROTOCOL_MERICA_TERMINAL].user = NULL;
+    list_deinit((list *)protocols[PROTOCOL_MERICA_TERMINAL].user);
     lws_context_destroy(self->context);
 }
 
-#ifdef IS_MAIN
+#ifndef NO_MAIN
 int main(int argc, const char **argv)
 {
-    struct ev_loop *loop = ev_default_loop(0);
+    struct ev_loop *loop = EV_DEFAULT;
     mt_server_t server;
 
     set_signal_exit(loop);
 
-    if (mt_server_init(&server, loop, STDIN_FILENO) == -1) {
+    if (mt_server_init(&server, loop, STDIN_FILENO) != 0) {
         return -1;
     }
 
-    //ev_timer timeout_watcher;
-    //ev_timer_init(&timeout_watcher, ev_timeout_cb, 1, 1);
-    //ev_timer_start(loop, &timeout_watcher);
-
     ev_run(loop, 0);
 
     mt_server_deinit(&server);