Add json-rpc-over-ws example

examples/json-rpc-over-websocket/Makefile

@@ -0,0 +1,10 @@
+PROG ?= example
+
+all: $(PROG)
+	$(DEBUGGER) ./$(PROG) $(ARGS)
+
+$(PROG): main.c
+	$(CC) main.c mjson.c ../../mongoose.c -I../.. -W -Wall -DMG_ENABLE_LINES=1 $(CFLAGS) -o $(PROG)
+
+clean:
+	rm -rf $(PROG) *.o *.dSYM *.gcov *.gcno *.gcda *.obj *.exe *.ilk *.pdb

examples/json-rpc-over-websocket/README.md

@@ -0,0 +1 @@
+See detailed tutorial at https://mongoose.ws/tutorials/websocket-server/

examples/json-rpc-over-websocket/main.c

@@ -0,0 +1,86 @@
+// Copyright (c) 2020 Cesanta Software Limited
+// All rights reserved
+//
+// See https://mongoose.ws/tutorials/json-rpc-over-websocket/
+
+#include "mjson.h"
+#include "mongoose.h"
+
+static const char *s_listen_on = "ws://localhost:8000";
+static const char *s_web_root = "web_root";
+
+static void sum(struct jsonrpc_request *r) {
+  double a = 0.0, b = 0.0;
+  mjson_get_number(r->params, r->params_len, "$[0]", &a);
+  mjson_get_number(r->params, r->params_len, "$[1]", &b);
+  jsonrpc_return_success(r, "%g", a + b);
+}
+
+static void multiply(struct jsonrpc_request *r) {
+  double a = 0.0, b = 0.0;
+  mjson_get_number(r->params, r->params_len, "$[0]", &a);
+  mjson_get_number(r->params, r->params_len, "$[1]", &b);
+  jsonrpc_return_success(r, "%g", a * b);
+}
+
+// This RESTful server implements the following endpoints:
+//   /websocket - upgrade to Websocket, and implement websocket echo server
+//   any other URI serves static files from s_web_root
+static void fn(struct mg_connection *c, int ev, void *ev_data, void *fn_data) {
+  if (ev == MG_EV_OPEN) {
+    // c->is_hexdumping = 1;
+  } else if (ev == MG_EV_WS_OPEN) {
+    c->label[0] = 'W';  // Mark this connection as an established WS client
+  } else if (ev == MG_EV_HTTP_MSG) {
+    struct mg_http_message *hm = (struct mg_http_message *) ev_data;
+    if (mg_http_match_uri(hm, "/websocket")) {
+      // Upgrade to websocket. From now on, a connection is a full-duplex
+      // Websocket connection, which will receive MG_EV_WS_MSG events.
+      mg_ws_upgrade(c, hm, NULL);
+    } else {
+      // Serve static files
+      struct mg_http_serve_opts opts = {.root_dir = s_web_root};
+      mg_http_serve_dir(c, ev_data, &opts);
+    }
+  } else if (ev == MG_EV_WS_MSG) {
+    // Got websocket frame. Received data is wm->data
+    struct mg_ws_message *wm = (struct mg_ws_message *) ev_data;
+    struct mg_str req = wm->data;
+    char *response = NULL;
+    jsonrpc_process(req.ptr, req.len, mjson_print_dynamic_buf, &response, NULL);
+    mg_ws_send(c, response, strlen(response), WEBSOCKET_OP_TEXT);
+    LOG(LL_INFO, ("[%.*s] -> [%s]", (int) req.len, req.ptr, response));
+    free(response);
+  }
+  (void) fn_data;
+}
+
+static void timer_fn(void *arg) {
+  struct mg_mgr *mgr = (struct mg_mgr *) arg;
+  // Broadcast "hi" message to all connected websocket clients.
+  // Traverse over all connections
+  for (struct mg_connection *c = mgr->conns; c != NULL; c = c->next) {
+    // Send JSON-RPC notifications to marked connections
+    const char *msg = "{\"method\":\"hiya!!\",\"params\":[1,2,3]}";
+    if (c->label[0] == 'W') mg_ws_send(c, msg, strlen(msg), WEBSOCKET_OP_TEXT);
+  }
+}
+
+int main(void) {
+  struct mg_mgr mgr;   // Event manager
+  struct mg_timer t1;  // Timer
+
+  mg_mgr_init(&mgr);  // Init event manager
+  mg_timer_init(&t1, 5000, MG_TIMER_REPEAT, timer_fn, &mgr);  // Init timer
+
+  jsonrpc_init(NULL, NULL);         // Init JSON-RPC instance
+  jsonrpc_export("sum", sum);       // And export a couple
+  jsonrpc_export("mul", multiply);  // of RPC functions
+
+  printf("Starting WS listener on %s/websocket\n", s_listen_on);
+  mg_http_listen(&mgr, s_listen_on, fn, NULL);  // Create HTTP listener
+  for (;;) mg_mgr_poll(&mgr, 1000);             // Infinite event loop
+  mg_timer_free(&t1);                           // Free timer resources
+  mg_mgr_free(&mgr);                            // Deallocate event manager
+  return 0;
+}

