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