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