| /* |
| * libwebsockets-test-server - libwebsockets test implementation |
| * |
| * Copyright (C) 2010-2011 Andy Green <andy@warmcat.com> |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation: |
| * version 2.1 of the License. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
| * MA 02110-1301 USA |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include <getopt.h> |
| #include <string.h> |
| #include <sys/time.h> |
| |
| #include "../lib/libwebsockets.h" |
| |
| |
| /* |
| * This demo server shows how to use libwebsockets for one or more |
| * websocket protocols in the same server |
| * |
| * It defines the following websocket protocols: |
| * |
| * dumb-increment-protocol: once the socket is opened, an incrementing |
| * ascii string is sent down it every 50ms. |
| * If you send "reset\n" on the websocket, then |
| * the incrementing number is reset to 0. |
| * |
| * lws-mirror-protocol: copies any received packet to every connection also |
| * using this protocol, including the sender |
| */ |
| |
| enum demo_protocols { |
| /* always first */ |
| PROTOCOL_HTTP = 0, |
| |
| PROTOCOL_DUMB_INCREMENT, |
| PROTOCOL_LWS_MIRROR, |
| |
| /* always last */ |
| DEMO_PROTOCOL_COUNT |
| }; |
| |
| |
| #define LOCAL_RESOURCE_PATH DATADIR"/libwebsockets-test-server" |
| |
| /* this protocol server (always the first one) just knows how to do HTTP */ |
| |
| static int callback_http(struct libwebsocket *wsi, |
| enum libwebsocket_callback_reasons reason, void *user, |
| void *in, size_t len) |
| { |
| switch (reason) { |
| case LWS_CALLBACK_HTTP: |
| fprintf(stderr, "serving HTTP URI %s\n", (char *)in); |
| |
| if (in && strcmp(in, "/favicon.ico") == 0) { |
| if (libwebsockets_serve_http_file(wsi, |
| LOCAL_RESOURCE_PATH"/favicon.ico", "image/x-icon")) |
| fprintf(stderr, "Failed to send favicon\n"); |
| break; |
| } |
| |
| /* send the script... when it runs it'll start websockets */ |
| |
| if (libwebsockets_serve_http_file(wsi, |
| LOCAL_RESOURCE_PATH"/test.html", "text/html")) |
| fprintf(stderr, "Failed to send HTTP file\n"); |
| break; |
| |
| default: |
| break; |
| } |
| |
| return 0; |
| } |
| |
| /* dumb_increment protocol */ |
| |
| /* |
| * one of these is auto-created for each connection and a pointer to the |
| * appropriate instance is passed to the callback in the user parameter |
| * |
| * for this example protocol we use it to individualize the count for each |
| * connection. |
| */ |
| |
| struct per_session_data__dumb_increment { |
| int number; |
| }; |
| |
| static int |
| callback_dumb_increment(struct libwebsocket *wsi, |
| enum libwebsocket_callback_reasons reason, |
| void *user, void *in, size_t len) |
| { |
| int n; |
| unsigned char buf[LWS_SEND_BUFFER_PRE_PADDING + 512 + |
| LWS_SEND_BUFFER_POST_PADDING]; |
| unsigned char *p = &buf[LWS_SEND_BUFFER_PRE_PADDING]; |
| struct per_session_data__dumb_increment *pss = user; |
| |
| switch (reason) { |
| |
| case LWS_CALLBACK_ESTABLISHED: |
| pss->number = 0; |
| break; |
| |
| /* |
| * in this protocol, we just use the broadcast action as the chance to |
| * send our own connection-specific data and ignore the broadcast info |
| * that is available in the 'in' parameter |
| */ |
| |
| case LWS_CALLBACK_BROADCAST: |
| n = sprintf((char *)p, "%d", pss->number++); |
| n = libwebsocket_write(wsi, p, n, LWS_WRITE_TEXT); |
| if (n < 0) { |
| fprintf(stderr, "ERROR writing to socket"); |
| return 1; |
| } |
| break; |
| |
| case LWS_CALLBACK_RECEIVE: |
| fprintf(stderr, "rx %d\n", (int)len); |
| if (len < 6) |
| break; |
| if (strcmp(in, "reset\n") == 0) |
| pss->number = 0; |
| break; |
| |
| default: |
| break; |
| } |
| |
| return 0; |
| } |
| |
| |
| /* lws-mirror_protocol */ |
| |
| #define MAX_MESSAGE_QUEUE 64 |
| |
| struct per_session_data__lws_mirror { |
| struct libwebsocket *wsi; |
| int ringbuffer_tail; |
| }; |
| |
| struct a_message { |
| void *payload; |
| size_t len; |
| }; |
| |
| static struct a_message ringbuffer[MAX_MESSAGE_QUEUE]; |
| static int ringbuffer_head; |
| |
| |
| static int |
| callback_lws_mirror(struct libwebsocket *wsi, |
| enum libwebsocket_callback_reasons reason, |
| void *user, void *in, size_t len) |
| { |
| int n; |
| struct per_session_data__lws_mirror *pss = user; |
| |
| switch (reason) { |
| |
| case LWS_CALLBACK_ESTABLISHED: |
| pss->ringbuffer_tail = ringbuffer_head; |
| pss->wsi = wsi; |
| break; |
| |
| case LWS_CALLBACK_CLIENT_WRITEABLE: |
| if (pss->ringbuffer_tail != ringbuffer_head) { |
| |
| n = libwebsocket_write(wsi, (unsigned char *) |
| ringbuffer[pss->ringbuffer_tail].payload + |
| LWS_SEND_BUFFER_PRE_PADDING, |
| ringbuffer[pss->ringbuffer_tail].len, |
| LWS_WRITE_TEXT); |
| if (n < 0) { |
| fprintf(stderr, "ERROR writing to socket"); |
| exit(1); |
| } |
| |
| if (pss->ringbuffer_tail == (MAX_MESSAGE_QUEUE - 1)) |
| pss->ringbuffer_tail = 0; |
| else |
| pss->ringbuffer_tail++; |
| |
| if (((ringbuffer_head - pss->ringbuffer_tail) % |
| MAX_MESSAGE_QUEUE) < (MAX_MESSAGE_QUEUE - 15)) |
| libwebsocket_rx_flow_control(wsi, 1); |
| |
| libwebsocket_callback_on_writable(wsi); |
| |
| } |
| break; |
| |
| case LWS_CALLBACK_BROADCAST: |
| n = libwebsocket_write(wsi, in, len, LWS_WRITE_TEXT); |
| if (n < 0) |
| fprintf(stderr, "mirror write failed\n"); |
| break; |
| |
| case LWS_CALLBACK_RECEIVE: |
| |
| if (ringbuffer[ringbuffer_head].payload) |
| free(ringbuffer[ringbuffer_head].payload); |
| |
| ringbuffer[ringbuffer_head].payload = |
| malloc(LWS_SEND_BUFFER_PRE_PADDING + len + |
| LWS_SEND_BUFFER_POST_PADDING); |
| ringbuffer[ringbuffer_head].len = len; |
| memcpy((char *)ringbuffer[ringbuffer_head].payload + |
| LWS_SEND_BUFFER_PRE_PADDING, in, len); |
| if (ringbuffer_head == (MAX_MESSAGE_QUEUE - 1)) |
| ringbuffer_head = 0; |
| else |
| ringbuffer_head++; |
| |
| if (((ringbuffer_head - pss->ringbuffer_tail) % |
| MAX_MESSAGE_QUEUE) > (MAX_MESSAGE_QUEUE - 10)) |
| libwebsocket_rx_flow_control(wsi, 0); |
| |
| libwebsocket_callback_on_writable_all_protocol( |
| libwebsockets_get_protocol(wsi)); |
| break; |
| |
| default: |
| break; |
| } |
| |
| return 0; |
| } |
| |
| |
| /* list of supported protocols and callbacks */ |
| |
| static struct libwebsocket_protocols protocols[] = { |
| /* first protocol must always be HTTP handler */ |
| [PROTOCOL_HTTP] = { |
| .name = "http-only", |
| .callback = callback_http, |
| }, |
| [PROTOCOL_DUMB_INCREMENT] = { |
| .name = "dumb-increment-protocol", |
| .callback = callback_dumb_increment, |
| .per_session_data_size = |
| sizeof(struct per_session_data__dumb_increment), |
| }, |
| [PROTOCOL_LWS_MIRROR] = { |
| .name = "lws-mirror-protocol", |
| .callback = callback_lws_mirror, |
| .per_session_data_size = |
| sizeof(struct per_session_data__lws_mirror), |
| }, |
| [DEMO_PROTOCOL_COUNT] = { /* end of list */ |
| .callback = NULL |
| } |
| }; |
| |
| static struct option options[] = { |
| { "help", no_argument, NULL, 'h' }, |
| { "port", required_argument, NULL, 'p' }, |
| { "ssl", no_argument, NULL, 's' }, |
| { NULL, 0, 0, 0 } |
| }; |
| |
| int main(int argc, char **argv) |
| { |
| int n = 0; |
| const char *cert_path = |
| LOCAL_RESOURCE_PATH"/libwebsockets-test-server.pem"; |
| const char *key_path = |
| LOCAL_RESOURCE_PATH"/libwebsockets-test-server.key.pem"; |
| unsigned char buf[LWS_SEND_BUFFER_PRE_PADDING + 1024 + |
| LWS_SEND_BUFFER_POST_PADDING]; |
| int port = 7681; |
| int use_ssl = 0; |
| struct libwebsocket_context *context; |
| #ifdef LWS_NO_FORK |
| unsigned int oldus = 0; |
| #endif |
| |
| fprintf(stderr, "libwebsockets test server\n" |
| "(C) Copyright 2010-2011 Andy Green <andy@warmcat.com> " |
| "licensed under LGPL2.1\n"); |
| |
| while (n >= 0) { |
| n = getopt_long(argc, argv, "hsp:", options, NULL); |
| if (n < 0) |
| continue; |
| switch (n) { |
| case 's': |
| use_ssl = 1; |
| break; |
| case 'p': |
| port = atoi(optarg); |
| break; |
| case 'h': |
| fprintf(stderr, "Usage: test-server " |
| "[--port=<p>] [--ssl]\n"); |
| exit(1); |
| } |
| } |
| |
| if (!use_ssl) |
| cert_path = key_path = NULL; |
| |
| context = libwebsocket_create_context(port, protocols, cert_path, |
| key_path, -1, -1); |
| if (context == NULL) { |
| fprintf(stderr, "libwebsocket init failed\n"); |
| return -1; |
| } |
| |
| buf[LWS_SEND_BUFFER_PRE_PADDING] = 'x'; |
| |
| #ifdef LWS_NO_FORK |
| |
| /* |
| * This example shows how to work with no forked service loop |
| */ |
| |
| fprintf(stderr, " Using no-fork service loop\n"); |
| |
| while (1) { |
| struct timeval tv; |
| |
| gettimeofday(&tv, NULL); |
| |
| /* |
| * This broadcasts to all dumb-increment-protocol connections |
| * at 20Hz. |
| * |
| * We're just sending a character 'x', in these examples the |
| * callbacks send their own per-connection content. |
| * |
| * You have to send something with nonzero length to get the |
| * callback actions delivered. |
| * |
| * We take care of pre-and-post padding allocation. |
| */ |
| |
| if (((unsigned int)tv.tv_usec - oldus) > 50000) { |
| libwebsockets_broadcast( |
| &protocols[PROTOCOL_DUMB_INCREMENT], |
| &buf[LWS_SEND_BUFFER_PRE_PADDING], 1); |
| oldus = tv.tv_usec; |
| } |
| |
| /* |
| * This example server does not fork or create a thread for |
| * websocket service, it all runs in this single loop. So, |
| * we have to give the websockets an opportunity to service |
| * "manually". |
| * |
| * If no socket is needing service, the call below returns |
| * immediately and quickly. |
| */ |
| |
| libwebsocket_service(context, 50); |
| } |
| |
| #else |
| |
| /* |
| * This example shows how to work with the forked websocket service loop |
| */ |
| |
| fprintf(stderr, " Using forked service loop\n"); |
| |
| /* |
| * This forks the websocket service action into a subprocess so we |
| * don't have to take care about it. |
| */ |
| |
| n = libwebsockets_fork_service_loop(context); |
| if (n < 0) { |
| fprintf(stderr, "Unable to fork service loop %d\n", n); |
| return 1; |
| } |
| |
| while (1) { |
| |
| usleep(50000); |
| |
| /* |
| * This broadcasts to all dumb-increment-protocol connections |
| * at 20Hz. |
| * |
| * We're just sending a character 'x', in these examples the |
| * callbacks send their own per-connection content. |
| * |
| * You have to send something with nonzero length to get the |
| * callback actions delivered. |
| * |
| * We take care of pre-and-post padding allocation. |
| */ |
| |
| libwebsockets_broadcast(&protocols[PROTOCOL_DUMB_INCREMENT], |
| &buf[LWS_SEND_BUFFER_PRE_PADDING], 1); |
| } |
| |
| #endif |
| |
| libwebsocket_context_destroy(context); |
| |
| return 0; |
| } |