+#include <stdlib.h>
+#include <stdio.h>
+#include <libwebsockets.h>
+#include <string.h>
+#include <ev.h>
+
+char *uids[10] = {
+ "evelyn",
+ "sera",
+ "solas",
+ "iron bull",
+ "cassandra",
+ "varric",
+ "dorian",
+ "vivienne",
+ "blackwall",
+ "cole"
+};
+
+#define JSON_STRING "{" \
+ "\"type\": \"rfid\"," \
+ "\"uid\": \"%s\"," \
+ "\"size\": %d" \
+ "}\n"
+
+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 */
+ /* .protocol */ NULL,
+ /* .cgienv */ NULL,
+ /* .extra_mimetypes */ NULL,
+ /* .interpret */ NULL,
+ /* .cgi_timeout */ 0,
+ /* .cache_max_age */ 0,
+ /* .auth_mask */ 0,
+ /* .cache_reusable */ 0,
+ /* .cache_revalidate */ 0,
+ /* .cache_intermediaries */ 0,
+ /* .origin_protocol */ LWSMPRO_FILE, /* files in a dir */
+ /* .mountpoint_len */ 1, /* char count */
+ /* .basic_auth_login_file */ NULL,
+};
+
+typedef struct per_vhost_data__dumb_increment {
+ struct lws_context *context;
+ struct lws_vhost *vhost;
+ const struct lws_protocols *protocol;
+} per_vhost_data__dumb_increment;
+
+typedef struct per_session_data__dumb_increment {
+ uint8_t card_type;
+ uint8_t sak;
+ uint8_t uid_size;
+ char *uid;
+ int number;
+} per_session_data__dumb_increment;
+
+typedef struct user_data {
+ //ev_ufr_io *ufr;
+} user_data;
+
+ static char line[512];
+
+static int callback_dumb_increment(struct lws *wsi,
+ enum lws_callback_reasons reason,
+ void *user, void *in, size_t len)
+{
+ per_session_data__dumb_increment *pss =
+ (per_session_data__dumb_increment *)user;
+ per_vhost_data__dumb_increment *vhd =
+ (per_vhost_data__dumb_increment *)
+ lws_protocol_vh_priv_get(lws_get_vhost(wsi), lws_get_protocol(wsi));
+
+ struct lws_context *context = lws_get_context(wsi);
+ user_data *data = (user_data *)lws_context_user(context);
+
+
+ unsigned char buf[LWS_PRE + 512];
+ unsigned char *p = &buf[LWS_PRE];
+ int n, m;
+
+ switch (reason) {
+ case LWS_CALLBACK_PROTOCOL_INIT:
+ vhd = lws_protocol_vh_priv_zalloc(
+ lws_get_vhost(wsi),
+ lws_get_protocol(wsi),
+ sizeof(struct per_vhost_data__dumb_increment)
+ );
+ vhd->context = lws_get_context(wsi);
+ vhd->protocol = lws_get_protocol(wsi);
+ vhd->vhost = lws_get_vhost(wsi);
+ break;
+
+ case LWS_CALLBACK_PROTOCOL_DESTROY:
+ if (!vhd) {
+ break;
+ }
+ break;
+
+ case LWS_CALLBACK_ESTABLISHED:
+ pss->number = 0;
+ break;
+
+ case LWS_CALLBACK_SERVER_WRITEABLE:
+ n = sprintf((char *)p, JSON_STRING, uids[pss->number % 10], pss->number);
+ pss->number++;
+ n = strlen(line);
+ m = lws_write(wsi, line, n, LWS_WRITE_TEXT);
+ if (m < n) {
+ printf("ERROR %d writing to di socket\n", n);
+ return -1;
+ }
+ break;
+
+ case LWS_CALLBACK_RECEIVE:
+ if (len < 6) {
+ break;
+ }
+ if (strcmp((const char *)in, "reset\n") == 0) {
+ pss->number = 0;
+ }
+ if (strcmp((const char *)in, "close\n") == 0) {
+ printf("dumb_inc: closing as requested\n");
+ lws_close_reason(wsi, LWS_CLOSE_STATUS_GOINGAWAY,
+ (unsigned char *)"seeya", 5);
+ return -1;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+enum demo_protocols {
+ /* always first */
+ PROTOCOL_HTTP = 0,
+
+ PROTOCOL_DUMB_INCREMENT,
+ PROTOCOL_LWS_MIRROR,
+ PROTOCOL_LWS_STATUS,
+
+ /* always last */
+ DEMO_PROTOCOL_COUNT
+};
+
+/* list of supported protocols and callbacks */
+
+static struct lws_protocols protocols[] = {
+ /* first protocol must always be HTTP handler */
+ {"http", lws_callback_http_dummy, 0, 0},
+ {
+ "dumb-increment-protocol",
+ callback_dumb_increment,
+ 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 */
+ },
+ {NULL, NULL, 0, 0} /* terminator */
+};
+
+struct lws_context *context;
+
+static void ev_timeout_cb(EV_P_ ev_timer *w, int revents)
+{
+ lws_callback_on_writable_all_protocol(context,
+ &protocols[PROTOCOL_DUMB_INCREMENT]);
+}
+
+static void signal_cb(EV_P_ ev_signal *w, int revents)
+{
+ fprintf(stderr, "signal caught, terminating\n");
+ switch (w->signum) {
+ case SIGTERM:
+ case SIGINT:
+ ev_break(loop, EVBREAK_ALL);
+ break;
+ default:
+ signal(SIGABRT, SIG_DFL);
+ abort();
+ break;
+ }
+}
+
+
+
+int server_init(void *user)
+{
+ struct lws_context_creation_info info;
+
+ protocols[PROTOCOL_DUMB_INCREMENT].user = (void *)line;
+
+ memset(&info, 0, sizeof info);
+ info.port = 80;
+ info.mounts = &mount;
+ info.protocols = protocols;
+ info.max_http_header_pool = 1;
+ info.options |= LWS_SERVER_OPTION_LIBEV;
+ info.user = user;
+
+ context = lws_create_context(&info);
+ if (!context) {
+ fprintf(stderr, "lws_create_context failed\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+
+
+static void stdin_cb(EV_P_ ev_io *w, int revents)
+{
+ static int pos = 0;
+
+ read(w->fd, &line[pos++], 1);
+
+ if (line[pos-1] == '\n') {
+ line[pos] = 0;
+ pos = 0;
+// puts(line);
+ lws_callback_on_writable_all_protocol(context,
+ &protocols[PROTOCOL_DUMB_INCREMENT]);
+ }
+
+}
+
+int main(int argc, const char **argv)
+{
+ int sigs[] = { SIGINT, SIGKILL, SIGTERM, SIGSEGV, SIGFPE };
+ struct ev_signal signals[ARRAY_SIZE(sigs)];
+ ev_io stdin_watcher;
+ struct ev_loop *loop = ev_default_loop(0);
+ ev_timer timeout_watcher;
+
+ for (int n = 0; n < ARRAY_SIZE(sigs); n++) {
+ ev_init(&signals[n], signal_cb);
+ ev_signal_set(&signals[n], sigs[n]);
+ ev_signal_start(loop, &signals[n]);
+ }
+
+ if (server_init(NULL) == -1) {
+ return -1;
+ }
+ lws_ev_initloop(context, loop, 0);
+
+ ev_io_init(&stdin_watcher, stdin_cb, /*STDIN_FILENO*/ 0, EV_READ);
+ ev_io_start(loop, &stdin_watcher);
+
+ ev_timer_init(&timeout_watcher, ev_timeout_cb, 1, 1);
+ //ev_timer_start(loop, &timeout_watcher);
+
+ ev_run(loop, 0);
+
+ lws_context_destroy(context);
+
+ return 0;
+}