| 1 | /***************************************************************************
|
|---|
| 2 | * _ _ ____ _
|
|---|
| 3 | * Project ___| | | | _ \| |
|
|---|
| 4 | * / __| | | | |_) | |
|
|---|
| 5 | * | (__| |_| | _ <| |___
|
|---|
| 6 | * \___|\___/|_| \_\_____|
|
|---|
| 7 | *
|
|---|
| 8 | * Copyright (C) 1998 - 2022, Daniel Stenberg, <daniel@haxx.se>, et al.
|
|---|
| 9 | *
|
|---|
| 10 | * This software is licensed as described in the file COPYING, which
|
|---|
| 11 | * you should have received as part of this distribution. The terms
|
|---|
| 12 | * are also available at https://curl.se/docs/copyright.html.
|
|---|
| 13 | *
|
|---|
| 14 | * You may opt to use, copy, modify, merge, publish, distribute and/or sell
|
|---|
| 15 | * copies of the Software, and permit persons to whom the Software is
|
|---|
| 16 | * furnished to do so, under the terms of the COPYING file.
|
|---|
| 17 | *
|
|---|
| 18 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|---|
| 19 | * KIND, either express or implied.
|
|---|
| 20 | *
|
|---|
| 21 | * SPDX-License-Identifier: curl
|
|---|
| 22 | *
|
|---|
| 23 | ***************************************************************************/
|
|---|
| 24 | #include "curl_setup.h"
|
|---|
| 25 | #include <curl/curl.h>
|
|---|
| 26 |
|
|---|
| 27 | #ifdef USE_WEBSOCKETS
|
|---|
| 28 |
|
|---|
| 29 | #include "urldata.h"
|
|---|
| 30 | #include "dynbuf.h"
|
|---|
| 31 | #include "rand.h"
|
|---|
| 32 | #include "curl_base64.h"
|
|---|
| 33 | #include "sendf.h"
|
|---|
| 34 | #include "multiif.h"
|
|---|
| 35 | #include "ws.h"
|
|---|
| 36 | #include "easyif.h"
|
|---|
| 37 | #include "transfer.h"
|
|---|
| 38 | #include "nonblock.h"
|
|---|
| 39 |
|
|---|
| 40 | /* The last 3 #include files should be in this order */
|
|---|
| 41 | #include "curl_printf.h"
|
|---|
| 42 | #include "curl_memory.h"
|
|---|
| 43 | #include "memdebug.h"
|
|---|
| 44 |
|
|---|
| 45 | struct wsfield {
|
|---|
| 46 | const char *name;
|
|---|
| 47 | const char *val;
|
|---|
| 48 | };
|
|---|
| 49 |
|
|---|
| 50 | CURLcode Curl_ws_request(struct Curl_easy *data, REQTYPE *req)
|
|---|
| 51 | {
|
|---|
| 52 | unsigned int i;
|
|---|
| 53 | CURLcode result = CURLE_OK;
|
|---|
| 54 | unsigned char rand[16];
|
|---|
| 55 | char *randstr;
|
|---|
| 56 | size_t randlen;
|
|---|
| 57 | char keyval[40];
|
|---|
| 58 | struct SingleRequest *k = &data->req;
|
|---|
| 59 | struct wsfield heads[]= {
|
|---|
| 60 | {
|
|---|
| 61 | /* The request MUST contain an |Upgrade| header field whose value
|
|---|
| 62 | MUST include the "websocket" keyword. */
|
|---|
| 63 | "Upgrade:", "websocket"
|
|---|
| 64 | },
|
|---|
| 65 | {
|
|---|
| 66 | /* The request MUST contain a |Connection| header field whose value
|
|---|
| 67 | MUST include the "Upgrade" token. */
|
|---|
| 68 | "Connection:", "Upgrade",
|
|---|
| 69 | },
|
|---|
| 70 | {
|
|---|
| 71 | /* The request MUST include a header field with the name
|
|---|
| 72 | |Sec-WebSocket-Version|. The value of this header field MUST be
|
|---|
| 73 | 13. */
|
|---|
| 74 | "Sec-WebSocket-Version:", "13",
|
|---|
| 75 | },
|
|---|
| 76 | {
|
|---|
| 77 | /* The request MUST include a header field with the name
|
|---|
| 78 | |Sec-WebSocket-Key|. The value of this header field MUST be a nonce
|
|---|
| 79 | consisting of a randomly selected 16-byte value that has been
|
|---|
| 80 | base64-encoded (see Section 4 of [RFC4648]). The nonce MUST be
|
|---|
| 81 | selected randomly for each connection. */
|
|---|
| 82 | "Sec-WebSocket-Key:", NULL,
|
|---|
| 83 | }
|
|---|
| 84 | };
|
|---|
| 85 | heads[3].val = &keyval[0];
|
|---|
| 86 |
|
|---|
| 87 | /* 16 bytes random */
|
|---|
| 88 | result = Curl_rand(data, (unsigned char *)rand, sizeof(rand));
|
|---|
| 89 | if(result)
|
|---|
| 90 | return result;
|
|---|
| 91 | result = Curl_base64_encode((char *)rand, sizeof(rand), &randstr, &randlen);
|
|---|
| 92 | if(result)
|
|---|
| 93 | return result;
|
|---|
| 94 | DEBUGASSERT(randlen < sizeof(keyval));
|
|---|
| 95 | if(randlen >= sizeof(keyval))
|
|---|
| 96 | return CURLE_FAILED_INIT;
|
|---|
| 97 | strcpy(keyval, randstr);
|
|---|
| 98 | free(randstr);
|
|---|
| 99 | for(i = 0; !result && (i < sizeof(heads)/sizeof(heads[0])); i++) {
|
|---|
| 100 | if(!Curl_checkheaders(data, STRCONST(heads[i].name))) {
|
|---|
| 101 | #ifdef USE_HYPER
|
|---|
| 102 | char field[128];
|
|---|
| 103 | msnprintf(field, sizeof(field), "%s %s", heads[i].name,
|
|---|
| 104 | heads[i].val);
|
|---|
| 105 | result = Curl_hyper_header(data, req, field);
|
|---|
| 106 | #else
|
|---|
| 107 | (void)data;
|
|---|
| 108 | result = Curl_dyn_addf(req, "%s %s\r\n", heads[i].name,
|
|---|
| 109 | heads[i].val);
|
|---|
| 110 | #endif
|
|---|
| 111 | }
|
|---|
| 112 | }
|
|---|
| 113 | k->upgr101 = UPGR101_WS;
|
|---|
| 114 | Curl_dyn_init(&data->req.p.http->ws.buf, MAX_WS_SIZE * 2);
|
|---|
| 115 | return result;
|
|---|
| 116 | }
|
|---|
| 117 |
|
|---|
| 118 | CURLcode Curl_ws_accept(struct Curl_easy *data)
|
|---|
| 119 | {
|
|---|
| 120 | struct SingleRequest *k = &data->req;
|
|---|
| 121 | struct HTTP *ws = data->req.p.http;
|
|---|
| 122 | struct connectdata *conn = data->conn;
|
|---|
| 123 | struct websocket *wsp = &data->req.p.http->ws;
|
|---|
| 124 | CURLcode result;
|
|---|
| 125 |
|
|---|
| 126 | /* Verify the Sec-WebSocket-Accept response.
|
|---|
| 127 |
|
|---|
| 128 | The sent value is the base64 encoded version of a SHA-1 hash done on the
|
|---|
| 129 | |Sec-WebSocket-Key| header field concatenated with
|
|---|
| 130 | the string "258EAFA5-E914-47DA-95CA-C5AB0DC85B11".
|
|---|
| 131 | */
|
|---|
| 132 |
|
|---|
| 133 | /* If the response includes a |Sec-WebSocket-Extensions| header field and
|
|---|
| 134 | this header field indicates the use of an extension that was not present
|
|---|
| 135 | in the client's handshake (the server has indicated an extension not
|
|---|
| 136 | requested by the client), the client MUST Fail the WebSocket Connection.
|
|---|
| 137 | */
|
|---|
| 138 |
|
|---|
| 139 | /* If the response includes a |Sec-WebSocket-Protocol| header field
|
|---|
| 140 | and this header field indicates the use of a subprotocol that was
|
|---|
| 141 | not present in the client's handshake (the server has indicated a
|
|---|
| 142 | subprotocol not requested by the client), the client MUST Fail
|
|---|
| 143 | the WebSocket Connection. */
|
|---|
| 144 |
|
|---|
| 145 | /* 4 bytes random */
|
|---|
| 146 | result = Curl_rand(data, (unsigned char *)&ws->ws.mask, sizeof(ws->ws.mask));
|
|---|
| 147 | if(result)
|
|---|
| 148 | return result;
|
|---|
| 149 |
|
|---|
| 150 | infof(data, "Received 101, switch to WebSocket; mask %02x%02x%02x%02x",
|
|---|
| 151 | ws->ws.mask[0], ws->ws.mask[1], ws->ws.mask[2], ws->ws.mask[3]);
|
|---|
| 152 | k->upgr101 = UPGR101_RECEIVED;
|
|---|
| 153 |
|
|---|
| 154 | if(data->set.connect_only)
|
|---|
| 155 | /* switch off non-blocking sockets */
|
|---|
| 156 | (void)curlx_nonblock(conn->sock[FIRSTSOCKET], FALSE);
|
|---|
| 157 |
|
|---|
| 158 | wsp->oleft = 0;
|
|---|
| 159 | return result;
|
|---|
| 160 | }
|
|---|
| 161 |
|
|---|
| 162 | #define WSBIT_FIN 0x80
|
|---|
| 163 | #define WSBIT_OPCODE_CONT 0
|
|---|
| 164 | #define WSBIT_OPCODE_TEXT (1)
|
|---|
| 165 | #define WSBIT_OPCODE_BIN (2)
|
|---|
| 166 | #define WSBIT_OPCODE_CLOSE (8)
|
|---|
| 167 | #define WSBIT_OPCODE_PING (9)
|
|---|
| 168 | #define WSBIT_OPCODE_PONG (0xa)
|
|---|
| 169 | #define WSBIT_OPCODE_MASK (0xf)
|
|---|
| 170 |
|
|---|
| 171 | #define WSBIT_MASK 0x80
|
|---|
| 172 |
|
|---|
| 173 | /* remove the spent bytes from the beginning of the buffer as that part has
|
|---|
| 174 | now been delivered to the application */
|
|---|
| 175 | static void ws_decode_shift(struct Curl_easy *data, size_t spent)
|
|---|
| 176 | {
|
|---|
| 177 | struct websocket *wsp = &data->req.p.http->ws;
|
|---|
| 178 | size_t len = Curl_dyn_len(&wsp->buf);
|
|---|
| 179 | size_t keep = len - spent;
|
|---|
| 180 | DEBUGASSERT(len >= spent);
|
|---|
| 181 | Curl_dyn_tail(&wsp->buf, keep);
|
|---|
| 182 | }
|
|---|
| 183 |
|
|---|
| 184 | /* ws_decode() decodes a binary frame into structured WebSocket data,
|
|---|
| 185 |
|
|---|
| 186 | wpkt - the incoming raw data. If NULL, work on the already buffered data.
|
|---|
| 187 | ilen - the size of the provided data, perhaps too little, perhaps too much
|
|---|
| 188 | out - stored pointed to extracted data
|
|---|
| 189 | olen - stored length of the extracted data
|
|---|
| 190 | oleft - number of unread bytes pending to that belongs to this frame
|
|---|
| 191 | more - if there is more data in there
|
|---|
| 192 | flags - stored bitmask about the frame
|
|---|
| 193 |
|
|---|
| 194 | Returns CURLE_AGAIN if there is only a partial frame in the buffer. Then it
|
|---|
| 195 | stores the first part in the ->extra buffer to be used in the next call
|
|---|
| 196 | when more data is provided.
|
|---|
| 197 | */
|
|---|
| 198 |
|
|---|
| 199 | static CURLcode ws_decode(struct Curl_easy *data,
|
|---|
| 200 | unsigned char *inbuf, size_t inlen,
|
|---|
| 201 | size_t *headlen, size_t *olen,
|
|---|
| 202 | curl_off_t *oleft,
|
|---|
| 203 | unsigned int *flags)
|
|---|
| 204 | {
|
|---|
| 205 | bool fin;
|
|---|
| 206 | unsigned char opcode;
|
|---|
| 207 | curl_off_t total;
|
|---|
| 208 | size_t dataindex = 2;
|
|---|
| 209 | curl_off_t payloadsize;
|
|---|
| 210 |
|
|---|
| 211 | *olen = *headlen = 0;
|
|---|
| 212 |
|
|---|
| 213 | if(inlen < 2) {
|
|---|
| 214 | /* the smallest possible frame is two bytes */
|
|---|
| 215 | infof(data, "WS: plen == %u, EAGAIN", (int)inlen);
|
|---|
| 216 | return CURLE_AGAIN;
|
|---|
| 217 | }
|
|---|
| 218 |
|
|---|
| 219 | fin = inbuf[0] & WSBIT_FIN;
|
|---|
| 220 | opcode = inbuf[0] & WSBIT_OPCODE_MASK;
|
|---|
| 221 | infof(data, "WS:%d received FIN bit %u", __LINE__, (int)fin);
|
|---|
| 222 | *flags = 0;
|
|---|
| 223 | switch(opcode) {
|
|---|
| 224 | case WSBIT_OPCODE_CONT:
|
|---|
| 225 | if(!fin)
|
|---|
| 226 | *flags |= CURLWS_CONT;
|
|---|
| 227 | infof(data, "WS: received OPCODE CONT");
|
|---|
| 228 | break;
|
|---|
| 229 | case WSBIT_OPCODE_TEXT:
|
|---|
| 230 | infof(data, "WS: received OPCODE TEXT");
|
|---|
| 231 | *flags |= CURLWS_TEXT;
|
|---|
| 232 | break;
|
|---|
| 233 | case WSBIT_OPCODE_BIN:
|
|---|
| 234 | infof(data, "WS: received OPCODE BINARY");
|
|---|
| 235 | *flags |= CURLWS_BINARY;
|
|---|
| 236 | break;
|
|---|
| 237 | case WSBIT_OPCODE_CLOSE:
|
|---|
| 238 | infof(data, "WS: received OPCODE CLOSE");
|
|---|
| 239 | *flags |= CURLWS_CLOSE;
|
|---|
| 240 | break;
|
|---|
| 241 | case WSBIT_OPCODE_PING:
|
|---|
| 242 | infof(data, "WS: received OPCODE PING");
|
|---|
| 243 | *flags |= CURLWS_PING;
|
|---|
| 244 | break;
|
|---|
| 245 | case WSBIT_OPCODE_PONG:
|
|---|
| 246 | infof(data, "WS: received OPCODE PONG");
|
|---|
| 247 | *flags |= CURLWS_PONG;
|
|---|
| 248 | break;
|
|---|
| 249 | }
|
|---|
| 250 |
|
|---|
| 251 | if(inbuf[1] & WSBIT_MASK) {
|
|---|
| 252 | /* A client MUST close a connection if it detects a masked frame. */
|
|---|
| 253 | failf(data, "WS: masked input frame");
|
|---|
| 254 | return CURLE_RECV_ERROR;
|
|---|
| 255 | }
|
|---|
| 256 | payloadsize = inbuf[1];
|
|---|
| 257 | if(payloadsize == 126) {
|
|---|
| 258 | if(inlen < 4) {
|
|---|
| 259 | infof(data, "WS:%d plen == %u, EAGAIN", __LINE__, (int)inlen);
|
|---|
| 260 | return CURLE_AGAIN; /* not enough data available */
|
|---|
| 261 | }
|
|---|
| 262 | payloadsize = (inbuf[2] << 8) | inbuf[3];
|
|---|
| 263 | dataindex += 2;
|
|---|
| 264 | }
|
|---|
| 265 | else if(payloadsize == 127) {
|
|---|
| 266 | /* 64 bit payload size */
|
|---|
| 267 | if(inlen < 10)
|
|---|
| 268 | return CURLE_AGAIN;
|
|---|
| 269 | if(inbuf[2] & 80) {
|
|---|
| 270 | failf(data, "WS: too large frame");
|
|---|
| 271 | return CURLE_RECV_ERROR;
|
|---|
| 272 | }
|
|---|
| 273 | dataindex += 8;
|
|---|
| 274 | payloadsize = ((curl_off_t)inbuf[2] << 56) |
|
|---|
| 275 | (curl_off_t)inbuf[3] << 48 |
|
|---|
| 276 | (curl_off_t)inbuf[4] << 40 |
|
|---|
| 277 | (curl_off_t)inbuf[5] << 32 |
|
|---|
| 278 | (curl_off_t)inbuf[6] << 24 |
|
|---|
| 279 | (curl_off_t)inbuf[7] << 16 |
|
|---|
| 280 | (curl_off_t)inbuf[8] << 8 |
|
|---|
| 281 | inbuf[9];
|
|---|
| 282 | }
|
|---|
| 283 |
|
|---|
| 284 | /* point to the payload */
|
|---|
| 285 | *headlen = dataindex;
|
|---|
| 286 | total = dataindex + payloadsize;
|
|---|
| 287 | if(total > (curl_off_t)inlen) {
|
|---|
| 288 | /* buffer contains partial frame */
|
|---|
| 289 | *olen = inlen - dataindex; /* bytes to write out */
|
|---|
| 290 | *oleft = total - inlen; /* bytes yet to come (for this frame) */
|
|---|
| 291 | payloadsize = total - dataindex;
|
|---|
| 292 | }
|
|---|
| 293 | else {
|
|---|
| 294 | /* we have the complete frame (`total` bytes) in buffer */
|
|---|
| 295 | *olen = payloadsize; /* bytes to write out */
|
|---|
| 296 | *oleft = 0; /* bytes yet to come (for this frame) */
|
|---|
| 297 | }
|
|---|
| 298 |
|
|---|
| 299 | infof(data, "WS: received %zu bytes payload (%zu left, buflen was %zu)",
|
|---|
| 300 | payloadsize, *oleft, inlen);
|
|---|
| 301 | return CURLE_OK;
|
|---|
| 302 | }
|
|---|
| 303 |
|
|---|
| 304 | /* Curl_ws_writecb() is the write callback for websocket traffic. The
|
|---|
| 305 | websocket data is provided to this raw, in chunks. This function should
|
|---|
| 306 | handle/decode the data and call the "real" underlying callback accordingly.
|
|---|
| 307 | */
|
|---|
| 308 | size_t Curl_ws_writecb(char *buffer, size_t size /* 1 */,
|
|---|
| 309 | size_t nitems, void *userp)
|
|---|
| 310 | {
|
|---|
| 311 | struct HTTP *ws = (struct HTTP *)userp;
|
|---|
| 312 | struct Curl_easy *data = ws->ws.data;
|
|---|
| 313 | struct websocket *wsp = &data->req.p.http->ws;
|
|---|
| 314 | void *writebody_ptr = data->set.out;
|
|---|
| 315 | if(data->set.ws_raw_mode)
|
|---|
| 316 | return data->set.fwrite_func(buffer, size, nitems, writebody_ptr);
|
|---|
| 317 | else if(nitems) {
|
|---|
| 318 | size_t wrote = 0, headlen;
|
|---|
| 319 | CURLcode result;
|
|---|
| 320 |
|
|---|
| 321 | if(buffer) {
|
|---|
| 322 | result = Curl_dyn_addn(&wsp->buf, buffer, nitems);
|
|---|
| 323 | if(result) {
|
|---|
| 324 | infof(data, "WS: error adding data to buffer %d", (int)result);
|
|---|
| 325 | return nitems - 1;
|
|---|
| 326 | }
|
|---|
| 327 | buffer = NULL;
|
|---|
| 328 | }
|
|---|
| 329 |
|
|---|
| 330 | while(Curl_dyn_len(&wsp->buf)) {
|
|---|
| 331 | unsigned char *wsbuf = Curl_dyn_uptr(&wsp->buf);
|
|---|
| 332 | size_t buflen = Curl_dyn_len(&wsp->buf);
|
|---|
| 333 | size_t write_len = 0;
|
|---|
| 334 | size_t consumed = 0;
|
|---|
| 335 |
|
|---|
| 336 | if(!ws->ws.frame.bytesleft) {
|
|---|
| 337 | unsigned int recvflags;
|
|---|
| 338 | curl_off_t fb_left;
|
|---|
| 339 |
|
|---|
| 340 | result = ws_decode(data, wsbuf, buflen,
|
|---|
| 341 | &headlen, &write_len, &fb_left, &recvflags);
|
|---|
| 342 | consumed += headlen;
|
|---|
| 343 | wsbuf += headlen;
|
|---|
| 344 | buflen -= headlen;
|
|---|
| 345 | if(result == CURLE_AGAIN)
|
|---|
| 346 | /* insufficient amount of data, keep it for later.
|
|---|
| 347 | * we pretend to have written all since we have a copy */
|
|---|
| 348 | return nitems;
|
|---|
| 349 | else if(result) {
|
|---|
| 350 | infof(data, "WS: decode error %d", (int)result);
|
|---|
| 351 | return nitems - 1;
|
|---|
| 352 | }
|
|---|
| 353 | /* New frame. store details about the frame to be reachable with
|
|---|
| 354 | curl_ws_meta() from within the write callback */
|
|---|
| 355 | ws->ws.frame.age = 0;
|
|---|
| 356 | ws->ws.frame.offset = 0;
|
|---|
| 357 | ws->ws.frame.flags = recvflags;
|
|---|
| 358 | ws->ws.frame.bytesleft = fb_left;
|
|---|
| 359 | }
|
|---|
| 360 | else {
|
|---|
| 361 | /* continuing frame */
|
|---|
| 362 | write_len = (size_t)ws->ws.frame.bytesleft;
|
|---|
| 363 | if(write_len > buflen)
|
|---|
| 364 | write_len = buflen;
|
|---|
| 365 | ws->ws.frame.offset += write_len;
|
|---|
| 366 | ws->ws.frame.bytesleft -= write_len;
|
|---|
| 367 | }
|
|---|
| 368 | if((ws->ws.frame.flags & CURLWS_PING) && !ws->ws.frame.bytesleft) {
|
|---|
| 369 | /* auto-respond to PINGs, only works for single-frame payloads atm */
|
|---|
| 370 | size_t bytes;
|
|---|
| 371 | infof(data, "WS: auto-respond to PING with a PONG");
|
|---|
| 372 | /* send back the exact same content as a PONG */
|
|---|
| 373 | result = curl_ws_send(data, wsbuf, write_len,
|
|---|
| 374 | &bytes, 0, CURLWS_PONG);
|
|---|
| 375 | if(result)
|
|---|
| 376 | return result;
|
|---|
| 377 | }
|
|---|
| 378 | else if(write_len || !wsp->frame.bytesleft) {
|
|---|
| 379 | /* deliver the decoded frame to the user callback */
|
|---|
| 380 | Curl_set_in_callback(data, true);
|
|---|
| 381 | wrote = data->set.fwrite_func((char *)wsbuf, 1,
|
|---|
| 382 | write_len, writebody_ptr);
|
|---|
| 383 | Curl_set_in_callback(data, false);
|
|---|
| 384 | if(wrote != write_len)
|
|---|
| 385 | return 0;
|
|---|
| 386 | }
|
|---|
| 387 | /* get rid of the buffered data consumed */
|
|---|
| 388 | consumed += write_len;
|
|---|
| 389 | ws_decode_shift(data, consumed);
|
|---|
| 390 | }
|
|---|
| 391 | }
|
|---|
| 392 | return nitems;
|
|---|
| 393 | }
|
|---|
| 394 |
|
|---|
| 395 |
|
|---|
| 396 | CURL_EXTERN CURLcode curl_ws_recv(struct Curl_easy *data, void *buffer,
|
|---|
| 397 | size_t buflen, size_t *nread,
|
|---|
| 398 | struct curl_ws_frame **metap)
|
|---|
| 399 | {
|
|---|
| 400 | CURLcode result;
|
|---|
| 401 | struct websocket *wsp = &data->req.p.http->ws;
|
|---|
| 402 | bool done = FALSE; /* not filled passed buffer yet */
|
|---|
| 403 |
|
|---|
| 404 | *nread = 0;
|
|---|
| 405 | *metap = NULL;
|
|---|
| 406 | /* get a download buffer */
|
|---|
| 407 | result = Curl_preconnect(data);
|
|---|
| 408 | if(result)
|
|---|
| 409 | return result;
|
|---|
| 410 |
|
|---|
| 411 | while(!done) {
|
|---|
| 412 | size_t write_len;
|
|---|
| 413 | unsigned int recvflags;
|
|---|
| 414 |
|
|---|
| 415 | if(!wsp->stillblen) {
|
|---|
| 416 | /* try to get more data */
|
|---|
| 417 | size_t n;
|
|---|
| 418 | result = curl_easy_recv(data, data->state.buffer,
|
|---|
| 419 | data->set.buffer_size, &n);
|
|---|
| 420 | if(result)
|
|---|
| 421 | return result;
|
|---|
| 422 | if(!n)
|
|---|
| 423 | /* connection closed */
|
|---|
| 424 | return CURLE_GOT_NOTHING;
|
|---|
| 425 | wsp->stillb = data->state.buffer;
|
|---|
| 426 | wsp->stillblen = n;
|
|---|
| 427 | }
|
|---|
| 428 |
|
|---|
| 429 | infof(data, "WS: got %u websocket bytes to decode",
|
|---|
| 430 | (int)wsp->stillblen);
|
|---|
| 431 | if(!wsp->frame.bytesleft) {
|
|---|
| 432 | size_t headlen;
|
|---|
| 433 | curl_off_t oleft;
|
|---|
| 434 | /* detect new frame */
|
|---|
| 435 | result = ws_decode(data, (unsigned char *)wsp->stillb, wsp->stillblen,
|
|---|
| 436 | &headlen, &write_len, &oleft, &recvflags);
|
|---|
| 437 | if(result == CURLE_AGAIN)
|
|---|
| 438 | /* a packet fragment only */
|
|---|
| 439 | break;
|
|---|
| 440 | else if(result)
|
|---|
| 441 | return result;
|
|---|
| 442 | wsp->stillb += headlen;
|
|---|
| 443 | wsp->stillblen -= headlen;
|
|---|
| 444 | wsp->frame.offset = 0;
|
|---|
| 445 | wsp->frame.bytesleft = oleft;
|
|---|
| 446 | wsp->frame.flags = recvflags;
|
|---|
| 447 | }
|
|---|
| 448 | else {
|
|---|
| 449 | /* existing frame, remaining payload handling */
|
|---|
| 450 | write_len = wsp->frame.bytesleft;
|
|---|
| 451 | if(write_len > wsp->stillblen)
|
|---|
| 452 | write_len = wsp->stillblen;
|
|---|
| 453 | }
|
|---|
| 454 |
|
|---|
| 455 | /* auto-respond to PINGs */
|
|---|
| 456 | if((wsp->frame.flags & CURLWS_PING) && !wsp->frame.bytesleft) {
|
|---|
| 457 | infof(data, "WS: auto-respond to PING with a PONG");
|
|---|
| 458 | /* send back the exact same content as a PONG */
|
|---|
| 459 | result = curl_ws_send(data, wsp->stillb, write_len,
|
|---|
| 460 | &write_len, 0, CURLWS_PONG);
|
|---|
| 461 | if(result)
|
|---|
| 462 | return result;
|
|---|
| 463 | }
|
|---|
| 464 | else if(write_len || !wsp->frame.bytesleft) {
|
|---|
| 465 | if(write_len > buflen)
|
|---|
| 466 | write_len = buflen;
|
|---|
| 467 | /* copy the payload to the user buffer */
|
|---|
| 468 | memcpy(buffer, wsp->stillb, write_len);
|
|---|
| 469 | *nread = write_len;
|
|---|
| 470 | done = TRUE;
|
|---|
| 471 | }
|
|---|
| 472 | if(write_len) {
|
|---|
| 473 | /* update buffer and frame info */
|
|---|
| 474 | wsp->frame.offset += write_len;
|
|---|
| 475 | DEBUGASSERT(wsp->frame.bytesleft >= (curl_off_t)write_len);
|
|---|
| 476 | if(wsp->frame.bytesleft)
|
|---|
| 477 | wsp->frame.bytesleft -= write_len;
|
|---|
| 478 | DEBUGASSERT(write_len <= wsp->stillblen);
|
|---|
| 479 | wsp->stillblen -= write_len;
|
|---|
| 480 | if(wsp->stillblen)
|
|---|
| 481 | wsp->stillb += write_len;
|
|---|
| 482 | else
|
|---|
| 483 | wsp->stillb = NULL;
|
|---|
| 484 | }
|
|---|
| 485 | }
|
|---|
| 486 | *metap = &wsp->frame;
|
|---|
| 487 | return CURLE_OK;
|
|---|
| 488 | }
|
|---|
| 489 |
|
|---|
| 490 | static void ws_xor(struct Curl_easy *data,
|
|---|
| 491 | const unsigned char *source,
|
|---|
| 492 | unsigned char *dest,
|
|---|
| 493 | size_t len)
|
|---|
| 494 | {
|
|---|
| 495 | struct websocket *wsp = &data->req.p.http->ws;
|
|---|
| 496 | size_t i;
|
|---|
| 497 | /* append payload after the mask, XOR appropriately */
|
|---|
| 498 | for(i = 0; i < len; i++) {
|
|---|
| 499 | dest[i] = source[i] ^ wsp->mask[wsp->xori];
|
|---|
| 500 | wsp->xori++;
|
|---|
| 501 | wsp->xori &= 3;
|
|---|
| 502 | }
|
|---|
| 503 | }
|
|---|
| 504 |
|
|---|
| 505 | /***
|
|---|
| 506 | RFC 6455 Section 5.2
|
|---|
| 507 |
|
|---|
| 508 | 0 1 2 3
|
|---|
| 509 | 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
|
|---|
| 510 | +-+-+-+-+-------+-+-------------+-------------------------------+
|
|---|
| 511 | |F|R|R|R| opcode|M| Payload len | Extended payload length |
|
|---|
| 512 | |I|S|S|S| (4) |A| (7) | (16/64) |
|
|---|
| 513 | |N|V|V|V| |S| | (if payload len==126/127) |
|
|---|
| 514 | | |1|2|3| |K| | |
|
|---|
| 515 | +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
|
|---|
| 516 | | Extended payload length continued, if payload len == 127 |
|
|---|
| 517 | + - - - - - - - - - - - - - - - +-------------------------------+
|
|---|
| 518 | | |Masking-key, if MASK set to 1 |
|
|---|
| 519 | +-------------------------------+-------------------------------+
|
|---|
| 520 | | Masking-key (continued) | Payload Data |
|
|---|
| 521 | +-------------------------------- - - - - - - - - - - - - - - - +
|
|---|
| 522 | : Payload Data continued ... :
|
|---|
| 523 | + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
|
|---|
| 524 | | Payload Data continued ... |
|
|---|
| 525 | +---------------------------------------------------------------+
|
|---|
| 526 | */
|
|---|
| 527 |
|
|---|
| 528 | static size_t ws_packethead(struct Curl_easy *data,
|
|---|
| 529 | size_t len, unsigned int flags)
|
|---|
| 530 | {
|
|---|
| 531 | struct HTTP *ws = data->req.p.http;
|
|---|
| 532 | unsigned char *out = (unsigned char *)data->state.ulbuf;
|
|---|
| 533 | unsigned char firstbyte = 0;
|
|---|
| 534 | int outi;
|
|---|
| 535 | unsigned char opcode;
|
|---|
| 536 | if(flags & CURLWS_TEXT) {
|
|---|
| 537 | opcode = WSBIT_OPCODE_TEXT;
|
|---|
| 538 | infof(data, "WS: send OPCODE TEXT");
|
|---|
| 539 | }
|
|---|
| 540 | else if(flags & CURLWS_CLOSE) {
|
|---|
| 541 | opcode = WSBIT_OPCODE_CLOSE;
|
|---|
| 542 | infof(data, "WS: send OPCODE CLOSE");
|
|---|
| 543 | }
|
|---|
| 544 | else if(flags & CURLWS_PING) {
|
|---|
| 545 | opcode = WSBIT_OPCODE_PING;
|
|---|
| 546 | infof(data, "WS: send OPCODE PING");
|
|---|
| 547 | }
|
|---|
| 548 | else if(flags & CURLWS_PONG) {
|
|---|
| 549 | opcode = WSBIT_OPCODE_PONG;
|
|---|
| 550 | infof(data, "WS: send OPCODE PONG");
|
|---|
| 551 | }
|
|---|
| 552 | else {
|
|---|
| 553 | opcode = WSBIT_OPCODE_BIN;
|
|---|
| 554 | infof(data, "WS: send OPCODE BINARY");
|
|---|
| 555 | }
|
|---|
| 556 |
|
|---|
| 557 | if(!(flags & CURLWS_CONT)) {
|
|---|
| 558 | /* if not marked as continuing, assume this is the final fragment */
|
|---|
| 559 | firstbyte |= WSBIT_FIN | opcode;
|
|---|
| 560 | ws->ws.contfragment = FALSE;
|
|---|
| 561 | }
|
|---|
| 562 | else if(ws->ws.contfragment) {
|
|---|
| 563 | /* the previous fragment was not a final one and this isn't either, keep a
|
|---|
| 564 | CONT opcode and no FIN bit */
|
|---|
| 565 | firstbyte |= WSBIT_OPCODE_CONT;
|
|---|
| 566 | }
|
|---|
| 567 | else {
|
|---|
| 568 | ws->ws.contfragment = TRUE;
|
|---|
| 569 | }
|
|---|
| 570 | out[0] = firstbyte;
|
|---|
| 571 | if(len > 65535) {
|
|---|
| 572 | out[1] = 127 | WSBIT_MASK;
|
|---|
| 573 | out[2] = (len >> 8) & 0xff;
|
|---|
| 574 | out[3] = len & 0xff;
|
|---|
| 575 | outi = 10;
|
|---|
| 576 | }
|
|---|
| 577 | else if(len > 126) {
|
|---|
| 578 | out[1] = 126 | WSBIT_MASK;
|
|---|
| 579 | out[2] = (len >> 8) & 0xff;
|
|---|
| 580 | out[3] = len & 0xff;
|
|---|
| 581 | outi = 4;
|
|---|
| 582 | }
|
|---|
| 583 | else {
|
|---|
| 584 | out[1] = (unsigned char)len | WSBIT_MASK;
|
|---|
| 585 | outi = 2;
|
|---|
| 586 | }
|
|---|
| 587 |
|
|---|
| 588 | infof(data, "WS: send FIN bit %u (byte %02x)",
|
|---|
| 589 | firstbyte & WSBIT_FIN ? 1 : 0,
|
|---|
| 590 | firstbyte);
|
|---|
| 591 | infof(data, "WS: send payload len %u", (int)len);
|
|---|
| 592 |
|
|---|
| 593 | /* 4 bytes mask */
|
|---|
| 594 | memcpy(&out[outi], &ws->ws.mask, 4);
|
|---|
| 595 |
|
|---|
| 596 | if(data->set.upload_buffer_size < (len + 10))
|
|---|
| 597 | return 0;
|
|---|
| 598 |
|
|---|
| 599 | /* pass over the mask */
|
|---|
| 600 | outi += 4;
|
|---|
| 601 |
|
|---|
| 602 | ws->ws.xori = 0;
|
|---|
| 603 | /* return packet size */
|
|---|
| 604 | return outi;
|
|---|
| 605 | }
|
|---|
| 606 |
|
|---|
| 607 | CURL_EXTERN CURLcode curl_ws_send(struct Curl_easy *data, const void *buffer,
|
|---|
| 608 | size_t buflen, size_t *sent,
|
|---|
| 609 | curl_off_t totalsize,
|
|---|
| 610 | unsigned int sendflags)
|
|---|
| 611 | {
|
|---|
| 612 | CURLcode result;
|
|---|
| 613 | size_t headlen;
|
|---|
| 614 | char *out;
|
|---|
| 615 | ssize_t written;
|
|---|
| 616 | struct websocket *wsp = &data->req.p.http->ws;
|
|---|
| 617 |
|
|---|
| 618 | if(!data->set.ws_raw_mode) {
|
|---|
| 619 | result = Curl_get_upload_buffer(data);
|
|---|
| 620 | if(result)
|
|---|
| 621 | return result;
|
|---|
| 622 | }
|
|---|
| 623 | else {
|
|---|
| 624 | if(totalsize || sendflags)
|
|---|
| 625 | return CURLE_BAD_FUNCTION_ARGUMENT;
|
|---|
| 626 | }
|
|---|
| 627 |
|
|---|
| 628 | if(data->set.ws_raw_mode) {
|
|---|
| 629 | if(!buflen)
|
|---|
| 630 | /* nothing to do */
|
|---|
| 631 | return CURLE_OK;
|
|---|
| 632 | /* raw mode sends exactly what was requested, and this is from within
|
|---|
| 633 | the write callback */
|
|---|
| 634 | if(Curl_is_in_callback(data)) {
|
|---|
| 635 | if(!data->conn) {
|
|---|
| 636 | failf(data, "No associated connection");
|
|---|
| 637 | return CURLE_SEND_ERROR;
|
|---|
| 638 | }
|
|---|
| 639 | result = Curl_write(data, data->conn->writesockfd, buffer, buflen,
|
|---|
| 640 | &written);
|
|---|
| 641 | }
|
|---|
| 642 | else
|
|---|
| 643 | result = Curl_senddata(data, buffer, buflen, &written);
|
|---|
| 644 |
|
|---|
| 645 | infof(data, "WS: wanted to send %zu bytes, sent %zu bytes",
|
|---|
| 646 | buflen, written);
|
|---|
| 647 | *sent = written;
|
|---|
| 648 | return result;
|
|---|
| 649 | }
|
|---|
| 650 |
|
|---|
| 651 | if(buflen > (data->set.upload_buffer_size - 10))
|
|---|
| 652 | /* don't do more than this in one go */
|
|---|
| 653 | buflen = data->set.upload_buffer_size - 10;
|
|---|
| 654 |
|
|---|
| 655 | if(sendflags & CURLWS_OFFSET) {
|
|---|
| 656 | if(totalsize) {
|
|---|
| 657 | /* a frame series 'totalsize' bytes big, this is the first */
|
|---|
| 658 | headlen = ws_packethead(data, totalsize, sendflags);
|
|---|
| 659 | wsp->sleft = totalsize - buflen;
|
|---|
| 660 | }
|
|---|
| 661 | else {
|
|---|
| 662 | headlen = 0;
|
|---|
| 663 | if((curl_off_t)buflen > wsp->sleft) {
|
|---|
| 664 | infof(data, "WS: unaligned frame size (sending %zu instead of %zu)",
|
|---|
| 665 | buflen, wsp->sleft);
|
|---|
| 666 | wsp->sleft = 0;
|
|---|
| 667 | }
|
|---|
| 668 | else
|
|---|
| 669 | wsp->sleft -= buflen;
|
|---|
| 670 | }
|
|---|
| 671 | }
|
|---|
| 672 | else
|
|---|
| 673 | headlen = ws_packethead(data, buflen, sendflags);
|
|---|
| 674 |
|
|---|
| 675 | /* headlen is the size of the frame header */
|
|---|
| 676 | out = data->state.ulbuf;
|
|---|
| 677 | if(buflen)
|
|---|
| 678 | /* for PING and PONG etc there might not be a payload */
|
|---|
| 679 | ws_xor(data, buffer, (unsigned char *)out + headlen, buflen);
|
|---|
| 680 |
|
|---|
| 681 | if(data->set.connect_only)
|
|---|
| 682 | result = Curl_senddata(data, out, buflen + headlen, &written);
|
|---|
| 683 | else
|
|---|
| 684 | result = Curl_write(data, data->conn->writesockfd, out,
|
|---|
| 685 | buflen + headlen, &written);
|
|---|
| 686 |
|
|---|
| 687 | infof(data, "WS: wanted to send %zu bytes, sent %zu bytes",
|
|---|
| 688 | headlen + buflen, written);
|
|---|
| 689 | *sent = written;
|
|---|
| 690 |
|
|---|
| 691 | return result;
|
|---|
| 692 | }
|
|---|
| 693 |
|
|---|
| 694 | void Curl_ws_done(struct Curl_easy *data)
|
|---|
| 695 | {
|
|---|
| 696 | struct websocket *wsp = &data->req.p.http->ws;
|
|---|
| 697 | DEBUGASSERT(wsp);
|
|---|
| 698 | Curl_dyn_free(&wsp->buf);
|
|---|
| 699 | }
|
|---|
| 700 |
|
|---|
| 701 | CURL_EXTERN struct curl_ws_frame *curl_ws_meta(struct Curl_easy *data)
|
|---|
| 702 | {
|
|---|
| 703 | /* we only return something for websocket, called from within the callback
|
|---|
| 704 | when not using raw mode */
|
|---|
| 705 | if(GOOD_EASY_HANDLE(data) && Curl_is_in_callback(data) && data->req.p.http &&
|
|---|
| 706 | !data->set.ws_raw_mode)
|
|---|
| 707 | return &data->req.p.http->ws.frame;
|
|---|
| 708 | return NULL;
|
|---|
| 709 | }
|
|---|
| 710 |
|
|---|
| 711 | #else
|
|---|
| 712 |
|
|---|
| 713 | CURL_EXTERN CURLcode curl_ws_recv(CURL *curl, void *buffer, size_t buflen,
|
|---|
| 714 | size_t *nread,
|
|---|
| 715 | struct curl_ws_frame **metap)
|
|---|
| 716 | {
|
|---|
| 717 | (void)curl;
|
|---|
| 718 | (void)buffer;
|
|---|
| 719 | (void)buflen;
|
|---|
| 720 | (void)nread;
|
|---|
| 721 | (void)metap;
|
|---|
| 722 | return CURLE_NOT_BUILT_IN;
|
|---|
| 723 | }
|
|---|
| 724 |
|
|---|
| 725 | CURL_EXTERN CURLcode curl_ws_send(CURL *curl, const void *buffer,
|
|---|
| 726 | size_t buflen, size_t *sent,
|
|---|
| 727 | curl_off_t framesize,
|
|---|
| 728 | unsigned int sendflags)
|
|---|
| 729 | {
|
|---|
| 730 | (void)curl;
|
|---|
| 731 | (void)buffer;
|
|---|
| 732 | (void)buflen;
|
|---|
| 733 | (void)sent;
|
|---|
| 734 | (void)framesize;
|
|---|
| 735 | (void)sendflags;
|
|---|
| 736 | return CURLE_NOT_BUILT_IN;
|
|---|
| 737 | }
|
|---|
| 738 |
|
|---|
| 739 | CURL_EXTERN struct curl_ws_frame *curl_ws_meta(struct Curl_easy *data)
|
|---|
| 740 | {
|
|---|
| 741 | (void)data;
|
|---|
| 742 | return NULL;
|
|---|
| 743 | }
|
|---|
| 744 | #endif /* USE_WEBSOCKETS */
|
|---|