7 1) The info struct gained two new members
9 - max_http_header_data: 0 for default (1024) or set the maximum amount of known
10 http header payload that lws can deal with. Payload in unknown http
11 headers is dropped silently. If for some reason you need to send huge
12 cookies or other HTTP-level headers, you can now increase this at context-
15 - max_http_header_pool: 0 for default (16) or set the maximum amount of http
16 headers that can be tracked by lws in this context. For the server, if
17 the header pool is completely in use then accepts on the listen socket
18 are disabled until one becomes free. For the client, if you simultaneously
19 have pending connects for more than this number of client connections,
20 additional connects will fail until some of the pending connections timeout
23 HTTP header processing in lws only exists until just after the first main
24 callback after the HTTP handshake... for ws connections that is ESTABLISHED and
25 for HTTP connections the HTTP callback.
27 So these settings are not related to the maximum number of simultaneous
28 connections, but the number of HTTP handshakes that may be expected or ongoing,
29 or have just completed, at one time. The reason it's useful is it changes the
30 memory allocation for header processing to be one-time at context creation
31 instead of every time there is a new connection, and gives you control over
34 Setting max_http_header_pool to 1 is fine it will just queue incoming
35 connections before the accept as necessary, you can still have as many
36 simultaneous post-header connections as you like.
41 1) LWS_SEND_BUFFER_POST_PADDING is now 0 and deprecated. You can remove it; if
42 you still use it, obviously it does nothing. Old binary code with nonzero
43 LWS_SEND_BUFFER_POST_PADDING is perfectly compatible, the old code just
44 allocated a buffer bigger than needed.
46 The example apps no longer user it.
48 The only path who made use of it was sending with LWS_WRITE_CLOSE.
50 If you use LWS_WRITE_CLOSE by hand in your user code, you need to allow an
51 extra 2 bytes space at the end of your buffer. This ONLY applies to
52 LWS_WRITE_CLOSE, which you normally don't send directly, but cause by returning
53 nonzero from a callback letting the library actually send it.
57 v1.6.0-chrome48-firefox42
58 =======================
60 Major API improvements
61 ----------------------
63 v1.6.0 has many cleanups and improvements in the API. Although at first it
64 looks pretty drastic, user code will only need four actions to update it.
66 - Do the three search/replaces in your user code, /libwebsocket_/lws_/,
67 /libwebsockets_/lws_/, and /struct\ libwebsocket/struct\ lws/
69 - Remove the context parameter from your user callbacks
71 - Remove context as the first parameter from the "Eleven APIS" listed in the
72 User Api Changes section
74 - Add lws_get_context(wsi) as the first parameter on the "Three APIS" listed
75 in the User Api Changes section, and anywhere else you still need context
77 That's it... generally only a handful of the 14 affected APIs are actually in
78 use in your user code and you can find them quickest by compiling and visiting
79 the errors each in turn. And the end results are much cleaner, more
80 predictable and maintainable.
86 1) lws now exposes his internal platform file abstraction in a way that can be
87 both used by user code to make it platform-agnostic, and be overridden or
88 subclassed by user code. This allows things like handling the URI "directory
89 space" as a virtual filesystem that may or may not be backed by a regular
90 filesystem. One example use is serving files from inside large compressed
91 archive storage without having to unpack anything except the file being
94 The test server shows how to use it, basically the platform-specific part of
95 lws prepares a file operations structure that lives in the lws context.
97 Helpers are provided to also leverage these platform-independent file handling
100 static inline lws_filefd_type
101 lws_plat_file_open(struct lws *wsi, const char *filename,
102 unsigned long *filelen, int flags)
104 lws_plat_file_close(struct lws *wsi, lws_filefd_type fd)
106 static inline unsigned long
107 lws_plat_file_seek_cur(struct lws *wsi, lws_filefd_type fd, long offset)
110 lws_plat_file_read(struct lws *wsi, lws_filefd_type fd, unsigned long *amount,
111 unsigned char *buf, unsigned long len)
114 lws_plat_file_write(struct lws *wsi, lws_filefd_type fd, unsigned long *amount,
115 unsigned char *buf, unsigned long len)
117 The user code can also override or subclass the file operations, to either
118 wrap or replace them. An example is shown in test server.
120 A wsi can be associated with the file activity, allowing per-connection
121 authentication and state to be used when interpreting the file request.
123 2) A new API void * lws_wsi_user(struct lws *wsi) lets you get the pointer to
124 the user data associated with the wsi, just from the wsi.
126 3) URI argument handling. Libwebsockets parses and protects URI arguments
127 like test.html?arg1=1&arg2=2, it decodes %xx uriencoding format and reduces
128 path attacks like ../.../../etc/passwd so they cannot go behind the web
129 server's /. There is a list of confirmed attacks we're proof against in
130 ./test-server/attack.sh.
132 There is a new API lws_hdr_copy_fragment that should be used now to access
133 the URI arguments (it returns the fragments length)
135 while (lws_hdr_copy_fragment(wsi, buf, sizeof(buf),
136 WSI_TOKEN_HTTP_URI_ARGS, n) > 0) {
137 lwsl_info("URI Arg %d: %s\n", ++n, buf);
140 For the example above, calling with n=0 will return "arg1=1" and n=1 "arg2=2".
141 All legal uriencodings will have been reduced in those strings.
143 lws_hdr_copy_fragment() returns the length of the x=y fragment, so it's also
144 possible to deal with arguments containing %00. If you don't care about that,
145 the returned string has '\0' appended to simplify processing.
153 - lws_callback_on_writable_all_protocol(const struct lws_protocols *protocol)
154 - lws_callback_all_protocol(const struct lws_protocols *protocol)
155 - lws_rx_flow_allow_all_protocol(lws_rx_flow_allow_all_protocol)
157 Now take an additional pointer to the lws_context in their first argument.
159 The reason for this change is struct lws_protocols has been changed to remove
160 members that lws used for private storage: so the protocols struct in now
161 truly const and may be reused serially or simultaneously by different contexts.
165 LWS_VISIBLE LWS_EXTERN int
166 lws_add_http_header_by_name(struct lws_context *context,
168 const unsigned char *name,
169 const unsigned char *value,
173 LWS_VISIBLE LWS_EXTERN int
174 lws_finalize_http_header(struct lws_context *context,
178 LWS_VISIBLE LWS_EXTERN int
179 lws_add_http_header_by_token(struct lws_context *context,
181 enum lws_token_indexes token,
182 const unsigned char *value,
186 LWS_VISIBLE LWS_EXTERN int
187 lws_add_http_header_content_length(struct lws_context *context,
189 unsigned long content_length,
192 LWS_VISIBLE LWS_EXTERN int
193 lws_add_http_header_status(struct lws_context *context, struct lws *wsi,
194 unsigned int code, unsigned char **p,
197 LWS_VISIBLE LWS_EXTERN int
198 lws_serve_http_file(struct lws_context *context, struct lws *wsi,
199 const char *file, const char *content_type,
200 const char *other_headers, int other_headers_len);
201 LWS_VISIBLE LWS_EXTERN int
202 lws_serve_http_file_fragment(struct lws_context *context, struct lws *wsi);
204 LWS_VISIBLE LWS_EXTERN int
205 lws_return_http_status(struct lws_context *context, struct lws *wsi,
206 unsigned int code, const char *html_body);
208 LWS_VISIBLE LWS_EXTERN int
209 lws_callback_on_writable(const struct lws_context *context, struct lws *wsi);
211 LWS_VISIBLE LWS_EXTERN void
212 lws_get_peer_addresses(struct lws_context *context, struct lws *wsi,
213 lws_sockfd_type fd, char *name, int name_len,
214 char *rip, int rip_len);
216 LWS_VISIBLE LWS_EXTERN int
217 lws_read(struct lws_context *context, struct lws *wsi,
218 unsigned char *buf, size_t len);
220 no longer require their initial struct lws_context * parameter.
222 3) Several older apis start with libwebsocket_ or libwebsockets_ while newer ones
223 all begin lws_. These apis have been changed to all begin with lws_.
225 To convert, search-replace
227 - libwebsockets_/lws_
229 - struct\ libwebsocket/struct\ lws
231 4) context parameter removed from user callback.
233 Since almost all apis no longer need the context as a parameter, it's no longer
234 provided at the user callback directly.
236 However if you need it, for ALL callbacks wsi is valid and has a valid context
237 pointer you can recover using lws_get_context(wsi).
240 v1.5-chrome47-firefox41
241 =======================
246 LWS_CALLBACK_CLIENT_CONNECTION_ERROR may provide an error string if in is
247 non-NULL. If so, the string has length len.
249 LWS_SERVER_OPTION_PEER_CERT_NOT_REQUIRED is available to relax the requirement
250 for peer certs if you are using the option to require client certs.
252 LWS_WITHOUT_BUILTIN_SHA1 cmake option forces lws to use SHA1() defined
253 externally, eg, byOpenSSL, and disables build of libwebsockets_SHA1()
256 v1.4-chrome43-firefox36
257 =======================
262 There's a new member in the info struct used to control context creation,
263 ssl_private_key_password, which allows passing into lws the passphrase on
266 There's a new member in struct protocols, id, which is ignored by lws but can
267 be used by the user code to mark the selected protocol by user-defined version
268 or capabliity flag information, for the case multiple versions of a protocol are
271 int lws_is_ssl(wsi) added to allow user code to know if the connection was made
272 over ssl or not. If LWS_SERVER_OPTION_ALLOW_NON_SSL_ON_SSL_PORT is used, both
273 ssl and non-ssl connections are possible and may need to be treated differently
276 int lws_partial_buffered(wsi) added... should be checked after any
277 libwebsocket_write that will be followed by another libwebsocket_write inside
278 the same writeable callback. If set, you can't do any more writes until the
279 writeable callback is called again. If you only do one write per writeable callback,
282 HTTP2-related: HTTP2 changes how headers are handled, lws now has new version-
283 agnositic header creation APIs. These do the right thing depending on each
284 connection's HTTP version without the user code having to know or care, except
285 to make sure to use the new APIs for headers (test-server is updated to use
286 them already, so look there for examples)
288 The APIs "render" the headers into a user-provided buffer and bump *p as it
289 is used. If *p reaches end, then the APIs return nonzero for error.
291 LWS_VISIBLE LWS_EXTERN int
292 lws_add_http_header_status(struct libwebsocket_context *context,
293 struct libwebsocket *wsi,
298 Start a response header reporting status like 200, 500, etc
300 LWS_VISIBLE LWS_EXTERN int
301 lws_add_http_header_by_name(struct libwebsocket_context *context,
302 struct libwebsocket *wsi,
303 const unsigned char *name,
304 const unsigned char *value,
309 Add a header like name: value in HTTP1.x
311 LWS_VISIBLE LWS_EXTERN int
312 lws_finalize_http_header(struct libwebsocket_context *context,
313 struct libwebsocket *wsi,
317 Finish off the headers, like add the extra \r\n in HTTP1.x
319 LWS_VISIBLE LWS_EXTERN int
320 lws_add_http_header_by_token(struct libwebsocket_context *context,
321 struct libwebsocket *wsi,
322 enum lws_token_indexes token,
323 const unsigned char *value,
328 Add a header by using a lws token as the name part. In HTTP2, this can be
329 compressed to one or two bytes.
335 protocols struct member no_buffer_all_partial_tx is removed. Under some
336 conditions like rewriting extension such as compression in use, the built-in
337 partial send buffering is the only way to deal with the problem, so turning
338 it off is deprecated.
344 HTTP2-related: API libwebsockets_serve_http_file() takes an extra parameter at
347 int other_headers_len)
349 If you are providing other headers, they must be generated using the new
350 HTTP-version-agnostic APIs, and you must provide the length of them using this
351 additional parameter.
353 struct lws_context_creation_info now has an additional member
354 SSL_CTX *provided_client_ssl_ctx you may set to an externally-initialized
355 SSL_CTX managed outside lws. Defaulting to zero keeps the existing behaviour of
356 lws managing the context, if you memset the struct to 0 or have as a filescope
357 initialized struct in bss, no need to change anything.
360 v1.3-chrome37-firefox30
361 =======================
364 CMakeLists.txt | 447 +++--
368 cmake/LibwebsocketsConfig.cmake.in | 17 +
369 cmake/LibwebsocketsConfigVersion.cmake.in | 11 +
370 config.h.cmake | 18 +
371 cross-ming.cmake | 31 +
372 cross-openwrt-makefile | 91 +
373 lib/client-handshake.c | 205 ++-
374 lib/client-parser.c | 58 +-
375 lib/client.c | 158 +-
376 lib/context.c | 341 ++++
377 lib/extension-deflate-frame.c | 2 +-
378 lib/extension.c | 178 ++
379 lib/handshake.c | 287 +---
380 lib/lextable.h | 338 ++++
382 lib/libwebsockets.c | 2089 +++--------------------
383 lib/libwebsockets.h | 253 ++-
384 lib/lws-plat-unix.c | 404 +++++
385 lib/lws-plat-win.c | 358 ++++
386 lib/minilex.c | 530 +++---
387 lib/output.c | 445 ++---
388 lib/parsers.c | 682 ++++----
389 lib/pollfd.c | 239 +++
390 lib/private-libwebsockets.h | 501 +++++-
391 lib/server-handshake.c | 274 +--
392 lib/server.c | 858 ++++++++--
393 lib/service.c | 517 ++++++
395 lib/ssl-http2.c | 78 +
396 lib/ssl.c | 571 +++++++
397 test-server/attack.sh | 101 +-
398 test-server/test-client.c | 9 +-
399 test-server/test-echo.c | 17 +-
400 test-server/test-fraggle.c | 7 -
401 test-server/test-ping.c | 12 +-
402 test-server/test-server.c | 330 ++--
403 test-server/test.html | 4 +-
404 win32port/client/client.vcxproj | 259 ---
405 win32port/client/client.vcxproj.filters | 39 -
406 .../libwebsocketswin32.vcxproj.filters | 93 -
407 win32port/server/server.vcxproj | 276 ---
408 win32port/server/server.vcxproj.filters | 51 -
409 win32port/win32helpers/gettimeofday.h | 59 +-
410 win32port/win32helpers/netdb.h | 1 -
411 win32port/win32helpers/strings.h | 0
412 win32port/win32helpers/sys/time.h | 1 -
413 win32port/win32helpers/unistd.h | 0
414 win32port/win32helpers/websock-w32.c | 104 --
415 win32port/win32helpers/websock-w32.h | 62 -
416 win32port/win32port.sln | 100 --
417 win32port/zlib/gzio.c | 3 +-
418 55 files changed, 6779 insertions(+), 5059 deletions(-)
424 POST method is supported
426 The protocol 0 / HTTP callback can now get two new kinds of callback,
427 LWS_CALLBACK_HTTP_BODY (in and len are a chunk of the body of the HTTP request)
428 and LWS_CALLBACK_HTTP_BODY_COMPLETION (the expected amount of body has arrived
429 and been passed to the user code already). These callbacks are used with the
430 post method (see the test server for details).
432 The period between the HTTP header completion and the completion of the body
433 processing is protected by a 5s timeout.
435 The chunks are stored in a malloc'd buffer of size protocols[0].rx_buffer_size.
438 New server option you can enable from user code
439 LWS_SERVER_OPTION_ALLOW_NON_SSL_ON_SSL_PORT allows non-SSL connections to
440 also be accepted on an SSL listening port. It's disabled unless you enable
444 Two new callbacks are added in protocols[0] that are optional for allowing
445 limited thread access to libwebsockets, LWS_CALLBACK_LOCK_POLL and
446 LWS_CALLBACK_UNLOCK_POLL.
448 If you use them, they protect internal and external poll list changes, but if
449 you want to use external thread access to libwebsocket_callback_on_writable()
450 you have to implement your locking here even if you don't use external
453 If you will use another thread for this, take a lot of care about managing
454 your list of live wsi by doing it from ESTABLISHED and CLOSED callbacks
455 (with your own locking).
457 If you configure cmake with -DLWS_WITH_LIBEV=1 then the code allowing the libev
458 eventloop instead of the default poll() one will also be compiled in. But to
459 use it, you must also set the LWS_SERVER_OPTION_LIBEV flag on the context
460 creation info struct options member.
462 IPV6 is supported and enabled by default except for Windows, you can disable
463 the support at build-time by giving -DLWS_IPV6=, and disable use of it even if
464 compiled in by making sure the flag LWS_SERVER_OPTION_DISABLE_IPV6 is set on
465 the context creation info struct options member.
467 You can give LWS_SERVER_OPTION_DISABLE_OS_CA_CERTS option flag to
468 guarantee the OS CAs will not be used, even if that support was selected at
471 Optional "token limits" may be enforced by setting the member "token_limits"
472 in struct lws_context_creation_info to point to a struct lws_token_limits.
473 NULL means no token limits used for compatibility.
479 Extra optional argument to libwebsockets_serve_http_file() allows injecion
480 of HTTP headers into the canned response. Eg, cookies may be added like
481 that without getting involved in having to send the header by hand.
483 A new info member http_proxy_address may be used at context creation time to
484 set the http proxy. If non-NULL, it overrides http_proxy environment var.
486 Cmake supports LWS_SSL_CLIENT_USE_OS_CA_CERTS defaulting to on, which gets
487 the client to use the OS CA Roots. If you're worried somebody with the
488 ability to forge for force creation of a client cert from the root CA in
489 your OS, you should disable this since your selfsigned $0 cert is a lot safer
493 v1.23-chrome32-firefox24
494 ========================
497 CMakeLists.txt | 573 ++++++++----
498 COPYING | 503 -----------
499 INSTALL | 365 --------
501 README.build | 371 ++------
502 README.coding | 63 ++
503 autogen.sh | 1578 ---------------------------------
505 cmake/FindGit.cmake | 163 ++++
506 cmake/FindOpenSSLbins.cmake | 15 +-
507 cmake/UseRPMTools.cmake | 176 ++++
508 config.h.cmake | 25 +-
509 configure.ac | 226 -----
510 cross-arm-linux-gnueabihf.cmake | 28 +
511 lib/Makefile.am | 89 --
512 lib/base64-decode.c | 98 +-
513 lib/client-handshake.c | 123 ++-
514 lib/client-parser.c | 19 +-
515 lib/client.c | 145 ++-
516 lib/daemonize.c | 4 +-
517 lib/extension.c | 2 +-
518 lib/getifaddrs.h | 4 +-
519 lib/handshake.c | 76 +-
520 lib/libwebsockets.c | 491 ++++++----
521 lib/libwebsockets.h | 164 ++--
522 lib/output.c | 214 ++++-
523 lib/parsers.c | 102 +--
524 lib/private-libwebsockets.h | 66 +-
525 lib/server-handshake.c | 5 +-
528 libwebsockets-api-doc.html | 249 +++---
529 libwebsockets.pc.in | 11 -
530 libwebsockets.spec | 14 +-
532 scripts/FindLibWebSockets.cmake | 33 +
533 scripts/kernel-doc | 1 +
534 test-server/Makefile.am | 131 ---
535 test-server/leaf.jpg | Bin 0 -> 2477518 bytes
536 test-server/test-client.c | 78 +-
537 test-server/test-echo.c | 33 +-
538 test-server/test-fraggle.c | 26 +-
539 test-server/test-ping.c | 15 +-
540 test-server/test-server.c | 197 +++-
541 test-server/test.html | 5 +-
542 win32port/win32helpers/gettimeofday.c | 74 +-
543 win32port/win32helpers/websock-w32.h | 6 +-
544 48 files changed, 2493 insertions(+), 4212 deletions(-)
550 - You can now call libwebsocket_callback_on_writable() on http connectons,
551 and get a LWS_CALLBACK_HTTP_WRITEABLE callback, the same way you can
552 regulate writes with a websocket protocol connection.
554 - A new member in the context creation parameter struct "ssl_cipher_list" is
555 added, replacing CIPHERS_LIST_STRING. NULL means use the ssl library
556 default list of ciphers.
558 - Not really an api addition, but libwebsocket_service_fd() will now zero
559 the revents field of the pollfd it was called with if it handled the
560 descriptor. So you can tell if it is a non-lws fd by checking revents
561 after the service call... if it's still nonzero, the descriptor
562 belongs to you and you need to take care of it.
564 - libwebsocket_rx_flow_allow_all_protocol(protocol) will unthrottle all
565 connections with the established protocol. It's designed to be
566 called from user server code when it sees it can accept more input
567 and may have throttled connections using the server rx flow apis
568 while it was unable to accept any other input The user server code
569 then does not have to try to track while connections it choked, this
570 will free up all of them in one call.
572 - there's a new, optional callback LWS_CALLBACK_CLOSED_HTTP which gets
573 called when an HTTP protocol socket closes
575 - for LWS_CALLBACK_FILTER_PROTOCOL_CONNECTION callback, the user_space alloc
576 has already been done before the callback happens. That means we can
577 use the user parameter to the callback to contain the user pointer, and
578 move the protocol name to the "in" parameter. The docs for this
579 callback are also updated to reflect how to check headers in there.
581 - libwebsocket_client_connect() is now properly nonblocking and async. See
582 README.coding and test-client.c for information on the callbacks you
583 can rely on controlling the async connection period with.
585 - if your OS does not support the http_proxy environment variable convention
586 (eg, reportedly OSX), you can use a new api libwebsocket_set_proxy()
587 to set the proxy details in between context creation and the connection
588 action. For OSes that support http_proxy, that's used automatically.
593 - the external poll callbacks now get the socket descriptor coming from the
594 "in" parameter. The user parameter provides the user_space for the
595 wsi as it normally does on the other callbacks.
596 LWS_CALLBACK_FILTER_NETWORK_CONNECTION also has the socket descriptor
597 delivered by @in now instead of @user.
599 - libwebsocket_write() now returns -1 for error, or the amount of data
600 actually accepted for send. Under load, the OS may signal it is
601 ready to send new data on the socket, but have only a restricted
602 amount of memory to buffer the packet compared to usual.
608 - libwebsocket_ensure_user_space() is removed from the public api, if you
609 were using it to get user_space, you need to adapt your code to only
610 use user_space inside the user callback.
612 - CIPHERS_LIST_STRING is removed
614 - autotools build has been removed. See README.build for info on how to
615 use CMake for your platform
618 v1.21-chrome26-firefox18
619 ========================
621 - Fixes buffer overflow bug in max frame size handling if you used the
622 default protocol buffer size. If you declared rx_buffer_size in your
623 protocol, which is recommended anyway, your code was unaffected.
625 v1.2-chrome26-firefox18
626 =======================
632 CMakeLists.txt | 544 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
633 LICENSE | 526 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
636 README.build | 258 ++++++++++++++++++++++++++++++++-----
637 README.coding | 52 ++++++++
638 changelog | 136 ++++++++++++++++++++
639 cmake/FindOpenSSLbins.cmake | 33 +++++
640 config.h.cmake | 173 +++++++++++++++++++++++++
641 configure.ac | 22 +++-
642 lib/Makefile.am | 20 ++-
643 lib/base64-decode.c | 2 +-
644 lib/client-handshake.c | 190 +++++++++++-----------------
645 lib/client-parser.c | 88 +++++++------
646 lib/client.c | 384 ++++++++++++++++++++++++++++++-------------------------
647 lib/daemonize.c | 32 +++--
648 lib/extension-deflate-frame.c | 58 +++++----
649 lib/extension-deflate-stream.c | 19 ++-
650 lib/extension-deflate-stream.h | 4 +-
651 lib/extension.c | 11 +-
652 lib/getifaddrs.c | 315 +++++++++++++++++++++++-----------------------
653 lib/getifaddrs.h | 30 ++---
654 lib/handshake.c | 124 +++++++++++-------
655 lib/libwebsockets.c | 736 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------------------
656 lib/libwebsockets.h | 237 ++++++++++++++++++++++------------
657 lib/output.c | 192 +++++++++++-----------------
658 lib/parsers.c | 966 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----------------------------------------------------------------
659 lib/private-libwebsockets.h | 225 +++++++++++++++++++++------------
660 lib/server-handshake.c | 82 ++++++------
661 lib/server.c | 96 +++++++-------
662 libwebsockets-api-doc.html | 189 ++++++++++++++++++----------
663 libwebsockets.spec | 17 +--
664 test-server/attack.sh | 148 ++++++++++++++++++++++
665 test-server/test-client.c | 125 +++++++++---------
666 test-server/test-echo.c | 31 +++--
667 test-server/test-fraggle.c | 32 ++---
668 test-server/test-ping.c | 52 ++++----
669 test-server/test-server.c | 129 ++++++++++++-------
670 win32port/libwebsocketswin32/libwebsocketswin32.vcxproj | 279 ----------------------------------------
671 win32port/libwebsocketswin32/libwebsocketswin32.vcxproj.filters | 23 +++-
672 41 files changed, 4398 insertions(+), 2219 deletions(-)
678 - lws_get_library_version() returns a const char * with a string like
679 "1.1 9e7f737", representing the library version from configure.ac
680 and the git HEAD hash the library was built from
682 - TCP Keepalive can now optionally be applied to all lws sockets, on Linux
683 also with controllable timeout, number of probes and probe interval.
684 (On BSD type OS, you can only use system default settings for the
685 timing and retries, although enabling it is supported by setting
686 ka_time to nonzero, the exact value has no meaning.)
687 This enables detection of idle connections which are logically okay,
688 but are in fact dead, due to network connectivity issues at the server,
689 client, or any intermediary. By default it's not enabled, but you
690 can enable it by setting a non-zero timeout (in seconds) at the new
691 ka_time member at context creation time.
693 - Two new optional user callbacks added, LWS_CALLBACK_PROTOCOL_DESTROY which
694 is called one-time per protocol as the context is being destroyed, and
695 LWS_CALLBACK_PROTOCOL_INIT which is called when the context is created
696 and the protocols are added, again it's a one-time affair.
697 This lets you manage per-protocol allocations properly including
698 cleaning up after yourself when the server goes down.
703 - libwebsocket_create_context() has changed from taking a ton of parameters
704 to just taking a pointer to a struct containing the parameters. The
705 struct lws_context_creation_info is in libwebsockets.h, the members
706 are in the same order as when they were parameters to the call
707 previously. The test apps are all updated accordingly so you can
708 see example code there.
710 - Header tokens are now deleted after the websocket connection is
711 established. Not just the header data is saved, but the pointer and
712 length array is also removed from (union) scope saving several hundred
713 bytes per connection once it is established
715 - struct libwebsocket_protocols has a new member rx_buffer_size, this
716 controls rx buffer size per connection of that protocol now. Sources
717 for apps built against older versions of the library won't declare
718 this in their protocols, defaulting it to 0. Zero buffer is legal,
719 it causes a default buffer to be allocated (currently 4096)
721 If you want to receive only atomic frames in your user callback, you
722 should set this to greater than your largest frame size. If a frame
723 comes that exceeds that, no error occurs but the callback happens as
724 soon as the buffer limit is reached, and again if it is reached again
725 or the frame completes. You can detect that has happened by seeing
726 there is still frame content pending using
727 libwebsockets_remaining_packet_payload()
729 By correctly setting this, you can save a lot of memory when your
730 protocol has small frames (see the test server and client sources).
732 - LWS_MAX_HEADER_LEN now defaults to 1024 and is the total amount of known
733 header payload lws can cope with, that includes the GET URL, origin
734 etc. Headers not understood by lws are ignored and their payload
735 not included in this.
741 - The configuration-time option MAX_USER_RX_BUFFER has been replaced by a
742 buffer size chosen per-protocol. For compatibility, there's a default
743 of 4096 rx buffer, but user code should set the appropriate size for
746 - LWS_INITIAL_HDR_ALLOC and LWS_ADDITIONAL_HDR_ALLOC are no longer needed
747 and have been removed. There's a new header management scheme that
748 handles them in a much more compact way.
750 - libwebsockets_hangup_on_client() is removed. If you want to close the
751 connection you must do so from the user callback and by returning
754 - libwebsocket_close_and_free_session() is now private to the library code
755 only and not exposed for user code. If you want to close the
756 connection, you must do so from the user callback by returning -1
763 - Cmake project file added, aimed initially at Windows support: this replaces
764 the visual studio project files that were in the tree until now.
766 - CyaSSL now supported in place of OpenSSL (--use-cyassl on configure)
768 - PATH_MAX or MAX_PATH no longer needed
770 - cutomizable frame rx buffer size by protocol
772 - optional TCP keepalive so dead peers can be detected, can be enabled at
773 context-creation time
775 - valgrind-clean: no SSL or CyaSSL: completely clean. With OpenSSL, 88 bytes
776 lost at OpenSSL library init and symptomless reports of uninitialized
777 memory usage... seems to be a known and ignored problem at OpenSSL
779 - By default debug is enabled and the library is built for -O0 -g to faclitate
780 that. Use --disable-debug configure option to build instead with -O4
781 and no -g (debug info), obviously providing best performance and
784 - 1.0 introduced some code to try to not deflate small frames, however this
785 seems to break when confronted with a mixture of frames above and
786 below the threshold, so it's removed. Veto the compression extension
787 in your user callback if you will typically have very small frames.
789 - There are many memory usage improvements, both a reduction in malloc/
790 realloc and architectural changes. A websocket connection now
791 consumes only 296 bytes with SSL or 272 bytes without on x86_64,
792 during header processing an additional 1262 bytes is allocated in a
793 single malloc, but is freed when the websocket connection starts.
794 The RX frame buffer defined by the protocol in user
795 code is also allocated per connection, this represents the largest
796 frame you can receive atomically in that protocol.
798 - On ARM9 build, just http+ws server no extensions or ssl, <12Kbytes .text
799 and 112 bytes per connection (+1328 only during header processing)
802 v1.1-chrome26-firefox18
803 =======================
809 README-test-server | 291 ---
810 README.build | 239 ++
811 README.coding | 138 ++
813 README.test-apps | 272 +++
814 configure.ac | 116 +-
815 lib/Makefile.am | 55 +-
816 lib/base64-decode.c | 5 +-
817 lib/client-handshake.c | 121 +-
818 lib/client-parser.c | 394 ++++
819 lib/client.c | 807 +++++++
820 lib/daemonize.c | 212 ++
821 lib/extension-deflate-frame.c | 132 +-
822 lib/extension-deflate-stream.c | 12 +-
823 lib/extension-x-google-mux.c | 1223 ----------
824 lib/extension-x-google-mux.h | 96 -
825 lib/extension.c | 8 -
826 lib/getifaddrs.c | 271 +++
827 lib/getifaddrs.h | 76 +
828 lib/handshake.c | 582 +----
829 lib/libwebsockets.c | 2493 ++++++---------------
830 lib/libwebsockets.h | 115 +-
832 lib/minilex.c | 440 ++++
833 lib/output.c | 628 ++++++
834 lib/parsers.c | 2016 +++++------------
835 lib/private-libwebsockets.h | 284 +--
836 lib/server-handshake.c | 275 +++
837 lib/server.c | 377 ++++
838 libwebsockets-api-doc.html | 300 +--
840 test-server/Makefile.am | 111 +-
841 test-server/libwebsockets.org-logo.png | Bin 0 -> 7029 bytes
842 test-server/test-client.c | 45 +-
843 test-server/test-echo.c | 330 +++
844 test-server/test-fraggle.c | 20 +-
845 test-server/test-ping.c | 22 +-
846 test-server/test-server-extpoll.c | 554 -----
847 test-server/test-server.c | 349 ++-
848 test-server/test.html | 3 +-
849 win32port/zlib/ZLib.vcxproj | 749 ++++---
850 win32port/zlib/ZLib.vcxproj.filters | 188 +-
851 win32port/zlib/adler32.c | 348 ++-
852 win32port/zlib/compress.c | 160 +-
853 win32port/zlib/crc32.c | 867 ++++----
854 win32port/zlib/crc32.h | 882 ++++----
855 win32port/zlib/deflate.c | 3799 +++++++++++++++-----------------
856 win32port/zlib/deflate.h | 688 +++---
857 win32port/zlib/gzclose.c | 50 +-
858 win32port/zlib/gzguts.h | 325 ++-
859 win32port/zlib/gzlib.c | 1157 +++++-----
860 win32port/zlib/gzread.c | 1242 ++++++-----
861 win32port/zlib/gzwrite.c | 1096 +++++----
862 win32port/zlib/infback.c | 1272 ++++++-----
863 win32port/zlib/inffast.c | 680 +++---
864 win32port/zlib/inffast.h | 22 +-
865 win32port/zlib/inffixed.h | 188 +-
866 win32port/zlib/inflate.c | 2976 +++++++++++++------------
867 win32port/zlib/inflate.h | 244 +-
868 win32port/zlib/inftrees.c | 636 +++---
869 win32port/zlib/inftrees.h | 124 +-
870 win32port/zlib/trees.c | 2468 +++++++++++----------
871 win32port/zlib/trees.h | 256 +--
872 win32port/zlib/uncompr.c | 118 +-
873 win32port/zlib/zconf.h | 934 ++++----
874 win32port/zlib/zlib.h | 3357 ++++++++++++++--------------
875 win32port/zlib/zutil.c | 642 +++---
876 win32port/zlib/zutil.h | 526 ++---
877 69 files changed, 19556 insertions(+), 20145 deletions(-)
882 - libwebsockets_serve_http_file() now takes a context as first argument
884 - libwebsockets_get_peer_addresses() now takes a context and wsi as first
891 - lwsl_...() logging apis, default to stderr but retargetable by user code;
892 may be used also by user code
894 - lws_set_log_level() set which logging apis are able to emit (defaults to
895 notice, warn, err severities), optionally set the emit callback
897 - lwsl_emit_syslog() helper callback emits to syslog
899 - lws_daemonize() helper code that forks the app into a headless daemon
900 properly, maintains a lock file with pid in suitable for sysvinit etc to
903 - LWS_CALLBACK_HTTP_FILE_COMPLETION callback added since http file
904 transfer is now asynchronous (see test server code)
906 - lws_frame_is_binary() from a wsi pointer, let you know if the received
907 data was sent in BINARY mode
913 - libwebsockets_fork_service_loop() - no longer supported (had intractable problems)
914 arrange your code to act from the user callback instead from same
915 process context as the service loop
917 - libwebsockets_broadcast() - use libwebsocket_callback_on_writable[_all_protocol]()
918 instead from same process context as the service loop. See the test apps
921 - x-google-mux() removed until someone wants it
923 - pre -v13 (ancient) protocol support removed
929 - echo test server and client compatible with echo.websocket.org added
931 - many new configure options (see README.build) to reduce footprint of the
932 library to what you actually need, eg, --without-client and
935 - http + websocket server can build to as little as 12K .text for ARM
937 - no more MAX_CLIENTS limitation; adapts to support the max number of fds
938 allowed to the process by ulimit, defaults to 1024 on Fedora and
939 Ubuntu. Use ulimit to control this without needing to configure
940 the library. Code here is smaller and faster.
942 - adaptive ratio of listen socket to connection socket service allows
943 good behaviour under Apache ab test load. Tested with thousands
944 of simultaneous connections
946 - reduction in per-connection memory footprint by moving to a union to hold
947 mutually-exclusive state for the connection
949 - robustness: Out of Memory taken care of for all allocation code now
951 - internal getifaddrs option if your toolchain lacks it (some uclibc)
953 - configurable memory limit for deflate operations
955 - improvements in SSL code nonblocking operation, possible hang solved,
956 some SSL operations broken down into pollable states so there is
957 no library blocking, timeout coverage for SSL_connect
959 - extpoll test server merged into single test server source
961 - robustness: library should deal with all recoverable socket conditions
963 - rx flowcontrol for backpressure notification fixed and implmeneted
964 correctly in the test server
966 - optimal lexical parser added for header processing; all headers in a
967 single 276-byte state table
969 - latency tracking api added (configure --with-latency)
971 - Improved in-tree documentation, REAME.build, README.coding,
972 README.test-apps, changelog
977 v1.0-chrome25-firefox17 (6cd1ea9b005933f)