easy.c 35 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343
  1. /***************************************************************************
  2. * _ _ ____ _
  3. * Project ___| | | | _ \| |
  4. * / __| | | | |_) | |
  5. * | (__| |_| | _ <| |___
  6. * \___|\___/|_| \_\_____|
  7. *
  8. * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
  9. *
  10. * This software is licensed as described in the file COPYING, which
  11. * you should have received as part of this distribution. The terms
  12. * are also available at https://curl.se/docs/copyright.html.
  13. *
  14. * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15. * copies of the Software, and permit persons to whom the Software is
  16. * furnished to do so, under the terms of the COPYING file.
  17. *
  18. * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19. * KIND, either express or implied.
  20. *
  21. * SPDX-License-Identifier: curl
  22. *
  23. ***************************************************************************/
  24. #include "curl_setup.h"
  25. #ifdef HAVE_NETINET_IN_H
  26. #include <netinet/in.h>
  27. #endif
  28. #ifdef HAVE_NETDB_H
  29. #include <netdb.h>
  30. #endif
  31. #ifdef HAVE_ARPA_INET_H
  32. #include <arpa/inet.h>
  33. #endif
  34. #ifdef HAVE_NET_IF_H
  35. #include <net/if.h>
  36. #endif
  37. #ifdef HAVE_SYS_IOCTL_H
  38. #include <sys/ioctl.h>
  39. #endif
  40. #ifdef HAVE_SYS_PARAM_H
  41. #include <sys/param.h>
  42. #endif
  43. #include "urldata.h"
  44. #include <curl/curl.h>
  45. #include "transfer.h"
  46. #include "vtls/vtls.h"
  47. #include "url.h"
  48. #include "getinfo.h"
  49. #include "hostip.h"
  50. #include "share.h"
  51. #include "strdup.h"
  52. #include "progress.h"
  53. #include "easyif.h"
  54. #include "multiif.h"
  55. #include "select.h"
  56. #include "cfilters.h"
  57. #include "sendf.h" /* for failf function prototype */
  58. #include "connect.h" /* for Curl_getconnectinfo */
  59. #include "slist.h"
  60. #include "mime.h"
  61. #include "amigaos.h"
  62. #include "macos.h"
  63. #include "warnless.h"
  64. #include "sigpipe.h"
  65. #include "vssh/ssh.h"
  66. #include "setopt.h"
  67. #include "http_digest.h"
  68. #include "system_win32.h"
  69. #include "http2.h"
  70. #include "dynbuf.h"
  71. #include "altsvc.h"
  72. #include "hsts.h"
  73. #include "easy_lock.h"
  74. /* The last 3 #include files should be in this order */
  75. #include "curl_printf.h"
  76. #include "curl_memory.h"
  77. #include "memdebug.h"
  78. /* true globals -- for curl_global_init() and curl_global_cleanup() */
  79. static unsigned int initialized;
  80. static long easy_init_flags;
  81. #ifdef GLOBAL_INIT_IS_THREADSAFE
  82. static curl_simple_lock s_lock = CURL_SIMPLE_LOCK_INIT;
  83. #define global_init_lock() curl_simple_lock_lock(&s_lock)
  84. #define global_init_unlock() curl_simple_lock_unlock(&s_lock)
  85. #else
  86. #define global_init_lock()
  87. #define global_init_unlock()
  88. #endif
  89. /*
  90. * strdup (and other memory functions) is redefined in complicated
  91. * ways, but at this point it must be defined as the system-supplied strdup
  92. * so the callback pointer is initialized correctly.
  93. */
  94. #if defined(_WIN32_WCE)
  95. #define system_strdup _strdup
  96. #elif !defined(HAVE_STRDUP)
  97. #define system_strdup Curl_strdup
  98. #else
  99. #define system_strdup strdup
  100. #endif
  101. #if defined(_MSC_VER) && defined(_DLL)
  102. # pragma warning(disable:4232) /* MSVC extension, dllimport identity */
  103. #endif
  104. /*
  105. * If a memory-using function (like curl_getenv) is used before
  106. * curl_global_init() is called, we need to have these pointers set already.
  107. */
  108. curl_malloc_callback Curl_cmalloc = (curl_malloc_callback)malloc;
  109. curl_free_callback Curl_cfree = (curl_free_callback)free;
  110. curl_realloc_callback Curl_crealloc = (curl_realloc_callback)realloc;
  111. curl_strdup_callback Curl_cstrdup = (curl_strdup_callback)system_strdup;
  112. curl_calloc_callback Curl_ccalloc = (curl_calloc_callback)calloc;
  113. #if defined(_WIN32) && defined(UNICODE)
  114. curl_wcsdup_callback Curl_cwcsdup = Curl_wcsdup;
  115. #endif
  116. #if defined(_MSC_VER) && defined(_DLL)
  117. # pragma warning(default:4232) /* MSVC extension, dllimport identity */
  118. #endif
  119. #ifdef DEBUGBUILD
  120. static char *leakpointer;
  121. #endif
  122. /**
  123. * curl_global_init() globally initializes curl given a bitwise set of the
  124. * different features of what to initialize.
  125. */
  126. static CURLcode global_init(long flags, bool memoryfuncs)
  127. {
  128. if(initialized++)
  129. return CURLE_OK;
  130. if(memoryfuncs) {
  131. /* Setup the default memory functions here (again) */
  132. Curl_cmalloc = (curl_malloc_callback)malloc;
  133. Curl_cfree = (curl_free_callback)free;
  134. Curl_crealloc = (curl_realloc_callback)realloc;
  135. Curl_cstrdup = (curl_strdup_callback)system_strdup;
  136. Curl_ccalloc = (curl_calloc_callback)calloc;
  137. #if defined(_WIN32) && defined(UNICODE)
  138. Curl_cwcsdup = (curl_wcsdup_callback)_wcsdup;
  139. #endif
  140. }
  141. if(Curl_trc_init()) {
  142. DEBUGF(fprintf(stderr, "Error: Curl_trc_init failed\n"));
  143. goto fail;
  144. }
  145. if(!Curl_ssl_init()) {
  146. DEBUGF(fprintf(stderr, "Error: Curl_ssl_init failed\n"));
  147. goto fail;
  148. }
  149. if(Curl_win32_init(flags)) {
  150. DEBUGF(fprintf(stderr, "Error: win32_init failed\n"));
  151. goto fail;
  152. }
  153. if(Curl_amiga_init()) {
  154. DEBUGF(fprintf(stderr, "Error: Curl_amiga_init failed\n"));
  155. goto fail;
  156. }
  157. if(Curl_macos_init()) {
  158. DEBUGF(fprintf(stderr, "Error: Curl_macos_init failed\n"));
  159. goto fail;
  160. }
  161. if(Curl_resolver_global_init()) {
  162. DEBUGF(fprintf(stderr, "Error: resolver_global_init failed\n"));
  163. goto fail;
  164. }
  165. if(Curl_ssh_init()) {
  166. DEBUGF(fprintf(stderr, "Error: Curl_ssh_init failed\n"));
  167. goto fail;
  168. }
  169. easy_init_flags = flags;
  170. #ifdef DEBUGBUILD
  171. if(getenv("CURL_GLOBAL_INIT"))
  172. /* alloc data that will leak if *cleanup() is not called! */
  173. leakpointer = malloc(1);
  174. #endif
  175. return CURLE_OK;
  176. fail:
  177. initialized--; /* undo the increase */
  178. return CURLE_FAILED_INIT;
  179. }
  180. /**
  181. * curl_global_init() globally initializes curl given a bitwise set of the
  182. * different features of what to initialize.
  183. */
  184. CURLcode curl_global_init(long flags)
  185. {
  186. CURLcode result;
  187. global_init_lock();
  188. result = global_init(flags, TRUE);
  189. global_init_unlock();
  190. return result;
  191. }
  192. /*
  193. * curl_global_init_mem() globally initializes curl and also registers the
  194. * user provided callback routines.
  195. */
  196. CURLcode curl_global_init_mem(long flags, curl_malloc_callback m,
  197. curl_free_callback f, curl_realloc_callback r,
  198. curl_strdup_callback s, curl_calloc_callback c)
  199. {
  200. CURLcode result;
  201. /* Invalid input, return immediately */
  202. if(!m || !f || !r || !s || !c)
  203. return CURLE_FAILED_INIT;
  204. global_init_lock();
  205. if(initialized) {
  206. /* Already initialized, don't do it again, but bump the variable anyway to
  207. work like curl_global_init() and require the same amount of cleanup
  208. calls. */
  209. initialized++;
  210. global_init_unlock();
  211. return CURLE_OK;
  212. }
  213. /* set memory functions before global_init() in case it wants memory
  214. functions */
  215. Curl_cmalloc = m;
  216. Curl_cfree = f;
  217. Curl_cstrdup = s;
  218. Curl_crealloc = r;
  219. Curl_ccalloc = c;
  220. /* Call the actual init function, but without setting */
  221. result = global_init(flags, FALSE);
  222. global_init_unlock();
  223. return result;
  224. }
  225. /**
  226. * curl_global_cleanup() globally cleanups curl, uses the value of
  227. * "easy_init_flags" to determine what needs to be cleaned up and what doesn't.
  228. */
  229. void curl_global_cleanup(void)
  230. {
  231. global_init_lock();
  232. if(!initialized) {
  233. global_init_unlock();
  234. return;
  235. }
  236. if(--initialized) {
  237. global_init_unlock();
  238. return;
  239. }
  240. Curl_ssl_cleanup();
  241. Curl_resolver_global_cleanup();
  242. #ifdef _WIN32
  243. Curl_win32_cleanup(easy_init_flags);
  244. #endif
  245. Curl_amiga_cleanup();
  246. Curl_ssh_cleanup();
  247. #ifdef DEBUGBUILD
  248. free(leakpointer);
  249. #endif
  250. easy_init_flags = 0;
  251. global_init_unlock();
  252. }
  253. /**
  254. * curl_global_trace() globally initializes curl logging.
  255. */
  256. CURLcode curl_global_trace(const char *config)
  257. {
  258. #ifndef CURL_DISABLE_VERBOSE_STRINGS
  259. CURLcode result;
  260. global_init_lock();
  261. result = Curl_trc_opt(config);
  262. global_init_unlock();
  263. return result;
  264. #else
  265. (void)config;
  266. return CURLE_OK;
  267. #endif
  268. }
  269. /*
  270. * curl_global_sslset() globally initializes the SSL backend to use.
  271. */
  272. CURLsslset curl_global_sslset(curl_sslbackend id, const char *name,
  273. const curl_ssl_backend ***avail)
  274. {
  275. CURLsslset rc;
  276. global_init_lock();
  277. rc = Curl_init_sslset_nolock(id, name, avail);
  278. global_init_unlock();
  279. return rc;
  280. }
  281. /*
  282. * curl_easy_init() is the external interface to alloc, setup and init an
  283. * easy handle that is returned. If anything goes wrong, NULL is returned.
  284. */
  285. struct Curl_easy *curl_easy_init(void)
  286. {
  287. CURLcode result;
  288. struct Curl_easy *data;
  289. /* Make sure we inited the global SSL stuff */
  290. global_init_lock();
  291. if(!initialized) {
  292. result = global_init(CURL_GLOBAL_DEFAULT, TRUE);
  293. if(result) {
  294. /* something in the global init failed, return nothing */
  295. DEBUGF(fprintf(stderr, "Error: curl_global_init failed\n"));
  296. global_init_unlock();
  297. return NULL;
  298. }
  299. }
  300. global_init_unlock();
  301. /* We use curl_open() with undefined URL so far */
  302. result = Curl_open(&data);
  303. if(result) {
  304. DEBUGF(fprintf(stderr, "Error: Curl_open failed\n"));
  305. return NULL;
  306. }
  307. return data;
  308. }
  309. #ifdef CURLDEBUG
  310. struct socketmonitor {
  311. struct socketmonitor *next; /* the next node in the list or NULL */
  312. struct pollfd socket; /* socket info of what to monitor */
  313. };
  314. struct events {
  315. long ms; /* timeout, run the timeout function when reached */
  316. bool msbump; /* set TRUE when timeout is set by callback */
  317. int num_sockets; /* number of nodes in the monitor list */
  318. struct socketmonitor *list; /* list of sockets to monitor */
  319. int running_handles; /* store the returned number */
  320. };
  321. /* events_timer
  322. *
  323. * Callback that gets called with a new value when the timeout should be
  324. * updated.
  325. */
  326. static int events_timer(struct Curl_multi *multi, /* multi handle */
  327. long timeout_ms, /* see above */
  328. void *userp) /* private callback pointer */
  329. {
  330. struct events *ev = userp;
  331. (void)multi;
  332. if(timeout_ms == -1)
  333. /* timeout removed */
  334. timeout_ms = 0;
  335. else if(timeout_ms == 0)
  336. /* timeout is already reached! */
  337. timeout_ms = 1; /* trigger asap */
  338. ev->ms = timeout_ms;
  339. ev->msbump = TRUE;
  340. return 0;
  341. }
  342. /* poll2cselect
  343. *
  344. * convert from poll() bit definitions to libcurl's CURL_CSELECT_* ones
  345. */
  346. static int poll2cselect(int pollmask)
  347. {
  348. int omask = 0;
  349. if(pollmask & POLLIN)
  350. omask |= CURL_CSELECT_IN;
  351. if(pollmask & POLLOUT)
  352. omask |= CURL_CSELECT_OUT;
  353. if(pollmask & POLLERR)
  354. omask |= CURL_CSELECT_ERR;
  355. return omask;
  356. }
  357. /* socketcb2poll
  358. *
  359. * convert from libcurl' CURL_POLL_* bit definitions to poll()'s
  360. */
  361. static short socketcb2poll(int pollmask)
  362. {
  363. short omask = 0;
  364. if(pollmask & CURL_POLL_IN)
  365. omask |= POLLIN;
  366. if(pollmask & CURL_POLL_OUT)
  367. omask |= POLLOUT;
  368. return omask;
  369. }
  370. /* events_socket
  371. *
  372. * Callback that gets called with information about socket activity to
  373. * monitor.
  374. */
  375. static int events_socket(struct Curl_easy *easy, /* easy handle */
  376. curl_socket_t s, /* socket */
  377. int what, /* see above */
  378. void *userp, /* private callback
  379. pointer */
  380. void *socketp) /* private socket
  381. pointer */
  382. {
  383. struct events *ev = userp;
  384. struct socketmonitor *m;
  385. struct socketmonitor *prev = NULL;
  386. #if defined(CURL_DISABLE_VERBOSE_STRINGS)
  387. (void) easy;
  388. #endif
  389. (void)socketp;
  390. m = ev->list;
  391. while(m) {
  392. if(m->socket.fd == s) {
  393. if(what == CURL_POLL_REMOVE) {
  394. struct socketmonitor *nxt = m->next;
  395. /* remove this node from the list of monitored sockets */
  396. if(prev)
  397. prev->next = nxt;
  398. else
  399. ev->list = nxt;
  400. free(m);
  401. m = nxt;
  402. infof(easy, "socket cb: socket %" CURL_FORMAT_SOCKET_T
  403. " REMOVED", s);
  404. }
  405. else {
  406. /* The socket 's' is already being monitored, update the activity
  407. mask. Convert from libcurl bitmask to the poll one. */
  408. m->socket.events = socketcb2poll(what);
  409. infof(easy, "socket cb: socket %" CURL_FORMAT_SOCKET_T
  410. " UPDATED as %s%s", s,
  411. (what&CURL_POLL_IN)?"IN":"",
  412. (what&CURL_POLL_OUT)?"OUT":"");
  413. }
  414. break;
  415. }
  416. prev = m;
  417. m = m->next; /* move to next node */
  418. }
  419. if(!m) {
  420. if(what == CURL_POLL_REMOVE) {
  421. /* this happens a bit too often, libcurl fix perhaps? */
  422. /* fprintf(stderr,
  423. "%s: socket %d asked to be REMOVED but not present!\n",
  424. __func__, s); */
  425. }
  426. else {
  427. m = malloc(sizeof(struct socketmonitor));
  428. if(m) {
  429. m->next = ev->list;
  430. m->socket.fd = s;
  431. m->socket.events = socketcb2poll(what);
  432. m->socket.revents = 0;
  433. ev->list = m;
  434. infof(easy, "socket cb: socket %" CURL_FORMAT_SOCKET_T
  435. " ADDED as %s%s", s,
  436. (what&CURL_POLL_IN)?"IN":"",
  437. (what&CURL_POLL_OUT)?"OUT":"");
  438. }
  439. else
  440. return CURLE_OUT_OF_MEMORY;
  441. }
  442. }
  443. return 0;
  444. }
  445. /*
  446. * events_setup()
  447. *
  448. * Do the multi handle setups that only event-based transfers need.
  449. */
  450. static void events_setup(struct Curl_multi *multi, struct events *ev)
  451. {
  452. /* timer callback */
  453. curl_multi_setopt(multi, CURLMOPT_TIMERFUNCTION, events_timer);
  454. curl_multi_setopt(multi, CURLMOPT_TIMERDATA, ev);
  455. /* socket callback */
  456. curl_multi_setopt(multi, CURLMOPT_SOCKETFUNCTION, events_socket);
  457. curl_multi_setopt(multi, CURLMOPT_SOCKETDATA, ev);
  458. }
  459. /* wait_or_timeout()
  460. *
  461. * waits for activity on any of the given sockets, or the timeout to trigger.
  462. */
  463. static CURLcode wait_or_timeout(struct Curl_multi *multi, struct events *ev)
  464. {
  465. bool done = FALSE;
  466. CURLMcode mcode = CURLM_OK;
  467. CURLcode result = CURLE_OK;
  468. while(!done) {
  469. CURLMsg *msg;
  470. struct socketmonitor *m;
  471. struct pollfd *f;
  472. struct pollfd fds[4];
  473. int numfds = 0;
  474. int pollrc;
  475. int i;
  476. struct curltime before;
  477. struct curltime after;
  478. /* populate the fds[] array */
  479. for(m = ev->list, f = &fds[0]; m; m = m->next) {
  480. f->fd = m->socket.fd;
  481. f->events = m->socket.events;
  482. f->revents = 0;
  483. /* fprintf(stderr, "poll() %d check socket %d\n", numfds, f->fd); */
  484. f++;
  485. numfds++;
  486. }
  487. /* get the time stamp to use to figure out how long poll takes */
  488. before = Curl_now();
  489. /* wait for activity or timeout */
  490. pollrc = Curl_poll(fds, numfds, ev->ms);
  491. if(pollrc < 0)
  492. return CURLE_UNRECOVERABLE_POLL;
  493. after = Curl_now();
  494. ev->msbump = FALSE; /* reset here */
  495. if(!pollrc) {
  496. /* timeout! */
  497. ev->ms = 0;
  498. /* fprintf(stderr, "call curl_multi_socket_action(TIMEOUT)\n"); */
  499. mcode = curl_multi_socket_action(multi, CURL_SOCKET_TIMEOUT, 0,
  500. &ev->running_handles);
  501. }
  502. else {
  503. /* here pollrc is > 0 */
  504. /* loop over the monitored sockets to see which ones had activity */
  505. for(i = 0; i< numfds; i++) {
  506. if(fds[i].revents) {
  507. /* socket activity, tell libcurl */
  508. int act = poll2cselect(fds[i].revents); /* convert */
  509. infof(multi->easyp,
  510. "call curl_multi_socket_action(socket "
  511. "%" CURL_FORMAT_SOCKET_T ")", fds[i].fd);
  512. mcode = curl_multi_socket_action(multi, fds[i].fd, act,
  513. &ev->running_handles);
  514. }
  515. }
  516. if(!ev->msbump) {
  517. /* If nothing updated the timeout, we decrease it by the spent time.
  518. * If it was updated, it has the new timeout time stored already.
  519. */
  520. timediff_t timediff = Curl_timediff(after, before);
  521. if(timediff > 0) {
  522. if(timediff > ev->ms)
  523. ev->ms = 0;
  524. else
  525. ev->ms -= (long)timediff;
  526. }
  527. }
  528. }
  529. if(mcode)
  530. return CURLE_URL_MALFORMAT;
  531. /* we don't really care about the "msgs_in_queue" value returned in the
  532. second argument */
  533. msg = curl_multi_info_read(multi, &pollrc);
  534. if(msg) {
  535. result = msg->data.result;
  536. done = TRUE;
  537. }
  538. }
  539. return result;
  540. }
  541. /* easy_events()
  542. *
  543. * Runs a transfer in a blocking manner using the events-based API
  544. */
  545. static CURLcode easy_events(struct Curl_multi *multi)
  546. {
  547. /* this struct is made static to allow it to be used after this function
  548. returns and curl_multi_remove_handle() is called */
  549. static struct events evs = {2, FALSE, 0, NULL, 0};
  550. /* if running event-based, do some further multi inits */
  551. events_setup(multi, &evs);
  552. return wait_or_timeout(multi, &evs);
  553. }
  554. #else /* CURLDEBUG */
  555. /* when not built with debug, this function doesn't exist */
  556. #define easy_events(x) CURLE_NOT_BUILT_IN
  557. #endif
  558. static CURLcode easy_transfer(struct Curl_multi *multi)
  559. {
  560. bool done = FALSE;
  561. CURLMcode mcode = CURLM_OK;
  562. CURLcode result = CURLE_OK;
  563. while(!done && !mcode) {
  564. int still_running = 0;
  565. mcode = curl_multi_poll(multi, NULL, 0, 1000, NULL);
  566. if(!mcode)
  567. mcode = curl_multi_perform(multi, &still_running);
  568. /* only read 'still_running' if curl_multi_perform() return OK */
  569. if(!mcode && !still_running) {
  570. int rc;
  571. CURLMsg *msg = curl_multi_info_read(multi, &rc);
  572. if(msg) {
  573. result = msg->data.result;
  574. done = TRUE;
  575. }
  576. }
  577. }
  578. /* Make sure to return some kind of error if there was a multi problem */
  579. if(mcode) {
  580. result = (mcode == CURLM_OUT_OF_MEMORY) ? CURLE_OUT_OF_MEMORY :
  581. /* The other multi errors should never happen, so return
  582. something suitably generic */
  583. CURLE_BAD_FUNCTION_ARGUMENT;
  584. }
  585. return result;
  586. }
  587. /*
  588. * easy_perform() is the external interface that performs a blocking
  589. * transfer as previously setup.
  590. *
  591. * CONCEPT: This function creates a multi handle, adds the easy handle to it,
  592. * runs curl_multi_perform() until the transfer is done, then detaches the
  593. * easy handle, destroys the multi handle and returns the easy handle's return
  594. * code.
  595. *
  596. * REALITY: it can't just create and destroy the multi handle that easily. It
  597. * needs to keep it around since if this easy handle is used again by this
  598. * function, the same multi handle must be reused so that the same pools and
  599. * caches can be used.
  600. *
  601. * DEBUG: if 'events' is set TRUE, this function will use a replacement engine
  602. * instead of curl_multi_perform() and use curl_multi_socket_action().
  603. */
  604. static CURLcode easy_perform(struct Curl_easy *data, bool events)
  605. {
  606. struct Curl_multi *multi;
  607. CURLMcode mcode;
  608. CURLcode result = CURLE_OK;
  609. SIGPIPE_VARIABLE(pipe_st);
  610. if(!data)
  611. return CURLE_BAD_FUNCTION_ARGUMENT;
  612. if(data->set.errorbuffer)
  613. /* clear this as early as possible */
  614. data->set.errorbuffer[0] = 0;
  615. data->state.os_errno = 0;
  616. if(data->multi) {
  617. failf(data, "easy handle already used in multi handle");
  618. return CURLE_FAILED_INIT;
  619. }
  620. if(data->multi_easy)
  621. multi = data->multi_easy;
  622. else {
  623. /* this multi handle will only ever have a single easy handled attached
  624. to it, so make it use minimal hashes */
  625. multi = Curl_multi_handle(1, 3, 7);
  626. if(!multi)
  627. return CURLE_OUT_OF_MEMORY;
  628. }
  629. if(multi->in_callback)
  630. return CURLE_RECURSIVE_API_CALL;
  631. /* Copy the MAXCONNECTS option to the multi handle */
  632. curl_multi_setopt(multi, CURLMOPT_MAXCONNECTS, (long)data->set.maxconnects);
  633. data->multi_easy = NULL; /* pretend it does not exist */
  634. mcode = curl_multi_add_handle(multi, data);
  635. if(mcode) {
  636. curl_multi_cleanup(multi);
  637. if(mcode == CURLM_OUT_OF_MEMORY)
  638. return CURLE_OUT_OF_MEMORY;
  639. return CURLE_FAILED_INIT;
  640. }
  641. /* assign this after curl_multi_add_handle() */
  642. data->multi_easy = multi;
  643. sigpipe_ignore(data, &pipe_st);
  644. /* run the transfer */
  645. result = events ? easy_events(multi) : easy_transfer(multi);
  646. /* ignoring the return code isn't nice, but atm we can't really handle
  647. a failure here, room for future improvement! */
  648. (void)curl_multi_remove_handle(multi, data);
  649. sigpipe_restore(&pipe_st);
  650. /* The multi handle is kept alive, owned by the easy handle */
  651. return result;
  652. }
  653. /*
  654. * curl_easy_perform() is the external interface that performs a blocking
  655. * transfer as previously setup.
  656. */
  657. CURLcode curl_easy_perform(struct Curl_easy *data)
  658. {
  659. return easy_perform(data, FALSE);
  660. }
  661. #ifdef CURLDEBUG
  662. /*
  663. * curl_easy_perform_ev() is the external interface that performs a blocking
  664. * transfer using the event-based API internally.
  665. */
  666. CURLcode curl_easy_perform_ev(struct Curl_easy *data)
  667. {
  668. return easy_perform(data, TRUE);
  669. }
  670. #endif
  671. /*
  672. * curl_easy_cleanup() is the external interface to cleaning/freeing the given
  673. * easy handle.
  674. */
  675. void curl_easy_cleanup(struct Curl_easy *data)
  676. {
  677. if(GOOD_EASY_HANDLE(data)) {
  678. SIGPIPE_VARIABLE(pipe_st);
  679. sigpipe_ignore(data, &pipe_st);
  680. Curl_close(&data);
  681. sigpipe_restore(&pipe_st);
  682. }
  683. }
  684. /*
  685. * curl_easy_getinfo() is an external interface that allows an app to retrieve
  686. * information from a performed transfer and similar.
  687. */
  688. #undef curl_easy_getinfo
  689. CURLcode curl_easy_getinfo(struct Curl_easy *data, CURLINFO info, ...)
  690. {
  691. va_list arg;
  692. void *paramp;
  693. CURLcode result;
  694. va_start(arg, info);
  695. paramp = va_arg(arg, void *);
  696. result = Curl_getinfo(data, info, paramp);
  697. va_end(arg);
  698. return result;
  699. }
  700. static CURLcode dupset(struct Curl_easy *dst, struct Curl_easy *src)
  701. {
  702. CURLcode result = CURLE_OK;
  703. enum dupstring i;
  704. enum dupblob j;
  705. /* Copy src->set into dst->set first, then deal with the strings
  706. afterwards */
  707. dst->set = src->set;
  708. Curl_mime_initpart(&dst->set.mimepost);
  709. /* clear all dest string and blob pointers first, in case we error out
  710. mid-function */
  711. memset(dst->set.str, 0, STRING_LAST * sizeof(char *));
  712. memset(dst->set.blobs, 0, BLOB_LAST * sizeof(struct curl_blob *));
  713. /* duplicate all strings */
  714. for(i = (enum dupstring)0; i< STRING_LASTZEROTERMINATED; i++) {
  715. result = Curl_setstropt(&dst->set.str[i], src->set.str[i]);
  716. if(result)
  717. return result;
  718. }
  719. /* duplicate all blobs */
  720. for(j = (enum dupblob)0; j < BLOB_LAST; j++) {
  721. result = Curl_setblobopt(&dst->set.blobs[j], src->set.blobs[j]);
  722. if(result)
  723. return result;
  724. }
  725. /* duplicate memory areas pointed to */
  726. i = STRING_COPYPOSTFIELDS;
  727. if(src->set.str[i]) {
  728. if(src->set.postfieldsize == -1)
  729. dst->set.str[i] = strdup(src->set.str[i]);
  730. else
  731. /* postfieldsize is curl_off_t, Curl_memdup() takes a size_t ... */
  732. dst->set.str[i] = Curl_memdup(src->set.str[i],
  733. curlx_sotouz(src->set.postfieldsize));
  734. if(!dst->set.str[i])
  735. return CURLE_OUT_OF_MEMORY;
  736. /* point to the new copy */
  737. dst->set.postfields = dst->set.str[i];
  738. }
  739. /* Duplicate mime data. */
  740. result = Curl_mime_duppart(dst, &dst->set.mimepost, &src->set.mimepost);
  741. if(src->set.resolve)
  742. dst->state.resolve = dst->set.resolve;
  743. return result;
  744. }
  745. /*
  746. * curl_easy_duphandle() is an external interface to allow duplication of a
  747. * given input easy handle. The returned handle will be a new working handle
  748. * with all options set exactly as the input source handle.
  749. */
  750. struct Curl_easy *curl_easy_duphandle(struct Curl_easy *data)
  751. {
  752. struct Curl_easy *outcurl = calloc(1, sizeof(struct Curl_easy));
  753. if(!outcurl)
  754. goto fail;
  755. /*
  756. * We setup a few buffers we need. We should probably make them
  757. * get setup on-demand in the code, as that would probably decrease
  758. * the likeliness of us forgetting to init a buffer here in the future.
  759. */
  760. outcurl->set.buffer_size = data->set.buffer_size;
  761. /* copy all userdefined values */
  762. if(dupset(outcurl, data))
  763. goto fail;
  764. Curl_dyn_init(&outcurl->state.headerb, CURL_MAX_HTTP_HEADER);
  765. /* the connection cache is setup on demand */
  766. outcurl->state.conn_cache = NULL;
  767. outcurl->state.lastconnect_id = -1;
  768. outcurl->state.recent_conn_id = -1;
  769. outcurl->id = -1;
  770. outcurl->progress.flags = data->progress.flags;
  771. outcurl->progress.callback = data->progress.callback;
  772. #ifndef CURL_DISABLE_COOKIES
  773. outcurl->state.cookielist = NULL;
  774. if(data->cookies && data->state.cookie_engine) {
  775. /* If cookies are enabled in the parent handle, we enable them
  776. in the clone as well! */
  777. outcurl->cookies = Curl_cookie_init(outcurl, NULL, outcurl->cookies,
  778. data->set.cookiesession);
  779. if(!outcurl->cookies)
  780. goto fail;
  781. }
  782. if(data->state.cookielist) {
  783. outcurl->state.cookielist = Curl_slist_duplicate(data->state.cookielist);
  784. if(!outcurl->state.cookielist)
  785. goto fail;
  786. }
  787. #endif
  788. if(data->state.url) {
  789. outcurl->state.url = strdup(data->state.url);
  790. if(!outcurl->state.url)
  791. goto fail;
  792. outcurl->state.url_alloc = TRUE;
  793. }
  794. if(data->state.referer) {
  795. outcurl->state.referer = strdup(data->state.referer);
  796. if(!outcurl->state.referer)
  797. goto fail;
  798. outcurl->state.referer_alloc = TRUE;
  799. }
  800. /* Reinitialize an SSL engine for the new handle
  801. * note: the engine name has already been copied by dupset */
  802. if(outcurl->set.str[STRING_SSL_ENGINE]) {
  803. if(Curl_ssl_set_engine(outcurl, outcurl->set.str[STRING_SSL_ENGINE]))
  804. goto fail;
  805. }
  806. #ifndef CURL_DISABLE_ALTSVC
  807. if(data->asi) {
  808. outcurl->asi = Curl_altsvc_init();
  809. if(!outcurl->asi)
  810. goto fail;
  811. if(outcurl->set.str[STRING_ALTSVC])
  812. (void)Curl_altsvc_load(outcurl->asi, outcurl->set.str[STRING_ALTSVC]);
  813. }
  814. #endif
  815. #ifndef CURL_DISABLE_HSTS
  816. if(data->hsts) {
  817. outcurl->hsts = Curl_hsts_init();
  818. if(!outcurl->hsts)
  819. goto fail;
  820. if(outcurl->set.str[STRING_HSTS])
  821. (void)Curl_hsts_loadfile(outcurl,
  822. outcurl->hsts, outcurl->set.str[STRING_HSTS]);
  823. (void)Curl_hsts_loadcb(outcurl, outcurl->hsts);
  824. }
  825. #endif
  826. #ifdef CURLRES_ASYNCH
  827. /* Clone the resolver handle, if present, for the new handle */
  828. if(Curl_resolver_duphandle(outcurl,
  829. &outcurl->state.async.resolver,
  830. data->state.async.resolver))
  831. goto fail;
  832. #endif
  833. #ifdef USE_ARES
  834. {
  835. CURLcode rc;
  836. rc = Curl_set_dns_servers(outcurl, data->set.str[STRING_DNS_SERVERS]);
  837. if(rc && rc != CURLE_NOT_BUILT_IN)
  838. goto fail;
  839. rc = Curl_set_dns_interface(outcurl, data->set.str[STRING_DNS_INTERFACE]);
  840. if(rc && rc != CURLE_NOT_BUILT_IN)
  841. goto fail;
  842. rc = Curl_set_dns_local_ip4(outcurl, data->set.str[STRING_DNS_LOCAL_IP4]);
  843. if(rc && rc != CURLE_NOT_BUILT_IN)
  844. goto fail;
  845. rc = Curl_set_dns_local_ip6(outcurl, data->set.str[STRING_DNS_LOCAL_IP6]);
  846. if(rc && rc != CURLE_NOT_BUILT_IN)
  847. goto fail;
  848. }
  849. #endif /* USE_ARES */
  850. Curl_initinfo(outcurl);
  851. outcurl->magic = CURLEASY_MAGIC_NUMBER;
  852. /* we reach this point and thus we are OK */
  853. return outcurl;
  854. fail:
  855. if(outcurl) {
  856. #ifndef CURL_DISABLE_COOKIES
  857. free(outcurl->cookies);
  858. #endif
  859. Curl_dyn_free(&outcurl->state.headerb);
  860. Curl_altsvc_cleanup(&outcurl->asi);
  861. Curl_hsts_cleanup(&outcurl->hsts);
  862. Curl_freeset(outcurl);
  863. free(outcurl);
  864. }
  865. return NULL;
  866. }
  867. /*
  868. * curl_easy_reset() is an external interface that allows an app to re-
  869. * initialize a session handle to the default values.
  870. */
  871. void curl_easy_reset(struct Curl_easy *data)
  872. {
  873. Curl_req_hard_reset(&data->req, data);
  874. /* zero out UserDefined data: */
  875. Curl_freeset(data);
  876. memset(&data->set, 0, sizeof(struct UserDefined));
  877. (void)Curl_init_userdefined(data);
  878. /* zero out Progress data: */
  879. memset(&data->progress, 0, sizeof(struct Progress));
  880. /* zero out PureInfo data: */
  881. Curl_initinfo(data);
  882. data->progress.flags |= PGRS_HIDE;
  883. data->state.current_speed = -1; /* init to negative == impossible */
  884. data->state.retrycount = 0; /* reset the retry counter */
  885. /* zero out authentication data: */
  886. memset(&data->state.authhost, 0, sizeof(struct auth));
  887. memset(&data->state.authproxy, 0, sizeof(struct auth));
  888. #if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_DIGEST_AUTH)
  889. Curl_http_auth_cleanup_digest(data);
  890. #endif
  891. }
  892. /*
  893. * curl_easy_pause() allows an application to pause or unpause a specific
  894. * transfer and direction. This function sets the full new state for the
  895. * current connection this easy handle operates on.
  896. *
  897. * NOTE: if you have the receiving paused and you call this function to remove
  898. * the pausing, you may get your write callback called at this point.
  899. *
  900. * Action is a bitmask consisting of CURLPAUSE_* bits in curl/curl.h
  901. *
  902. * NOTE: This is one of few API functions that are allowed to be called from
  903. * within a callback.
  904. */
  905. CURLcode curl_easy_pause(struct Curl_easy *data, int action)
  906. {
  907. struct SingleRequest *k;
  908. CURLcode result = CURLE_OK;
  909. int oldstate;
  910. int newstate;
  911. bool recursive = FALSE;
  912. bool keep_changed, unpause_read, not_all_paused;
  913. if(!GOOD_EASY_HANDLE(data) || !data->conn)
  914. /* crazy input, don't continue */
  915. return CURLE_BAD_FUNCTION_ARGUMENT;
  916. if(Curl_is_in_callback(data))
  917. recursive = TRUE;
  918. k = &data->req;
  919. oldstate = k->keepon & (KEEP_RECV_PAUSE| KEEP_SEND_PAUSE);
  920. /* first switch off both pause bits then set the new pause bits */
  921. newstate = (k->keepon &~ (KEEP_RECV_PAUSE| KEEP_SEND_PAUSE)) |
  922. ((action & CURLPAUSE_RECV)?KEEP_RECV_PAUSE:0) |
  923. ((action & CURLPAUSE_SEND)?KEEP_SEND_PAUSE:0);
  924. keep_changed = ((newstate & (KEEP_RECV_PAUSE| KEEP_SEND_PAUSE)) != oldstate);
  925. not_all_paused = (newstate & (KEEP_RECV_PAUSE|KEEP_SEND_PAUSE)) !=
  926. (KEEP_RECV_PAUSE|KEEP_SEND_PAUSE);
  927. unpause_read = ((k->keepon & ~newstate & KEEP_SEND_PAUSE) &&
  928. (data->mstate == MSTATE_PERFORMING ||
  929. data->mstate == MSTATE_RATELIMITING));
  930. /* Unpausing writes is detected on the next run in
  931. * transfer.c:Curl_readwrite(). This is because this may result
  932. * in a transfer error if the application's callbacks fail */
  933. /* Set the new keepon state, so it takes effect no matter what error
  934. * may happen afterwards. */
  935. k->keepon = newstate;
  936. /* If not completely pausing both directions now, run again in any case. */
  937. if(not_all_paused) {
  938. Curl_expire(data, 0, EXPIRE_RUN_NOW);
  939. /* reset the too-slow time keeper */
  940. data->state.keeps_speed.tv_sec = 0;
  941. /* Simulate socket events on next run for unpaused directions */
  942. if(!(newstate & KEEP_SEND_PAUSE))
  943. data->state.select_bits |= CURL_CSELECT_OUT;
  944. if(!(newstate & KEEP_RECV_PAUSE))
  945. data->state.select_bits |= CURL_CSELECT_IN;
  946. /* On changes, tell application to update its timers. */
  947. if(keep_changed && data->multi) {
  948. if(Curl_update_timer(data->multi)) {
  949. result = CURLE_ABORTED_BY_CALLBACK;
  950. goto out;
  951. }
  952. }
  953. }
  954. if(unpause_read) {
  955. result = Curl_creader_unpause(data);
  956. if(result)
  957. goto out;
  958. }
  959. out:
  960. if(!result && !data->state.done && keep_changed)
  961. /* This transfer may have been moved in or out of the bundle, update the
  962. corresponding socket callback, if used */
  963. result = Curl_updatesocket(data);
  964. if(recursive)
  965. /* this might have called a callback recursively which might have set this
  966. to false again on exit */
  967. Curl_set_in_callback(data, TRUE);
  968. return result;
  969. }
  970. static CURLcode easy_connection(struct Curl_easy *data,
  971. struct connectdata **connp)
  972. {
  973. curl_socket_t sfd;
  974. if(!data)
  975. return CURLE_BAD_FUNCTION_ARGUMENT;
  976. /* only allow these to be called on handles with CURLOPT_CONNECT_ONLY */
  977. if(!data->set.connect_only) {
  978. failf(data, "CONNECT_ONLY is required");
  979. return CURLE_UNSUPPORTED_PROTOCOL;
  980. }
  981. sfd = Curl_getconnectinfo(data, connp);
  982. if(sfd == CURL_SOCKET_BAD) {
  983. failf(data, "Failed to get recent socket");
  984. return CURLE_UNSUPPORTED_PROTOCOL;
  985. }
  986. return CURLE_OK;
  987. }
  988. /*
  989. * Receives data from the connected socket. Use after successful
  990. * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
  991. * Returns CURLE_OK on success, error code on error.
  992. */
  993. CURLcode curl_easy_recv(struct Curl_easy *data, void *buffer, size_t buflen,
  994. size_t *n)
  995. {
  996. CURLcode result;
  997. ssize_t n1;
  998. struct connectdata *c;
  999. if(Curl_is_in_callback(data))
  1000. return CURLE_RECURSIVE_API_CALL;
  1001. result = easy_connection(data, &c);
  1002. if(result)
  1003. return result;
  1004. if(!data->conn)
  1005. /* on first invoke, the transfer has been detached from the connection and
  1006. needs to be reattached */
  1007. Curl_attach_connection(data, c);
  1008. *n = 0;
  1009. result = Curl_conn_recv(data, FIRSTSOCKET, buffer, buflen, &n1);
  1010. if(result)
  1011. return result;
  1012. *n = (size_t)n1;
  1013. return CURLE_OK;
  1014. }
  1015. #ifdef USE_WEBSOCKETS
  1016. CURLcode Curl_connect_only_attach(struct Curl_easy *data)
  1017. {
  1018. CURLcode result;
  1019. struct connectdata *c = NULL;
  1020. result = easy_connection(data, &c);
  1021. if(result)
  1022. return result;
  1023. if(!data->conn)
  1024. /* on first invoke, the transfer has been detached from the connection and
  1025. needs to be reattached */
  1026. Curl_attach_connection(data, c);
  1027. return CURLE_OK;
  1028. }
  1029. #endif /* USE_WEBSOCKETS */
  1030. /*
  1031. * Sends data over the connected socket.
  1032. *
  1033. * This is the private internal version of curl_easy_send()
  1034. */
  1035. CURLcode Curl_senddata(struct Curl_easy *data, const void *buffer,
  1036. size_t buflen, size_t *n)
  1037. {
  1038. CURLcode result;
  1039. struct connectdata *c = NULL;
  1040. SIGPIPE_VARIABLE(pipe_st);
  1041. *n = 0;
  1042. result = easy_connection(data, &c);
  1043. if(result)
  1044. return result;
  1045. if(!data->conn)
  1046. /* on first invoke, the transfer has been detached from the connection and
  1047. needs to be reattached */
  1048. Curl_attach_connection(data, c);
  1049. sigpipe_ignore(data, &pipe_st);
  1050. result = Curl_conn_send(data, FIRSTSOCKET, buffer, buflen, n);
  1051. sigpipe_restore(&pipe_st);
  1052. if(result && result != CURLE_AGAIN)
  1053. return CURLE_SEND_ERROR;
  1054. return result;
  1055. }
  1056. /*
  1057. * Sends data over the connected socket. Use after successful
  1058. * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
  1059. */
  1060. CURLcode curl_easy_send(struct Curl_easy *data, const void *buffer,
  1061. size_t buflen, size_t *n)
  1062. {
  1063. size_t written = 0;
  1064. CURLcode result;
  1065. if(Curl_is_in_callback(data))
  1066. return CURLE_RECURSIVE_API_CALL;
  1067. result = Curl_senddata(data, buffer, buflen, &written);
  1068. *n = written;
  1069. return result;
  1070. }
  1071. /*
  1072. * Wrapper to call functions in Curl_conncache_foreach()
  1073. *
  1074. * Returns always 0.
  1075. */
  1076. static int conn_upkeep(struct Curl_easy *data,
  1077. struct connectdata *conn,
  1078. void *param)
  1079. {
  1080. struct curltime *now = param;
  1081. if(Curl_timediff(*now, conn->keepalive) <= data->set.upkeep_interval_ms)
  1082. return 0;
  1083. /* briefly attach for action */
  1084. Curl_attach_connection(data, conn);
  1085. if(conn->handler->connection_check) {
  1086. /* Do a protocol-specific keepalive check on the connection. */
  1087. conn->handler->connection_check(data, conn, CONNCHECK_KEEPALIVE);
  1088. }
  1089. else {
  1090. /* Do the generic action on the FIRSTSOCKET filter chain */
  1091. Curl_conn_keep_alive(data, conn, FIRSTSOCKET);
  1092. }
  1093. Curl_detach_connection(data);
  1094. conn->keepalive = *now;
  1095. return 0; /* continue iteration */
  1096. }
  1097. static CURLcode upkeep(struct conncache *conn_cache, void *data)
  1098. {
  1099. struct curltime now = Curl_now();
  1100. /* Loop over every connection and make connection alive. */
  1101. Curl_conncache_foreach(data,
  1102. conn_cache,
  1103. &now,
  1104. conn_upkeep);
  1105. return CURLE_OK;
  1106. }
  1107. /*
  1108. * Performs connection upkeep for the given session handle.
  1109. */
  1110. CURLcode curl_easy_upkeep(struct Curl_easy *data)
  1111. {
  1112. /* Verify that we got an easy handle we can work with. */
  1113. if(!GOOD_EASY_HANDLE(data))
  1114. return CURLE_BAD_FUNCTION_ARGUMENT;
  1115. if(data->multi_easy) {
  1116. /* Use the common function to keep connections alive. */
  1117. return upkeep(&data->multi_easy->conn_cache, data);
  1118. }
  1119. else {
  1120. /* No connections, so just return success */
  1121. return CURLE_OK;
  1122. }
  1123. }