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