Lines Matching full:multi
78 /* On a debug build, we want to fail hard on multi handles that
89 static void move_pending_to_connect(struct Curl_multi *multi,
91 static CURLMcode singlesocket(struct Curl_multi *multi,
94 struct Curl_multi *multi,
96 static CURLMcode multi_timeout(struct Curl_multi *multi,
98 static void process_pending_handles(struct Curl_multi *multi);
99 static void multi_xfer_bufs_free(struct Curl_multi *multi);
195 DEBUGASSERT(data->multi->num_alive > 0); in mstate()
196 data->multi->num_alive--; in mstate()
197 if(!data->multi->num_alive) { in mstate()
199 multi_xfer_bufs_free(data->multi); in mstate()
377 * the list kept in the multi handle.
379 static void multi_addmsg(struct Curl_multi *multi, struct Curl_message *msg) in multi_addmsg() argument
381 Curl_llist_append(&multi->msglist, msg, &msg->list); in multi_addmsg()
388 struct Curl_multi *multi = calloc(1, sizeof(struct Curl_multi)); in Curl_multi_handle() local
390 if(!multi) in Curl_multi_handle()
393 multi->magic = CURL_MULTI_HANDLE; in Curl_multi_handle()
395 Curl_init_dnscache(&multi->hostcache, dnssize); in Curl_multi_handle()
397 sh_init(&multi->sockhash, hashsize); in Curl_multi_handle()
399 if(Curl_conncache_init(&multi->conn_cache, chashsize)) in Curl_multi_handle()
402 Curl_llist_init(&multi->msglist, NULL); in Curl_multi_handle()
403 Curl_llist_init(&multi->pending, NULL); in Curl_multi_handle()
404 Curl_llist_init(&multi->msgsent, NULL); in Curl_multi_handle()
406 multi->multiplexing = TRUE; in Curl_multi_handle()
407 multi->max_concurrent_streams = 100; in Curl_multi_handle()
410 multi->wsa_event = WSACreateEvent(); in Curl_multi_handle()
411 if(multi->wsa_event == WSA_INVALID_EVENT) in Curl_multi_handle()
415 if(wakeup_create(multi->wakeup_pair) < 0) { in Curl_multi_handle()
416 multi->wakeup_pair[0] = CURL_SOCKET_BAD; in Curl_multi_handle()
417 multi->wakeup_pair[1] = CURL_SOCKET_BAD; in Curl_multi_handle()
419 else if(curlx_nonblock(multi->wakeup_pair[0], TRUE) < 0 || in Curl_multi_handle()
420 curlx_nonblock(multi->wakeup_pair[1], TRUE) < 0) { in Curl_multi_handle()
421 wakeup_close(multi->wakeup_pair[0]); in Curl_multi_handle()
422 wakeup_close(multi->wakeup_pair[1]); in Curl_multi_handle()
423 multi->wakeup_pair[0] = CURL_SOCKET_BAD; in Curl_multi_handle()
424 multi->wakeup_pair[1] = CURL_SOCKET_BAD; in Curl_multi_handle()
429 return multi; in Curl_multi_handle()
433 sockhash_destroy(&multi->sockhash); in Curl_multi_handle()
434 Curl_hash_destroy(&multi->hostcache); in Curl_multi_handle()
435 Curl_conncache_destroy(&multi->conn_cache); in Curl_multi_handle()
436 free(multi); in Curl_multi_handle()
448 static void multi_warn_debug(struct Curl_multi *multi, struct Curl_easy *data) in multi_warn_debug() argument
450 if(!multi->warned) { in multi_warn_debug()
454 multi->warned = true; in multi_warn_debug()
469 static void link_easy(struct Curl_multi *multi, in link_easy() argument
474 if(multi->easyp) { in link_easy()
475 struct Curl_easy *last = multi->easylp; in link_easy()
478 multi->easylp = data; /* the new last node */ in link_easy()
483 multi->easylp = multi->easyp = data; /* both first and last */ in link_easy()
488 static void unlink_easy(struct Curl_multi *multi, in unlink_easy() argument
495 multi->easyp = data->next; /* point to first node */ in unlink_easy()
501 multi->easylp = data->prev; /* point to last node */ in unlink_easy()
507 CURLMcode curl_multi_add_handle(struct Curl_multi *multi, in curl_multi_add_handle() argument
512 if(!GOOD_MULTI_HANDLE(multi)) in curl_multi_add_handle()
520 adding to more than one multi stack */ in curl_multi_add_handle()
521 if(data->multi) in curl_multi_add_handle()
524 if(multi->in_callback) in curl_multi_add_handle()
527 if(multi->dead) { in curl_multi_add_handle()
531 if(multi->num_alive) in curl_multi_add_handle()
533 multi->dead = FALSE; in curl_multi_add_handle()
538 is a private multi handle here that we can kill */ in curl_multi_add_handle()
548 * modification of easy nor multi handle allowed before this except for in curl_multi_add_handle()
549 * potential multi's connection cache growing which won't be undone in this in curl_multi_add_handle()
557 /* make the Curl_easy refer back to this multi handle - before Curl_expire() in curl_multi_add_handle()
559 data->multi = multi; in curl_multi_add_handle()
579 memset(&multi->timer_lastcall, 0, sizeof(multi->timer_lastcall)); in curl_multi_add_handle()
581 rc = Curl_update_timer(multi); in curl_multi_add_handle()
588 /* for multi interface connections, we share DNS cache automatically if the in curl_multi_add_handle()
592 data->dns.hostcache = &multi->hostcache; in curl_multi_add_handle()
596 /* Point to the shared or multi handle connection cache */ in curl_multi_add_handle()
600 data->state.conn_cache = &multi->conn_cache; in curl_multi_add_handle()
608 data->psl = &multi->psl; in curl_multi_add_handle()
611 link_easy(multi, data); in curl_multi_add_handle()
614 multi->num_easy++; in curl_multi_add_handle()
617 multi->num_alive++; in curl_multi_add_handle()
634 multi_warn_debug(multi, data); in curl_multi_add_handle()
642 * Curl_hash_print(&multi->sockhash, debug_print_sock_hash);
719 process_pending_handles(data->multi); /* connection / multiplex */ in multi_done()
826 CURLMcode curl_multi_remove_handle(struct Curl_multi *multi, in curl_multi_remove_handle() argument
835 if(!GOOD_MULTI_HANDLE(multi)) in curl_multi_remove_handle()
843 if(!data->multi) in curl_multi_remove_handle()
846 /* Prevent users from trying to remove an easy handle from the wrong multi */ in curl_multi_remove_handle()
847 if(data->multi != multi) in curl_multi_remove_handle()
850 if(multi->in_callback) in curl_multi_remove_handle()
860 multi->num_alive--; in curl_multi_remove_handle()
880 /* The timer must be shut down before data->multi is set to NULL, else the in curl_multi_remove_handle()
889 Curl_llist_remove(&multi->pending, &data->connect_queue, NULL); in curl_multi_remove_handle()
891 Curl_llist_remove(&multi->msgsent, &data->connect_queue, NULL); in curl_multi_remove_handle()
894 unlink_easy(multi, data); in curl_multi_remove_handle()
897 /* stop using the multi handle's DNS cache, *after* the possible in curl_multi_remove_handle()
911 (void)singlesocket(multi, easy); /* to let the application know what sockets in curl_multi_remove_handle()
918 /* This removes a handle that was part the multi interface that used in curl_multi_remove_handle()
922 anymore once removed from the multi handle in curl_multi_remove_handle()
943 if(data->psl == &multi->psl) in curl_multi_remove_handle()
948 since we're not part of that multi handle anymore */ in curl_multi_remove_handle()
951 data->multi = NULL; /* clear the association to this multi handle */ in curl_multi_remove_handle()
955 for(e = multi->msglist.head; e; e = e->next) { in curl_multi_remove_handle()
959 Curl_llist_remove(&multi->msglist, e, NULL); in curl_multi_remove_handle()
967 multi->num_easy--; /* one less to care about now */ in curl_multi_remove_handle()
969 process_pending_handles(multi); in curl_multi_remove_handle()
971 rc = Curl_update_timer(multi); in curl_multi_remove_handle()
978 bool Curl_multiplex_wanted(const struct Curl_multi *multi) in Curl_multiplex_wanted() argument
980 return (multi && (multi->multiplexing)); in Curl_multiplex_wanted()
1169 failf(data, "multi_getsock: unexpected multi state %d", data->mstate); in multi_getsock()
1175 CURLMcode curl_multi_fdset(struct Curl_multi *multi, in curl_multi_fdset() argument
1188 if(!GOOD_MULTI_HANDLE(multi)) in curl_multi_fdset()
1191 if(multi->in_callback) in curl_multi_fdset()
1195 for(data = multi->easyp; data; data = data->next) { in curl_multi_fdset()
1216 CURLMcode curl_multi_waitfds(struct Curl_multi *multi, in curl_multi_waitfds() argument
1232 if(!GOOD_MULTI_HANDLE(multi)) in curl_multi_waitfds()
1235 if(multi->in_callback) in curl_multi_waitfds()
1239 for(data = multi->easyp; data; data = data->next) { in curl_multi_waitfds()
1319 static CURLMcode multi_wait(struct Curl_multi *multi, argument
1339 DEBUGASSERT(multi->wsa_event != WSA_INVALID_EVENT);
1345 if(!GOOD_MULTI_HANDLE(multi))
1348 if(multi->in_callback)
1357 (void)multi_timeout(multi, &timeout_internal);
1365 for(data = multi->easyp; data; data = data->next) {
1403 if(WSAEventSelect(ps.sockets[i], multi->wsa_event, mask) != 0) {
1427 if(WSAEventSelect(extra_fds[i].fd, multi->wsa_event, mask) != 0) {
1451 if(use_wakeup && multi->wakeup_pair[0] != CURL_SOCKET_BAD) {
1457 ufds[nfds].fd = multi->wakeup_pair[0];
1486 WSAWaitForMultipleEvents(1, &multi->wsa_event, FALSE, timeout_ms, FALSE);
1511 WSAEventSelect(s, multi->wsa_event, 0);
1531 for(data = multi->easyp; data; data = data->next) {
1541 WSAEventSelect(ps.sockets[i], multi->wsa_event, 0);
1546 WSAResetEvent(multi->wsa_event);
1549 if(use_wakeup && multi->wakeup_pair[0] != CURL_SOCKET_BAD) {
1558 nread = wakeup_read(multi->wakeup_pair[0], buf, sizeof(buf));
1586 if(!curl_multi_timeout(multi, &sleep_ms) && sleep_ms) {
1589 /* when there are no easy handles in the multi, this holds a -1
1600 CURLMcode curl_multi_wait(struct Curl_multi *multi, argument
1606 return multi_wait(multi, extra_fds, extra_nfds, timeout_ms, ret, FALSE,
1610 CURLMcode curl_multi_poll(struct Curl_multi *multi, argument
1616 return multi_wait(multi, extra_fds, extra_nfds, timeout_ms, ret, TRUE,
1620 CURLMcode curl_multi_wakeup(struct Curl_multi *multi) argument
1627 if(!GOOD_MULTI_HANDLE(multi))
1632 if(WSASetEvent(multi->wsa_event))
1638 if(multi->wakeup_pair[1] != CURL_SOCKET_BAD) {
1651 if(wakeup_write(multi->wakeup_pair[1], buf, sizeof(buf)) < 0) {
1680 static bool multi_ischanged(struct Curl_multi *multi, bool clear) argument
1682 bool retval = multi->recheckstate;
1684 multi->recheckstate = FALSE;
1690 * this multi handle that has changed state (multiplexing become possible, the
1692 * multi handle should move CONNECT_PEND handles back to CONNECT to have them
1695 void Curl_multi_connchanged(struct Curl_multi *multi) argument
1697 multi->recheckstate = TRUE;
1700 CURLMcode Curl_multi_add_perform(struct Curl_multi *multi, argument
1706 if(multi->in_callback)
1709 rc = curl_multi_add_handle(multi, data);
1740 * multi_do_more() is called during the DO_MORE multi state. It is basically a
1815 * over from the multi interface until the connection phase is done on
1835 * We are DOING this is being called over and over from the multi interface
1902 static void set_in_callback(struct Curl_multi *multi, bool value) argument
1904 multi->in_callback = value;
1907 static CURLMcode multi_runsingle(struct Curl_multi *multi, argument
1925 if(multi->dead) {
1926 /* a multi-level callback returned error before, meaning every individual
1934 multi_warn_debug(multi, data);
1942 if(multi_ischanged(multi, TRUE)) {
1943 DEBUGF(infof(data, "multi changed, check CONNECT_PEND queue"));
1944 process_pending_handles(multi); /* multiplexed */
2000 Curl_llist_append(&multi->pending, data, &data->connect_queue);
2002 unlink_easy(multi, data);
2007 process_pending_handles(data->multi);
2068 rc = singlesocket(multi, data);
2368 process_pending_handles(multi); /* multiplexed */
2593 process_pending_handles(multi); /* multiplexing */
2634 !multi_ischanged(multi, false)) {
2657 process_pending_handles(multi); /* connection */
2712 multi_addmsg(multi, msg);
2718 Curl_llist_append(&multi->msgsent, data, &data->connect_queue);
2720 unlink_easy(multi, data);
2723 } while((rc == CURLM_CALL_MULTI_PERFORM) || multi_ischanged(multi, FALSE));
2730 CURLMcode curl_multi_perform(struct Curl_multi *multi, int *running_handles) argument
2737 if(!GOOD_MULTI_HANDLE(multi))
2740 if(multi->in_callback)
2743 data = multi->easyp;
2760 result = multi_runsingle(multi, &now, data);
2779 multi->timetree = Curl_splaygetbest(now, multi->timetree, &t);
2789 move_pending_to_connect(multi, data);
2792 (void)add_next_timeout(now, multi, t->payload);
2796 *running_handles = multi->num_alive;
2799 returncode = Curl_update_timer(multi);
2805 multi handle */
2806 static void unlink_all_msgsent_handles(struct Curl_multi *multi) argument
2808 struct Curl_llist_element *e = multi->msgsent.head;
2812 data->multi = NULL;
2816 CURLMcode curl_multi_cleanup(struct Curl_multi *multi) argument
2821 if(GOOD_MULTI_HANDLE(multi)) {
2822 if(multi->in_callback)
2825 multi->magic = 0; /* not good anymore */
2827 unlink_all_msgsent_handles(multi);
2828 process_pending_handles(multi);
2830 data = multi->easyp;
2845 data->multi = NULL; /* clear the association */
2848 if(data->psl == &multi->psl)
2856 Curl_conncache_close_all_connections(&multi->conn_cache);
2858 sockhash_destroy(&multi->sockhash);
2859 Curl_conncache_destroy(&multi->conn_cache);
2860 Curl_hash_destroy(&multi->hostcache);
2861 Curl_psl_destroy(&multi->psl);
2864 WSACloseEvent(multi->wsa_event);
2867 wakeup_close(multi->wakeup_pair[0]);
2868 wakeup_close(multi->wakeup_pair[1]);
2873 Curl_free_multi_ssl_backend_data(multi->ssl_backend_data);
2876 multi_xfer_bufs_free(multi);
2877 free(multi);
2887 * This function is the primary way for a multi/multi_socket application to
2894 CURLMsg *curl_multi_info_read(struct Curl_multi *multi, int *msgs_in_queue) argument
2900 if(GOOD_MULTI_HANDLE(multi) &&
2901 !multi->in_callback &&
2902 Curl_llist_count(&multi->msglist)) {
2907 e = multi->msglist.head;
2912 Curl_llist_remove(&multi->msglist, e, NULL);
2914 *msgs_in_queue = curlx_uztosi(Curl_llist_count(&multi->msglist));
2926 static CURLMcode singlesocket(struct Curl_multi *multi, argument
2952 entry = sh_getentry(&multi->sockhash, s);
2965 entry = sh_addentry(&multi->sockhash, s);
3005 if(multi->socket_cb) {
3006 set_in_callback(multi, TRUE);
3007 rc = multi->socket_cb(data, s, comboaction, multi->socket_userp,
3010 set_in_callback(multi, FALSE);
3012 multi->dead = TRUE;
3021 * Need to remove the easy handle from the multi->sockhash->transfers and
3022 * remove multi->sockhash entry when this was the last transfer */
3037 entry = sh_getentry(&multi->sockhash, s);
3049 if(multi->socket_cb) {
3050 set_in_callback(multi, TRUE);
3051 rc = multi->socket_cb(data, s, CURL_POLL_REMOVE,
3052 multi->socket_userp, entry->socketp);
3053 set_in_callback(multi, FALSE);
3055 multi->dead = TRUE;
3059 sh_delentry(entry, &multi->sockhash, s);
3078 if(singlesocket(data->multi, data))
3098 struct Curl_multi *multi = data->multi; local
3099 if(multi) {
3101 a multi handle, and only then this is necessary */
3102 struct Curl_sh_entry *entry = sh_getentry(&multi->sockhash, s);
3106 if(multi->socket_cb) {
3107 set_in_callback(multi, TRUE);
3108 rc = multi->socket_cb(data, s, CURL_POLL_REMOVE,
3109 multi->socket_userp, entry->socketp);
3110 set_in_callback(multi, FALSE);
3114 sh_delentry(entry, &multi->sockhash, s);
3116 /* This just marks the multi handle as "dead" without returning an
3119 multi->dead = TRUE;
3138 struct Curl_multi *multi, argument
3175 multi->timetree = Curl_splayinsert(*tv, multi->timetree,
3181 static CURLMcode multi_socket(struct Curl_multi *multi, argument
3197 result = curl_multi_perform(multi, running_handles);
3202 data = multi->easyp;
3204 result = singlesocket(multi, data);
3213 struct Curl_sh_entry *entry = sh_getentry(&multi->sockhash, s);
3257 memset(&multi->timer_lastcall, 0, sizeof(multi->timer_lastcall));
3278 result = multi_runsingle(multi, &now, data);
3283 result = singlesocket(multi, data);
3292 multi->timetree = Curl_splaygetbest(now, multi->timetree, &t);
3295 (void)add_next_timeout(now, multi, t->payload);
3302 *running_handles = multi->num_alive;
3307 CURLMcode curl_multi_setopt(struct Curl_multi *multi, argument
3314 if(!GOOD_MULTI_HANDLE(multi))
3317 if(multi->in_callback)
3324 multi->socket_cb = va_arg(param, curl_socket_callback);
3327 multi->socket_userp = va_arg(param, void *);
3330 multi->push_cb = va_arg(param, curl_push_callback);
3333 multi->push_userp = va_arg(param, void *);
3336 multi->multiplexing = va_arg(param, long) & CURLPIPE_MULTIPLEX ? 1 : 0;
3339 multi->timer_cb = va_arg(param, curl_multi_timer_callback);
3342 multi->timer_userp = va_arg(param, void *);
3347 multi->maxconnects = (unsigned int)uarg;
3350 multi->max_host_connections = va_arg(param, long);
3353 multi->max_total_connections = va_arg(param, long);
3371 multi->max_concurrent_streams = (unsigned int)streams;
3382 /* we define curl_multi_socket() in the public multi.h header */
3385 CURLMcode curl_multi_socket(struct Curl_multi *multi, curl_socket_t s, argument
3389 if(multi->in_callback)
3391 result = multi_socket(multi, FALSE, s, 0, running_handles);
3393 result = Curl_update_timer(multi);
3397 CURLMcode curl_multi_socket_action(struct Curl_multi *multi, curl_socket_t s, argument
3401 if(multi->in_callback)
3403 result = multi_socket(multi, FALSE, s, ev_bitmask, running_handles);
3405 result = Curl_update_timer(multi);
3409 CURLMcode curl_multi_socket_all(struct Curl_multi *multi, int *running_handles) argument
3412 if(multi->in_callback)
3414 result = multi_socket(multi, TRUE, CURL_SOCKET_BAD, 0, running_handles);
3416 result = Curl_update_timer(multi);
3420 static CURLMcode multi_timeout(struct Curl_multi *multi, argument
3425 if(multi->dead) {
3430 if(multi->timetree) {
3435 multi->timetree = Curl_splay(tv_zero, multi->timetree);
3437 if(Curl_splaycomparekeys(multi->timetree->key, now) > 0) {
3439 timediff_t diff = Curl_timediff_ceil(multi->timetree->key, now);
3454 CURLMcode curl_multi_timeout(struct Curl_multi *multi, argument
3458 if(!GOOD_MULTI_HANDLE(multi))
3461 if(multi->in_callback)
3464 return multi_timeout(multi, timeout_ms);
3471 CURLMcode Curl_update_timer(struct Curl_multi *multi) argument
3476 if(!multi->timer_cb || multi->dead)
3478 if(multi_timeout(multi, &timeout_ms)) {
3483 if(Curl_splaycomparekeys(none, multi->timer_lastcall)) {
3484 multi->timer_lastcall = none;
3487 set_in_callback(multi, TRUE);
3488 rc = multi->timer_cb(multi, -1, multi->timer_userp);
3489 set_in_callback(multi, FALSE);
3491 multi->dead = TRUE;
3499 /* When multi_timeout() is done, multi->timetree points to the node with the
3503 if(Curl_splaycomparekeys(multi->timetree->key, multi->timer_lastcall) == 0)
3506 multi->timer_lastcall = multi->timetree->key;
3508 set_in_callback(multi, TRUE);
3509 rc = multi->timer_cb(multi, timeout_ms, multi->timer_userp);
3510 set_in_callback(multi, FALSE);
3512 multi->dead = TRUE;
3594 struct Curl_multi *multi = data->multi; local
3598 /* this is only interesting while there is still an associated multi struct
3600 if(!multi)
3636 rc = Curl_splayremove(multi->timetree, &data->state.timenode,
3637 &multi->timetree);
3646 multi->timetree = Curl_splayinsert(*nowp, multi->timetree,
3669 struct Curl_multi *multi = data->multi; local
3672 /* this is only interesting while there is still an associated multi struct
3674 if(!multi)
3683 rc = Curl_splayremove(multi->timetree, &data->state.timenode,
3684 &multi->timetree);
3704 CURLMcode curl_multi_assign(struct Curl_multi *multi, curl_socket_t s, argument
3709 there = sh_getentry(&multi->sockhash, s);
3719 size_t Curl_multi_max_host_connections(struct Curl_multi *multi) argument
3721 return multi ? multi->max_host_connections : 0;
3724 size_t Curl_multi_max_total_connections(struct Curl_multi *multi) argument
3726 return multi ? multi->max_total_connections : 0;
3738 DEBUGASSERT(data->multi);
3744 process_pending_handles(data->multi);
3747 static void move_pending_to_connect(struct Curl_multi *multi, argument
3753 link_easy(multi, data);
3758 Curl_llist_remove(&multi->pending, &data->connect_queue, NULL);
3778 static void process_pending_handles(struct Curl_multi *multi) argument
3780 struct Curl_llist_element *e = multi->pending.head;
3783 move_pending_to_connect(multi, data);
3789 if(data && data->multi)
3790 data->multi->in_callback = value;
3795 return (data && data->multi && data->multi->in_callback);
3798 unsigned int Curl_multi_max_concurrent_streams(struct Curl_multi *multi) argument
3800 DEBUGASSERT(multi);
3801 return multi->max_concurrent_streams;
3804 struct Curl_easy **curl_multi_get_handles(struct Curl_multi *multi) argument
3807 (multi->num_easy + 1));
3810 struct Curl_easy *e = multi->easyp;
3812 DEBUGASSERT(i < multi->num_easy);
3826 DEBUGASSERT(data->multi);
3829 if(!data->multi) {
3830 failf(data, "transfer has no multi handle");
3837 if(data->multi->xfer_buf_borrowed) {
3842 if(data->multi->xfer_buf &&
3843 data->set.buffer_size > data->multi->xfer_buf_len) {
3845 free(data->multi->xfer_buf);
3846 data->multi->xfer_buf = NULL;
3847 data->multi->xfer_buf_len = 0;
3850 if(!data->multi->xfer_buf) {
3851 data->multi->xfer_buf = malloc((size_t)data->set.buffer_size);
3852 if(!data->multi->xfer_buf) {
3857 data->multi->xfer_buf_len = data->set.buffer_size;
3860 data->multi->xfer_buf_borrowed = TRUE;
3861 *pbuf = data->multi->xfer_buf;
3862 *pbuflen = data->multi->xfer_buf_len;
3870 DEBUGASSERT(data->multi);
3871 DEBUGASSERT(!buf || data->multi->xfer_buf == buf);
3872 data->multi->xfer_buf_borrowed = FALSE;
3879 DEBUGASSERT(data->multi);
3882 if(!data->multi) {
3883 failf(data, "transfer has no multi handle");
3890 if(data->multi->xfer_ulbuf_borrowed) {
3895 if(data->multi->xfer_ulbuf &&
3896 data->set.upload_buffer_size > data->multi->xfer_ulbuf_len) {
3898 free(data->multi->xfer_ulbuf);
3899 data->multi->xfer_ulbuf = NULL;
3900 data->multi->xfer_ulbuf_len = 0;
3903 if(!data->multi->xfer_ulbuf) {
3904 data->multi->xfer_ulbuf = malloc((size_t)data->set.upload_buffer_size);
3905 if(!data->multi->xfer_ulbuf) {
3910 data->multi->xfer_ulbuf_len = data->set.upload_buffer_size;
3913 data->multi->xfer_ulbuf_borrowed = TRUE;
3914 *pbuf = data->multi->xfer_ulbuf;
3915 *pbuflen = data->multi->xfer_ulbuf_len;
3923 DEBUGASSERT(data->multi);
3924 DEBUGASSERT(!buf || data->multi->xfer_ulbuf == buf);
3925 data->multi->xfer_ulbuf_borrowed = FALSE;
3928 static void multi_xfer_bufs_free(struct Curl_multi *multi) argument
3930 DEBUGASSERT(multi);
3931 Curl_safefree(multi->xfer_buf);
3932 multi->xfer_buf_len = 0;
3933 multi->xfer_buf_borrowed = FALSE;
3934 Curl_safefree(multi->xfer_ulbuf);
3935 multi->xfer_ulbuf_len = 0;
3936 multi->xfer_ulbuf_borrowed = FALSE;