examples/json-rpc-over-websocket/mjson.h

@@ -0,0 +1,204 @@
+// Copyright (c) 2018-2020 Cesanta Software Limited
+// All rights reserved
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef MJSON_H
+#define MJSON_H
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef MJSON_ENABLE_PRINT
+#define MJSON_ENABLE_PRINT 1
+#endif
+
+#ifndef MJSON_ENABLE_RPC
+#define MJSON_ENABLE_RPC 1
+#endif
+
+#ifndef MJSON_ENABLE_BASE64
+#define MJSON_ENABLE_BASE64 1
+#endif
+
+#ifndef MJSON_ENABLE_MERGE
+#define MJSON_ENABLE_MERGE 1
+#endif
+
+#ifndef MJSON_ENABLE_PRETTY
+#define MJSON_ENABLE_PRETTY 1
+#endif
+
+#ifndef MJSON_ENABLE_NEXT
+#define MJSON_ENABLE_NEXT 1
+#endif
+
+#ifndef MJSON_RPC_LIST_NAME
+#define MJSON_RPC_LIST_NAME "rpc.list"
+#endif
+
+#ifndef MJSON_DYNBUF_CHUNK
+#define MJSON_DYNBUF_CHUNK 256  // Allocation granularity for print_dynamic_buf
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MJSON_ERROR_INVALID_INPUT (-1)
+#define MJSON_ERROR_TOO_DEEP (-2)
+#define MJSON_TOK_INVALID 0
+#define MJSON_TOK_KEY 1
+#define MJSON_TOK_STRING 11
+#define MJSON_TOK_NUMBER 12
+#define MJSON_TOK_TRUE 13
+#define MJSON_TOK_FALSE 14
+#define MJSON_TOK_NULL 15
+#define MJSON_TOK_ARRAY 91
+#define MJSON_TOK_OBJECT 123
+#define MJSON_TOK_IS_VALUE(t) ((t) > 10 && (t) < 20)
+
+typedef int (*mjson_cb_t)(int ev, const char *s, int off, int len, void *ud);
+
+#ifndef MJSON_MAX_DEPTH
+#define MJSON_MAX_DEPTH 20
+#endif
+
+int mjson(const char *s, int len, mjson_cb_t cb, void *ud);
+int mjson_find(const char *s, int len, const char *jp, const char **, int *);
+int mjson_get_number(const char *s, int len, const char *path, double *v);
+int mjson_get_bool(const char *s, int len, const char *path, int *v);
+int mjson_get_string(const char *s, int len, const char *path, char *to, int n);
+int mjson_get_hex(const char *s, int len, const char *path, char *to, int n);
+
+#if MJSON_ENABLE_NEXT
+int mjson_next(const char *s, int n, int off, int *koff, int *klen, int *voff,
+               int *vlen, int *vtype);
+#endif
+
+#if MJSON_ENABLE_BASE64
+int mjson_get_base64(const char *s, int len, const char *path, char *to, int n);
+int mjson_base64_dec(const char *src, int n, char *dst, int dlen);
+#endif
+
+#if MJSON_ENABLE_PRINT
+typedef int (*mjson_print_fn_t)(const char *buf, int len, void *userdata);
+typedef int (*mjson_vprint_fn_t)(mjson_print_fn_t, void *, va_list *);
+
+struct mjson_fixedbuf {
+  char *ptr;
+  int size, len;
+};
+
+int mjson_printf(mjson_print_fn_t, void *, const char *fmt, ...);
+int mjson_vprintf(mjson_print_fn_t, void *, const char *fmt, va_list *ap);
+int mjson_print_str(mjson_print_fn_t, void *, const char *s, int len);
+int mjson_print_int(mjson_print_fn_t, void *, int value, int is_signed);
+int mjson_print_long(mjson_print_fn_t, void *, long value, int is_signed);
+int mjson_print_buf(mjson_print_fn_t fn, void *, const char *buf, int len);
+int mjson_print_dbl(mjson_print_fn_t fn, void *, double, int width);
+
+int mjson_print_null(const char *ptr, int len, void *userdata);
+int mjson_print_fixed_buf(const char *ptr, int len, void *userdata);
+int mjson_print_dynamic_buf(const char *ptr, int len, void *userdata);
+
+int mjson_snprintf(char *buf, size_t len, const char *fmt, ...);
+char *mjson_aprintf(const char *fmt, ...);
+
+#if MJSON_ENABLE_PRETTY
+int mjson_pretty(const char *, int, const char *, mjson_print_fn_t, void *);
+#endif
+
+#if MJSON_ENABLE_MERGE
+int mjson_merge(const char *, int, const char *, int, mjson_print_fn_t, void *);
+#endif
+
+#endif  // MJSON_ENABLE_PRINT
+
+#if MJSON_ENABLE_RPC
+
+void jsonrpc_init(mjson_print_fn_t, void *userdata);
+int mjson_globmatch(const char *s1, int n1, const char *s2, int n2);
+
+struct jsonrpc_request {
+  struct jsonrpc_ctx *ctx;
+  const char *frame;    // Points to the whole frame
+  int frame_len;        // Frame length
+  const char *params;   // Points to the "params" in the request frame
+  int params_len;       // Length of the "params"
+  const char *id;       // Points to the "id" in the request frame
+  int id_len;           // Length of the "id"
+  const char *method;   // Points to the "method" in the request frame
+  int method_len;       // Length of the "method"
+  mjson_print_fn_t fn;  // Printer function
+  void *fndata;         // Printer function data
+  void *userdata;       // Callback's user data as specified at export time
+};
+
+struct jsonrpc_method {
+  const char *method;
+  int method_sz;
+  void (*cb)(struct jsonrpc_request *);
+  struct jsonrpc_method *next;
+};
+
+// Main RPC context, stores current request information and a list of
+// exported RPC methods.
+struct jsonrpc_ctx {
+  struct jsonrpc_method *methods;
+  mjson_print_fn_t response_cb;
+  void *response_cb_data;
+};
+
+// Registers function fn under the given name within the given RPC context
+#define jsonrpc_ctx_export(ctx, name, fn)                                 \
+  do {                                                                    \
+    static struct jsonrpc_method m = {(name), sizeof(name) - 1, (fn), 0}; \
+    m.next = (ctx)->methods;                                              \
+    (ctx)->methods = &m;                                                  \
+  } while (0)
+
+void jsonrpc_ctx_init(struct jsonrpc_ctx *ctx, mjson_print_fn_t, void *);
+void jsonrpc_return_error(struct jsonrpc_request *r, int code,
+                          const char *message, const char *data_fmt, ...);
+void jsonrpc_return_success(struct jsonrpc_request *r, const char *result_fmt,
+                            ...);
+void jsonrpc_ctx_process(struct jsonrpc_ctx *ctx, const char *req, int req_sz,
+                         mjson_print_fn_t fn, void *fndata, void *userdata);
+
+extern struct jsonrpc_ctx jsonrpc_default_context;
+extern void jsonrpc_list(struct jsonrpc_request *r);
+
+#define jsonrpc_export(name, fn) \
+  jsonrpc_ctx_export(&jsonrpc_default_context, (name), (fn))
+
+#define jsonrpc_process(buf, len, fn, fnd, ud) \
+  jsonrpc_ctx_process(&jsonrpc_default_context, (buf), (len), (fn), (fnd), (ud))
+
+#define JSONRPC_ERROR_INVALID -32700    /* Invalid JSON was received */
+#define JSONRPC_ERROR_NOT_FOUND -32601  /* The method does not exist */
+#define JSONRPC_ERROR_BAD_PARAMS -32602 /* Invalid params passed */
+#define JSONRPC_ERROR_INTERNAL -32603   /* Internal JSON-RPC error */
+
+#endif  // MJSON_ENABLE_RPC
+#ifdef __cplusplus
+}
+#endif
+#endif  // MJSON_H

