The function fails, if a previous frame has not been completely
read yet. Also it fails in *CURLWS_RAW_MODE*.
+The read function in libcurl usually treats a return value of 0
+as the end of file indication and stops any further reads. This
+would prevent sending WebSocket frames of length 0.
+
+If the read function calls `curl_ws_start_frame()` however, a return
+value of 0 is *not* treated as an end of file and libcurl calls
+the read function again.
+
# FLAGS
Supports all flags documented in curl_ws_meta(3).
typedef enum {
CW_OUT_NONE,
CW_OUT_BODY,
+ CW_OUT_BODY_0LEN,
CW_OUT_HDS
} cw_out_type;
{
switch(otype) {
case CW_OUT_BODY:
+ case CW_OUT_BODY_0LEN:
*pwcb = data->set.fwrite_func;
*pwcb_data = data->set.out;
*pmax_write = CURL_MAX_WRITE_SIZE;
}
*pconsumed = 0;
- while(blen && !ctx->paused) {
- if(!flush_all && blen < min_write)
- break;
- wlen = max_write ? CURLMIN(blen, max_write) : blen;
+ if(otype == CW_OUT_BODY_0LEN) {
+ DEBUGASSERT(!blen);
Curl_set_in_callback(data, TRUE);
- nwritten = wcb((char *)CURL_UNCONST(buf), 1, wlen, wcb_data);
+ nwritten = wcb((char *)CURL_UNCONST(buf), 1, blen, wcb_data);
Curl_set_in_callback(data, FALSE);
- CURL_TRC_WRITE(data, "[OUT] wrote %zu %s bytes -> %zu",
- wlen, (otype == CW_OUT_BODY) ? "body" : "header",
- nwritten);
- if(CURL_WRITEFUNC_PAUSE == nwritten) {
- if(data->conn && data->conn->handler->flags & PROTOPT_NONETWORK) {
- /* Protocols that work without network cannot be paused. This is
- actually only FILE:// just now, and it cannot pause since the
- transfer is not done using the "normal" procedure. */
- failf(data, "Write callback asked for PAUSE when not supported");
+ CURL_TRC_WRITE(data, "[OUT] wrote %zu BODY bytes -> %zu",
+ blen, nwritten);
+ }
+ else {
+ while(blen && !ctx->paused) {
+ if(!flush_all && blen < min_write)
+ break;
+ wlen = max_write ? CURLMIN(blen, max_write) : blen;
+ Curl_set_in_callback(data, TRUE);
+ nwritten = wcb((char *)CURL_UNCONST(buf), 1, wlen, wcb_data);
+ Curl_set_in_callback(data, FALSE);
+ CURL_TRC_WRITE(data, "[OUT] wrote %zu %s bytes -> %zu",
+ wlen, (otype == CW_OUT_BODY) ? "body" : "header",
+ nwritten);
+ if(CURL_WRITEFUNC_PAUSE == nwritten) {
+ if(data->conn && data->conn->handler->flags & PROTOPT_NONETWORK) {
+ /* Protocols that work without network cannot be paused. This is
+ actually only FILE:// just now, and it cannot pause since the
+ transfer is not done using the "normal" procedure. */
+ failf(data, "Write callback asked for PAUSE when not supported");
+ return CURLE_WRITE_ERROR;
+ }
+ ctx->paused = TRUE;
+ CURL_TRC_WRITE(data, "[OUT] PAUSE requested by client");
+ return Curl_xfer_pause_recv(data, TRUE);
+ }
+ else if(CURL_WRITEFUNC_ERROR == nwritten) {
+ failf(data, "client returned ERROR on write of %zu bytes", wlen);
return CURLE_WRITE_ERROR;
}
- ctx->paused = TRUE;
- CURL_TRC_WRITE(data, "[OUT] PAUSE requested by client");
- return Curl_xfer_pause_recv(data, TRUE);
- }
- else if(CURL_WRITEFUNC_ERROR == nwritten) {
- failf(data, "client returned ERROR on write of %zu bytes", wlen);
- return CURLE_WRITE_ERROR;
- }
- else if(nwritten != wlen) {
- failf(data, "Failure writing output to destination, "
- "passed %zu returned %zd", wlen, nwritten);
- return CURLE_WRITE_ERROR;
+ else if(nwritten != wlen) {
+ failf(data, "Failure writing output to destination, "
+ "passed %zu returned %zd", wlen, nwritten);
+ return CURLE_WRITE_ERROR;
+ }
+ *pconsumed += nwritten;
+ blen -= nwritten;
+ buf += nwritten;
}
- *pconsumed += nwritten;
- blen -= nwritten;
- buf += nwritten;
}
return CURLE_OK;
}
if((type & CLIENTWRITE_BODY) ||
((type & CLIENTWRITE_HEADER) && data->set.include_header)) {
- result = cw_out_do_write(ctx, data, CW_OUT_BODY, flush_all, buf, blen);
+ cw_out_type otype = (!blen && (type & CLIENTWRITE_0LEN)) ?
+ CW_OUT_BODY_0LEN : CW_OUT_BODY;
+ result = cw_out_do_write(ctx, data, otype, flush_all, buf, blen);
if(result)
return result;
}
Curl_creader_def_needs_rewind,
Curl_creader_def_total_length,
Curl_creader_def_resume_from,
- Curl_creader_def_rewind,
- Curl_creader_def_unpause,
+ Curl_creader_def_cntrl,
Curl_creader_def_is_paused,
cr_exp100_done,
sizeof(struct cr_exp100_ctx)
Curl_creader_def_needs_rewind,
cr_chunked_total_length,
Curl_creader_def_resume_from,
- Curl_creader_def_rewind,
- Curl_creader_def_unpause,
+ Curl_creader_def_cntrl,
Curl_creader_def_is_paused,
Curl_creader_def_done,
sizeof(struct chunked_reader)
return CURLE_OK;
}
-static CURLcode cr_mime_rewind(struct Curl_easy *data,
- struct Curl_creader *reader)
+static CURLcode cr_mime_cntrl(struct Curl_easy *data,
+ struct Curl_creader *reader,
+ Curl_creader_cntrl opcode)
{
struct cr_mime_ctx *ctx = reader->ctx;
- CURLcode result = mime_rewind(ctx->part);
- if(result)
- failf(data, "Cannot rewind mime/post data");
- return result;
-}
-
-static CURLcode cr_mime_unpause(struct Curl_easy *data,
- struct Curl_creader *reader)
-{
- struct cr_mime_ctx *ctx = reader->ctx;
- (void)data;
- mime_unpause(ctx->part);
+ switch(opcode) {
+ case CURL_CRCNTRL_REWIND: {
+ CURLcode result = mime_rewind(ctx->part);
+ if(result)
+ failf(data, "Cannot rewind mime/post data");
+ return result;
+ }
+ case CURL_CRCNTRL_UNPAUSE:
+ mime_unpause(ctx->part);
+ break;
+ case CURL_CRCNTRL_CLEAR_EOS:
+ ctx->seen_eos = FALSE;
+ break;
+ default:
+ break;
+ }
return CURLE_OK;
}
cr_mime_needs_rewind,
cr_mime_total_length,
cr_mime_resume_from,
- cr_mime_rewind,
- cr_mime_unpause,
+ cr_mime_cntrl,
cr_mime_is_paused,
Curl_creader_def_done,
sizeof(struct cr_mime_ctx)
CURL_TRC_READ(data, "client start, rewind readers");
while(r) {
- result = r->crt->rewind(data, r);
+ result = r->crt->cntrl(data, r, CURL_CRCNTRL_REWIND);
if(result) {
failf(data, "rewind of client reader '%s' failed: %d",
r->crt->name, result);
return reader->crt->do_read(data, reader, buf, blen, nread, eos);
}
+void Curl_creader_clear_eos(struct Curl_easy *data,
+ struct Curl_creader *reader)
+{
+ while(reader) {
+ (void)reader->crt->cntrl(data, reader, CURL_CRCNTRL_CLEAR_EOS);
+ reader = reader->next;
+ }
+}
+
CURLcode Curl_creader_def_init(struct Curl_easy *data,
struct Curl_creader *reader)
{
return CURLE_READ_ERROR;
}
-CURLcode Curl_creader_def_rewind(struct Curl_easy *data,
- struct Curl_creader *reader)
-{
- (void)data;
- (void)reader;
- return CURLE_OK;
-}
-
-CURLcode Curl_creader_def_unpause(struct Curl_easy *data,
- struct Curl_creader *reader)
+CURLcode Curl_creader_def_cntrl(struct Curl_easy *data,
+ struct Curl_creader *reader,
+ Curl_creader_cntrl opcode)
{
(void)data;
(void)reader;
+ (void)opcode;
return CURLE_OK;
}
return CURLE_OK;
}
-static CURLcode cr_in_unpause(struct Curl_easy *data,
- struct Curl_creader *reader)
+static CURLcode cr_in_cntrl(struct Curl_easy *data,
+ struct Curl_creader *reader,
+ Curl_creader_cntrl opcode)
{
struct cr_in_ctx *ctx = reader->ctx;
- (void)data;
- ctx->is_paused = FALSE;
+
+ switch(opcode) {
+ case CURL_CRCNTRL_REWIND:
+ return cr_in_rewind(data, reader);
+ case CURL_CRCNTRL_UNPAUSE:
+ ctx->is_paused = FALSE;
+ break;
+ case CURL_CRCNTRL_CLEAR_EOS:
+ ctx->seen_eos = FALSE;
+ break;
+ default:
+ break;
+ }
return CURLE_OK;
}
cr_in_needs_rewind,
cr_in_total_length,
cr_in_resume_from,
- cr_in_rewind,
- cr_in_unpause,
+ cr_in_cntrl,
cr_in_is_paused,
Curl_creader_def_done,
sizeof(struct cr_in_ctx)
Curl_creader_def_needs_rewind,
cr_lc_total_length,
Curl_creader_def_resume_from,
- Curl_creader_def_rewind,
- Curl_creader_def_unpause,
+ Curl_creader_def_cntrl,
Curl_creader_def_is_paused,
Curl_creader_def_done,
sizeof(struct cr_lc_ctx)
Curl_creader_def_needs_rewind,
cr_null_total_length,
Curl_creader_def_resume_from,
- Curl_creader_def_rewind,
- Curl_creader_def_unpause,
+ Curl_creader_def_cntrl,
Curl_creader_def_is_paused,
Curl_creader_def_done,
sizeof(struct Curl_creader)
return ctx->index > 0;
}
-static CURLcode cr_buf_rewind(struct Curl_easy *data,
- struct Curl_creader *reader)
+static CURLcode cr_buf_cntrl(struct Curl_easy *data,
+ struct Curl_creader *reader,
+ Curl_creader_cntrl opcode)
{
struct cr_buf_ctx *ctx = reader->ctx;
(void)data;
- ctx->index = 0;
+ switch(opcode) {
+ case CURL_CRCNTRL_REWIND:
+ ctx->index = 0;
+ break;
+ default:
+ break;
+ }
return CURLE_OK;
}
cr_buf_needs_rewind,
cr_buf_total_length,
cr_buf_resume_from,
- cr_buf_rewind,
- Curl_creader_def_unpause,
+ cr_buf_cntrl,
Curl_creader_def_is_paused,
Curl_creader_def_done,
sizeof(struct cr_buf_ctx)
CURLcode result = CURLE_OK;
while(reader) {
- result = reader->crt->unpause(data, reader);
+ result = reader->crt->cntrl(data, reader, CURL_CRCNTRL_UNPAUSE);
if(result)
break;
reader = reader->next;
#define CLIENTWRITE_1XX (1<<5) /* a 1xx response related HEADER */
#define CLIENTWRITE_TRAILER (1<<6) /* a trailer HEADER */
#define CLIENTWRITE_EOS (1<<7) /* End Of transfer download Stream */
+#define CLIENTWRITE_0LEN (1<<8) /* write even 0-length buffers */
/**
* Write `len` bytes at `prt` to the client. `type` indicates what
struct Curl_cwriter *writer);
+typedef enum {
+ CURL_CRCNTRL_REWIND,
+ CURL_CRCNTRL_UNPAUSE,
+ CURL_CRCNTRL_CLEAR_EOS
+} Curl_creader_cntrl;
/* Client Reader Type, provides the implementation */
struct Curl_crtype {
struct Curl_creader *reader);
CURLcode (*resume_from)(struct Curl_easy *data,
struct Curl_creader *reader, curl_off_t offset);
- CURLcode (*rewind)(struct Curl_easy *data, struct Curl_creader *reader);
- CURLcode (*unpause)(struct Curl_easy *data, struct Curl_creader *reader);
+ CURLcode (*cntrl)(struct Curl_easy *data, struct Curl_creader *reader,
+ Curl_creader_cntrl opcode);
bool (*is_paused)(struct Curl_easy *data, struct Curl_creader *reader);
void (*done)(struct Curl_easy *data,
struct Curl_creader *reader, int premature);
CURLcode Curl_creader_def_resume_from(struct Curl_easy *data,
struct Curl_creader *reader,
curl_off_t offset);
-CURLcode Curl_creader_def_rewind(struct Curl_easy *data,
- struct Curl_creader *reader);
-CURLcode Curl_creader_def_unpause(struct Curl_easy *data,
- struct Curl_creader *reader);
+CURLcode Curl_creader_def_cntrl(struct Curl_easy *data,
+ struct Curl_creader *reader,
+ Curl_creader_cntrl opcode);
bool Curl_creader_def_is_paused(struct Curl_easy *data,
struct Curl_creader *reader);
void Curl_creader_def_done(struct Curl_easy *data,
struct Curl_creader *reader,
char *buf, size_t blen, size_t *nread, bool *eos);
+/* Tell the reader and all below that any EOS state is to be cleared */
+void Curl_creader_clear_eos(struct Curl_easy *data,
+ struct Curl_creader *reader);
+
/**
* Create a new creader instance with given type and phase. Is not
* inserted into the writer chain by this call.
Curl_creader_def_needs_rewind,
cr_eob_total_length,
Curl_creader_def_resume_from,
- Curl_creader_def_rewind,
- Curl_creader_def_unpause,
+ Curl_creader_def_cntrl,
Curl_creader_def_is_paused,
Curl_creader_def_done,
sizeof(struct cr_eob_ctx)
static CURLcode ws_dec_pass_payload(struct ws_decoder *dec,
struct Curl_easy *data,
struct bufq *inraw,
- ws_write_payload *write_payload,
+ ws_write_payload *write_cb,
void *write_ctx)
{
const unsigned char *inbuf;
while(remain && Curl_bufq_peek(inraw, &inbuf, &inlen)) {
if((curl_off_t)inlen > remain)
inlen = (size_t)remain;
- nwritten = write_payload(inbuf, inlen, dec->frame_age, dec->frame_flags,
- dec->payload_offset, dec->payload_len,
- write_ctx, &result);
+ nwritten = write_cb(inbuf, inlen, dec->frame_age, dec->frame_flags,
+ dec->payload_offset, dec->payload_len,
+ write_ctx, &result);
if(nwritten < 0)
return result;
Curl_bufq_skip(inraw, (size_t)nwritten);
static CURLcode ws_dec_pass(struct ws_decoder *dec,
struct Curl_easy *data,
struct bufq *inraw,
- ws_write_payload *write_payload,
+ ws_write_payload *write_cb,
void *write_ctx)
{
CURLcode result;
ssize_t nwritten;
const unsigned char tmp = '\0';
/* special case of a 0 length frame, need to write once */
- nwritten = write_payload(&tmp, 0, dec->frame_age, dec->frame_flags,
- 0, 0, write_ctx, &result);
+ nwritten = write_cb(&tmp, 0, dec->frame_age, dec->frame_flags,
+ 0, 0, write_ctx, &result);
if(nwritten < 0)
return result;
dec->state = WS_DEC_INIT;
}
FALLTHROUGH();
case WS_DEC_PAYLOAD:
- result = ws_dec_pass_payload(dec, data, inraw, write_payload, write_ctx);
+ result = ws_dec_pass_payload(dec, data, inraw, write_cb, write_ctx);
ws_dec_info(dec, data, "passing");
if(result)
return result;
update_meta(ws, frame_age, frame_flags, payload_offset,
payload_len, buflen);
- *err = Curl_cwriter_write(data, ctx->next_writer, ctx->cw_type,
+ *err = Curl_cwriter_write(data, ctx->next_writer,
+ (ctx->cw_type | CLIENTWRITE_0LEN),
(const char *)buf, buflen);
if(*err)
return -1;
return result;
ctx->read_eos = eos;
- if(!nread) {
+ if(!Curl_bufq_is_empty(&ws->sendbuf)) {
+ /* client_read started a new frame, we disregard any eos reported */
+ ctx->read_eos = FALSE;
+ Curl_creader_clear_eos(data, reader->next);
+ }
+ else if(!nread) {
/* nothing to convert, return this right away */
if(ctx->read_eos)
ctx->eos = TRUE;
goto out;
}
- if(!ws->enc.payload_remain) {
+ if(!ws->enc.payload_remain && Curl_bufq_is_empty(&ws->sendbuf)) {
/* encode the data as a new BINARY frame */
result = ws_enc_write_head(data, &ws->enc, CURLWS_BINARY, nread,
&ws->sendbuf);
Curl_creader_def_needs_rewind,
Curl_creader_def_total_length,
Curl_creader_def_resume_from,
- Curl_creader_def_rewind,
- Curl_creader_def_unpause,
+ Curl_creader_def_cntrl,
Curl_creader_def_is_paused,
Curl_creader_def_done,
sizeof(struct cr_ws_ctx)
return CURLE_FAILED_INIT;
}
- CURL_TRC_WS(data, "curl_start_frame(flags=%x, frame_len=%" FMT_OFF_T,
+ CURL_TRC_WS(data, "curl_ws_start_frame(flags=%x, frame_len=%" FMT_OFF_T,
flags, frame_len);
if(!data->conn) {
if not client.exists():
pytest.skip(f'example client not built: {client.name}')
url = f'ws://localhost:{env.ws_port}/'
- r = client.run(args=[f'-{model}', '-m', str(0), '-M', str(10), url])
+ r = client.run(args=[f'-{model}', '-m', str(1), '-M', str(10), url])
r.check_exit_code(0)
@pytest.mark.parametrize("model", [
large = 20000
r = client.run(args=[f'-{model}', '-c', str(count), '-m', str(large), url])
r.check_exit_code(0)
+
+ @pytest.mark.parametrize("model", [
+ pytest.param(1, id='multi_perform'),
+ pytest.param(2, id='curl_ws_send+recv'),
+ ])
+ def test_20_09_data_empty(self, env: Env, ws_echo, model):
+ client = LocalClient(env=env, name='cli_ws_data')
+ if not client.exists():
+ pytest.skip(f'example client not built: {client.name}')
+ url = f'ws://localhost:{env.ws_port}/'
+ count = 10
+ large = 0
+ r = client.run(args=[f'-{model}', '-c', str(count), '-m', str(large), url])
+ r.check_exit_code(0)
char *recv_buf;
size_t send_len, nsent;
size_t recv_len, nrcvd;
+ int nframes;
+ int read_calls;
+ int write_calls;
+ int frames_read;
+ int frames_written;
+ BIT(frame_reading);
};
static size_t test_ws_data_m1_read(char *buf, size_t nitems, size_t buflen,
size_t len = nitems * buflen;
size_t left = ctx->send_len - ctx->nsent;
- curl_mfprintf(stderr, "m1_read(len=%zu, left=%zu)\n", len, left);
- if(left) {
+ ctx->read_calls++;
+
+ if(ctx->frames_read >= ctx->nframes)
+ goto out;
+
+ if(!ctx->frame_reading) {
+ curl_ws_start_frame(ctx->easy, CURLWS_BINARY, ctx->send_len);
+ ctx->frame_reading = TRUE;
+ }
+
+ if(ctx->frame_reading) {
+ bool complete;
if(left > len)
left = len;
memcpy(buf, ctx->send_buf + ctx->nsent, left);
ctx->nsent += left;
+ complete = (ctx->send_len == ctx->nsent);
+ curl_mfprintf(stderr, "m1_read(len=%zu, call #%d, frame #%d%s) -> %zu\n",
+ len, ctx->read_calls, ctx->frames_read,
+ complete ? " complete" : "", left);
+ if(complete) {
+ ++ctx->frames_read;
+ ctx->frame_reading = FALSE;
+ ctx->nsent = 0;
+ }
return left;
}
- return CURL_READFUNC_PAUSE;
+out:
+ curl_mfprintf(stderr, "m1_read(len=%zu, call #%d) -> EOS\n",
+ len, ctx->read_calls);
+ return 0;
}
static size_t test_ws_data_m1_write(char *buf, size_t nitems, size_t buflen,
{
struct test_ws_m1_ctx *ctx = userdata;
size_t len = nitems * buflen;
+ bool complete;
- curl_mfprintf(stderr, "m1_write(len=%zu)\n", len);
- if(len > (ctx->recv_len - ctx->nrcvd))
+ ctx->write_calls++;
+ if(len > (ctx->recv_len - ctx->nrcvd)) {
+ curl_mfprintf(stderr, "m1_write(len=%zu, call #%d) -> ERROR\n",
+ len, ctx->write_calls);
return CURL_WRITEFUNC_ERROR;
+ }
memcpy(ctx->recv_buf + ctx->nrcvd, buf, len);
ctx->nrcvd += len;
+ complete = (ctx->recv_len == ctx->nrcvd);
+
+ if(memcmp(ctx->send_buf, ctx->recv_buf, ctx->nrcvd)) {
+ curl_mfprintf(stderr, "m1_write(len=%zu, call #%d, frame #%d) -> "
+ "data differs\n",
+ len, ctx->write_calls, ctx->frames_written);
+ debug_dump("", "expected:", stderr,
+ (unsigned char *)ctx->send_buf, ctx->nrcvd, 0);
+ debug_dump("", "received:", stderr,
+ (unsigned char *)ctx->recv_buf, ctx->nrcvd, 0);
+ return CURL_WRITEFUNC_ERROR;
+ }
+
+ curl_mfprintf(stderr, "m1_write(len=%zu, call #%d, frame #%d%s) -> %zu\n",
+ len, ctx->write_calls, ctx->frames_written,
+ complete ? " complete" : "", len);
+ if(complete) {
+ ++ctx->frames_written;
+ ctx->nrcvd = 0;
+ }
return len;
}
/* WebSocket Mode 1: multi handle, READ/WRITEFUNCTION use */
static CURLcode test_ws_data_m1_echo(const char *url,
- size_t count,
size_t plen_min,
size_t plen_max)
{
struct test_ws_m1_ctx m1_ctx;
size_t i, len;
+ curl_mfprintf(stderr, "test_ws_data_m1_echo(min=%zu, max=%zu)\n",
+ plen_min, plen_max);
memset(&m1_ctx, 0, sizeof(m1_ctx));
m1_ctx.send_buf = calloc(1, plen_max + 1);
m1_ctx.recv_buf = calloc(1, plen_max + 1);
goto out;
}
- curl_easy_setopt(m1_ctx.easy, CURLOPT_URL, url);
- /* use the callback style */
- curl_easy_setopt(m1_ctx.easy, CURLOPT_USERAGENT, "ws-data");
- curl_easy_setopt(m1_ctx.easy, CURLOPT_VERBOSE, 1L);
- /* we want to send */
- curl_easy_setopt(m1_ctx.easy, CURLOPT_UPLOAD, 1L);
- curl_easy_setopt(m1_ctx.easy, CURLOPT_READFUNCTION, test_ws_data_m1_read);
- curl_easy_setopt(m1_ctx.easy, CURLOPT_READDATA, &m1_ctx);
- curl_easy_setopt(m1_ctx.easy, CURLOPT_WRITEFUNCTION, test_ws_data_m1_write);
- curl_easy_setopt(m1_ctx.easy, CURLOPT_WRITEDATA, &m1_ctx);
-
- curl_multi_add_handle(multi, m1_ctx.easy);
-
for(len = plen_min; len <= plen_max; ++len) {
/* init what we want to send and expect to receive */
+ curl_mfprintf(stderr, "m1_echo, iter len=%zu\n", len);
+
m1_ctx.send_len = len;
m1_ctx.nsent = 0;
m1_ctx.recv_len = len;
m1_ctx.nrcvd = 0;
+ m1_ctx.nframes = 2;
+ m1_ctx.read_calls = 0;
+ m1_ctx.write_calls = 0;
+ m1_ctx.frames_read = 0;
+ m1_ctx.frames_written = 0;
memset(m1_ctx.recv_buf, 0, plen_max);
curl_easy_pause(m1_ctx.easy, CURLPAUSE_CONT);
- for(i = 0; i < count; ++i) {
- while(1) {
- int still_running; /* keep number of running handles */
- CURLMcode mc = curl_multi_perform(multi, &still_running);
-
- if(!still_running || (m1_ctx.nrcvd == m1_ctx.recv_len)) {
- /* got the full echo back or failed */
- break;
- }
-
- if(!mc && still_running) {
- mc = curl_multi_poll(multi, NULL, 0, 1, NULL);
- }
- if(mc) {
- r = CURLE_RECV_ERROR;
- goto out;
- }
-
+ curl_easy_reset(m1_ctx.easy);
+ curl_easy_setopt(m1_ctx.easy, CURLOPT_URL, url);
+ /* use the callback style */
+ curl_easy_setopt(m1_ctx.easy, CURLOPT_USERAGENT, "ws-data");
+ curl_easy_setopt(m1_ctx.easy, CURLOPT_VERBOSE, 1L);
+ /* we want to send */
+ curl_easy_setopt(m1_ctx.easy, CURLOPT_UPLOAD, 1L);
+ curl_easy_setopt(m1_ctx.easy, CURLOPT_READFUNCTION, test_ws_data_m1_read);
+ curl_easy_setopt(m1_ctx.easy, CURLOPT_READDATA, &m1_ctx);
+ curl_easy_setopt(m1_ctx.easy, CURLOPT_WRITEFUNCTION,
+ test_ws_data_m1_write);
+ curl_easy_setopt(m1_ctx.easy, CURLOPT_WRITEDATA, &m1_ctx);
+
+ curl_multi_add_handle(multi, m1_ctx.easy);
+
+ while(1) {
+ int still_running; /* keep number of running handles */
+ CURLMcode mc = curl_multi_perform(multi, &still_running);
+
+ if(!still_running || (m1_ctx.frames_written >= m1_ctx.nframes)) {
+ /* got the full echo back or failed */
+ break;
}
- if(memcmp(m1_ctx.send_buf, m1_ctx.recv_buf, m1_ctx.send_len)) {
- curl_mfprintf(stderr, "recv_data: data differs\n");
- debug_dump("", "expected:", stderr,
- (unsigned char *)m1_ctx.send_buf, m1_ctx.send_len, 0);
- debug_dump("", "received:", stderr,
- (unsigned char *)m1_ctx.recv_buf, m1_ctx.nrcvd, 0);
+ if(!mc && still_running) {
+ mc = curl_multi_poll(multi, NULL, 0, 1, NULL);
+ }
+ if(mc) {
r = CURLE_RECV_ERROR;
goto out;
}
}
+
+ curl_multi_remove_handle(multi, m1_ctx.easy);
+
+ /* check results */
+ if(m1_ctx.frames_read < m1_ctx.nframes) {
+ curl_mfprintf(stderr, "m1_echo, sent only %d/%d frames\n",
+ m1_ctx.frames_read, m1_ctx.nframes);
+ r = CURLE_SEND_ERROR;
+ goto out;
+ }
+ if(m1_ctx.frames_written < m1_ctx.frames_read) {
+ curl_mfprintf(stderr, "m1_echo, received only %d/%d frames\n",
+ m1_ctx.frames_written, m1_ctx.frames_read);
+ r = CURLE_RECV_ERROR;
+ goto out;
+ }
}
out:
curl_global_init(CURL_GLOBAL_ALL);
if(model == 1)
- res = test_ws_data_m1_echo(url, count, plen_min, plen_max);
+ res = test_ws_data_m1_echo(url, plen_min, plen_max);
else
res = test_ws_data_m2_echo(url, count, plen_min, plen_max);
projects / thirdparty / curl.git / commitdiff
