changelog

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