2 * libwebsockets - small server side websockets and web server implementation
4 * Copyright (C) 2010-2014 Andy Green <andy@warmcat.com>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation:
9 * version 2.1 of the License.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
22 #include "private-libwebsockets.h"
24 #ifndef LWS_BUILD_HASH
25 #define LWS_BUILD_HASH "unknown-build-hash"
28 static const char *library_version = LWS_LIBRARY_VERSION " " LWS_BUILD_HASH;
31 * lws_get_library_version: get version and git hash library built from
33 * returns a const char * to a string like "1.1 178d78c"
34 * representing the library version followed by the git head hash it
38 LWS_VISIBLE const char *
39 lws_get_library_version(void)
41 return library_version;
45 * libwebsocket_create_context() - Create the websocket handler
46 * @info: pointer to struct with parameters
48 * This function creates the listening socket (if serving) and takes care
49 * of all initialization in one step.
51 * After initialization, it returns a struct libwebsocket_context * that
52 * represents this server. After calling, user code needs to take care
53 * of calling libwebsocket_service() with the context pointer to get the
54 * server's sockets serviced. This must be done in the same process
55 * context as the initialization call.
57 * The protocol callback functions are called for a handful of events
58 * including http requests coming in, websocket connections becoming
59 * established, and data arriving; it's also called periodically to allow
62 * HTTP requests are sent always to the FIRST protocol in @protocol, since
63 * at that time websocket protocol has not been negotiated. Other
64 * protocols after the first one never see any HTTP callack activity.
66 * The server created is a simple http server by default; part of the
67 * websocket standard is upgrading this http connection to a websocket one.
69 * This allows the same server to provide files like scripts and favicon /
70 * images or whatever over http and dynamic data over websockets all in
71 * one place; they're all handled in the user callback.
74 LWS_VISIBLE struct libwebsocket_context *
75 libwebsocket_create_context(struct lws_context_creation_info *info)
77 struct libwebsocket_context *context = NULL;
82 int pid_daemon = get_daemonize_pid();
84 lwsl_notice("Initial logging level %d\n", log_level);
85 lwsl_notice("Library version: %s\n", library_version);
87 if (!(info->options & LWS_SERVER_OPTION_DISABLE_IPV6))
88 lwsl_notice("IPV6 compiled in and enabled\n");
90 lwsl_notice("IPV6 compiled in but disabled\n");
92 lwsl_notice("IPV6 not compiled in\n");
94 lws_feature_status_libev(info);
95 lwsl_info(" LWS_MAX_HEADER_LEN: %u\n", LWS_MAX_HEADER_LEN);
96 lwsl_info(" LWS_MAX_PROTOCOLS: %u\n", LWS_MAX_PROTOCOLS);
98 lwsl_info(" SPEC_LATEST_SUPPORTED: %u\n", SPEC_LATEST_SUPPORTED);
99 lwsl_info(" AWAITING_TIMEOUT: %u\n", AWAITING_TIMEOUT);
100 lwsl_info(" SYSTEM_RANDOM_FILEPATH: '%s'\n", SYSTEM_RANDOM_FILEPATH);
101 lwsl_info(" LWS_MAX_ZLIB_CONN_BUFFER: %u\n", LWS_MAX_ZLIB_CONN_BUFFER);
103 if (lws_plat_context_early_init())
106 context = lws_zalloc(sizeof(struct libwebsocket_context));
108 lwsl_err("No memory for websocket context\n");
113 context->started_with_parent = pid_daemon;
114 lwsl_notice(" Started with daemon pid %d\n", pid_daemon);
117 context->listen_service_extraseen = 0;
118 context->protocols = info->protocols;
119 context->token_limits = info->token_limits;
120 context->listen_port = info->port;
121 context->http_proxy_port = 0;
122 context->http_proxy_address[0] = '\0';
123 context->options = info->options;
124 context->iface = info->iface;
125 context->ka_time = info->ka_time;
126 context->ka_interval = info->ka_interval;
127 context->ka_probes = info->ka_probes;
130 /* (Issue #264) In order to *avoid breaking backwards compatibility*, we
131 * enable libev mediated SIGINT handling with a default handler of
132 * libwebsocket_sigint_cb. The handler can be overridden or disabled
133 * by invoking libwebsocket_sigint_cfg after creating the context, but
134 * before invoking libwebsocket_initloop:
136 context->use_ev_sigint = 1;
137 context->lws_ev_sigint_cb = &libwebsocket_sigint_cb;
138 #endif /* LWS_USE_LIBEV */
141 /* to reduce this allocation, */
142 context->max_fds = getdtablesize();
143 lwsl_notice(" static allocation: %u + (%u x %u fds) = %u bytes\n",
144 sizeof(struct libwebsocket_context),
145 sizeof(struct libwebsocket_pollfd) +
146 sizeof(struct libwebsocket *),
148 sizeof(struct libwebsocket_context) +
149 ((sizeof(struct libwebsocket_pollfd) +
150 sizeof(struct libwebsocket *)) *
153 context->fds = lws_zalloc(sizeof(struct libwebsocket_pollfd) *
155 if (context->fds == NULL) {
156 lwsl_err("Unable to allocate fds array for %d connections\n",
161 if (lws_plat_init_lookup(context)) {
165 if (lws_plat_init_fd_tables(context)) {
169 lws_context_init_extensions(info, context);
171 context->user_space = info->user;
173 strcpy(context->canonical_hostname, "unknown");
175 lws_server_get_canonical_hostname(context, info);
177 /* split the proxy ads:port if given */
179 if (info->http_proxy_address) {
180 strncpy(context->http_proxy_address, info->http_proxy_address,
181 sizeof(context->http_proxy_address) - 1);
182 context->http_proxy_address[
183 sizeof(context->http_proxy_address) - 1] = '\0';
184 context->http_proxy_port = info->http_proxy_port;
186 #ifdef LWS_HAVE_GETENV
187 p = getenv("http_proxy");
189 strncpy(context->http_proxy_address, p,
190 sizeof(context->http_proxy_address) - 1);
191 context->http_proxy_address[
192 sizeof(context->http_proxy_address) - 1] = '\0';
194 p = strchr(context->http_proxy_address, ':');
196 lwsl_err("http_proxy needs to be ads:port\n");
200 context->http_proxy_port = atoi(p + 1);
205 if (context->http_proxy_address[0])
206 lwsl_notice(" Proxy %s:%u\n",
207 context->http_proxy_address,
208 context->http_proxy_port);
211 " per-conn mem: %u + %u headers + protocol rx buf\n",
212 sizeof(struct libwebsocket),
213 sizeof(struct allocated_headers));
215 if (lws_context_init_server_ssl(info, context))
218 if (lws_context_init_client_ssl(info, context))
221 if (lws_context_init_server(info, context))
225 * drop any root privs for this process
226 * to listen on port < 1023 we would have needed root, but now we are
227 * listening, we don't want the power for anything else
229 lws_plat_drop_app_privileges(info);
231 /* initialize supported protocols */
233 for (context->count_protocols = 0;
234 info->protocols[context->count_protocols].callback;
235 context->count_protocols++) {
237 lwsl_parser(" Protocol: %s\n",
238 info->protocols[context->count_protocols].name);
240 info->protocols[context->count_protocols].owning_server =
242 info->protocols[context->count_protocols].protocol_index =
243 context->count_protocols;
246 * inform all the protocols that they are doing their one-time
247 * initialization if they want to
249 info->protocols[context->count_protocols].callback(context,
250 NULL, LWS_CALLBACK_PROTOCOL_INIT, NULL, NULL, 0);
254 * give all extensions a chance to create any per-context
255 * allocations they need
258 if (info->port != CONTEXT_PORT_NO_LISTEN) {
259 if (lws_ext_callback_for_each_extension_type(context, NULL,
260 LWS_EXT_CALLBACK_SERVER_CONTEXT_CONSTRUCT,
264 if (lws_ext_callback_for_each_extension_type(context, NULL,
265 LWS_EXT_CALLBACK_CLIENT_CONTEXT_CONSTRUCT,
272 libwebsocket_context_destroy(context);
277 * libwebsocket_context_destroy() - Destroy the websocket context
278 * @context: Websocket context
280 * This function closes any active connections and then frees the
281 * context. After calling this, any further use of the context is
285 libwebsocket_context_destroy(struct libwebsocket_context *context)
287 /* Note that this is used for freeing partially allocated structs as well
288 * so make sure you don't try to free something uninitialized */
290 struct libwebsocket_protocols *protocol = NULL;
292 lwsl_notice("%s\n", __func__);
298 if (context->worst_latency_info[0])
299 lwsl_notice("Worst latency: %s\n", context->worst_latency_info);
302 for (n = 0; n < context->fds_count; n++) {
303 struct libwebsocket *wsi =
304 wsi_from_fd(context, context->fds[n].fd);
307 libwebsocket_close_and_free_session(context,
308 wsi, LWS_CLOSE_STATUS_NOSTATUS_CONTEXT_DESTROY /* no protocol close */);
313 * give all extensions a chance to clean up any per-context
314 * allocations they might have made
316 // TODO: I am not sure, but are we never supposed to be able to run a server
317 // and client at the same time for a given context?
318 // Otherwise both of these callbacks should always be called!
319 if (context->listen_port != CONTEXT_PORT_NO_LISTEN) {
320 if (lws_ext_callback_for_each_extension_type(context, NULL,
321 LWS_EXT_CALLBACK_SERVER_CONTEXT_DESTRUCT, NULL, 0) < 0) {
322 lwsl_err("Got error from server extension callback on cleanup");
325 if (lws_ext_callback_for_each_extension_type(context, NULL,
326 LWS_EXT_CALLBACK_CLIENT_CONTEXT_DESTRUCT, NULL, 0) < 0) {
327 lwsl_err("Got error from client extension callback on cleanup");
332 * inform all the protocols that they are done and will have no more
335 protocol = context->protocols;
337 while (protocol->callback) {
338 protocol->callback(context, NULL, LWS_CALLBACK_PROTOCOL_DESTROY,
344 lws_plat_context_early_destroy(context);
346 lws_ssl_context_destroy(context);
349 lws_free(context->fds);
351 lws_plat_context_late_destroy(context);