changelog

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