changelog

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