examples/json-rpc-over-websocket/web_root/index.html

@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html lang="en">
+  <body>
+    <h1>JSON-RPC over Websocket demo</h1>
+    <input id="url" type="text" placeholder="Type URL" value="ws://localhost:8000/websocket" style="width:20em;" /> 
+    <button id="connect">connect</button>
+    <div style="height: 0.3em;">&nbsp;</div>
+    <button id="btn1">Calculate 1 + 2</button>
+    <button id="btn2">Calculate 2 * 3</button>
+    <div style="margin-top: 1em;">Event log:</div>
+    <div id="log" style="background: #eee; height: 10em; padding: 0.5em; overflow:auto;"><div>
+  </body>
+  <script src="rpc-over-websocket.js"></script>
+  <script>
+    var rpc, E = function(id) { return document.getElementById(id); };
+    var url = E('url'), connect = E('connect'), btn1 = E('btn1'), btn2 = E('btn2'), msglog = E('log');
+    var enable = function(en) { btn1.disabled = btn2.disabled = !en; url.disabled = en; connect.innerHTML = en ? 'disconnect' : 'connect'; };
+    var log = text => msglog.innerHTML += text + '<br/>\n';
+    enable(false);
+    connect.onclick = function() {
+      console.log(rpc);
+      if (rpc) { rpc.close(); rpc = null; return; }
+      rpc = jsonrpc(url.value,
+            () => enable(true),
+            () => enable(false),
+            msg => log('NOTIFICATION: ' + JSON.stringify(msg)));
+    };
+    btn1.onclick = ev => rpc.call('sum', [1, 2]).then(res => log('SUM:' + JSON.stringify(res)));
+    btn2.onclick = ev => rpc.call('mul', [2, 3]).then(res => log('MUL:' + JSON.stringify(res)));
+  </script>
+</html>

