« back to all changes in this revision
Viewing changes to .pc/08_lp1124508.patch/lib/multi.c
- browse files at revision 69
- compare with another revision
- download diff
- download tarball
- view history from revision 69
- Committer: Package Import Robot
- Author(s): Sebastien Bacher
- Date: 2013-05-07 12:16:37 UTC
- mfrom: (3.4.37 sid)
- Revision ID: package-import@ubuntu.com-20130507121637-9t3i98qgsyr9dw5d
Tags: 7.30.0-1ubuntu1
* Resynchronize on Debian. Remaining changes:
- Drop dependencies not in main:
+ Build-Depends: Drop stunnel4 and libssh2-1-dev.
+ Drop libssh2-1-dev from binary package Depends.
- Add new libcurl3-udeb package.
- Add new curl-udeb package.
* Add warning to debian/patches/series.
- Drop dependencies not in main:
+ Build-Depends: Drop stunnel4 and libssh2-1-dev.
+ Drop libssh2-1-dev from binary package Depends.
- Add new libcurl3-udeb package.
- Add new curl-udeb package.
* Add warning to debian/patches/series.
- files added:
- debian/libcurl4-doc.doc-base
- packages/Android
- vs
- vs/t
- vs/t/lib
- vs/vc6
- vs/vc6/lib
- vs/vc6/src
- vs/vc8
- vs/vc8/lib
- files removed:
- .pc/08_lp1124508.patch
- .pc/08_lp1124508.patch/lib
- .pc/09_curl-tailmatch.patch
- .pc/09_curl-tailmatch.patch/lib
- debian/libcurl3-udeb.links
- files modified:
- .pc/01_runtests_gdb.patch/tests/runtests.pl
added
removed
.pc/08_lp1124508.patch/lib/multi.c
1
/***************************************************************************
2
* _ _ ____ _
3
* Project ___| | | | _ \| |
4
* / __| | | | |_) | |
5
* | (__| |_| | _ <| |___
6
* \___|\___/|_| \_\_____|
7
*
8
* Copyright (C) 1998 - 2013, 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 http://curl.haxx.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
***************************************************************************/
22
23
#include "curl_setup.h"
24
25
#include <curl/curl.h>
26
27
#include "urldata.h"
28
#include "transfer.h"
29
#include "url.h"
30
#include "connect.h"
31
#include "progress.h"
32
#include "easyif.h"
33
#include "multiif.h"
34
#include "sendf.h"
35
#include "timeval.h"
36
#include "http.h"
37
#include "select.h"
38
#include "warnless.h"
39
#include "speedcheck.h"
40
#include "conncache.h"
41
#include "bundles.h"
42
#include "multihandle.h"
43
44
#define _MPRINTF_REPLACE /* use our functions only */
45
#include <curl/mprintf.h>
46
47
#include "curl_memory.h"
48
/* The last #include file should be: */
49
#include "memdebug.h"
50
51
/*
52
CURL_SOCKET_HASH_TABLE_SIZE should be a prime number. Increasing it from 97
53
to 911 takes on a 32-bit machine 4 x 804 = 3211 more bytes. Still, every
54
CURL handle takes 45-50 K memory, therefore this 3K are not significant.
55
*/
56
#ifndef CURL_SOCKET_HASH_TABLE_SIZE
57
#define CURL_SOCKET_HASH_TABLE_SIZE 911
58
#endif
59
60
61
#define CURL_MULTI_HANDLE 0x000bab1e
62
63
#define GOOD_MULTI_HANDLE(x) \
64
((x) && (((struct Curl_multi *)(x))->type == CURL_MULTI_HANDLE))
65
#define GOOD_EASY_HANDLE(x) \
66
((x) && (((struct SessionHandle *)(x))->magic == CURLEASY_MAGIC_NUMBER))
67
68
static void singlesocket(struct Curl_multi *multi,
69
struct Curl_one_easy *easy);
70
static int update_timer(struct Curl_multi *multi);
71
72
static CURLcode addHandleToSendOrPendPipeline(struct SessionHandle *handle,
73
struct connectdata *conn);
74
static int checkPendPipeline(struct connectdata *conn);
75
static void moveHandleFromSendToRecvPipeline(struct SessionHandle *handle,
76
struct connectdata *conn);
77
static void moveHandleFromRecvToDonePipeline(struct SessionHandle *handle,
78
struct connectdata *conn);
79
static bool isHandleAtHead(struct SessionHandle *handle,
80
struct curl_llist *pipeline);
81
static CURLMcode add_next_timeout(struct timeval now,
82
struct Curl_multi *multi,
83
struct SessionHandle *d);
84
85
#ifdef DEBUGBUILD
86
static const char * const statename[]={
87
"INIT",
88
"CONNECT",
89
"WAITRESOLVE",
90
"WAITCONNECT",
91
"WAITPROXYCONNECT",
92
"PROTOCONNECT",
93
"WAITDO",
94
"DO",
95
"DOING",
96
"DO_MORE",
97
"DO_DONE",
98
"WAITPERFORM",
99
"PERFORM",
100
"TOOFAST",
101
"DONE",
102
"COMPLETED",
103
"MSGSENT",
104
};
105
#endif
106
107
static void multi_freetimeout(void *a, void *b);
108
109
/* always use this function to change state, to make debugging easier */
110
static void mstate(struct Curl_one_easy *easy, CURLMstate state
111
#ifdef DEBUGBUILD
112
, int lineno
113
#endif
114
)
115
{
116
#ifdef DEBUGBUILD
117
long connection_id = -5000;
118
#endif
119
CURLMstate oldstate = easy->state;
120
121
if(oldstate == state)
122
/* don't bother when the new state is the same as the old state */
123
return;
124
125
easy->state = state;
126
127
#ifdef DEBUGBUILD
128
if(easy->easy_conn) {
129
if(easy->state > CURLM_STATE_CONNECT &&
130
easy->state < CURLM_STATE_COMPLETED)
131
connection_id = easy->easy_conn->connection_id;
132
133
infof(easy->easy_handle,
134
"STATE: %s => %s handle %p; line %d (connection #%ld) \n",
135
statename[oldstate], statename[easy->state],
136
(char *)easy, lineno, connection_id);
137
}
138
#endif
139
if(state == CURLM_STATE_COMPLETED)
140
/* changing to COMPLETED means there's one less easy handle 'alive' */
141
easy->easy_handle->multi->num_alive--;
142
}
143
144
#ifndef DEBUGBUILD
145
#define multistate(x,y) mstate(x,y)
146
#else
147
#define multistate(x,y) mstate(x,y, __LINE__)
148
#endif
149
150
/*
151
* We add one of these structs to the sockhash for a particular socket
152
*/
153
154
struct Curl_sh_entry {
155
struct SessionHandle *easy;
156
time_t timestamp;
157
int action; /* what action READ/WRITE this socket waits for */
158
curl_socket_t socket; /* mainly to ease debugging */
159
void *socketp; /* settable by users with curl_multi_assign() */
160
};
161
/* bits for 'action' having no bits means this socket is not expecting any
162
action */
163
#define SH_READ 1
164
#define SH_WRITE 2
165
166
/* make sure this socket is present in the hash for this handle */
167
static struct Curl_sh_entry *sh_addentry(struct curl_hash *sh,
168
curl_socket_t s,
169
struct SessionHandle *data)
170
{
171
struct Curl_sh_entry *there =
172
Curl_hash_pick(sh, (char *)&s, sizeof(curl_socket_t));
173
struct Curl_sh_entry *check;
174
175
if(there)
176
/* it is present, return fine */
177
return there;
178
179
/* not present, add it */
180
check = calloc(1, sizeof(struct Curl_sh_entry));
181
if(!check)
182
return NULL; /* major failure */
183
check->easy = data;
184
check->socket = s;
185
186
/* make/add new hash entry */
187
if(NULL == Curl_hash_add(sh, (char *)&s, sizeof(curl_socket_t), check)) {
188
free(check);
189
return NULL; /* major failure */
190
}
191
192
return check; /* things are good in sockhash land */
193
}
194
195
196
/* delete the given socket + handle from the hash */
197
static void sh_delentry(struct curl_hash *sh, curl_socket_t s)
198
{
199
struct Curl_sh_entry *there =
200
Curl_hash_pick(sh, (char *)&s, sizeof(curl_socket_t));
201
202
if(there) {
203
/* this socket is in the hash */
204
/* We remove the hash entry. (This'll end up in a call to
205
sh_freeentry().) */
206
Curl_hash_delete(sh, (char *)&s, sizeof(curl_socket_t));
207
}
208
}
209
210
/*
211
* free a sockhash entry
212
*/
213
static void sh_freeentry(void *freethis)
214
{
215
struct Curl_sh_entry *p = (struct Curl_sh_entry *) freethis;
216
217
if(p)
218
free(p);
219
}
220
221
static size_t fd_key_compare(void*k1, size_t k1_len, void*k2, size_t k2_len)
222
{
223
(void) k1_len; (void) k2_len;
224
225
return (*((int* ) k1)) == (*((int* ) k2));
226
}
227
228
static size_t hash_fd(void* key, size_t key_length, size_t slots_num)
229
{
230
int fd = * ((int* ) key);
231
(void) key_length;
232
233
return (fd % (int)slots_num);
234
}
235
236
/*
237
* sh_init() creates a new socket hash and returns the handle for it.
238
*
239
* Quote from README.multi_socket:
240
*
241
* "Some tests at 7000 and 9000 connections showed that the socket hash lookup
242
* is somewhat of a bottle neck. Its current implementation may be a bit too
243
* limiting. It simply has a fixed-size array, and on each entry in the array
244
* it has a linked list with entries. So the hash only checks which list to
245
* scan through. The code I had used so for used a list with merely 7 slots
246
* (as that is what the DNS hash uses) but with 7000 connections that would
247
* make an average of 1000 nodes in each list to run through. I upped that to
248
* 97 slots (I believe a prime is suitable) and noticed a significant speed
249
* increase. I need to reconsider the hash implementation or use a rather
250
* large default value like this. At 9000 connections I was still below 10us
251
* per call."
252
*
253
*/
254
static struct curl_hash *sh_init(void)
255
{
256
return Curl_hash_alloc(CURL_SOCKET_HASH_TABLE_SIZE, hash_fd, fd_key_compare,
257
sh_freeentry);
258
}
259
260
/*
261
* multi_addmsg()
262
*
263
* Called when a transfer is completed. Adds the given msg pointer to
264
* the list kept in the multi handle.
265
*/
266
static CURLMcode multi_addmsg(struct Curl_multi *multi,
267
struct Curl_message *msg)
268
{
269
if(!Curl_llist_insert_next(multi->msglist, multi->msglist->tail, msg))
270
return CURLM_OUT_OF_MEMORY;
271
272
return CURLM_OK;
273
}
274
275
/*
276
* multi_freeamsg()
277
*
278
* Callback used by the llist system when a single list entry is destroyed.
279
*/
280
static void multi_freeamsg(void *a, void *b)
281
{
282
(void)a;
283
(void)b;
284
}
285
286
CURLM *curl_multi_init(void)
287
{
288
struct Curl_multi *multi = calloc(1, sizeof(struct Curl_multi));
289
290
if(!multi)
291
return NULL;
292
293
multi->type = CURL_MULTI_HANDLE;
294
295
multi->hostcache = Curl_mk_dnscache();
296
if(!multi->hostcache)
297
goto error;
298
299
multi->sockhash = sh_init();
300
if(!multi->sockhash)
301
goto error;
302
303
multi->conn_cache = Curl_conncache_init();
304
if(!multi->conn_cache)
305
goto error;
306
307
multi->msglist = Curl_llist_alloc(multi_freeamsg);
308
if(!multi->msglist)
309
goto error;
310
311
/* Let's make the doubly-linked list a circular list. This makes
312
the linked list code simpler and allows inserting at the end
313
with less work (we didn't keep a tail pointer before). */
314
multi->easy.next = &multi->easy;
315
multi->easy.prev = &multi->easy;
316
317
return (CURLM *) multi;
318
319
error:
320
321
Curl_hash_destroy(multi->sockhash);
322
multi->sockhash = NULL;
323
Curl_hash_destroy(multi->hostcache);
324
multi->hostcache = NULL;
325
Curl_conncache_destroy(multi->conn_cache);
326
multi->conn_cache = NULL;
327
328
free(multi);
329
return NULL;
330
}
331
332
CURLMcode curl_multi_add_handle(CURLM *multi_handle,
333
CURL *easy_handle)
334
{
335
struct curl_llist *timeoutlist;
336
struct Curl_one_easy *easy;
337
struct Curl_multi *multi = (struct Curl_multi *)multi_handle;
338
struct SessionHandle *data = (struct SessionHandle *)easy_handle;
339
struct SessionHandle *new_closure = NULL;
340
struct curl_hash *hostcache = NULL;
341
342
/* First, make some basic checks that the CURLM handle is a good handle */
343
if(!GOOD_MULTI_HANDLE(multi))
344
return CURLM_BAD_HANDLE;
345
346
/* Verify that we got a somewhat good easy handle too */
347
if(!GOOD_EASY_HANDLE(easy_handle))
348
return CURLM_BAD_EASY_HANDLE;
349
350
/* Prevent users from adding same easy handle more than
351
once and prevent adding to more than one multi stack */
352
if(data->multi)
353
/* possibly we should create a new unique error code for this condition */
354
return CURLM_BAD_EASY_HANDLE;
355
356
/* Allocate and initialize timeout list for easy handle */
357
timeoutlist = Curl_llist_alloc(multi_freetimeout);
358
if(!timeoutlist)
359
return CURLM_OUT_OF_MEMORY;
360
361
/* Allocate new node for the doubly-linked circular list of
362
Curl_one_easy structs that holds pointers to easy handles */
363
easy = calloc(1, sizeof(struct Curl_one_easy));
364
if(!easy) {
365
Curl_llist_destroy(timeoutlist, NULL);
366
return CURLM_OUT_OF_MEMORY;
367
}
368
369
/* In case multi handle has no hostcache yet, allocate one */
370
if(!multi->hostcache) {
371
hostcache = Curl_mk_dnscache();
372
if(!hostcache) {
373
free(easy);
374
Curl_llist_destroy(timeoutlist, NULL);
375
return CURLM_OUT_OF_MEMORY;
376
}
377
}
378
379
/* In case multi handle has no closure_handle yet, allocate
380
a new easy handle to use when closing cached connections */
381
if(!multi->closure_handle) {
382
new_closure = (struct SessionHandle *)curl_easy_init();
383
if(!new_closure) {
384
Curl_hash_destroy(hostcache);
385
free(easy);
386
Curl_llist_destroy(timeoutlist, NULL);
387
return CURLM_OUT_OF_MEMORY;
388
}
389
}
390
391
/*
392
** No failure allowed in this function beyond this point. And
393
** no modification of easy nor multi handle allowed before this
394
** except for potential multi's connection cache growing which
395
** won't be undone in this function no matter what.
396
*/
397
398
/* In case a new closure handle has been initialized above, it
399
is associated now with the multi handle which lacked one. */
400
if(new_closure) {
401
multi->closure_handle = new_closure;
402
Curl_easy_addmulti(multi->closure_handle, multi_handle);
403
multi->closure_handle->state.conn_cache = multi->conn_cache;
404
}
405
406
/* In case hostcache has been allocated above,
407
it is associated now with the multi handle. */
408
if(hostcache)
409
multi->hostcache = hostcache;
410
411
/* Make easy handle use timeout list initialized above */
412
data->state.timeoutlist = timeoutlist;
413
timeoutlist = NULL;
414
415
/* set the easy handle */
416
easy->easy_handle = data;
417
multistate(easy, CURLM_STATE_INIT);
418
419
/* set the back pointer to one_easy to assist in removal */
420
easy->easy_handle->multi_pos = easy;
421
422
/* for multi interface connections, we share DNS cache automatically if the
423
easy handle's one is currently not set. */
424
if(!easy->easy_handle->dns.hostcache ||
425
(easy->easy_handle->dns.hostcachetype == HCACHE_NONE)) {
426
easy->easy_handle->dns.hostcache = multi->hostcache;
427
easy->easy_handle->dns.hostcachetype = HCACHE_MULTI;
428
}
429
430
/* Point to the multi's connection cache */
431
easy->easy_handle->state.conn_cache = multi->conn_cache;
432
433
/* This adds the new entry at the 'end' of the doubly-linked circular
434
list of Curl_one_easy structs to try and maintain a FIFO queue so
435
the pipelined requests are in order. */
436
437
/* We add this new entry last in the list. We make our 'next' point to the
438
'first' struct and our 'prev' point to the previous 'prev' */
439
easy->next = &multi->easy;
440
easy->prev = multi->easy.prev;
441
442
/* make 'easy' the last node in the chain */
443
multi->easy.prev = easy;
444
445
/* if there was a prev node, make sure its 'next' pointer links to
446
the new node */
447
easy->prev->next = easy;
448
449
/* make the SessionHandle refer back to this multi handle */
450
Curl_easy_addmulti(easy_handle, multi_handle);
451
452
/* make the SessionHandle struct refer back to this struct */
453
easy->easy_handle->set.one_easy = easy;
454
455
/* Set the timeout for this handle to expire really soon so that it will
456
be taken care of even when this handle is added in the midst of operation
457
when only the curl_multi_socket() API is used. During that flow, only
458
sockets that time-out or have actions will be dealt with. Since this
459
handle has no action yet, we make sure it times out to get things to
460
happen. */
461
Curl_expire(easy->easy_handle, 1);
462
463
/* increase the node-counter */
464
multi->num_easy++;
465
466
/* increase the alive-counter */
467
multi->num_alive++;
468
469
/* A somewhat crude work-around for a little glitch in update_timer() that
470
happens if the lastcall time is set to the same time when the handle is
471
removed as when the next handle is added, as then the check in
472
update_timer() that prevents calling the application multiple times with
473
the same timer infor will not trigger and then the new handle's timeout
474
will not be notified to the app.
475
476
The work-around is thus simply to clear the 'lastcall' variable to force
477
update_timer() to always trigger a callback to the app when a new easy
478
handle is added */
479
memset(&multi->timer_lastcall, 0, sizeof(multi->timer_lastcall));
480
481
update_timer(multi);
482
return CURLM_OK;
483
}
484
485
#if 0
486
/* Debug-function, used like this:
487
*
488
* Curl_hash_print(multi->sockhash, debug_print_sock_hash);
489
*
490
* Enable the hash print function first by editing hash.c
491
*/
492
static void debug_print_sock_hash(void *p)
493
{
494
struct Curl_sh_entry *sh = (struct Curl_sh_entry *)p;
495
496
fprintf(stderr, " [easy %p/magic %x/socket %d]",
497
(void *)sh->easy, sh->easy->magic, (int)sh->socket);
498
}
499
#endif
500
501
CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
502
CURL *curl_handle)
503
{
504
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
505
struct Curl_one_easy *easy;
506
struct SessionHandle *data = curl_handle;
507
508
/* First, make some basic checks that the CURLM handle is a good handle */
509
if(!GOOD_MULTI_HANDLE(multi))
510
return CURLM_BAD_HANDLE;
511
512
/* Verify that we got a somewhat good easy handle too */
513
if(!GOOD_EASY_HANDLE(curl_handle))
514
return CURLM_BAD_EASY_HANDLE;
515
516
/* pick-up from the 'curl_handle' the kept position in the list */
517
easy = data->multi_pos;
518
519
if(easy) {
520
bool premature = (easy->state < CURLM_STATE_COMPLETED) ? TRUE : FALSE;
521
bool easy_owns_conn = (easy->easy_conn &&
522
(easy->easy_conn->data == easy->easy_handle)) ?
523
TRUE : FALSE;
524
525
/* If the 'state' is not INIT or COMPLETED, we might need to do something
526
nice to put the easy_handle in a good known state when this returns. */
527
if(premature)
528
/* this handle is "alive" so we need to count down the total number of
529
alive connections when this is removed */
530
multi->num_alive--;
531
532
if(easy->easy_conn &&
533
(easy->easy_conn->send_pipe->size +
534
easy->easy_conn->recv_pipe->size > 1) &&
535
easy->state > CURLM_STATE_WAITDO &&
536
easy->state < CURLM_STATE_COMPLETED) {
537
/* If the handle is in a pipeline and has started sending off its
538
request but not received its response yet, we need to close
539
connection. */
540
easy->easy_conn->bits.close = TRUE;
541
/* Set connection owner so that Curl_done() closes it.
542
We can sefely do this here since connection is killed. */
543
easy->easy_conn->data = easy->easy_handle;
544
}
545
546
/* The timer must be shut down before easy->multi is set to NULL,
547
else the timenode will remain in the splay tree after
548
curl_easy_cleanup is called. */
549
Curl_expire(easy->easy_handle, 0);
550
551
/* destroy the timeout list that is held in the easy handle */
552
if(data->state.timeoutlist) {
553
Curl_llist_destroy(data->state.timeoutlist, NULL);
554
data->state.timeoutlist = NULL;
555
}
556
557
if(easy->easy_handle->dns.hostcachetype == HCACHE_MULTI) {
558
/* stop using the multi handle's DNS cache */
559
easy->easy_handle->dns.hostcache = NULL;
560
easy->easy_handle->dns.hostcachetype = HCACHE_NONE;
561
}
562
563
if(easy->easy_conn) {
564
565
/* we must call Curl_done() here (if we still "own it") so that we don't
566
leave a half-baked one around */
567
if(easy_owns_conn) {
568
569
/* Curl_done() clears the conn->data field to lose the association
570
between the easy handle and the connection
571
572
Note that this ignores the return code simply because there's
573
nothing really useful to do with it anyway! */
574
(void)Curl_done(&easy->easy_conn, easy->result, premature);
575
}
576
else
577
/* Clear connection pipelines, if Curl_done above was not called */
578
Curl_getoff_all_pipelines(easy->easy_handle, easy->easy_conn);
579
}
580
581
/* as this was using a shared connection cache we clear the pointer
582
to that since we're not part of that multi handle anymore */
583
easy->easy_handle->state.conn_cache = NULL;
584
585
/* change state without using multistate(), only to make singlesocket() do
586
what we want */
587
easy->state = CURLM_STATE_COMPLETED;
588
singlesocket(multi, easy); /* to let the application know what sockets
589
that vanish with this handle */
590
591
/* Remove the association between the connection and the handle */
592
if(easy->easy_conn) {
593
easy->easy_conn->data = NULL;
594
easy->easy_conn = NULL;
595
}
596
597
Curl_easy_addmulti(easy->easy_handle, NULL); /* clear the association
598
to this multi handle */
599
600
{
601
/* make sure there's no pending message in the queue sent from this easy
602
handle */
603
struct curl_llist_element *e;
604
605
for(e = multi->msglist->head; e; e = e->next) {
606
struct Curl_message *msg = e->ptr;
607
608
if(msg->extmsg.easy_handle == easy->easy_handle) {
609
Curl_llist_remove(multi->msglist, e, NULL);
610
/* there can only be one from this specific handle */
611
break;
612
}
613
}
614
}
615
616
/* make the previous node point to our next */
617
if(easy->prev)
618
easy->prev->next = easy->next;
619
/* make our next point to our previous node */
620
if(easy->next)
621
easy->next->prev = easy->prev;
622
623
easy->easy_handle->set.one_easy = NULL; /* detached */
624
625
/* Null the position in the controlling structure */
626
easy->easy_handle->multi_pos = NULL;
627
628
/* NOTE NOTE NOTE
629
We do not touch the easy handle here! */
630
free(easy);
631
632
multi->num_easy--; /* one less to care about now */
633
634
update_timer(multi);
635
return CURLM_OK;
636
}
637
else
638
return CURLM_BAD_EASY_HANDLE; /* twasn't found */
639
}
640
641
bool Curl_multi_canPipeline(const struct Curl_multi* multi)
642
{
643
return multi->pipelining_enabled;
644
}
645
646
void Curl_multi_handlePipeBreak(struct SessionHandle *data)
647
{
648
struct Curl_one_easy *one_easy = data->set.one_easy;
649
650
if(one_easy)
651
one_easy->easy_conn = NULL;
652
}
653
654
static int waitconnect_getsock(struct connectdata *conn,
655
curl_socket_t *sock,
656
int numsocks)
657
{
658
if(!numsocks)
659
return GETSOCK_BLANK;
660
661
sock[0] = conn->sock[FIRSTSOCKET];
662
663
/* when we've sent a CONNECT to a proxy, we should rather wait for the
664
socket to become readable to be able to get the response headers */
665
if(conn->tunnel_state[FIRSTSOCKET] == TUNNEL_CONNECT)
666
return GETSOCK_READSOCK(0);
667
668
return GETSOCK_WRITESOCK(0);
669
}
670
671
static int domore_getsock(struct connectdata *conn,
672
curl_socket_t *socks,
673
int numsocks)
674
{
675
if(conn && conn->handler->domore_getsock)
676
return conn->handler->domore_getsock(conn, socks, numsocks);
677
return GETSOCK_BLANK;
678
}
679
680
/* returns bitmapped flags for this handle and its sockets */
681
static int multi_getsock(struct Curl_one_easy *easy,
682
curl_socket_t *socks, /* points to numsocks number
683
of sockets */
684
int numsocks)
685
{
686
/* If the pipe broke, or if there's no connection left for this easy handle,
687
then we MUST bail out now with no bitmask set. The no connection case can
688
happen when this is called from curl_multi_remove_handle() =>
689
singlesocket() => multi_getsock().
690
*/
691
if(easy->easy_handle->state.pipe_broke || !easy->easy_conn)
692
return 0;
693
694
if(easy->state > CURLM_STATE_CONNECT &&
695
easy->state < CURLM_STATE_COMPLETED) {
696
/* Set up ownership correctly */
697
easy->easy_conn->data = easy->easy_handle;
698
}
699
700
switch(easy->state) {
701
default:
702
#if 0 /* switch back on these cases to get the compiler to check for all enums
703
to be present */
704
case CURLM_STATE_TOOFAST: /* returns 0, so will not select. */
705
case CURLM_STATE_COMPLETED:
706
case CURLM_STATE_MSGSENT:
707
case CURLM_STATE_INIT:
708
case CURLM_STATE_CONNECT:
709
case CURLM_STATE_WAITDO:
710
case CURLM_STATE_DONE:
711
case CURLM_STATE_LAST:
712
/* this will get called with CURLM_STATE_COMPLETED when a handle is
713
removed */
714
#endif
715
return 0;
716
717
case CURLM_STATE_WAITRESOLVE:
718
return Curl_resolver_getsock(easy->easy_conn, socks, numsocks);
719
720
case CURLM_STATE_PROTOCONNECT:
721
return Curl_protocol_getsock(easy->easy_conn, socks, numsocks);
722
723
case CURLM_STATE_DO:
724
case CURLM_STATE_DOING:
725
return Curl_doing_getsock(easy->easy_conn, socks, numsocks);
726
727
case CURLM_STATE_WAITPROXYCONNECT:
728
case CURLM_STATE_WAITCONNECT:
729
return waitconnect_getsock(easy->easy_conn, socks, numsocks);
730
731
case CURLM_STATE_DO_MORE:
732
return domore_getsock(easy->easy_conn, socks, numsocks);
733
734
case CURLM_STATE_DO_DONE: /* since is set after DO is completed, we switch
735
to waiting for the same as the *PERFORM
736
states */
737
case CURLM_STATE_PERFORM:
738
case CURLM_STATE_WAITPERFORM:
739
return Curl_single_getsock(easy->easy_conn, socks, numsocks);
740
}
741
742
}
743
744
CURLMcode curl_multi_fdset(CURLM *multi_handle,
745
fd_set *read_fd_set, fd_set *write_fd_set,
746
fd_set *exc_fd_set, int *max_fd)
747
{
748
/* Scan through all the easy handles to get the file descriptors set.
749
Some easy handles may not have connected to the remote host yet,
750
and then we must make sure that is done. */
751
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
752
struct Curl_one_easy *easy;
753
int this_max_fd=-1;
754
curl_socket_t sockbunch[MAX_SOCKSPEREASYHANDLE];
755
int bitmap;
756
int i;
757
(void)exc_fd_set; /* not used */
758
759
if(!GOOD_MULTI_HANDLE(multi))
760
return CURLM_BAD_HANDLE;
761
762
easy=multi->easy.next;
763
while(easy != &multi->easy) {
764
bitmap = multi_getsock(easy, sockbunch, MAX_SOCKSPEREASYHANDLE);
765
766
for(i=0; i< MAX_SOCKSPEREASYHANDLE; i++) {
767
curl_socket_t s = CURL_SOCKET_BAD;
768
769
if((bitmap & GETSOCK_READSOCK(i)) && VALID_SOCK((sockbunch[i]))) {
770
FD_SET(sockbunch[i], read_fd_set);
771
s = sockbunch[i];
772
}
773
if((bitmap & GETSOCK_WRITESOCK(i)) && VALID_SOCK((sockbunch[i]))) {
774
FD_SET(sockbunch[i], write_fd_set);
775
s = sockbunch[i];
776
}
777
if(s == CURL_SOCKET_BAD)
778
/* this socket is unused, break out of loop */
779
break;
780
else {
781
if((int)s > this_max_fd)
782
this_max_fd = (int)s;
783
}
784
}
785
786
easy = easy->next; /* check next handle */
787
}
788
789
*max_fd = this_max_fd;
790
791
return CURLM_OK;
792
}
793
794
CURLMcode curl_multi_wait(CURLM *multi_handle,
795
struct curl_waitfd extra_fds[],
796
unsigned int extra_nfds,
797
int timeout_ms,
798
int *ret)
799
{
800
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
801
struct Curl_one_easy *easy;
802
curl_socket_t sockbunch[MAX_SOCKSPEREASYHANDLE];
803
int bitmap;
804
unsigned int i;
805
unsigned int nfds = extra_nfds;
806
struct pollfd *ufds = NULL;
807
808
if(!GOOD_MULTI_HANDLE(multi))
809
return CURLM_BAD_HANDLE;
810
811
/* Count up how many fds we have from the multi handle */
812
easy=multi->easy.next;
813
while(easy != &multi->easy) {
814
bitmap = multi_getsock(easy, sockbunch, MAX_SOCKSPEREASYHANDLE);
815
816
for(i=0; i< MAX_SOCKSPEREASYHANDLE; i++) {
817
curl_socket_t s = CURL_SOCKET_BAD;
818
819
if(bitmap & GETSOCK_READSOCK(i)) {
820
++nfds;
821
s = sockbunch[i];
822
}
823
if(bitmap & GETSOCK_WRITESOCK(i)) {
824
++nfds;
825
s = sockbunch[i];
826
}
827
if(s == CURL_SOCKET_BAD) {
828
break;
829
}
830
}
831
832
easy = easy->next; /* check next handle */
833
}
834
835
if(nfds) {
836
ufds = malloc(nfds * sizeof(struct pollfd));
837
if(!ufds)
838
return CURLM_OUT_OF_MEMORY;
839
}
840
nfds = 0;
841
842
/* Add the curl handles to our pollfds first */
843
easy=multi->easy.next;
844
while(easy != &multi->easy) {
845
bitmap = multi_getsock(easy, sockbunch, MAX_SOCKSPEREASYHANDLE);
846
847
for(i=0; i< MAX_SOCKSPEREASYHANDLE; i++) {
848
curl_socket_t s = CURL_SOCKET_BAD;
849
850
if(bitmap & GETSOCK_READSOCK(i)) {
851
ufds[nfds].fd = sockbunch[i];
852
ufds[nfds].events = POLLIN;
853
++nfds;
854
s = sockbunch[i];
855
}
856
if(bitmap & GETSOCK_WRITESOCK(i)) {
857
ufds[nfds].fd = sockbunch[i];
858
ufds[nfds].events = POLLOUT;
859
++nfds;
860
s = sockbunch[i];
861
}
862
if(s == CURL_SOCKET_BAD) {
863
break;
864
}
865
}
866
867
easy = easy->next; /* check next handle */
868
}
869
870
/* Add external file descriptions from poll-like struct curl_waitfd */
871
for(i = 0; i < extra_nfds; i++) {
872
ufds[nfds].fd = extra_fds[i].fd;
873
ufds[nfds].events = 0;
874
if(extra_fds[i].events & CURL_WAIT_POLLIN)
875
ufds[nfds].events |= POLLIN;
876
if(extra_fds[i].events & CURL_WAIT_POLLPRI)
877
ufds[nfds].events |= POLLPRI;
878
if(extra_fds[i].events & CURL_WAIT_POLLOUT)
879
ufds[nfds].events |= POLLOUT;
880
++nfds;
881
}
882
883
if(nfds)
884
/* wait... */
885
i = Curl_poll(ufds, nfds, timeout_ms);
886
else
887
i = 0;
888
889
Curl_safefree(ufds);
890
if(ret)
891
*ret = i;
892
return CURLM_OK;
893
}
894
895
static CURLMcode multi_runsingle(struct Curl_multi *multi,
896
struct timeval now,
897
struct Curl_one_easy *easy)
898
{
899
struct Curl_message *msg = NULL;
900
bool connected;
901
bool async;
902
bool protocol_connect = FALSE;
903
bool dophase_done = FALSE;
904
bool done = FALSE;
905
CURLMcode result = CURLM_OK;
906
struct SingleRequest *k;
907
struct SessionHandle *data;
908
long timeout_ms;
909
910
if(!GOOD_EASY_HANDLE(easy->easy_handle))
911
return CURLM_BAD_EASY_HANDLE;
912
913
data = easy->easy_handle;
914
915
do {
916
/* this is a single-iteration do-while loop just to allow a
917
break to skip to the end of it */
918
bool disconnect_conn = FALSE;
919
920
/* Handle the case when the pipe breaks, i.e., the connection
921
we're using gets cleaned up and we're left with nothing. */
922
if(data->state.pipe_broke) {
923
infof(data, "Pipe broke: handle 0x%p, url = %s\n",
924
easy, data->state.path);
925
926
if(easy->state < CURLM_STATE_COMPLETED) {
927
/* Head back to the CONNECT state */
928
multistate(easy, CURLM_STATE_CONNECT);
929
result = CURLM_CALL_MULTI_PERFORM;
930
easy->result = CURLE_OK;
931
}
932
933
data->state.pipe_broke = FALSE;
934
easy->easy_conn = NULL;
935
break;
936
}
937
938
if(!easy->easy_conn &&
939
easy->state > CURLM_STATE_CONNECT &&
940
easy->state < CURLM_STATE_DONE) {
941
/* In all these states, the code will blindly access 'easy->easy_conn'
942
so this is precaution that it isn't NULL. And it silences static
943
analyzers. */
944
failf(data, "In state %d with no easy_conn, bail out!\n", easy->state);
945
return CURLM_INTERNAL_ERROR;
946
}
947
948
if(easy->easy_conn && easy->state > CURLM_STATE_CONNECT &&
949
easy->state < CURLM_STATE_COMPLETED)
950
/* Make sure we set the connection's current owner */
951
easy->easy_conn->data = data;
952
953
if(easy->easy_conn &&
954
(easy->state >= CURLM_STATE_CONNECT) &&
955
(easy->state < CURLM_STATE_COMPLETED)) {
956
/* we need to wait for the connect state as only then is the start time
957
stored, but we must not check already completed handles */
958
959
timeout_ms = Curl_timeleft(data, &now,
960
(easy->state <= CURLM_STATE_WAITDO)?
961
TRUE:FALSE);
962
963
if(timeout_ms < 0) {
964
/* Handle timed out */
965
if(easy->state == CURLM_STATE_WAITRESOLVE)
966
failf(data, "Resolving timed out after %ld milliseconds",
967
Curl_tvdiff(now, data->progress.t_startsingle));
968
else if(easy->state == CURLM_STATE_WAITCONNECT)
969
failf(data, "Connection timed out after %ld milliseconds",
970
Curl_tvdiff(now, data->progress.t_startsingle));
971
else {
972
k = &data->req;
973
failf(data, "Operation timed out after %ld milliseconds with %"
974
FORMAT_OFF_T " out of %" FORMAT_OFF_T " bytes received",
975
Curl_tvdiff(now, data->progress.t_startsingle), k->bytecount,
976
k->size);
977
}
978
979
/* Force the connection closed because the server could continue to
980
send us stuff at any time. (The disconnect_conn logic used below
981
doesn't work at this point). */
982
easy->easy_conn->bits.close = TRUE;
983
easy->result = CURLE_OPERATION_TIMEDOUT;
984
multistate(easy, CURLM_STATE_COMPLETED);
985
break;
986
}
987
}
988
989
switch(easy->state) {
990
case CURLM_STATE_INIT:
991
/* init this transfer. */
992
easy->result=Curl_pretransfer(data);
993
994
if(CURLE_OK == easy->result) {
995
/* after init, go CONNECT */
996
multistate(easy, CURLM_STATE_CONNECT);
997
result = CURLM_CALL_MULTI_PERFORM;
998
}
999
break;
1000
1001
case CURLM_STATE_CONNECT:
1002
/* Connect. We get a connection identifier filled in. */
1003
Curl_pgrsTime(data, TIMER_STARTSINGLE);
1004
easy->result = Curl_connect(data, &easy->easy_conn,
1005
&async, &protocol_connect);
1006
1007
if(CURLE_OK == easy->result) {
1008
/* Add this handle to the send or pend pipeline */
1009
easy->result = addHandleToSendOrPendPipeline(data,
1010
easy->easy_conn);
1011
if(CURLE_OK != easy->result)
1012
disconnect_conn = TRUE;
1013
else {
1014
if(async)
1015
/* We're now waiting for an asynchronous name lookup */
1016
multistate(easy, CURLM_STATE_WAITRESOLVE);
1017
else {
1018
/* after the connect has been sent off, go WAITCONNECT unless the
1019
protocol connect is already done and we can go directly to
1020
WAITDO or DO! */
1021
result = CURLM_CALL_MULTI_PERFORM;
1022
1023
if(protocol_connect)
1024
multistate(easy, multi->pipelining_enabled?
1025
CURLM_STATE_WAITDO:CURLM_STATE_DO);
1026
else {
1027
#ifndef CURL_DISABLE_HTTP
1028
if(easy->easy_conn->tunnel_state[FIRSTSOCKET] == TUNNEL_CONNECT)
1029
multistate(easy, CURLM_STATE_WAITPROXYCONNECT);
1030
else
1031
#endif
1032
multistate(easy, CURLM_STATE_WAITCONNECT);
1033
}
1034
}
1035
}
1036
}
1037
break;
1038
1039
case CURLM_STATE_WAITRESOLVE:
1040
/* awaiting an asynch name resolve to complete */
1041
{
1042
struct Curl_dns_entry *dns = NULL;
1043
1044
/* check if we have the name resolved by now */
1045
easy->result = Curl_resolver_is_resolved(easy->easy_conn, &dns);
1046
1047
/* Update sockets here, because the socket(s) may have been
1048
closed and the application thus needs to be told, even if it
1049
is likely that the same socket(s) will again be used further
1050
down. If the name has not yet been resolved, it is likely
1051
that new sockets have been opened in an attempt to contact
1052
another resolver. */
1053
singlesocket(multi, easy);
1054
1055
if(dns) {
1056
/* Perform the next step in the connection phase, and then move on
1057
to the WAITCONNECT state */
1058
easy->result = Curl_async_resolved(easy->easy_conn,
1059
&protocol_connect);
1060
1061
if(CURLE_OK != easy->result)
1062
/* if Curl_async_resolved() returns failure, the connection struct
1063
is already freed and gone */
1064
easy->easy_conn = NULL; /* no more connection */
1065
else {
1066
/* call again please so that we get the next socket setup */
1067
result = CURLM_CALL_MULTI_PERFORM;
1068
if(protocol_connect)
1069
multistate(easy, multi->pipelining_enabled?
1070
CURLM_STATE_WAITDO:CURLM_STATE_DO);
1071
else {
1072
#ifndef CURL_DISABLE_HTTP
1073
if(easy->easy_conn->tunnel_state[FIRSTSOCKET] == TUNNEL_CONNECT)
1074
multistate(easy, CURLM_STATE_WAITPROXYCONNECT);
1075
else
1076
#endif
1077
multistate(easy, CURLM_STATE_WAITCONNECT);
1078
}
1079
}
1080
}
1081
1082
if(CURLE_OK != easy->result) {
1083
/* failure detected */
1084
disconnect_conn = TRUE;
1085
break;
1086
}
1087
}
1088
break;
1089
1090
#ifndef CURL_DISABLE_HTTP
1091
case CURLM_STATE_WAITPROXYCONNECT:
1092
/* this is HTTP-specific, but sending CONNECT to a proxy is HTTP... */
1093
easy->result = Curl_http_connect(easy->easy_conn, &protocol_connect);
1094
1095
if(easy->easy_conn->bits.proxy_connect_closed) {
1096
/* reset the error buffer */
1097
if(data->set.errorbuffer)
1098
data->set.errorbuffer[0] = '\0';
1099
data->state.errorbuf = FALSE;
1100
1101
easy->result = CURLE_OK;
1102
result = CURLM_CALL_MULTI_PERFORM;
1103
multistate(easy, CURLM_STATE_CONNECT);
1104
}
1105
else if(CURLE_OK == easy->result) {
1106
if(easy->easy_conn->tunnel_state[FIRSTSOCKET] == TUNNEL_COMPLETE)
1107
multistate(easy, CURLM_STATE_WAITCONNECT);
1108
}
1109
break;
1110
#endif
1111
1112
case CURLM_STATE_WAITCONNECT:
1113
/* awaiting a completion of an asynch connect */
1114
easy->result = Curl_is_connected(easy->easy_conn,
1115
FIRSTSOCKET,
1116
&connected);
1117
if(connected) {
1118
1119
if(!easy->result)
1120
/* if everything is still fine we do the protocol-specific connect
1121
setup */
1122
easy->result = Curl_protocol_connect(easy->easy_conn,
1123
&protocol_connect);
1124
}
1125
1126
if(CURLE_OK != easy->result) {
1127
/* failure detected */
1128
/* Just break, the cleaning up is handled all in one place */
1129
disconnect_conn = TRUE;
1130
break;
1131
}
1132
1133
if(connected) {
1134
if(!protocol_connect) {
1135
/* We have a TCP connection, but 'protocol_connect' may be false
1136
and then we continue to 'STATE_PROTOCONNECT'. If protocol
1137
connect is TRUE, we move on to STATE_DO.
1138
BUT if we are using a proxy we must change to WAITPROXYCONNECT
1139
*/
1140
#ifndef CURL_DISABLE_HTTP
1141
if(easy->easy_conn->tunnel_state[FIRSTSOCKET] == TUNNEL_CONNECT)
1142
multistate(easy, CURLM_STATE_WAITPROXYCONNECT);
1143
else
1144
#endif
1145
multistate(easy, CURLM_STATE_PROTOCONNECT);
1146
1147
}
1148
else
1149
/* after the connect has completed, go WAITDO or DO */
1150
multistate(easy, multi->pipelining_enabled?
1151
CURLM_STATE_WAITDO:CURLM_STATE_DO);
1152
1153
result = CURLM_CALL_MULTI_PERFORM;
1154
}
1155
break;
1156
1157
case CURLM_STATE_PROTOCONNECT:
1158
/* protocol-specific connect phase */
1159
easy->result = Curl_protocol_connecting(easy->easy_conn,
1160
&protocol_connect);
1161
if((easy->result == CURLE_OK) && protocol_connect) {
1162
/* after the connect has completed, go WAITDO or DO */
1163
multistate(easy, multi->pipelining_enabled?
1164
CURLM_STATE_WAITDO:CURLM_STATE_DO);
1165
result = CURLM_CALL_MULTI_PERFORM;
1166
}
1167
else if(easy->result) {
1168
/* failure detected */
1169
Curl_posttransfer(data);
1170
Curl_done(&easy->easy_conn, easy->result, TRUE);
1171
disconnect_conn = TRUE;
1172
}
1173
break;
1174
1175
case CURLM_STATE_WAITDO:
1176
/* Wait for our turn to DO when we're pipelining requests */
1177
#ifdef DEBUGBUILD
1178
infof(data, "WAITDO: Conn %ld send pipe %zu inuse %d athead %d\n",
1179
easy->easy_conn->connection_id,
1180
easy->easy_conn->send_pipe->size,
1181
easy->easy_conn->writechannel_inuse?1:0,
1182
isHandleAtHead(data,
1183
easy->easy_conn->send_pipe)?1:0);
1184
#endif
1185
if(!easy->easy_conn->writechannel_inuse &&
1186
isHandleAtHead(data,
1187
easy->easy_conn->send_pipe)) {
1188
/* Grab the channel */
1189
easy->easy_conn->writechannel_inuse = TRUE;
1190
multistate(easy, CURLM_STATE_DO);
1191
result = CURLM_CALL_MULTI_PERFORM;
1192
}
1193
break;
1194
1195
case CURLM_STATE_DO:
1196
if(data->set.connect_only) {
1197
/* keep connection open for application to use the socket */
1198
easy->easy_conn->bits.close = FALSE;
1199
multistate(easy, CURLM_STATE_DONE);
1200
easy->result = CURLE_OK;
1201
result = CURLM_CALL_MULTI_PERFORM;
1202
}
1203
else {
1204
/* Perform the protocol's DO action */
1205
easy->result = Curl_do(&easy->easy_conn,
1206
&dophase_done);
1207
1208
if(CURLE_OK == easy->result) {
1209
if(!dophase_done) {
1210
/* some steps needed for wildcard matching */
1211
if(data->set.wildcardmatch) {
1212
struct WildcardData *wc = &data->wildcard;
1213
if(wc->state == CURLWC_DONE || wc->state == CURLWC_SKIP) {
1214
/* skip some states if it is important */
1215
Curl_done(&easy->easy_conn, CURLE_OK, FALSE);
1216
multistate(easy, CURLM_STATE_DONE);
1217
result = CURLM_CALL_MULTI_PERFORM;
1218
break;
1219
}
1220
}
1221
/* DO was not completed in one function call, we must continue
1222
DOING... */
1223
multistate(easy, CURLM_STATE_DOING);
1224
result = CURLM_OK;
1225
}
1226
1227
/* after DO, go DO_DONE... or DO_MORE */
1228
else if(easy->easy_conn->bits.do_more) {
1229
/* we're supposed to do more, but we need to sit down, relax
1230
and wait a little while first */
1231
multistate(easy, CURLM_STATE_DO_MORE);
1232
result = CURLM_OK;
1233
}
1234
else {
1235
/* we're done with the DO, now DO_DONE */
1236
multistate(easy, CURLM_STATE_DO_DONE);
1237
result = CURLM_CALL_MULTI_PERFORM;
1238
}
1239
}
1240
else if((CURLE_SEND_ERROR == easy->result) &&
1241
easy->easy_conn->bits.reuse) {
1242
/*
1243
* In this situation, a connection that we were trying to use
1244
* may have unexpectedly died. If possible, send the connection
1245
* back to the CONNECT phase so we can try again.
1246
*/
1247
char *newurl = NULL;
1248
followtype follow=FOLLOW_NONE;
1249
CURLcode drc;
1250
bool retry = FALSE;
1251
1252
drc = Curl_retry_request(easy->easy_conn, &newurl);
1253
if(drc) {
1254
/* a failure here pretty much implies an out of memory */
1255
easy->result = drc;
1256
disconnect_conn = TRUE;
1257
}
1258
else
1259
retry = (newurl)?TRUE:FALSE;
1260
1261
Curl_posttransfer(data);
1262
drc = Curl_done(&easy->easy_conn, easy->result, FALSE);
1263
1264
/* When set to retry the connection, we must to go back to
1265
* the CONNECT state */
1266
if(retry) {
1267
if((drc == CURLE_OK) || (drc == CURLE_SEND_ERROR)) {
1268
follow = FOLLOW_RETRY;
1269
drc = Curl_follow(data, newurl, follow);
1270
if(drc == CURLE_OK) {
1271
multistate(easy, CURLM_STATE_CONNECT);
1272
result = CURLM_CALL_MULTI_PERFORM;
1273
easy->result = CURLE_OK;
1274
}
1275
else {
1276
/* Follow failed */
1277
easy->result = drc;
1278
free(newurl);
1279
}
1280
}
1281
else {
1282
/* done didn't return OK or SEND_ERROR */
1283
easy->result = drc;
1284
free(newurl);
1285
}
1286
}
1287
else {
1288
/* Have error handler disconnect conn if we can't retry */
1289
disconnect_conn = TRUE;
1290
}
1291
}
1292
else {
1293
/* failure detected */
1294
Curl_posttransfer(data);
1295
Curl_done(&easy->easy_conn, easy->result, FALSE);
1296
disconnect_conn = TRUE;
1297
}
1298
}
1299
break;
1300
1301
case CURLM_STATE_DOING:
1302
/* we continue DOING until the DO phase is complete */
1303
easy->result = Curl_protocol_doing(easy->easy_conn,
1304
&dophase_done);
1305
if(CURLE_OK == easy->result) {
1306
if(dophase_done) {
1307
/* after DO, go DO_DONE or DO_MORE */
1308
multistate(easy, easy->easy_conn->bits.do_more?
1309
CURLM_STATE_DO_MORE:
1310
CURLM_STATE_DO_DONE);
1311
result = CURLM_CALL_MULTI_PERFORM;
1312
} /* dophase_done */
1313
}
1314
else {
1315
/* failure detected */
1316
Curl_posttransfer(data);
1317
Curl_done(&easy->easy_conn, easy->result, FALSE);
1318
disconnect_conn = TRUE;
1319
}
1320
break;
1321
1322
case CURLM_STATE_DO_MORE:
1323
/*
1324
* When we are connected, DO MORE and then go DO_DONE
1325
*/
1326
easy->result = Curl_do_more(easy->easy_conn, &dophase_done);
1327
1328
/* No need to remove this handle from the send pipeline here since that
1329
is done in Curl_done() */
1330
if(CURLE_OK == easy->result) {
1331
if(dophase_done) {
1332
multistate(easy, CURLM_STATE_DO_DONE);
1333
result = CURLM_CALL_MULTI_PERFORM;
1334
}
1335
else
1336
/* stay in DO_MORE */
1337
result = CURLM_OK;
1338
}
1339
else {
1340
/* failure detected */
1341
Curl_posttransfer(data);
1342
Curl_done(&easy->easy_conn, easy->result, FALSE);
1343
disconnect_conn = TRUE;
1344
}
1345
break;
1346
1347
case CURLM_STATE_DO_DONE:
1348
/* Move ourselves from the send to recv pipeline */
1349
moveHandleFromSendToRecvPipeline(data, easy->easy_conn);
1350
/* Check if we can move pending requests to send pipe */
1351
checkPendPipeline(easy->easy_conn);
1352
multistate(easy, CURLM_STATE_WAITPERFORM);
1353
result = CURLM_CALL_MULTI_PERFORM;
1354
break;
1355
1356
case CURLM_STATE_WAITPERFORM:
1357
/* Wait for our turn to PERFORM */
1358
if(!easy->easy_conn->readchannel_inuse &&
1359
isHandleAtHead(data,
1360
easy->easy_conn->recv_pipe)) {
1361
/* Grab the channel */
1362
easy->easy_conn->readchannel_inuse = TRUE;
1363
multistate(easy, CURLM_STATE_PERFORM);
1364
result = CURLM_CALL_MULTI_PERFORM;
1365
}
1366
#ifdef DEBUGBUILD
1367
else {
1368
infof(data, "WAITPERFORM: Conn %ld recv pipe %zu inuse %d athead %d\n",
1369
easy->easy_conn->connection_id,
1370
easy->easy_conn->recv_pipe->size,
1371
easy->easy_conn->readchannel_inuse?1:0,
1372
isHandleAtHead(data,
1373
easy->easy_conn->recv_pipe)?1:0);
1374
}
1375
#endif
1376
break;
1377
1378
case CURLM_STATE_TOOFAST: /* limit-rate exceeded in either direction */
1379
/* if both rates are within spec, resume transfer */
1380
if(Curl_pgrsUpdate(easy->easy_conn))
1381
easy->result = CURLE_ABORTED_BY_CALLBACK;
1382
else
1383
easy->result = Curl_speedcheck(data, now);
1384
1385
if(( (data->set.max_send_speed == 0) ||
1386
(data->progress.ulspeed < data->set.max_send_speed )) &&
1387
( (data->set.max_recv_speed == 0) ||
1388
(data->progress.dlspeed < data->set.max_recv_speed)))
1389
multistate(easy, CURLM_STATE_PERFORM);
1390
break;
1391
1392
case CURLM_STATE_PERFORM:
1393
{
1394
char *newurl = NULL;
1395
bool retry = FALSE;
1396
1397
/* check if over send speed */
1398
if((data->set.max_send_speed > 0) &&
1399
(data->progress.ulspeed > data->set.max_send_speed)) {
1400
int buffersize;
1401
1402
multistate(easy, CURLM_STATE_TOOFAST);
1403
1404
/* calculate upload rate-limitation timeout. */
1405
buffersize = (int)(data->set.buffer_size ?
1406
data->set.buffer_size : BUFSIZE);
1407
timeout_ms = Curl_sleep_time(data->set.max_send_speed,
1408
data->progress.ulspeed, buffersize);
1409
Curl_expire(data, timeout_ms);
1410
break;
1411
}
1412
1413
/* check if over recv speed */
1414
if((data->set.max_recv_speed > 0) &&
1415
(data->progress.dlspeed > data->set.max_recv_speed)) {
1416
int buffersize;
1417
1418
multistate(easy, CURLM_STATE_TOOFAST);
1419
1420
/* Calculate download rate-limitation timeout. */
1421
buffersize = (int)(data->set.buffer_size ?
1422
data->set.buffer_size : BUFSIZE);
1423
timeout_ms = Curl_sleep_time(data->set.max_recv_speed,
1424
data->progress.dlspeed, buffersize);
1425
Curl_expire(data, timeout_ms);
1426
break;
1427
}
1428
1429
/* read/write data if it is ready to do so */
1430
easy->result = Curl_readwrite(easy->easy_conn, &done);
1431
1432
k = &data->req;
1433
1434
if(!(k->keepon & KEEP_RECV)) {
1435
/* We're done receiving */
1436
easy->easy_conn->readchannel_inuse = FALSE;
1437
}
1438
1439
if(!(k->keepon & KEEP_SEND)) {
1440
/* We're done sending */
1441
easy->easy_conn->writechannel_inuse = FALSE;
1442
}
1443
1444
if(done || (easy->result == CURLE_RECV_ERROR)) {
1445
/* If CURLE_RECV_ERROR happens early enough, we assume it was a race
1446
* condition and the server closed the re-used connection exactly when
1447
* we wanted to use it, so figure out if that is indeed the case.
1448
*/
1449
CURLcode ret = Curl_retry_request(easy->easy_conn, &newurl);
1450
if(!ret)
1451
retry = (newurl)?TRUE:FALSE;
1452
1453
if(retry) {
1454
/* if we are to retry, set the result to OK and consider the
1455
request as done */
1456
easy->result = CURLE_OK;
1457
done = TRUE;
1458
}
1459
}
1460
1461
if(easy->result) {
1462
/*
1463
* The transfer phase returned error, we mark the connection to get
1464
* closed to prevent being re-used. This is because we can't possibly
1465
* know if the connection is in a good shape or not now. Unless it is
1466
* a protocol which uses two "channels" like FTP, as then the error
1467
* happened in the data connection.
1468
*/
1469
1470
if(!(easy->easy_conn->handler->flags & PROTOPT_DUAL))
1471
easy->easy_conn->bits.close = TRUE;
1472
1473
Curl_posttransfer(data);
1474
Curl_done(&easy->easy_conn, easy->result, FALSE);
1475
}
1476
else if(done) {
1477
followtype follow=FOLLOW_NONE;
1478
1479
/* call this even if the readwrite function returned error */
1480
Curl_posttransfer(data);
1481
1482
/* we're no longer receiving */
1483
moveHandleFromRecvToDonePipeline(data,
1484
easy->easy_conn);
1485
1486
/* expire the new receiving pipeline head */
1487
if(easy->easy_conn->recv_pipe->head)
1488
Curl_expire(easy->easy_conn->recv_pipe->head->ptr, 1);
1489
1490
/* Check if we can move pending requests to send pipe */
1491
checkPendPipeline(easy->easy_conn);
1492
1493
/* When we follow redirects or is set to retry the connection, we must
1494
to go back to the CONNECT state */
1495
if(data->req.newurl || retry) {
1496
if(!retry) {
1497
/* if the URL is a follow-location and not just a retried request
1498
then figure out the URL here */
1499
newurl = data->req.newurl;
1500
data->req.newurl = NULL;
1501
follow = FOLLOW_REDIR;
1502
}
1503
else
1504
follow = FOLLOW_RETRY;
1505
easy->result = Curl_done(&easy->easy_conn, CURLE_OK, FALSE);
1506
if(easy->result == CURLE_OK)
1507
easy->result = Curl_follow(data, newurl, follow);
1508
if(CURLE_OK == easy->result) {
1509
multistate(easy, CURLM_STATE_CONNECT);
1510
result = CURLM_CALL_MULTI_PERFORM;
1511
newurl = NULL; /* handed over the memory ownership to
1512
Curl_follow(), make sure we don't free() it
1513
here */
1514
}
1515
}
1516
else {
1517
/* after the transfer is done, go DONE */
1518
1519
/* but first check to see if we got a location info even though we're
1520
not following redirects */
1521
if(data->req.location) {
1522
if(newurl)
1523
free(newurl);
1524
newurl = data->req.location;
1525
data->req.location = NULL;
1526
easy->result = Curl_follow(data, newurl, FOLLOW_FAKE);
1527
if(CURLE_OK == easy->result)
1528
newurl = NULL; /* allocation was handed over Curl_follow() */
1529
else
1530
disconnect_conn = TRUE;
1531
}
1532
1533
multistate(easy, CURLM_STATE_DONE);
1534
result = CURLM_CALL_MULTI_PERFORM;
1535
}
1536
}
1537
1538
if(newurl)
1539
free(newurl);
1540
break;
1541
}
1542
1543
case CURLM_STATE_DONE:
1544
1545
if(easy->easy_conn) {
1546
/* Remove ourselves from the receive and done pipelines. Handle
1547
should be on one of these lists, depending upon how we got here. */
1548
Curl_removeHandleFromPipeline(data,
1549
easy->easy_conn->recv_pipe);
1550
Curl_removeHandleFromPipeline(data,
1551
easy->easy_conn->done_pipe);
1552
/* Check if we can move pending requests to send pipe */
1553
checkPendPipeline(easy->easy_conn);
1554
1555
if(easy->easy_conn->bits.stream_was_rewound) {
1556
/* This request read past its response boundary so we quickly let
1557
the other requests consume those bytes since there is no
1558
guarantee that the socket will become active again */
1559
result = CURLM_CALL_MULTI_PERFORM;
1560
}
1561
1562
/* post-transfer command */
1563
easy->result = Curl_done(&easy->easy_conn, CURLE_OK, FALSE);
1564
/*
1565
* If there are other handles on the pipeline, Curl_done won't set
1566
* easy_conn to NULL. In such a case, curl_multi_remove_handle() can
1567
* access free'd data, if the connection is free'd and the handle
1568
* removed before we perform the processing in CURLM_STATE_COMPLETED
1569
*/
1570
if(easy->easy_conn)
1571
easy->easy_conn = NULL;
1572
}
1573
1574
if(data->set.wildcardmatch) {
1575
if(data->wildcard.state != CURLWC_DONE) {
1576
/* if a wildcard is set and we are not ending -> lets start again
1577
with CURLM_STATE_INIT */
1578
result = CURLM_CALL_MULTI_PERFORM;
1579
multistate(easy, CURLM_STATE_INIT);
1580
break;
1581
}
1582
}
1583
1584
/* after we have DONE what we're supposed to do, go COMPLETED, and
1585
it doesn't matter what the Curl_done() returned! */
1586
multistate(easy, CURLM_STATE_COMPLETED);
1587
1588
break;
1589
1590
case CURLM_STATE_COMPLETED:
1591
/* this is a completed transfer, it is likely to still be connected */
1592
1593
/* This node should be delinked from the list now and we should post
1594
an information message that we are complete. */
1595
1596
/* Important: reset the conn pointer so that we don't point to memory
1597
that could be freed anytime */
1598
easy->easy_conn = NULL;
1599
1600
Curl_expire(data, 0); /* stop all timers */
1601
break;
1602
1603
case CURLM_STATE_MSGSENT:
1604
return CURLM_OK; /* do nothing */
1605
1606
default:
1607
return CURLM_INTERNAL_ERROR;
1608
}
1609
1610
if(easy->state < CURLM_STATE_COMPLETED) {
1611
if(CURLE_OK != easy->result) {
1612
/*
1613
* If an error was returned, and we aren't in completed state now,
1614
* then we go to completed and consider this transfer aborted.
1615
*/
1616
1617
/* NOTE: no attempt to disconnect connections must be made
1618
in the case blocks above - cleanup happens only here */
1619
1620
data->state.pipe_broke = FALSE;
1621
1622
if(easy->easy_conn) {
1623
/* if this has a connection, unsubscribe from the pipelines */
1624
easy->easy_conn->writechannel_inuse = FALSE;
1625
easy->easy_conn->readchannel_inuse = FALSE;
1626
Curl_removeHandleFromPipeline(data,
1627
easy->easy_conn->send_pipe);
1628
Curl_removeHandleFromPipeline(data,
1629
easy->easy_conn->recv_pipe);
1630
Curl_removeHandleFromPipeline(data,
1631
easy->easy_conn->done_pipe);
1632
/* Check if we can move pending requests to send pipe */
1633
checkPendPipeline(easy->easy_conn);
1634
1635
if(disconnect_conn) {
1636
/* disconnect properly */
1637
Curl_disconnect(easy->easy_conn, /* dead_connection */ FALSE);
1638
1639
/* This is where we make sure that the easy_conn pointer is reset.
1640
We don't have to do this in every case block above where a
1641
failure is detected */
1642
easy->easy_conn = NULL;
1643
}
1644
}
1645
else if(easy->state == CURLM_STATE_CONNECT) {
1646
/* Curl_connect() failed */
1647
(void)Curl_posttransfer(data);
1648
}
1649
1650
multistate(easy, CURLM_STATE_COMPLETED);
1651
}
1652
/* if there's still a connection to use, call the progress function */
1653
else if(easy->easy_conn && Curl_pgrsUpdate(easy->easy_conn)) {
1654
/* aborted due to progress callback return code must close the
1655
connection */
1656
easy->easy_conn->bits.close = TRUE;
1657
1658
/* if not yet in DONE state, go there, otherwise COMPLETED */
1659
multistate(easy, (easy->state < CURLM_STATE_DONE)?
1660
CURLM_STATE_DONE: CURLM_STATE_COMPLETED);
1661
result = CURLM_CALL_MULTI_PERFORM;
1662
}
1663
}
1664
} WHILE_FALSE; /* just to break out from! */
1665
1666
if(CURLM_STATE_COMPLETED == easy->state) {
1667
/* now fill in the Curl_message with this info */
1668
msg = &easy->msg;
1669
1670
msg->extmsg.msg = CURLMSG_DONE;
1671
msg->extmsg.easy_handle = data;
1672
msg->extmsg.data.result = easy->result;
1673
1674
result = multi_addmsg(multi, msg);
1675
1676
multistate(easy, CURLM_STATE_MSGSENT);
1677
}
1678
1679
return result;
1680
}
1681
1682
1683
CURLMcode curl_multi_perform(CURLM *multi_handle, int *running_handles)
1684
{
1685
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
1686
struct Curl_one_easy *easy;
1687
CURLMcode returncode=CURLM_OK;
1688
struct Curl_tree *t;
1689
struct timeval now = Curl_tvnow();
1690
1691
if(!GOOD_MULTI_HANDLE(multi))
1692
return CURLM_BAD_HANDLE;
1693
1694
easy=multi->easy.next;
1695
while(easy != &multi->easy) {
1696
CURLMcode result;
1697
struct WildcardData *wc = &easy->easy_handle->wildcard;
1698
1699
if(easy->easy_handle->set.wildcardmatch) {
1700
if(!wc->filelist) {
1701
CURLcode ret = Curl_wildcard_init(wc); /* init wildcard structures */
1702
if(ret)
1703
return CURLM_OUT_OF_MEMORY;
1704
}
1705
}
1706
1707
do
1708
result = multi_runsingle(multi, now, easy);
1709
while(CURLM_CALL_MULTI_PERFORM == result);
1710
1711
if(easy->easy_handle->set.wildcardmatch) {
1712
/* destruct wildcard structures if it is needed */
1713
if(wc->state == CURLWC_DONE || result)
1714
Curl_wildcard_dtor(wc);
1715
}
1716
1717
if(result)
1718
returncode = result;
1719
1720
easy = easy->next; /* operate on next handle */
1721
}
1722
1723
/*
1724
* Simply remove all expired timers from the splay since handles are dealt
1725
* with unconditionally by this function and curl_multi_timeout() requires
1726
* that already passed/handled expire times are removed from the splay.
1727
*
1728
* It is important that the 'now' value is set at the entry of this function
1729
* and not for the current time as it may have ticked a little while since
1730
* then and then we risk this loop to remove timers that actually have not
1731
* been handled!
1732
*/
1733
do {
1734
multi->timetree = Curl_splaygetbest(now, multi->timetree, &t);
1735
if(t)
1736
/* the removed may have another timeout in queue */
1737
(void)add_next_timeout(now, multi, t->payload);
1738
1739
} while(t);
1740
1741
*running_handles = multi->num_alive;
1742
1743
if(CURLM_OK >= returncode)
1744
update_timer(multi);
1745
1746
return returncode;
1747
}
1748
1749
static void close_all_connections(struct Curl_multi *multi)
1750
{
1751
struct connectdata *conn;
1752
1753
conn = Curl_conncache_find_first_connection(multi->conn_cache);
1754
while(conn) {
1755
conn->data = multi->closure_handle;
1756
1757
/* This will remove the connection from the cache */
1758
(void)Curl_disconnect(conn, FALSE);
1759
1760
conn = Curl_conncache_find_first_connection(multi->conn_cache);
1761
}
1762
}
1763
1764
CURLMcode curl_multi_cleanup(CURLM *multi_handle)
1765
{
1766
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
1767
struct Curl_one_easy *easy;
1768
struct Curl_one_easy *nexteasy;
1769
1770
if(GOOD_MULTI_HANDLE(multi)) {
1771
multi->type = 0; /* not good anymore */
1772
1773
/* Close all the connections in the connection cache */
1774
close_all_connections(multi);
1775
1776
multi->closure_handle->dns.hostcache = multi->hostcache;
1777
Curl_hostcache_clean(multi->closure_handle);
1778
1779
Curl_close(multi->closure_handle);
1780
multi->closure_handle = NULL;
1781
1782
Curl_hash_destroy(multi->sockhash);
1783
multi->sockhash = NULL;
1784
1785
Curl_conncache_destroy(multi->conn_cache);
1786
multi->conn_cache = NULL;
1787
1788
/* remove the pending list of messages */
1789
Curl_llist_destroy(multi->msglist, NULL);
1790
multi->msglist = NULL;
1791
1792
/* remove all easy handles */
1793
easy = multi->easy.next;
1794
while(easy != &multi->easy) {
1795
nexteasy=easy->next;
1796
if(easy->easy_handle->dns.hostcachetype == HCACHE_MULTI) {
1797
/* clear out the usage of the shared DNS cache */
1798
Curl_hostcache_clean(easy->easy_handle);
1799
easy->easy_handle->dns.hostcache = NULL;
1800
easy->easy_handle->dns.hostcachetype = HCACHE_NONE;
1801
}
1802
1803
/* Clear the pointer to the connection cache */
1804
easy->easy_handle->state.conn_cache = NULL;
1805
1806
Curl_easy_addmulti(easy->easy_handle, NULL); /* clear the association */
1807
1808
free(easy);
1809
easy = nexteasy;
1810
}
1811
1812
Curl_hash_destroy(multi->hostcache);
1813
multi->hostcache = NULL;
1814
1815
free(multi);
1816
1817
return CURLM_OK;
1818
}
1819
else
1820
return CURLM_BAD_HANDLE;
1821
}
1822
1823
/*
1824
* curl_multi_info_read()
1825
*
1826
* This function is the primary way for a multi/multi_socket application to
1827
* figure out if a transfer has ended. We MUST make this function as fast as
1828
* possible as it will be polled frequently and we MUST NOT scan any lists in
1829
* here to figure out things. We must scale fine to thousands of handles and
1830
* beyond. The current design is fully O(1).
1831
*/
1832
1833
CURLMsg *curl_multi_info_read(CURLM *multi_handle, int *msgs_in_queue)
1834
{
1835
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
1836
struct Curl_message *msg;
1837
1838
*msgs_in_queue = 0; /* default to none */
1839
1840
if(GOOD_MULTI_HANDLE(multi) && Curl_llist_count(multi->msglist)) {
1841
/* there is one or more messages in the list */
1842
struct curl_llist_element *e;
1843
1844
/* extract the head of the list to return */
1845
e = multi->msglist->head;
1846
1847
msg = e->ptr;
1848
1849
/* remove the extracted entry */
1850
Curl_llist_remove(multi->msglist, e, NULL);
1851
1852
*msgs_in_queue = curlx_uztosi(Curl_llist_count(multi->msglist));
1853
1854
return &msg->extmsg;
1855
}
1856
else
1857
return NULL;
1858
}
1859
1860
/*
1861
* singlesocket() checks what sockets we deal with and their "action state"
1862
* and if we have a different state in any of those sockets from last time we
1863
* call the callback accordingly.
1864
*/
1865
static void singlesocket(struct Curl_multi *multi,
1866
struct Curl_one_easy *easy)
1867
{
1868
curl_socket_t socks[MAX_SOCKSPEREASYHANDLE];
1869
int i;
1870
struct Curl_sh_entry *entry;
1871
curl_socket_t s;
1872
int num;
1873
unsigned int curraction;
1874
struct Curl_one_easy *easy_by_hash;
1875
bool remove_sock_from_hash;
1876
1877
for(i=0; i< MAX_SOCKSPEREASYHANDLE; i++)
1878
socks[i] = CURL_SOCKET_BAD;
1879
1880
/* Fill in the 'current' struct with the state as it is now: what sockets to
1881
supervise and for what actions */
1882
curraction = multi_getsock(easy, socks, MAX_SOCKSPEREASYHANDLE);
1883
1884
/* We have 0 .. N sockets already and we get to know about the 0 .. M
1885
sockets we should have from now on. Detect the differences, remove no
1886
longer supervised ones and add new ones */
1887
1888
/* walk over the sockets we got right now */
1889
for(i=0; (i< MAX_SOCKSPEREASYHANDLE) &&
1890
(curraction & (GETSOCK_READSOCK(i) | GETSOCK_WRITESOCK(i)));
1891
i++) {
1892
int action = CURL_POLL_NONE;
1893
1894
s = socks[i];
1895
1896
/* get it from the hash */
1897
entry = Curl_hash_pick(multi->sockhash, (char *)&s, sizeof(s));
1898
1899
if(curraction & GETSOCK_READSOCK(i))
1900
action |= CURL_POLL_IN;
1901
if(curraction & GETSOCK_WRITESOCK(i))
1902
action |= CURL_POLL_OUT;
1903
1904
if(entry) {
1905
/* yeps, already present so check if it has the same action set */
1906
if(entry->action == action)
1907
/* same, continue */
1908
continue;
1909
}
1910
else {
1911
/* this is a socket we didn't have before, add it! */
1912
entry = sh_addentry(multi->sockhash, s, easy->easy_handle);
1913
if(!entry)
1914
/* fatal */
1915
return;
1916
}
1917
1918
/* we know (entry != NULL) at this point, see the logic above */
1919
if(multi->socket_cb)
1920
multi->socket_cb(easy->easy_handle,
1921
s,
1922
action,
1923
multi->socket_userp,
1924
entry->socketp);
1925
1926
entry->action = action; /* store the current action state */
1927
}
1928
1929
num = i; /* number of sockets */
1930
1931
/* when we've walked over all the sockets we should have right now, we must
1932
make sure to detect sockets that are removed */
1933
for(i=0; i< easy->numsocks; i++) {
1934
int j;
1935
s = easy->sockets[i];
1936
for(j=0; j<num; j++) {
1937
if(s == socks[j]) {
1938
/* this is still supervised */
1939
s = CURL_SOCKET_BAD;
1940
break;
1941
}
1942
}
1943
if(s != CURL_SOCKET_BAD) {
1944
1945
/* this socket has been removed. Tell the app to remove it */
1946
remove_sock_from_hash = TRUE;
1947
1948
entry = Curl_hash_pick(multi->sockhash, (char *)&s, sizeof(s));
1949
if(entry) {
1950
/* check if the socket to be removed serves a connection which has
1951
other easy-s in a pipeline. In this case the socket should not be
1952
removed. */
1953
struct connectdata *easy_conn;
1954
1955
easy_by_hash = entry->easy->multi_pos;
1956
easy_conn = easy_by_hash->easy_conn;
1957
if(easy_conn) {
1958
if(easy_conn->recv_pipe && easy_conn->recv_pipe->size > 1) {
1959
/* the handle should not be removed from the pipe yet */
1960
remove_sock_from_hash = FALSE;
1961
1962
/* Update the sockhash entry to instead point to the next in line
1963
for the recv_pipe, or the first (in case this particular easy
1964
isn't already) */
1965
if(entry->easy == easy->easy_handle) {
1966
if(isHandleAtHead(easy->easy_handle, easy_conn->recv_pipe))
1967
entry->easy = easy_conn->recv_pipe->head->next->ptr;
1968
else
1969
entry->easy = easy_conn->recv_pipe->head->ptr;
1970
}
1971
}
1972
if(easy_conn->send_pipe && easy_conn->send_pipe->size > 1) {
1973
/* the handle should not be removed from the pipe yet */
1974
remove_sock_from_hash = FALSE;
1975
1976
/* Update the sockhash entry to instead point to the next in line
1977
for the send_pipe, or the first (in case this particular easy
1978
isn't already) */
1979
if(entry->easy == easy->easy_handle) {
1980
if(isHandleAtHead(easy->easy_handle, easy_conn->send_pipe))
1981
entry->easy = easy_conn->send_pipe->head->next->ptr;
1982
else
1983
entry->easy = easy_conn->send_pipe->head->ptr;
1984
}
1985
}
1986
/* Don't worry about overwriting recv_pipe head with send_pipe_head,
1987
when action will be asked on the socket (see multi_socket()), the
1988
head of the correct pipe will be taken according to the
1989
action. */
1990
}
1991
}
1992
else
1993
/* just a precaution, this socket really SHOULD be in the hash already
1994
but in case it isn't, we don't have to tell the app to remove it
1995
either since it never got to know about it */
1996
remove_sock_from_hash = FALSE;
1997
1998
if(remove_sock_from_hash) {
1999
/* in this case 'entry' is always non-NULL */
2000
if(multi->socket_cb)
2001
multi->socket_cb(easy->easy_handle,
2002
s,
2003
CURL_POLL_REMOVE,
2004
multi->socket_userp,
2005
entry->socketp);
2006
sh_delentry(multi->sockhash, s);
2007
}
2008
2009
}
2010
}
2011
2012
memcpy(easy->sockets, socks, num*sizeof(curl_socket_t));
2013
easy->numsocks = num;
2014
}
2015
2016
/*
2017
* add_next_timeout()
2018
*
2019
* Each SessionHandle has a list of timeouts. The add_next_timeout() is called
2020
* when it has just been removed from the splay tree because the timeout has
2021
* expired. This function is then to advance in the list to pick the next
2022
* timeout to use (skip the already expired ones) and add this node back to
2023
* the splay tree again.
2024
*
2025
* The splay tree only has each sessionhandle as a single node and the nearest
2026
* timeout is used to sort it on.
2027
*/
2028
static CURLMcode add_next_timeout(struct timeval now,
2029
struct Curl_multi *multi,
2030
struct SessionHandle *d)
2031
{
2032
struct timeval *tv = &d->state.expiretime;
2033
struct curl_llist *list = d->state.timeoutlist;
2034
struct curl_llist_element *e;
2035
2036
/* move over the timeout list for this specific handle and remove all
2037
timeouts that are now passed tense and store the next pending
2038
timeout in *tv */
2039
for(e = list->head; e; ) {
2040
struct curl_llist_element *n = e->next;
2041
long diff = curlx_tvdiff(*(struct timeval *)e->ptr, now);
2042
if(diff <= 0)
2043
/* remove outdated entry */
2044
Curl_llist_remove(list, e, NULL);
2045
else
2046
/* the list is sorted so get out on the first mismatch */
2047
break;
2048
e = n;
2049
}
2050
e = list->head;
2051
if(!e) {
2052
/* clear the expire times within the handles that we remove from the
2053
splay tree */
2054
tv->tv_sec = 0;
2055
tv->tv_usec = 0;
2056
}
2057
else {
2058
/* copy the first entry to 'tv' */
2059
memcpy(tv, e->ptr, sizeof(*tv));
2060
2061
/* remove first entry from list */
2062
Curl_llist_remove(list, e, NULL);
2063
2064
/* insert this node again into the splay */
2065
multi->timetree = Curl_splayinsert(*tv, multi->timetree,
2066
&d->state.timenode);
2067
}
2068
return CURLM_OK;
2069
}
2070
2071
2072
static CURLMcode multi_socket(struct Curl_multi *multi,
2073
bool checkall,
2074
curl_socket_t s,
2075
int ev_bitmask,
2076
int *running_handles)
2077
{
2078
CURLMcode result = CURLM_OK;
2079
struct SessionHandle *data = NULL;
2080
struct Curl_tree *t;
2081
struct timeval now = Curl_tvnow();
2082
2083
if(checkall) {
2084
struct Curl_one_easy *easyp;
2085
/* *perform() deals with running_handles on its own */
2086
result = curl_multi_perform(multi, running_handles);
2087
2088
/* walk through each easy handle and do the socket state change magic
2089
and callbacks */
2090
easyp=multi->easy.next;
2091
while(easyp != &multi->easy) {
2092
singlesocket(multi, easyp);
2093
easyp = easyp->next;
2094
}
2095
2096
/* or should we fall-through and do the timer-based stuff? */
2097
return result;
2098
}
2099
else if(s != CURL_SOCKET_TIMEOUT) {
2100
2101
struct Curl_sh_entry *entry =
2102
Curl_hash_pick(multi->sockhash, (char *)&s, sizeof(s));
2103
2104
if(!entry)
2105
/* Unmatched socket, we can't act on it but we ignore this fact. In
2106
real-world tests it has been proved that libevent can in fact give
2107
the application actions even though the socket was just previously
2108
asked to get removed, so thus we better survive stray socket actions
2109
and just move on. */
2110
;
2111
else {
2112
data = entry->easy;
2113
2114
if(data->magic != CURLEASY_MAGIC_NUMBER)
2115
/* bad bad bad bad bad bad bad */
2116
return CURLM_INTERNAL_ERROR;
2117
2118
/* If the pipeline is enabled, take the handle which is in the head of
2119
the pipeline. If we should write into the socket, take the send_pipe
2120
head. If we should read from the socket, take the recv_pipe head. */
2121
if(data->set.one_easy->easy_conn) {
2122
if((ev_bitmask & CURL_POLL_OUT) &&
2123
data->set.one_easy->easy_conn->send_pipe &&
2124
data->set.one_easy->easy_conn->send_pipe->head)
2125
data = data->set.one_easy->easy_conn->send_pipe->head->ptr;
2126
else if((ev_bitmask & CURL_POLL_IN) &&
2127
data->set.one_easy->easy_conn->recv_pipe &&
2128
data->set.one_easy->easy_conn->recv_pipe->head)
2129
data = data->set.one_easy->easy_conn->recv_pipe->head->ptr;
2130
}
2131
2132
if(data->set.one_easy->easy_conn &&
2133
!(data->set.one_easy->easy_conn->handler->flags & PROTOPT_DIRLOCK))
2134
/* set socket event bitmask if they're not locked */
2135
data->set.one_easy->easy_conn->cselect_bits = ev_bitmask;
2136
2137
do
2138
result = multi_runsingle(multi, now, data->set.one_easy);
2139
while(CURLM_CALL_MULTI_PERFORM == result);
2140
2141
if(data->set.one_easy->easy_conn &&
2142
!(data->set.one_easy->easy_conn->handler->flags & PROTOPT_DIRLOCK))
2143
/* clear the bitmask only if not locked */
2144
data->set.one_easy->easy_conn->cselect_bits = 0;
2145
2146
if(CURLM_OK >= result)
2147
/* get the socket(s) and check if the state has been changed since
2148
last */
2149
singlesocket(multi, data->set.one_easy);
2150
2151
/* Now we fall-through and do the timer-based stuff, since we don't want
2152
to force the user to have to deal with timeouts as long as at least
2153
one connection in fact has traffic. */
2154
2155
data = NULL; /* set data to NULL again to avoid calling
2156
multi_runsingle() in case there's no need to */
2157
}
2158
}
2159
2160
now.tv_usec += 40000; /* compensate for bad precision timers that might've
2161
triggered too early */
2162
if(now.tv_usec >= 1000000) {
2163
now.tv_sec++;
2164
now.tv_usec -= 1000000;
2165
}
2166
2167
/*
2168
* The loop following here will go on as long as there are expire-times left
2169
* to process in the splay and 'data' will be re-assigned for every expired
2170
* handle we deal with.
2171
*/
2172
do {
2173
/* the first loop lap 'data' can be NULL */
2174
if(data) {
2175
do
2176
result = multi_runsingle(multi, now, data->set.one_easy);
2177
while(CURLM_CALL_MULTI_PERFORM == result);
2178
2179
if(CURLM_OK >= result)
2180
/* get the socket(s) and check if the state has been changed since
2181
last */
2182
singlesocket(multi, data->set.one_easy);
2183
}
2184
2185
/* Check if there's one (more) expired timer to deal with! This function
2186
extracts a matching node if there is one */
2187
2188
multi->timetree = Curl_splaygetbest(now, multi->timetree, &t);
2189
if(t) {
2190
data = t->payload; /* assign this for next loop */
2191
(void)add_next_timeout(now, multi, t->payload);
2192
}
2193
2194
} while(t);
2195
2196
*running_handles = multi->num_alive;
2197
return result;
2198
}
2199
2200
#undef curl_multi_setopt
2201
CURLMcode curl_multi_setopt(CURLM *multi_handle,
2202
CURLMoption option, ...)
2203
{
2204
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
2205
CURLMcode res = CURLM_OK;
2206
va_list param;
2207
2208
if(!GOOD_MULTI_HANDLE(multi))
2209
return CURLM_BAD_HANDLE;
2210
2211
va_start(param, option);
2212
2213
switch(option) {
2214
case CURLMOPT_SOCKETFUNCTION:
2215
multi->socket_cb = va_arg(param, curl_socket_callback);
2216
break;
2217
case CURLMOPT_SOCKETDATA:
2218
multi->socket_userp = va_arg(param, void *);
2219
break;
2220
case CURLMOPT_PIPELINING:
2221
multi->pipelining_enabled = (0 != va_arg(param, long)) ? TRUE : FALSE;
2222
break;
2223
case CURLMOPT_TIMERFUNCTION:
2224
multi->timer_cb = va_arg(param, curl_multi_timer_callback);
2225
break;
2226
case CURLMOPT_TIMERDATA:
2227
multi->timer_userp = va_arg(param, void *);
2228
break;
2229
case CURLMOPT_MAXCONNECTS:
2230
multi->maxconnects = va_arg(param, long);
2231
break;
2232
default:
2233
res = CURLM_UNKNOWN_OPTION;
2234
break;
2235
}
2236
va_end(param);
2237
return res;
2238
}
2239
2240
/* we define curl_multi_socket() in the public multi.h header */
2241
#undef curl_multi_socket
2242
2243
CURLMcode curl_multi_socket(CURLM *multi_handle, curl_socket_t s,
2244
int *running_handles)
2245
{
2246
CURLMcode result = multi_socket((struct Curl_multi *)multi_handle, FALSE, s,
2247
0, running_handles);
2248
if(CURLM_OK >= result)
2249
update_timer((struct Curl_multi *)multi_handle);
2250
return result;
2251
}
2252
2253
CURLMcode curl_multi_socket_action(CURLM *multi_handle, curl_socket_t s,
2254
int ev_bitmask, int *running_handles)
2255
{
2256
CURLMcode result = multi_socket((struct Curl_multi *)multi_handle, FALSE, s,
2257
ev_bitmask, running_handles);
2258
if(CURLM_OK >= result)
2259
update_timer((struct Curl_multi *)multi_handle);
2260
return result;
2261
}
2262
2263
CURLMcode curl_multi_socket_all(CURLM *multi_handle, int *running_handles)
2264
2265
{
2266
CURLMcode result = multi_socket((struct Curl_multi *)multi_handle,
2267
TRUE, CURL_SOCKET_BAD, 0, running_handles);
2268
if(CURLM_OK >= result)
2269
update_timer((struct Curl_multi *)multi_handle);
2270
return result;
2271
}
2272
2273
static CURLMcode multi_timeout(struct Curl_multi *multi,
2274
long *timeout_ms)
2275
{
2276
static struct timeval tv_zero = {0,0};
2277
2278
if(multi->timetree) {
2279
/* we have a tree of expire times */
2280
struct timeval now = Curl_tvnow();
2281
2282
/* splay the lowest to the bottom */
2283
multi->timetree = Curl_splay(tv_zero, multi->timetree);
2284
2285
if(Curl_splaycomparekeys(multi->timetree->key, now) > 0) {
2286
/* some time left before expiration */
2287
*timeout_ms = curlx_tvdiff(multi->timetree->key, now);
2288
if(!*timeout_ms)
2289
/*
2290
* Since we only provide millisecond resolution on the returned value
2291
* and the diff might be less than one millisecond here, we don't
2292
* return zero as that may cause short bursts of busyloops on fast
2293
* processors while the diff is still present but less than one
2294
* millisecond! instead we return 1 until the time is ripe.
2295
*/
2296
*timeout_ms=1;
2297
}
2298
else
2299
/* 0 means immediately */
2300
*timeout_ms = 0;
2301
}
2302
else
2303
*timeout_ms = -1;
2304
2305
return CURLM_OK;
2306
}
2307
2308
CURLMcode curl_multi_timeout(CURLM *multi_handle,
2309
long *timeout_ms)
2310
{
2311
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
2312
2313
/* First, make some basic checks that the CURLM handle is a good handle */
2314
if(!GOOD_MULTI_HANDLE(multi))
2315
return CURLM_BAD_HANDLE;
2316
2317
return multi_timeout(multi, timeout_ms);
2318
}
2319
2320
/*
2321
* Tell the application it should update its timers, if it subscribes to the
2322
* update timer callback.
2323
*/
2324
static int update_timer(struct Curl_multi *multi)
2325
{
2326
long timeout_ms;
2327
2328
if(!multi->timer_cb)
2329
return 0;
2330
if(multi_timeout(multi, &timeout_ms)) {
2331
return -1;
2332
}
2333
if(timeout_ms < 0) {
2334
static const struct timeval none={0,0};
2335
if(Curl_splaycomparekeys(none, multi->timer_lastcall)) {
2336
multi->timer_lastcall = none;
2337
/* there's no timeout now but there was one previously, tell the app to
2338
disable it */
2339
return multi->timer_cb((CURLM*)multi, -1, multi->timer_userp);
2340
}
2341
return 0;
2342
}
2343
2344
/* When multi_timeout() is done, multi->timetree points to the node with the
2345
* timeout we got the (relative) time-out time for. We can thus easily check
2346
* if this is the same (fixed) time as we got in a previous call and then
2347
* avoid calling the callback again. */
2348
if(Curl_splaycomparekeys(multi->timetree->key, multi->timer_lastcall) == 0)
2349
return 0;
2350
2351
multi->timer_lastcall = multi->timetree->key;
2352
2353
return multi->timer_cb((CURLM*)multi, timeout_ms, multi->timer_userp);
2354
}
2355
2356
static CURLcode addHandleToSendOrPendPipeline(struct SessionHandle *handle,
2357
struct connectdata *conn)
2358
{
2359
size_t pipeLen = conn->send_pipe->size + conn->recv_pipe->size;
2360
struct curl_llist_element *sendhead = conn->send_pipe->head;
2361
struct curl_llist *pipeline;
2362
CURLcode rc;
2363
2364
if(!Curl_isPipeliningEnabled(handle) ||
2365
pipeLen == 0)
2366
pipeline = conn->send_pipe;
2367
else {
2368
if(conn->server_supports_pipelining &&
2369
pipeLen < MAX_PIPELINE_LENGTH)
2370
pipeline = conn->send_pipe;
2371
else
2372
pipeline = conn->pend_pipe;
2373
}
2374
2375
rc = Curl_addHandleToPipeline(handle, pipeline);
2376
2377
if(pipeline == conn->send_pipe && sendhead != conn->send_pipe->head) {
2378
/* this is a new one as head, expire it */
2379
conn->writechannel_inuse = FALSE; /* not in use yet */
2380
#ifdef DEBUGBUILD
2381
infof(conn->data, "%p is at send pipe head!\n",
2382
conn->send_pipe->head->ptr);
2383
#endif
2384
Curl_expire(conn->send_pipe->head->ptr, 1);
2385
}
2386
2387
return rc;
2388
}
2389
2390
static int checkPendPipeline(struct connectdata *conn)
2391
{
2392
int result = 0;
2393
struct curl_llist_element *sendhead = conn->send_pipe->head;
2394
2395
size_t pipeLen = conn->send_pipe->size + conn->recv_pipe->size;
2396
if(conn->server_supports_pipelining || pipeLen == 0) {
2397
struct curl_llist_element *curr = conn->pend_pipe->head;
2398
const size_t maxPipeLen =
2399
conn->server_supports_pipelining ? MAX_PIPELINE_LENGTH : 1;
2400
2401
while(pipeLen < maxPipeLen && curr) {
2402
Curl_llist_move(conn->pend_pipe, curr,
2403
conn->send_pipe, conn->send_pipe->tail);
2404
Curl_pgrsTime(curr->ptr, TIMER_PRETRANSFER);
2405
++result; /* count how many handles we moved */
2406
curr = conn->pend_pipe->head;
2407
++pipeLen;
2408
}
2409
}
2410
2411
if(result) {
2412
conn->now = Curl_tvnow();
2413
/* something moved, check for a new send pipeline leader */
2414
if(sendhead != conn->send_pipe->head) {
2415
/* this is a new one as head, expire it */
2416
conn->writechannel_inuse = FALSE; /* not in use yet */
2417
#ifdef DEBUGBUILD
2418
infof(conn->data, "%p is at send pipe head!\n",
2419
conn->send_pipe->head->ptr);
2420
#endif
2421
Curl_expire(conn->send_pipe->head->ptr, 1);
2422
}
2423
}
2424
2425
return result;
2426
}
2427
2428
/* Move this transfer from the sending list to the receiving list.
2429
2430
Pay special attention to the new sending list "leader" as it needs to get
2431
checked to update what sockets it acts on.
2432
2433
*/
2434
static void moveHandleFromSendToRecvPipeline(struct SessionHandle *handle,
2435
struct connectdata *conn)
2436
{
2437
struct curl_llist_element *curr;
2438
2439
curr = conn->send_pipe->head;
2440
while(curr) {
2441
if(curr->ptr == handle) {
2442
Curl_llist_move(conn->send_pipe, curr,
2443
conn->recv_pipe, conn->recv_pipe->tail);
2444
2445
if(conn->send_pipe->head) {
2446
/* Since there's a new easy handle at the start of the send pipeline,
2447
set its timeout value to 1ms to make it trigger instantly */
2448
conn->writechannel_inuse = FALSE; /* not used now */
2449
#ifdef DEBUGBUILD
2450
infof(conn->data, "%p is at send pipe head B!\n",
2451
conn->send_pipe->head->ptr);
2452
#endif
2453
Curl_expire(conn->send_pipe->head->ptr, 1);
2454
}
2455
2456
/* The receiver's list is not really interesting here since either this
2457
handle is now first in the list and we'll deal with it soon, or
2458
another handle is already first and thus is already taken care of */
2459
2460
break; /* we're done! */
2461
}
2462
curr = curr->next;
2463
}
2464
}
2465
2466
static void moveHandleFromRecvToDonePipeline(struct SessionHandle *handle,
2467
struct connectdata *conn)
2468
{
2469
struct curl_llist_element *curr;
2470
2471
curr = conn->recv_pipe->head;
2472
while(curr) {
2473
if(curr->ptr == handle) {
2474
Curl_llist_move(conn->recv_pipe, curr,
2475
conn->done_pipe, conn->done_pipe->tail);
2476
break;
2477
}
2478
curr = curr->next;
2479
}
2480
}
2481
static bool isHandleAtHead(struct SessionHandle *handle,
2482
struct curl_llist *pipeline)
2483
{
2484
struct curl_llist_element *curr = pipeline->head;
2485
if(curr)
2486
return (curr->ptr == handle) ? TRUE : FALSE;
2487
2488
return FALSE;
2489
}
2490
2491
/*
2492
* multi_freetimeout()
2493
*
2494
* Callback used by the llist system when a single timeout list entry is
2495
* destroyed.
2496
*/
2497
static void multi_freetimeout(void *user, void *entryptr)
2498
{
2499
(void)user;
2500
2501
/* the entry was plain malloc()'ed */
2502
free(entryptr);
2503
}
2504
2505
/*
2506
* multi_addtimeout()
2507
*
2508
* Add a timestamp to the list of timeouts. Keep the list sorted so that head
2509
* of list is always the timeout nearest in time.
2510
*
2511
*/
2512
static CURLMcode
2513
multi_addtimeout(struct curl_llist *timeoutlist,
2514
struct timeval *stamp)
2515
{
2516
struct curl_llist_element *e;
2517
struct timeval *timedup;
2518
struct curl_llist_element *prev = NULL;
2519
2520
timedup = malloc(sizeof(*timedup));
2521
if(!timedup)
2522
return CURLM_OUT_OF_MEMORY;
2523
2524
/* copy the timestamp */
2525
memcpy(timedup, stamp, sizeof(*timedup));
2526
2527
if(Curl_llist_count(timeoutlist)) {
2528
/* find the correct spot in the list */
2529
for(e = timeoutlist->head; e; e = e->next) {
2530
struct timeval *checktime = e->ptr;
2531
long diff = curlx_tvdiff(*checktime, *timedup);
2532
if(diff > 0)
2533
break;
2534
prev = e;
2535
}
2536
2537
}
2538
/* else
2539
this is the first timeout on the list */
2540
2541
if(!Curl_llist_insert_next(timeoutlist, prev, timedup)) {
2542
free(timedup);
2543
return CURLM_OUT_OF_MEMORY;
2544
}
2545
2546
return CURLM_OK;
2547
}
2548
2549
/*
2550
* Curl_expire()
2551
*
2552
* given a number of milliseconds from now to use to set the 'act before
2553
* this'-time for the transfer, to be extracted by curl_multi_timeout()
2554
*
2555
* Note that the timeout will be added to a queue of timeouts if it defines a
2556
* moment in time that is later than the current head of queue.
2557
*
2558
* Pass zero to clear all timeout values for this handle.
2559
*/
2560
void Curl_expire(struct SessionHandle *data, long milli)
2561
{
2562
struct Curl_multi *multi = data->multi;
2563
struct timeval *nowp = &data->state.expiretime;
2564
int rc;
2565
2566
/* this is only interesting for multi-interface using libcurl, and only
2567
while there is still a multi interface struct remaining! */
2568
if(!multi)
2569
return;
2570
2571
if(!milli) {
2572
/* No timeout, clear the time data. */
2573
if(nowp->tv_sec || nowp->tv_usec) {
2574
/* Since this is an cleared time, we must remove the previous entry from
2575
the splay tree */
2576
struct curl_llist *list = data->state.timeoutlist;
2577
2578
rc = Curl_splayremovebyaddr(multi->timetree,
2579
&data->state.timenode,
2580
&multi->timetree);
2581
if(rc)
2582
infof(data, "Internal error clearing splay node = %d\n", rc);
2583
2584
/* flush the timeout list too */
2585
while(list->size > 0)
2586
Curl_llist_remove(list, list->tail, NULL);
2587
2588
#ifdef DEBUGBUILD
2589
infof(data, "Expire cleared\n");
2590
#endif
2591
nowp->tv_sec = 0;
2592
nowp->tv_usec = 0;
2593
}
2594
}
2595
else {
2596
struct timeval set;
2597
2598
set = Curl_tvnow();
2599
set.tv_sec += milli/1000;
2600
set.tv_usec += (milli%1000)*1000;
2601
2602
if(set.tv_usec >= 1000000) {
2603
set.tv_sec++;
2604
set.tv_usec -= 1000000;
2605
}
2606
2607
if(nowp->tv_sec || nowp->tv_usec) {
2608
/* This means that the struct is added as a node in the splay tree.
2609
Compare if the new time is earlier, and only remove-old/add-new if it
2610
is. */
2611
long diff = curlx_tvdiff(set, *nowp);
2612
if(diff > 0) {
2613
/* the new expire time was later so just add it to the queue
2614
and get out */
2615
multi_addtimeout(data->state.timeoutlist, &set);
2616
return;
2617
}
2618
2619
/* the new time is newer than the presently set one, so add the current
2620
to the queue and update the head */
2621
multi_addtimeout(data->state.timeoutlist, nowp);
2622
2623
/* Since this is an updated time, we must remove the previous entry from
2624
the splay tree first and then re-add the new value */
2625
rc = Curl_splayremovebyaddr(multi->timetree,
2626
&data->state.timenode,
2627
&multi->timetree);
2628
if(rc)
2629
infof(data, "Internal error removing splay node = %d\n", rc);
2630
}
2631
2632
*nowp = set;
2633
data->state.timenode.payload = data;
2634
multi->timetree = Curl_splayinsert(*nowp,
2635
multi->timetree,
2636
&data->state.timenode);
2637
}
2638
#if 0
2639
Curl_splayprint(multi->timetree, 0, TRUE);
2640
#endif
2641
}
2642
2643
CURLMcode curl_multi_assign(CURLM *multi_handle,
2644
curl_socket_t s, void *hashp)
2645
{
2646
struct Curl_sh_entry *there = NULL;
2647
struct Curl_multi *multi = (struct Curl_multi *)multi_handle;
2648
2649
if(s != CURL_SOCKET_BAD)
2650
there = Curl_hash_pick(multi->sockhash, (char *)&s, sizeof(curl_socket_t));
2651
2652
if(!there)
2653
return CURLM_BAD_SOCKET;
2654
2655
there->socketp = hashp;
2656
2657
return CURLM_OK;
2658
}
2659
2660
#ifdef DEBUGBUILD
2661
void Curl_multi_dump(const struct Curl_multi *multi_handle)
2662
{
2663
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
2664
struct Curl_one_easy *easy;
2665
int i;
2666
fprintf(stderr, "* Multi status: %d handles, %d alive\n",
2667
multi->num_easy, multi->num_alive);
2668
for(easy=multi->easy.next; easy != &multi->easy; easy = easy->next) {
2669
if(easy->state < CURLM_STATE_COMPLETED) {
2670
/* only display handles that are not completed */
2671
fprintf(stderr, "handle %p, state %s, %d sockets\n",
2672
(void *)easy->easy_handle,
2673
statename[easy->state], easy->numsocks);
2674
for(i=0; i < easy->numsocks; i++) {
2675
curl_socket_t s = easy->sockets[i];
2676
struct Curl_sh_entry *entry =
2677
Curl_hash_pick(multi->sockhash, (char *)&s, sizeof(s));
2678
2679
fprintf(stderr, "%d ", (int)s);
2680
if(!entry) {
2681
fprintf(stderr, "INTERNAL CONFUSION\n");
2682
continue;
2683
}
2684
fprintf(stderr, "[%s %s] ",
2685
entry->action&CURL_POLL_IN?"RECVING":"",
2686
entry->action&CURL_POLL_OUT?"SENDING":"");
2687
}
2688
if(easy->numsocks)
2689
fprintf(stderr, "\n");
2690
}
2691
}
2692
}
2693
#endif
Loggerhead is a web-based interface for Breezy
Version: 2.0.1