changelog

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