Lines Matching refs:data
72 struct SessionHandle *data);
109 static void mstate(struct SessionHandle *data, CURLMstate state
118 CURLMstate oldstate = data->mstate;
124 data->mstate = state;
127 if(data->mstate >= CURLM_STATE_CONNECT_PEND &&
128 data->mstate < CURLM_STATE_COMPLETED) {
129 if(data->easy_conn)
130 connection_id = data->easy_conn->connection_id;
132 infof(data,
134 statename[oldstate], statename[data->mstate],
135 (void *)data, lineno, connection_id);
140 data->multi->num_alive--;
168 struct SessionHandle *data)
182 check->easy = data;
352 struct SessionHandle *data = (struct SessionHandle *)easy_handle;
364 if(data->multi)
380 data->state.timeoutlist = timeoutlist;
384 multistate(data, CURLM_STATE_INIT);
386 if((data->set.global_dns_cache) &&
387 (data->dns.hostcachetype != HCACHE_GLOBAL)) {
392 data->dns.hostcache = global;
393 data->dns.hostcachetype = HCACHE_GLOBAL;
398 else if(!data->dns.hostcache ||
399 (data->dns.hostcachetype == HCACHE_NONE)) {
400 data->dns.hostcache = multi->hostcache;
401 data->dns.hostcachetype = HCACHE_MULTI;
405 data->state.conn_cache = multi->conn_cache;
413 data->next = NULL; /* end of the line */
416 last->next = data;
417 data->prev = last;
418 multi->easylp = data; /* the new last node */
422 data->next = NULL;
423 data->prev = NULL;
424 multi->easylp = multi->easyp = data; /* both first and last */
428 data->multi = multi_handle;
436 Curl_expire(data, 1);
472 (void *)sh->data, sh->data->magic, (int)sh->socket);
481 struct SessionHandle *data = easy;
492 if(!data->multi)
496 bool premature = (data->mstate < CURLM_STATE_COMPLETED) ? TRUE : FALSE;
497 bool easy_owns_conn = (data->easy_conn &&
498 (data->easy_conn->data == easy)) ?
508 if(data->easy_conn &&
509 (data->easy_conn->send_pipe->size +
510 data->easy_conn->recv_pipe->size > 1) &&
511 data->mstate > CURLM_STATE_WAITDO &&
512 data->mstate < CURLM_STATE_COMPLETED) {
516 data->easy_conn->bits.close = TRUE;
519 data->easy_conn->data = easy;
522 /* The timer must be shut down before data->multi is set to NULL,
525 Curl_expire(data, 0);
528 if(data->state.timeoutlist) {
529 Curl_llist_destroy(data->state.timeoutlist, NULL);
530 data->state.timeoutlist = NULL;
533 if(data->dns.hostcachetype == HCACHE_MULTI) {
535 data->dns.hostcache = NULL;
536 data->dns.hostcachetype = HCACHE_NONE;
539 if(data->easy_conn) {
545 /* Curl_done() clears the conn->data field to lose the association
550 (void)Curl_done(&data->easy_conn, data->result, premature);
554 Curl_getoff_all_pipelines(data, data->easy_conn);
557 Curl_wildcard_dtor(&data->wildcard);
561 data->state.conn_cache = NULL;
565 data->mstate = CURLM_STATE_COMPLETED;
570 if(data->easy_conn) {
571 data->easy_conn->data = NULL;
572 data->easy_conn = NULL;
575 data->multi = NULL; /* clear the association to this multi handle */
594 if(data->prev)
595 data->prev->next = data->next;
597 multi->easyp = data->next; /* point to first node */
600 if(data->next)
601 data->next->prev = data->prev;
603 multi->easylp = data->prev; /* point to last node */
622 void Curl_multi_handlePipeBreak(struct SessionHandle *data)
624 data->easy_conn = NULL;
665 static int multi_getsock(struct SessionHandle *data,
675 if(data->state.pipe_broke || !data->easy_conn)
678 if(data->mstate > CURLM_STATE_CONNECT &&
679 data->mstate < CURLM_STATE_COMPLETED) {
681 data->easy_conn->data = data;
684 switch(data->mstate) {
702 return Curl_resolver_getsock(data->easy_conn, socks, numsocks);
705 return Curl_protocol_getsock(data->easy_conn, socks, numsocks);
709 return Curl_doing_getsock(data->easy_conn, socks, numsocks);
713 return waitconnect_getsock(data->easy_conn, socks, numsocks);
716 return domore_getsock(data->easy_conn, socks, numsocks);
723 return Curl_single_getsock(data->easy_conn, socks, numsocks);
736 struct SessionHandle *data;
746 data=multi->easyp;
747 while(data) {
748 bitmap = multi_getsock(data, sockbunch, MAX_SOCKSPEREASYHANDLE);
770 data = data->next; /* check next handle */
785 struct SessionHandle *data;
805 data=multi->easyp;
806 while(data) {
807 bitmap = multi_getsock(data, sockbunch, MAX_SOCKSPEREASYHANDLE);
825 data = data->next; /* check next handle */
843 data=multi->easyp;
844 while(data) {
845 bitmap = multi_getsock(data, sockbunch, MAX_SOCKSPEREASYHANDLE);
867 data = data->next; /* check next handle */
886 infof(data, "Curl_poll(%d ds, %d ms)\n", nfds, timeout_ms);
920 struct SessionHandle *data)
933 if(!GOOD_EASY_HANDLE(data))
943 if(data->state.pipe_broke) {
944 infof(data, "Pipe broke: handle 0x%p, url = %s\n",
945 (void *)data, data->state.path);
947 if(data->mstate < CURLM_STATE_COMPLETED) {
949 multistate(data, CURLM_STATE_CONNECT);
951 data->result = CURLE_OK;
954 data->state.pipe_broke = FALSE;
955 data->easy_conn = NULL;
959 if(!data->easy_conn &&
960 data->mstate > CURLM_STATE_CONNECT &&
961 data->mstate < CURLM_STATE_DONE) {
962 /* In all these states, the code will blindly access 'data->easy_conn'
965 failf(data, "In state %d with no easy_conn, bail out!\n", data->mstate);
969 if(data->easy_conn && data->mstate > CURLM_STATE_CONNECT &&
970 data->mstate < CURLM_STATE_COMPLETED)
972 data->easy_conn->data = data;
974 if(data->easy_conn &&
975 (data->mstate >= CURLM_STATE_CONNECT) &&
976 (data->mstate < CURLM_STATE_COMPLETED)) {
980 timeout_ms = Curl_timeleft(data, &now,
981 (data->mstate <= CURLM_STATE_WAITDO)?
986 if(data->mstate == CURLM_STATE_WAITRESOLVE)
987 failf(data, "Resolving timed out after %ld milliseconds",
988 Curl_tvdiff(now, data->progress.t_startsingle));
989 else if(data->mstate == CURLM_STATE_WAITCONNECT)
990 failf(data, "Connection timed out after %ld milliseconds",
991 Curl_tvdiff(now, data->progress.t_startsingle));
993 k = &data->req;
995 failf(data, "Operation timed out after %ld milliseconds with %"
998 Curl_tvdiff(k->now, data->progress.t_startsingle),
1002 failf(data, "Operation timed out after %ld milliseconds with %"
1004 Curl_tvdiff(now, data->progress.t_startsingle),
1012 data->easy_conn->bits.close = TRUE;
1013 data->result = CURLE_OPERATION_TIMEDOUT;
1014 multistate(data, CURLM_STATE_COMPLETED);
1019 switch(data->mstate) {
1022 data->result=Curl_pretransfer(data);
1024 if(CURLE_OK == data->result) {
1026 multistate(data, CURLM_STATE_CONNECT);
1027 Curl_pgrsTime(data, TIMER_STARTSINGLE);
1039 data->result = Curl_connect(data, &data->easy_conn,
1041 if(CURLE_NO_CONNECTION_AVAILABLE == data->result) {
1044 multistate(data, CURLM_STATE_CONNECT_PEND);
1045 data->result = CURLE_OK;
1049 if(CURLE_OK == data->result) {
1051 data->result = Curl_add_handle_to_pipeline(data, data->easy_conn);
1052 if(CURLE_OK != data->result)
1057 multistate(data, CURLM_STATE_WAITRESOLVE);
1065 multistate(data, multi->pipelining_enabled?
1069 if(data->easy_conn->tunnel_state[FIRSTSOCKET] == TUNNEL_CONNECT)
1070 multistate(data, CURLM_STATE_WAITPROXYCONNECT);
1073 multistate(data, CURLM_STATE_WAITCONNECT);
1086 data->result = Curl_resolver_is_resolved(data->easy_conn, &dns);
1094 singlesocket(multi, data);
1099 data->result = Curl_async_resolved(data->easy_conn,
1102 if(CURLE_OK != data->result)
1105 data->easy_conn = NULL; /* no more connection */
1110 multistate(data, multi->pipelining_enabled?
1114 if(data->easy_conn->tunnel_state[FIRSTSOCKET] == TUNNEL_CONNECT)
1115 multistate(data, CURLM_STATE_WAITPROXYCONNECT);
1118 multistate(data, CURLM_STATE_WAITCONNECT);
1123 if(CURLE_OK != data->result) {
1134 data->result = Curl_http_connect(data->easy_conn, &protocol_connect);
1136 if(data->easy_conn->bits.proxy_connect_closed) {
1138 if(data->set.errorbuffer)
1139 data->set.errorbuffer[0] = '\0';
1140 data->state.errorbuf = FALSE;
1142 data->result = CURLE_OK;
1144 multistate(data, CURLM_STATE_CONNECT);
1146 else if(CURLE_OK == data->result) {
1147 if(data->easy_conn->tunnel_state[FIRSTSOCKET] == TUNNEL_COMPLETE)
1148 multistate(data, CURLM_STATE_WAITCONNECT);
1155 data->result = Curl_is_connected(data->easy_conn,
1160 if(!data->result)
1163 data->result = Curl_protocol_connect(data->easy_conn,
1167 if(CURLE_OK != data->result) {
1182 if(data->easy_conn->tunnel_state[FIRSTSOCKET] == TUNNEL_CONNECT)
1183 multistate(data, CURLM_STATE_WAITPROXYCONNECT);
1186 multistate(data, CURLM_STATE_PROTOCONNECT);
1191 multistate(data, multi->pipelining_enabled?
1200 data->result = Curl_protocol_connecting(data->easy_conn,
1202 if((data->result == CURLE_OK) && protocol_connect) {
1204 multistate(data, multi->pipelining_enabled?
1208 else if(data->result) {
1210 Curl_posttransfer(data);
1211 Curl_done(&data->easy_conn, data->result, TRUE);
1219 infof(data, "WAITDO: Conn %ld send pipe %zu inuse %s athead %s\n",
1220 data->easy_conn->connection_id,
1221 data->easy_conn->send_pipe->size,
1222 data->easy_conn->writechannel_inuse?"TRUE":"FALSE",
1223 isHandleAtHead(data,
1224 data->easy_conn->send_pipe)?"TRUE":"FALSE");
1226 if(!data->easy_conn->writechannel_inuse &&
1227 isHandleAtHead(data,
1228 data->easy_conn->send_pipe)) {
1230 data->easy_conn->writechannel_inuse = TRUE;
1231 multistate(data, CURLM_STATE_DO);
1237 if(data->set.connect_only) {
1239 data->easy_conn->bits.close = FALSE;
1240 multistate(data, CURLM_STATE_DONE);
1241 data->result = CURLE_OK;
1246 data->result = Curl_do(&data->easy_conn, &dophase_done);
1248 /* When Curl_do() returns failure, data->easy_conn might be NULL! */
1250 if(CURLE_OK == data->result) {
1253 if(data->set.wildcardmatch) {
1254 struct WildcardData *wc = &data->wildcard;
1257 Curl_done(&data->easy_conn, CURLE_OK, FALSE);
1258 multistate(data, CURLM_STATE_DONE);
1265 multistate(data, CURLM_STATE_DOING);
1270 else if(data->easy_conn->bits.do_more) {
1273 multistate(data, CURLM_STATE_DO_MORE);
1278 multistate(data, CURLM_STATE_DO_DONE);
1282 else if((CURLE_SEND_ERROR == data->result) &&
1283 data->easy_conn->bits.reuse) {
1294 drc = Curl_retry_request(data->easy_conn, &newurl);
1297 data->result = drc;
1303 Curl_posttransfer(data);
1304 drc = Curl_done(&data->easy_conn, data->result, FALSE);
1311 drc = Curl_follow(data, newurl, follow);
1313 multistate(data, CURLM_STATE_CONNECT);
1315 data->result = CURLE_OK;
1319 data->result = drc;
1325 data->result = drc;
1336 Curl_posttransfer(data);
1337 if(data->easy_conn)
1338 Curl_done(&data->easy_conn, data->result, FALSE);
1346 data->result = Curl_protocol_doing(data->easy_conn,
1348 if(CURLE_OK == data->result) {
1351 multistate(data, data->easy_conn->bits.do_more?
1359 Curl_posttransfer(data);
1360 Curl_done(&data->easy_conn, data->result, FALSE);
1369 data->result = Curl_do_more(data->easy_conn, &control);
1373 if(CURLE_OK == data->result) {
1377 multistate(data, control==1?
1388 Curl_posttransfer(data);
1389 Curl_done(&data->easy_conn, data->result, FALSE);
1396 Curl_move_handle_from_send_to_recv_pipe(data, data->easy_conn);
1402 if((data->easy_conn->sockfd != CURL_SOCKET_BAD) ||
1403 (data->easy_conn->writesockfd != CURL_SOCKET_BAD))
1404 multistate(data, CURLM_STATE_WAITPERFORM);
1406 multistate(data, CURLM_STATE_DONE);
1412 if(!data->easy_conn->readchannel_inuse &&
1413 isHandleAtHead(data,
1414 data->easy_conn->recv_pipe)) {
1416 data->easy_conn->readchannel_inuse = TRUE;
1417 multistate(data, CURLM_STATE_PERFORM);
1422 infof(data, "WAITPERFORM: Conn %ld recv pipe %zu inuse %s athead %s\n",
1423 data->easy_conn->connection_id,
1424 data->easy_conn->recv_pipe->size,
1425 data->easy_conn->readchannel_inuse?"TRUE":"FALSE",
1426 isHandleAtHead(data,
1427 data->easy_conn->recv_pipe)?"TRUE":"FALSE");
1434 if(Curl_pgrsUpdate(data->easy_conn))
1435 data->result = CURLE_ABORTED_BY_CALLBACK;
1437 data->result = Curl_speedcheck(data, now);
1439 if(( (data->set.max_send_speed == 0) ||
1440 (data->progress.ulspeed < data->set.max_send_speed )) &&
1441 ( (data->set.max_recv_speed == 0) ||
1442 (data->progress.dlspeed < data->set.max_recv_speed)))
1443 multistate(data, CURLM_STATE_PERFORM);
1452 if((data->set.max_send_speed > 0) &&
1453 (data->progress.ulspeed > data->set.max_send_speed)) {
1456 multistate(data, CURLM_STATE_TOOFAST);
1459 buffersize = (int)(data->set.buffer_size ?
1460 data->set.buffer_size : BUFSIZE);
1461 timeout_ms = Curl_sleep_time(data->set.max_send_speed,
1462 data->progress.ulspeed, buffersize);
1463 Curl_expire(data, timeout_ms);
1468 if((data->set.max_recv_speed > 0) &&
1469 (data->progress.dlspeed > data->set.max_recv_speed)) {
1472 multistate(data, CURLM_STATE_TOOFAST);
1475 buffersize = (int)(data->set.buffer_size ?
1476 data->set.buffer_size : BUFSIZE);
1477 timeout_ms = Curl_sleep_time(data->set.max_recv_speed,
1478 data->progress.dlspeed, buffersize);
1479 Curl_expire(data, timeout_ms);
1483 /* read/write data if it is ready to do so */
1484 data->result = Curl_readwrite(data->easy_conn, &done);
1486 k = &data->req;
1490 data->easy_conn->readchannel_inuse = FALSE;
1495 data->easy_conn->writechannel_inuse = FALSE;
1498 if(done || (data->result == CURLE_RECV_ERROR)) {
1503 CURLcode ret = Curl_retry_request(data->easy_conn, &newurl);
1510 data->result = CURLE_OK;
1515 if(data->result) {
1521 * happened in the data connection.
1524 if(!(data->easy_conn->handler->flags & PROTOPT_DUAL))
1525 data->easy_conn->bits.close = TRUE;
1527 Curl_posttransfer(data);
1528 Curl_done(&data->easy_conn, data->result, FALSE);
1534 Curl_posttransfer(data);
1537 Curl_removeHandleFromPipeline(data, data->easy_conn->recv_pipe);
1540 if(data->easy_conn->recv_pipe->head)
1541 Curl_expire(data->easy_conn->recv_pipe->head->ptr, 1);
1548 if(data->req.newurl || retry) {
1552 newurl = data->req.newurl;
1553 data->req.newurl = NULL;
1558 data->result = Curl_done(&data->easy_conn, CURLE_OK, FALSE);
1559 if(CURLE_OK == data->result) {
1560 data->result = Curl_follow(data, newurl, follow);
1561 if(CURLE_OK == data->result) {
1562 multistate(data, CURLM_STATE_CONNECT);
1575 if(data->req.location) {
1578 newurl = data->req.location;
1579 data->req.location = NULL;
1580 data->result = Curl_follow(data, newurl, FOLLOW_FAKE);
1581 if(CURLE_OK == data->result)
1587 multistate(data, CURLM_STATE_DONE);
1601 if(data->easy_conn) {
1605 Curl_removeHandleFromPipeline(data, data->easy_conn->recv_pipe);
1610 res = Curl_done(&data->easy_conn, CURLE_OK, FALSE);
1613 if(!data->result)
1614 data->result = res;
1619 * access free'd data, if the connection is free'd and the handle
1622 if(data->easy_conn)
1623 data->easy_conn = NULL;
1626 if(data->set.wildcardmatch) {
1627 if(data->wildcard.state != CURLWC_DONE) {
1630 multistate(data, CURLM_STATE_INIT);
1637 multistate(data, CURLM_STATE_COMPLETED);
1648 data->easy_conn = NULL;
1650 Curl_expire(data, 0); /* stop all timers */
1660 if(data->mstate < CURLM_STATE_COMPLETED) {
1661 if(CURLE_OK != data->result) {
1670 data->state.pipe_broke = FALSE;
1672 if(data->easy_conn) {
1674 data->easy_conn->writechannel_inuse = FALSE;
1675 data->easy_conn->readchannel_inuse = FALSE;
1676 Curl_removeHandleFromPipeline(data,
1677 data->easy_conn->send_pipe);
1678 Curl_removeHandleFromPipeline(data,
1679 data->easy_conn->recv_pipe);
1685 Curl_disconnect(data->easy_conn, /* dead_connection */ FALSE);
1690 data->easy_conn = NULL;
1693 else if(data->mstate == CURLM_STATE_CONNECT) {
1695 (void)Curl_posttransfer(data);
1698 multistate(data, CURLM_STATE_COMPLETED);
1701 else if(data->easy_conn && Curl_pgrsUpdate(data->easy_conn)) {
1704 data->result = CURLE_ABORTED_BY_CALLBACK;
1705 data->easy_conn->bits.close = TRUE;
1708 multistate(data, (data->mstate < CURLM_STATE_DONE)?
1715 if(CURLM_STATE_COMPLETED == data->mstate) {
1717 msg = &data->msg;
1720 msg->extmsg.easy_handle = data;
1721 msg->extmsg.data.result = data->result;
1725 multistate(data, CURLM_STATE_MSGSENT);
1735 struct SessionHandle *data;
1743 data=multi->easyp;
1744 while(data) {
1746 struct WildcardData *wc = &data->wildcard;
1749 if(data->set.wildcardmatch) {
1757 sigpipe_ignore(data, &pipe_st);
1759 result = multi_runsingle(multi, now, data);
1763 if(data->set.wildcardmatch) {
1772 data = data->next; /* operate on next handle */
1807 conn->data = multi->closure_handle;
1819 struct SessionHandle *data;
1854 data = multi->easyp;
1855 while(data) {
1856 nextdata=data->next;
1857 if(data->dns.hostcachetype == HCACHE_MULTI) {
1859 Curl_hostcache_clean(data, data->dns.hostcache);
1860 data->dns.hostcache = NULL;
1861 data->dns.hostcachetype = HCACHE_NONE;
1865 data->state.conn_cache = NULL;
1866 data->multi = NULL; /* clear the association */
1868 data = nextdata;
1931 struct SessionHandle *data)
1946 curraction = multi_getsock(data, socks, MAX_SOCKSPEREASYHANDLE);
1976 entry = sh_addentry(multi->sockhash, s, data);
1984 multi->socket_cb(data,
1997 for(i=0; i< data->numsocks; i++) {
1999 s = data->sockets[i];
2017 struct connectdata *easy_conn = data->easy_conn;
2026 if(entry->easy == data) {
2027 if(isHandleAtHead(data, easy_conn->recv_pipe))
2040 if(entry->easy == data) {
2041 if(isHandleAtHead(data, easy_conn->send_pipe))
2062 multi->socket_cb(data,
2073 memcpy(data->sockets, socks, num*sizeof(curl_socket_t));
2074 data->numsocks = num;
2089 struct Curl_multi *multi = conn->data->multi;
2098 multi->socket_cb(conn->data, s, CURL_POLL_REMOVE,
2172 struct SessionHandle *data = NULL;
2183 data=multi->easyp;
2184 while(data) {
2185 singlesocket(multi, data);
2186 data = data->next;
2208 data = entry->easy;
2210 if(data->magic != CURLEASY_MAGIC_NUMBER)
2217 if(data->easy_conn) {
2219 data->easy_conn->send_pipe &&
2220 data->easy_conn->send_pipe->head)
2221 data = data->easy_conn->send_pipe->head->ptr;
2223 data->easy_conn->recv_pipe &&
2224 data->easy_conn->recv_pipe->head)
2225 data = data->easy_conn->recv_pipe->head->ptr;
2228 if(data->easy_conn &&
2229 !(data->easy_conn->handler->flags & PROTOPT_DIRLOCK))
2231 data->easy_conn->cselect_bits = ev_bitmask;
2233 sigpipe_ignore(data, &pipe_st);
2235 result = multi_runsingle(multi, now, data);
2239 if(data->easy_conn &&
2240 !(data->easy_conn->handler->flags & PROTOPT_DIRLOCK))
2242 data->easy_conn->cselect_bits = 0;
2247 singlesocket(multi, data);
2253 data = NULL; /* set data to NULL again to avoid calling
2269 * to process in the splay and 'data' will be re-assigned for every expired
2273 /* the first loop lap 'data' can be NULL */
2274 if(data) {
2277 sigpipe_ignore(data, &pipe_st);
2279 result = multi_runsingle(multi, now, data);
2286 singlesocket(multi, data);
2294 data = t->payload; /* assign this for next loop */
2568 void Curl_expire(struct SessionHandle *data, long milli)
2570 struct Curl_multi *multi = data->multi;
2571 struct timeval *nowp = &data->state.expiretime;
2580 /* No timeout, clear the time data. */
2584 struct curl_llist *list = data->state.timeoutlist;
2587 &data->state.timenode,
2590 infof(data, "Internal error clearing splay node = %d\n", rc);
2597 infof(data, "Expire cleared\n");
2623 multi_addtimeout(data->state.timeoutlist, &set);
2629 multi_addtimeout(data->state.timeoutlist, nowp);
2634 &data->state.timenode,
2637 infof(data, "Internal error removing splay node = %d\n", rc);
2641 data->state.timenode.payload = data;
2644 &data->state.timenode);
2705 struct SessionHandle *data;
2707 data=multi->easyp;
2708 while(data) {
2709 if(data->mstate == CURLM_STATE_CONNECT_PEND) {
2710 multistate(data, CURLM_STATE_CONNECT);
2712 Curl_expire(data, 1);
2714 data = data->next; /* operate on next handle */
2722 struct SessionHandle *data;
2726 for(data=multi->easyp; data; data = data->next) {
2727 if(data->mstate < CURLM_STATE_COMPLETED) {
2730 (void *)data,
2731 statename[data->mstate], data->numsocks);
2732 for(i=0; i < data->numsocks; i++) {
2733 curl_socket_t s = data->sockets[i];
2746 if(data->numsocks)