examples/json-rpc-over-websocket/web_root/rpc-over-websocket.js

@@ -0,0 +1,36 @@
+// JSON-RPC over Websocket implementation
+var JSONRPC_TIMEOUT_MS = 1000;
+
+var jsonrpc = function(url, onopen, onclose, onnotification) {
+  var rpcid = 0, pending = {}, ws = new WebSocket(url);
+  if (!ws) return null;
+  ws.onclose = onclose;
+  ws.onmessage = function(ev) {
+    const frame = JSON.parse(ev.data);
+    console.log('rcvd', frame, 'pending:', pending);
+    if (frame.id !== undefined) {
+      if (pending[frame.id] !== undefined) pending[frame.id](frame);  // Resolve
+      delete (pending[frame.id]);
+    } else {
+      if (onnotification) onnotification(frame);
+    }
+  };
+  if (onopen) onopen();
+  return {
+    close: () => ws.close(),
+    call: function(method, params) {
+      const id = rpcid++, request = {id, method, params};
+      ws.send(JSON.stringify(request));
+      console.log('sent', request);
+      return new Promise(function(resolve, reject) {
+        setTimeout(JSONRPC_TIMEOUT_MS, function() {
+          if (pending[id] === undefined) return;
+          log('Timing out frame ', JSON.stringify(request));
+          delete (pending[id]);
+          reject();
+        });
+        pending[id] = x => resolve(x);
+      });
+    },
+  };
+};

examples/websocket-server/main.c

@@ -1,10 +1,7 @@
 // Copyright (c) 2020 Cesanta Software Limited
 // All rights reserved
 //
-// Example Websocket server. Usage:
-//  1. Start this server, type `make`
-//  2. Open https://www.websocket.org/echo.html in your browser
-//  3. In the "Location" text field, type ws://127.0.0.1:8000/websocket
+// Example Websocket server. See https://mongoose.ws/tutorials/websocket-server/
 
 #include "mongoose.h"