1 /*
2 * lws-minimal-ws-client-tx
3 *
4 * Written in 2010-2019 by Andy Green <andy@warmcat.com>
5 *
6 * This file is made available under the Creative Commons CC0 1.0
7 * Universal Public Domain Dedication.
8 *
9 * This demonstrates a ws "publisher" to go with the minimal-ws-broker
10 * example.
11 *
12 * Two threads are spawned that produce messages to be sent to the broker,
13 * via a local ringbuffer. Locking is provided to make ringbuffer access
14 * threadsafe.
15 *
16 * When a nailed-up client connection to the broker is established, the
17 * ringbuffer is sent to the broker, which distributes the events to all
18 * connected clients.
19 */
20
21 #include <libwebsockets.h>
22 #include <string.h>
23 #include <signal.h>
24 #if defined(WIN32)
25 #define HAVE_STRUCT_TIMESPEC
26 #if defined(pid_t)
27 #undef pid_t
28 #endif
29 #endif
30 #include <pthread.h>
31
32 static int interrupted;
33
34 /* one of these created for each message */
35
36 struct msg {
37 void *payload; /* is malloc'd */
38 size_t len;
39 };
40
41 struct per_vhost_data__minimal {
42 struct lws_context *context;
43 struct lws_vhost *vhost;
44 const struct lws_protocols *protocol;
45 pthread_t pthread_spam[2];
46
47 lws_sorted_usec_list_t sul;
48
49 pthread_mutex_t lock_ring; /* serialize access to the ring buffer */
50 struct lws_ring *ring; /* ringbuffer holding unsent messages */
51 uint32_t tail;
52
53 struct lws_client_connect_info i;
54 struct lws *client_wsi;
55
56 int counter;
57 char finished;
58 char established;
59 };
60
61 #if defined(WIN32)
usleep(unsigned long l)62 static void usleep(unsigned long l) { Sleep(l / 1000); }
63 #endif
64
65 static void
__minimal_destroy_message(void * _msg)66 __minimal_destroy_message(void *_msg)
67 {
68 struct msg *msg = _msg;
69
70 free(msg->payload);
71 msg->payload = NULL;
72 msg->len = 0;
73 }
74
75 static void *
thread_spam(void * d)76 thread_spam(void *d)
77 {
78 struct per_vhost_data__minimal *vhd =
79 (struct per_vhost_data__minimal *)d;
80 struct msg amsg;
81 int len = 128, index = 1, n, whoami = 0;
82
83 for (n = 0; n < (int)LWS_ARRAY_SIZE(vhd->pthread_spam); n++)
84 if (pthread_equal(pthread_self(), vhd->pthread_spam[n]))
85 whoami = n + 1;
86
87 do {
88 /* don't generate output if client not connected */
89 if (!vhd->established)
90 goto wait;
91
92 pthread_mutex_lock(&vhd->lock_ring); /* --------- ring lock { */
93
94 /* only create if space in ringbuffer */
95 n = (int)lws_ring_get_count_free_elements(vhd->ring);
96 if (!n) {
97 lwsl_user("dropping!\n");
98 goto wait_unlock;
99 }
100
101 amsg.payload = malloc((unsigned int)(LWS_PRE + len));
102 if (!amsg.payload) {
103 lwsl_user("OOM: dropping\n");
104 goto wait_unlock;
105 }
106 n = lws_snprintf((char *)amsg.payload + LWS_PRE, (unsigned int)len,
107 "tid: %d, msg: %d", whoami, index++);
108 amsg.len = (unsigned int)n;
109 n = (int)lws_ring_insert(vhd->ring, &amsg, 1);
110 if (n != 1) {
111 __minimal_destroy_message(&amsg);
112 lwsl_user("dropping!\n");
113 } else
114 /*
115 * This will cause a LWS_CALLBACK_EVENT_WAIT_CANCELLED
116 * in the lws service thread context.
117 */
118 lws_cancel_service(vhd->context);
119
120 wait_unlock:
121 pthread_mutex_unlock(&vhd->lock_ring); /* } ring lock ------- */
122
123 wait:
124 usleep(100000);
125
126 } while (!vhd->finished);
127
128 lwsl_notice("thread_spam %d exiting\n", whoami);
129
130 pthread_exit(NULL);
131
132 return NULL;
133 }
134
135 static void
sul_connect_attempt(struct lws_sorted_usec_list * sul)136 sul_connect_attempt(struct lws_sorted_usec_list *sul)
137 {
138 struct per_vhost_data__minimal *vhd =
139 lws_container_of(sul, struct per_vhost_data__minimal, sul);
140
141 vhd->i.context = vhd->context;
142 vhd->i.port = 7681;
143 vhd->i.address = "localhost";
144 vhd->i.path = "/publisher";
145 vhd->i.host = vhd->i.address;
146 vhd->i.origin = vhd->i.address;
147 vhd->i.ssl_connection = 0;
148
149 vhd->i.protocol = "lws-minimal-broker";
150 vhd->i.pwsi = &vhd->client_wsi;
151
152 if (!lws_client_connect_via_info(&vhd->i))
153 lws_sul_schedule(vhd->context, 0, &vhd->sul,
154 sul_connect_attempt, 10 * LWS_US_PER_SEC);
155 }
156
157 static int
callback_minimal_broker(struct lws * wsi,enum lws_callback_reasons reason,void * user,void * in,size_t len)158 callback_minimal_broker(struct lws *wsi, enum lws_callback_reasons reason,
159 void *user, void *in, size_t len)
160 {
161 struct per_vhost_data__minimal *vhd =
162 (struct per_vhost_data__minimal *)
163 lws_protocol_vh_priv_get(lws_get_vhost(wsi),
164 lws_get_protocol(wsi));
165 const struct msg *pmsg;
166 void *retval;
167 int n, m, r = 0;
168
169 switch (reason) {
170
171 /* --- protocol lifecycle callbacks --- */
172
173 case LWS_CALLBACK_PROTOCOL_INIT:
174 vhd = lws_protocol_vh_priv_zalloc(lws_get_vhost(wsi),
175 lws_get_protocol(wsi),
176 sizeof(struct per_vhost_data__minimal));
177 vhd->context = lws_get_context(wsi);
178 vhd->protocol = lws_get_protocol(wsi);
179 vhd->vhost = lws_get_vhost(wsi);
180
181 vhd->ring = lws_ring_create(sizeof(struct msg), 8,
182 __minimal_destroy_message);
183 if (!vhd->ring)
184 return 1;
185
186 pthread_mutex_init(&vhd->lock_ring, NULL);
187
188 /* start the content-creating threads */
189
190 for (n = 0; n < (int)LWS_ARRAY_SIZE(vhd->pthread_spam); n++)
191 if (pthread_create(&vhd->pthread_spam[n], NULL,
192 thread_spam, vhd)) {
193 lwsl_err("thread creation failed\n");
194 r = 1;
195 goto init_fail;
196 }
197
198 sul_connect_attempt(&vhd->sul);
199 break;
200
201 case LWS_CALLBACK_PROTOCOL_DESTROY:
202 init_fail:
203 vhd->finished = 1;
204 for (n = 0; n < (int)LWS_ARRAY_SIZE(vhd->pthread_spam); n++)
205 pthread_join(vhd->pthread_spam[n], &retval);
206
207 if (vhd->ring)
208 lws_ring_destroy(vhd->ring);
209
210 lws_sul_cancel(&vhd->sul);
211 pthread_mutex_destroy(&vhd->lock_ring);
212
213 return r;
214
215 case LWS_CALLBACK_CLIENT_CONNECTION_ERROR:
216 lwsl_err("CLIENT_CONNECTION_ERROR: %s\n",
217 in ? (char *)in : "(null)");
218 vhd->client_wsi = NULL;
219 lws_sul_schedule(vhd->context, 0, &vhd->sul,
220 sul_connect_attempt, LWS_US_PER_SEC);
221 break;
222
223 /* --- client callbacks --- */
224
225 case LWS_CALLBACK_CLIENT_ESTABLISHED:
226 lwsl_user("%s: established\n", __func__);
227 vhd->established = 1;
228 break;
229
230 case LWS_CALLBACK_CLIENT_WRITEABLE:
231 pthread_mutex_lock(&vhd->lock_ring); /* --------- ring lock { */
232 pmsg = lws_ring_get_element(vhd->ring, &vhd->tail);
233 if (!pmsg)
234 goto skip;
235
236 /* notice we allowed for LWS_PRE in the payload already */
237 m = lws_write(wsi, ((unsigned char *)pmsg->payload) + LWS_PRE,
238 pmsg->len, LWS_WRITE_TEXT);
239 if (m < (int)pmsg->len) {
240 pthread_mutex_unlock(&vhd->lock_ring); /* } ring lock */
241 lwsl_err("ERROR %d writing to ws socket\n", m);
242 return -1;
243 }
244
245 lws_ring_consume_single_tail(vhd->ring, &vhd->tail, 1);
246
247 /* more to do for us? */
248 if (lws_ring_get_element(vhd->ring, &vhd->tail))
249 /* come back as soon as we can write more */
250 lws_callback_on_writable(wsi);
251
252 skip:
253 pthread_mutex_unlock(&vhd->lock_ring); /* } ring lock ------- */
254 break;
255
256 case LWS_CALLBACK_CLIENT_CLOSED:
257 vhd->client_wsi = NULL;
258 vhd->established = 0;
259 lws_sul_schedule(vhd->context, 0, &vhd->sul,
260 sul_connect_attempt, LWS_US_PER_SEC);
261 break;
262
263 case LWS_CALLBACK_EVENT_WAIT_CANCELLED:
264 /*
265 * When the "spam" threads add a message to the ringbuffer,
266 * they create this event in the lws service thread context
267 * using lws_cancel_service().
268 *
269 * We respond by scheduling a writable callback for the
270 * connected client, if any.
271 */
272 if (vhd && vhd->client_wsi && vhd->established)
273 lws_callback_on_writable(vhd->client_wsi);
274 break;
275
276 default:
277 break;
278 }
279
280 return lws_callback_http_dummy(wsi, reason, user, in, len);
281 }
282
283 static const struct lws_protocols protocols[] = {
284 {
285 "lws-minimal-broker",
286 callback_minimal_broker,
287 0, 0, 0, NULL, 0
288 },
289 LWS_PROTOCOL_LIST_TERM
290 };
291
292 static void
sigint_handler(int sig)293 sigint_handler(int sig)
294 {
295 interrupted = 1;
296 }
297
main(int argc,const char ** argv)298 int main(int argc, const char **argv)
299 {
300 struct lws_context_creation_info info;
301 struct lws_context *context;
302 const char *p;
303 int n = 0, logs = LLL_USER | LLL_ERR | LLL_WARN | LLL_NOTICE
304 /* for LLL_ verbosity above NOTICE to be built into lws,
305 * lws must have been configured and built with
306 * -DCMAKE_BUILD_TYPE=DEBUG instead of =RELEASE */
307 /* | LLL_INFO */ /* | LLL_PARSER */ /* | LLL_HEADER */
308 /* | LLL_EXT */ /* | LLL_CLIENT */ /* | LLL_LATENCY */
309 /* | LLL_DEBUG */;
310
311 signal(SIGINT, sigint_handler);
312
313 if ((p = lws_cmdline_option(argc, argv, "-d")))
314 logs = atoi(p);
315
316 lws_set_log_level(logs, NULL);
317 lwsl_user("LWS minimal ws client tx\n");
318 lwsl_user(" Run minimal-ws-broker and browse to that\n");
319
320 memset(&info, 0, sizeof info); /* otherwise uninitialized garbage */
321 info.port = CONTEXT_PORT_NO_LISTEN; /* we do not run any server */
322 info.protocols = protocols;
323 /*
324 * since we know this lws context is only ever going to be used with
325 * one client wsis / fds / sockets at a time, let lws know it doesn't
326 * have to use the default allocations for fd tables up to ulimit -n.
327 * It will just allocate for 1 internal and 1 (+ 1 http2 nwsi) that we
328 * will use.
329 */
330 info.fd_limit_per_thread = 1 + 1 + 1;
331
332 context = lws_create_context(&info);
333 if (!context) {
334 lwsl_err("lws init failed\n");
335 return 1;
336 }
337
338 while (n >= 0 && !interrupted)
339 n = lws_service(context, 0);
340
341 lws_context_destroy(context);
342 lwsl_user("Completed\n");
343
344 return 0;
345 }
346