| /* |
| * ws protocol handler plugin for "lws-minimal" |
| * |
| * Copyright (C) 2010-2018 Andy Green <andy@warmcat.com> |
| * |
| * This file is made available under the Creative Commons CC0 1.0 |
| * Universal Public Domain Dedication. |
| * |
| * This version uses an lws_ring ringbuffer to cache up to 8 messages at a time, |
| * so it's not so easy to lose messages. |
| */ |
| |
| #if !defined (LWS_PLUGIN_STATIC) |
| #define LWS_DLL |
| #define LWS_INTERNAL |
| #include <libwebsockets.h> |
| #endif |
| |
| #include <string.h> |
| |
| /* one of these created for each message */ |
| |
| struct msg { |
| void *payload; /* is malloc'd */ |
| size_t len; |
| }; |
| |
| /* one of these is created for each client connecting to us */ |
| |
| struct per_session_data__minimal { |
| struct per_session_data__minimal *pss_list; |
| struct lws *wsi; |
| uint32_t tail; |
| }; |
| |
| /* one of these is created for each vhost our protocol is used with */ |
| |
| struct per_vhost_data__minimal { |
| struct lws_context *context; |
| struct lws_vhost *vhost; |
| const struct lws_protocols *protocol; |
| |
| struct per_session_data__minimal *pss_list; /* linked-list of live pss*/ |
| |
| struct lws_ring *ring; /* ringbuffer holding unsent messages */ |
| }; |
| |
| /* destroys the message when everyone has had a copy of it */ |
| |
| static void |
| __minimal_destroy_message(void *_msg) |
| { |
| struct msg *msg = _msg; |
| |
| free(msg->payload); |
| msg->payload = NULL; |
| msg->len = 0; |
| } |
| |
| static int |
| callback_minimal(struct lws *wsi, enum lws_callback_reasons reason, |
| void *user, void *in, size_t len) |
| { |
| struct per_session_data__minimal *pss = |
| (struct per_session_data__minimal *)user; |
| struct per_vhost_data__minimal *vhd = |
| (struct per_vhost_data__minimal *) |
| lws_protocol_vh_priv_get(lws_get_vhost(wsi), |
| lws_get_protocol(wsi)); |
| const struct msg *pmsg; |
| struct msg amsg; |
| uint32_t oldest; |
| 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__minimal)); |
| vhd->context = lws_get_context(wsi); |
| vhd->protocol = lws_get_protocol(wsi); |
| vhd->vhost = lws_get_vhost(wsi); |
| |
| vhd->ring = lws_ring_create(sizeof(struct msg), 8, |
| __minimal_destroy_message); |
| break; |
| |
| case LWS_CALLBACK_PROTOCOL_DESTROY: |
| lws_ring_destroy(vhd->ring); |
| break; |
| |
| case LWS_CALLBACK_ESTABLISHED: |
| /* add ourselves to the list of live pss held in the vhd */ |
| pss->pss_list = vhd->pss_list; |
| vhd->pss_list = pss; |
| pss->tail = lws_ring_get_oldest_tail(vhd->ring); |
| pss->wsi = wsi; |
| break; |
| |
| case LWS_CALLBACK_CLOSED: |
| /* remove our closing pss from the list of live pss */ |
| lws_start_foreach_llp(struct per_session_data__minimal **, |
| ppss, vhd->pss_list) { |
| if (*ppss == pss) { |
| *ppss = pss->pss_list; |
| break; |
| } |
| } lws_end_foreach_llp(ppss, pss_list); |
| break; |
| |
| case LWS_CALLBACK_SERVER_WRITEABLE: |
| pmsg = lws_ring_get_element(vhd->ring, &pss->tail); |
| if (!pmsg) |
| break; |
| |
| /* notice we allowed for LWS_PRE in the payload already */ |
| m = lws_write(wsi, pmsg->payload + LWS_PRE, pmsg->len, |
| LWS_WRITE_TEXT); |
| if (m < (int)pmsg->len) { |
| lwsl_err("ERROR %d writing to di socket\n", n); |
| return -1; |
| } |
| |
| n = lws_ring_get_oldest_tail(vhd->ring) == pss->tail; |
| lws_ring_consume(vhd->ring, &pss->tail, NULL, 1); |
| |
| if (n) { /* we may have been the oldest tail */ |
| n = 0; |
| oldest = pss->tail; |
| lws_start_foreach_llp( |
| struct per_session_data__minimal **, |
| ppss, vhd->pss_list) { |
| m = lws_ring_get_count_waiting_elements( |
| vhd->ring, &(*ppss)->tail); |
| if (m > n) { |
| n = m; |
| oldest = (*ppss)->tail; |
| } |
| } lws_end_foreach_llp(ppss, pss_list); |
| |
| /* this will delete any entries behind the new oldest */ |
| lws_ring_update_oldest_tail(vhd->ring, oldest); |
| } |
| |
| /* more to do? */ |
| if (lws_ring_get_element(vhd->ring, &pss->tail)) |
| /* come back as soon as we can write more */ |
| lws_callback_on_writable(pss->wsi); |
| break; |
| |
| case LWS_CALLBACK_RECEIVE: |
| n = (int)lws_ring_get_count_free_elements(vhd->ring); |
| if (!n) { |
| lwsl_user("dropping!\n"); |
| break; |
| } |
| |
| amsg.len = len; |
| /* notice we over-allocate by LWS_PRE */ |
| amsg.payload = malloc(LWS_PRE + len); |
| if (!amsg.payload) { |
| lwsl_user("OOM: dropping\n"); |
| break; |
| } |
| |
| memcpy((char *)amsg.payload + LWS_PRE, in, len); |
| if (!lws_ring_insert(vhd->ring, &amsg, 1)) { |
| __minimal_destroy_message(&amsg); |
| lwsl_user("dropping!\n"); |
| break; |
| } |
| |
| /* |
| * let everybody know we want to write something on them |
| * as soon as they are ready |
| */ |
| lws_start_foreach_llp(struct per_session_data__minimal **, |
| ppss, vhd->pss_list) { |
| lws_callback_on_writable((*ppss)->wsi); |
| } lws_end_foreach_llp(ppss, pss_list); |
| break; |
| |
| case LWS_CALLBACK_TIMER: |
| lwsl_notice("%s: LWS_CALLBACK_TIMER\n", __func__); |
| lws_set_timer(wsi, 3); |
| break; |
| |
| default: |
| break; |
| } |
| |
| return 0; |
| } |
| |
| #define LWS_PLUGIN_PROTOCOL_MINIMAL \ |
| { \ |
| "lws-minimal", \ |
| callback_minimal, \ |
| sizeof(struct per_session_data__minimal), \ |
| 128, \ |
| 0, NULL, 0 \ |
| } |
| |
| #if !defined (LWS_PLUGIN_STATIC) |
| |
| /* boilerplate needed if we are built as a dynamic plugin */ |
| |
| static const struct lws_protocols protocols[] = { |
| LWS_PLUGIN_PROTOCOL_MINIMAL |
| }; |
| |
| LWS_EXTERN LWS_VISIBLE int |
| init_protocol_minimal(struct lws_context *context, |
| struct lws_plugin_capability *c) |
| { |
| if (c->api_magic != LWS_PLUGIN_API_MAGIC) { |
| lwsl_err("Plugin API %d, library API %d", LWS_PLUGIN_API_MAGIC, |
| c->api_magic); |
| return 1; |
| } |
| |
| c->protocols = protocols; |
| c->count_protocols = ARRAY_SIZE(protocols); |
| c->extensions = NULL; |
| c->count_extensions = 0; |
| |
| return 0; |
| } |
| |
| LWS_EXTERN LWS_VISIBLE int |
| destroy_protocol_minimal(struct lws_context *context) |
| { |
| return 0; |
| } |
| #endif |