2002-09-03 07:52:59 -04:00
|
|
|
/***************************************************************************
|
2003-03-25 09:23:12 -05:00
|
|
|
* _ _ ____ _
|
|
|
|
* Project ___| | | | _ \| |
|
|
|
|
* / __| | | | |_) | |
|
|
|
|
* | (__| |_| | _ <| |___
|
1999-12-29 09:20:26 -05:00
|
|
|
* \___|\___/|_| \_\_____|
|
|
|
|
*
|
2004-01-07 04:19:33 -05:00
|
|
|
* Copyright (C) 1998 - 2004, Daniel Stenberg, <daniel@haxx.se>, et al.
|
1999-12-29 09:20:26 -05:00
|
|
|
*
|
2002-09-03 07:52:59 -04:00
|
|
|
* This software is licensed as described in the file COPYING, which
|
|
|
|
* you should have received as part of this distribution. The terms
|
|
|
|
* are also available at http://curl.haxx.se/docs/copyright.html.
|
2003-03-25 09:23:12 -05:00
|
|
|
*
|
2001-01-03 04:29:33 -05:00
|
|
|
* You may opt to use, copy, modify, merge, publish, distribute and/or sell
|
|
|
|
* copies of the Software, and permit persons to whom the Software is
|
2002-09-03 07:52:59 -04:00
|
|
|
* furnished to do so, under the terms of the COPYING file.
|
1999-12-29 09:20:26 -05:00
|
|
|
*
|
2001-01-03 04:29:33 -05:00
|
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
|
|
* KIND, either express or implied.
|
1999-12-29 09:20:26 -05:00
|
|
|
*
|
2001-01-03 04:29:33 -05:00
|
|
|
* $Id$
|
2002-09-03 07:52:59 -04:00
|
|
|
***************************************************************************/
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
/* -- WIN32 approved -- */
|
2000-08-24 10:26:33 -04:00
|
|
|
|
|
|
|
#include "setup.h"
|
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
|
|
|
|
#include <errno.h>
|
|
|
|
|
|
|
|
#if defined(WIN32) && !defined(__GNUC__) || defined(__MINGW32__)
|
|
|
|
#include <time.h>
|
|
|
|
#include <io.h>
|
|
|
|
#else
|
|
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#endif
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
|
|
|
#include <netdb.h>
|
|
|
|
#ifdef HAVE_ARPA_INET_H
|
|
|
|
#include <arpa/inet.h>
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_NET_IF_H
|
|
|
|
#include <net/if.h>
|
|
|
|
#endif
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <signal.h>
|
|
|
|
|
|
|
|
#ifdef HAVE_SYS_PARAM_H
|
|
|
|
#include <sys/param.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_SYS_SELECT_H
|
|
|
|
#include <sys/select.h>
|
|
|
|
#endif
|
|
|
|
|
2003-01-15 06:43:03 -05:00
|
|
|
#ifdef VMS
|
2001-08-06 08:14:53 -04:00
|
|
|
#include <in.h>
|
|
|
|
#include <inet.h>
|
|
|
|
#endif
|
|
|
|
|
2002-06-11 11:10:18 -04:00
|
|
|
#ifdef HAVE_SETJMP_H
|
|
|
|
#include <setjmp.h>
|
|
|
|
#endif
|
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
#ifndef HAVE_SELECT
|
|
|
|
#error "We can't compile without select() support!"
|
|
|
|
#endif
|
|
|
|
#ifndef HAVE_SOCKET
|
|
|
|
#error "We can't compile without socket() support!"
|
|
|
|
#endif
|
|
|
|
|
2003-02-28 10:50:05 -05:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
#endif
|
|
|
|
|
2004-04-26 03:20:11 -04:00
|
|
|
#ifdef USE_LIBIDN
|
|
|
|
#include <idna.h>
|
|
|
|
#include <stringprep.h>
|
|
|
|
#endif
|
|
|
|
|
2003-02-28 10:50:05 -05:00
|
|
|
#ifdef HAVE_OPENSSL_ENGINE_H
|
|
|
|
#include <openssl/engine.h>
|
|
|
|
#endif
|
1999-12-29 09:20:26 -05:00
|
|
|
#include "urldata.h"
|
|
|
|
#include "netrc.h"
|
|
|
|
|
|
|
|
#include "formdata.h"
|
|
|
|
#include "base64.h"
|
|
|
|
#include "ssluse.h"
|
|
|
|
#include "hostip.h"
|
|
|
|
#include "if2ip.h"
|
2001-01-17 08:23:01 -05:00
|
|
|
#include "transfer.h"
|
1999-12-29 09:20:26 -05:00
|
|
|
#include "sendf.h"
|
|
|
|
#include "progress.h"
|
|
|
|
#include "cookie.h"
|
2000-05-22 10:12:12 -04:00
|
|
|
#include "strequal.h"
|
2000-11-06 03:12:30 -05:00
|
|
|
#include "escape.h"
|
2001-05-30 07:06:56 -04:00
|
|
|
#include "strtok.h"
|
2003-01-08 10:50:52 -05:00
|
|
|
#include "share.h"
|
2003-05-12 08:45:14 -04:00
|
|
|
#include "content_encoding.h"
|
2003-05-23 02:44:24 -04:00
|
|
|
#include "http_digest.h"
|
2003-06-10 08:22:19 -04:00
|
|
|
#include "http_negotiate.h"
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
/* And now for the protocols */
|
|
|
|
#include "ftp.h"
|
|
|
|
#include "dict.h"
|
|
|
|
#include "telnet.h"
|
|
|
|
#include "http.h"
|
|
|
|
#include "file.h"
|
|
|
|
#include "ldap.h"
|
2001-08-15 02:55:42 -04:00
|
|
|
#include "url.h"
|
2001-10-01 04:59:17 -04:00
|
|
|
#include "connect.h"
|
2004-04-26 03:20:11 -04:00
|
|
|
#include "inet_ntop.h"
|
2004-02-02 05:13:54 -05:00
|
|
|
#include <ca-bundle.h>
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2002-01-04 04:38:52 -05:00
|
|
|
#if defined(HAVE_INET_NTOA_R) && !defined(HAVE_INET_NTOA_R_DECL)
|
|
|
|
#include "inet_ntoa_r.h"
|
|
|
|
#endif
|
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
#define _MPRINTF_REPLACE /* use our functions only */
|
|
|
|
#include <curl/mprintf.h>
|
|
|
|
|
2003-12-02 08:27:29 -05:00
|
|
|
#ifdef HAVE_KRB4
|
2000-09-21 04:50:05 -04:00
|
|
|
#include "security.h"
|
|
|
|
#endif
|
2004-05-11 07:30:23 -04:00
|
|
|
#include "memory.h"
|
2002-06-11 11:10:18 -04:00
|
|
|
|
2000-10-09 07:12:34 -04:00
|
|
|
/* The last #include file should be: */
|
|
|
|
#include "memdebug.h"
|
2000-09-21 04:50:05 -04:00
|
|
|
|
2001-02-20 12:35:51 -05:00
|
|
|
/* Local static prototypes */
|
2001-08-30 18:48:34 -04:00
|
|
|
static int ConnectionKillOne(struct SessionHandle *data);
|
|
|
|
static bool ConnectionExists(struct SessionHandle *data,
|
2001-02-20 12:35:51 -05:00
|
|
|
struct connectdata *needle,
|
|
|
|
struct connectdata **usethis);
|
2001-08-30 18:48:34 -04:00
|
|
|
static unsigned int ConnectionStore(struct SessionHandle *data,
|
2001-02-20 12:35:51 -05:00
|
|
|
struct connectdata *conn);
|
2003-03-24 18:10:38 -05:00
|
|
|
static bool safe_strequal(char* str1, char* str2);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2003-08-05 10:40:59 -04:00
|
|
|
#ifndef USE_ARES
|
|
|
|
/* not for Win32, unless it is cygwin
|
|
|
|
not for ares builds */
|
|
|
|
#if !defined(WIN32) || defined(__CYGWIN32__)
|
|
|
|
|
2001-03-15 09:38:30 -05:00
|
|
|
#ifndef RETSIGTYPE
|
|
|
|
#define RETSIGTYPE void
|
|
|
|
#endif
|
2002-06-11 11:47:01 -04:00
|
|
|
#ifdef HAVE_SIGSETJMP
|
2002-06-11 11:44:27 -04:00
|
|
|
extern sigjmp_buf curl_jmpenv;
|
2002-06-11 11:47:01 -04:00
|
|
|
#endif
|
2001-03-15 09:38:30 -05:00
|
|
|
static
|
2003-10-18 16:14:33 -04:00
|
|
|
RETSIGTYPE alarmfunc(int sig)
|
2001-03-15 09:38:30 -05:00
|
|
|
{
|
|
|
|
/* this is for "-ansi -Wall -pedantic" to stop complaining! (rabe) */
|
2003-10-18 16:14:33 -04:00
|
|
|
(void)sig;
|
2002-06-11 11:10:18 -04:00
|
|
|
#ifdef HAVE_SIGSETJMP
|
|
|
|
siglongjmp(curl_jmpenv, 1);
|
|
|
|
#endif
|
2001-03-15 09:38:30 -05:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
2003-08-05 10:40:59 -04:00
|
|
|
#endif /* USE_ARES */
|
2001-03-15 09:38:30 -05:00
|
|
|
|
2003-07-21 09:16:30 -04:00
|
|
|
void Curl_safefree(void *ptr)
|
|
|
|
{
|
|
|
|
if(ptr)
|
|
|
|
free(ptr);
|
|
|
|
}
|
2001-11-07 09:13:29 -05:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This is the internal function curl_easy_cleanup() calls. This should
|
|
|
|
* cleanup and free all resources associated with this sessionhandle.
|
|
|
|
*
|
|
|
|
* NOTE: if we ever add something that attempts to write to a socket or
|
|
|
|
* similar here, we must ignore SIGPIPE first. It is currently only done
|
|
|
|
* when curl_easy_perform() is invoked.
|
|
|
|
*/
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
CURLcode Curl_close(struct SessionHandle *data)
|
1999-12-29 09:20:26 -05:00
|
|
|
{
|
2001-02-20 12:35:51 -05:00
|
|
|
/* Loop through all open connections and kill them one by one */
|
|
|
|
while(-1 != ConnectionKillOne(data));
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-08-28 04:37:54 -04:00
|
|
|
#ifdef USE_SSLEAY
|
2001-11-07 09:13:29 -05:00
|
|
|
/* Close down all open SSL info and sessions */
|
2001-08-28 04:37:54 -04:00
|
|
|
Curl_SSL_Close_All(data);
|
|
|
|
#endif
|
|
|
|
|
2002-10-17 03:10:39 -04:00
|
|
|
if(data->change.cookielist) /* clean up list if any */
|
|
|
|
curl_slist_free_all(data->change.cookielist);
|
|
|
|
|
2003-07-21 09:16:30 -04:00
|
|
|
Curl_safefree(data->state.auth_host);
|
|
|
|
Curl_safefree(data->state.scratch);
|
2003-01-20 07:52:34 -05:00
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->change.proxy_alloc)
|
|
|
|
free(data->change.proxy);
|
2001-09-18 11:30:38 -04:00
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->change.referer_alloc)
|
|
|
|
free(data->change.referer);
|
2001-09-18 11:30:38 -04:00
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->change.url_alloc)
|
|
|
|
free(data->change.url);
|
2000-07-28 03:56:06 -04:00
|
|
|
|
2003-07-21 09:16:30 -04:00
|
|
|
Curl_safefree(data->state.headerbuff);
|
2000-06-20 05:28:09 -04:00
|
|
|
|
2002-06-11 07:13:01 -04:00
|
|
|
#ifndef CURL_DISABLE_HTTP
|
2003-08-04 11:02:42 -04:00
|
|
|
Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);
|
2003-04-11 03:39:16 -04:00
|
|
|
if(data->set.cookiejar) {
|
2001-08-29 05:32:18 -04:00
|
|
|
/* we have a "destination" for all the cookies to get dumped to */
|
2003-04-11 03:39:16 -04:00
|
|
|
if(Curl_cookie_output(data->cookies, data->set.cookiejar))
|
2004-01-26 11:16:44 -05:00
|
|
|
infof(data, "WARNING: failed to save cookies in %s\n",
|
|
|
|
data->set.cookiejar);
|
2003-04-11 03:39:16 -04:00
|
|
|
}
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2003-08-04 11:02:42 -04:00
|
|
|
if( !data->share || (data->cookies != data->share->cookies) ) {
|
|
|
|
Curl_cookie_cleanup(data->cookies);
|
|
|
|
}
|
|
|
|
Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
|
2002-06-11 07:13:01 -04:00
|
|
|
#endif
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-02-20 12:35:51 -05:00
|
|
|
/* free the connection cache */
|
2001-08-30 18:48:34 -04:00
|
|
|
free(data->state.connects);
|
2000-04-11 17:47:28 -04:00
|
|
|
|
2003-07-21 09:16:30 -04:00
|
|
|
Curl_safefree(data->info.contenttype);
|
2002-01-29 05:49:32 -05:00
|
|
|
|
2003-05-22 18:38:46 -04:00
|
|
|
Curl_digest_cleanup(data);
|
|
|
|
|
2004-02-16 10:24:22 -05:00
|
|
|
#ifdef USE_ARES
|
|
|
|
/* this destroys the channel and we cannot use it anymore after this */
|
|
|
|
ares_destroy(data->state.areschannel);
|
|
|
|
#endif
|
|
|
|
|
2003-08-04 11:02:42 -04:00
|
|
|
/* No longer a dirty share, if it exists */
|
|
|
|
if (data->share)
|
|
|
|
data->share->dirty--;
|
|
|
|
|
2001-02-20 12:35:51 -05:00
|
|
|
free(data);
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_OK;
|
|
|
|
}
|
2000-04-11 17:47:28 -04:00
|
|
|
|
2004-04-13 03:16:26 -04:00
|
|
|
/**
|
|
|
|
* Curl_open()
|
|
|
|
*
|
|
|
|
* @param curl is a pointer to a sessionhandle pointer that gets set by this
|
|
|
|
* function.
|
|
|
|
* @return CURLcode
|
|
|
|
*/
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
CURLcode Curl_open(struct SessionHandle **curl)
|
2000-04-11 17:47:28 -04:00
|
|
|
{
|
2004-05-11 17:17:03 -04:00
|
|
|
CURLcode res = CURLE_OK;
|
2001-08-30 18:48:34 -04:00
|
|
|
struct SessionHandle *data;
|
2000-04-11 17:47:28 -04:00
|
|
|
/* Very simple start-up: alloc the struct, init it with zeroes and return */
|
2001-08-30 18:48:34 -04:00
|
|
|
data = (struct SessionHandle *)malloc(sizeof(struct SessionHandle));
|
2001-10-09 02:23:26 -04:00
|
|
|
if(!data)
|
|
|
|
/* this is a very serious error */
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2001-10-09 02:23:26 -04:00
|
|
|
memset(data, 0, sizeof(struct SessionHandle));
|
|
|
|
|
2004-02-16 10:24:22 -05:00
|
|
|
#ifdef USE_ARES
|
|
|
|
if(ARES_SUCCESS != ares_init(&data->state.areschannel)) {
|
|
|
|
free(data);
|
|
|
|
return CURLE_FAILED_INIT;
|
|
|
|
}
|
|
|
|
/* make sure that all other returns from this function should destroy the
|
|
|
|
ares channel before returning error! */
|
|
|
|
#endif
|
|
|
|
|
2001-10-09 02:23:26 -04:00
|
|
|
/* We do some initial setup here, all those fields that can't be just 0 */
|
|
|
|
|
|
|
|
data->state.headerbuff=(char*)malloc(HEADERSIZE);
|
2004-05-11 17:17:03 -04:00
|
|
|
if(!data->state.headerbuff)
|
|
|
|
res = CURLE_OUT_OF_MEMORY;
|
|
|
|
else {
|
|
|
|
data->state.headersize=HEADERSIZE;
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2004-05-11 17:17:03 -04:00
|
|
|
data->set.out = stdout; /* default output to stdout */
|
|
|
|
data->set.in = stdin; /* default input from stdin */
|
|
|
|
data->set.err = stderr; /* default stderr to stderr */
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2004-05-11 17:17:03 -04:00
|
|
|
/* use fwrite as default function to store output */
|
|
|
|
data->set.fwrite = (curl_write_callback)fwrite;
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2004-05-11 17:17:03 -04:00
|
|
|
/* use fread as default function to read input */
|
|
|
|
data->set.fread = (curl_read_callback)fread;
|
2001-01-26 10:52:01 -05:00
|
|
|
|
2004-05-11 17:17:03 -04:00
|
|
|
data->set.infilesize = -1; /* we don't know any size */
|
2001-05-30 08:51:24 -04:00
|
|
|
|
2004-05-11 17:17:03 -04:00
|
|
|
data->state.current_speed = -1; /* init to negative == impossible */
|
2001-08-28 04:37:54 -04:00
|
|
|
|
2004-05-11 17:17:03 -04:00
|
|
|
data->set.httpreq = HTTPREQ_GET; /* Default HTTP request */
|
|
|
|
data->set.ftp_use_epsv = TRUE; /* FTP defaults to EPSV operations */
|
|
|
|
data->set.ftp_use_eprt = TRUE; /* FTP defaults to EPRT operations */
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2004-05-11 17:17:03 -04:00
|
|
|
data->set.dns_cache_timeout = 60; /* Timeout every 60 seconds by default */
|
2001-02-20 12:35:51 -05:00
|
|
|
|
2004-05-11 17:17:03 -04:00
|
|
|
/* make libcurl quiet by default: */
|
|
|
|
data->set.hide_progress = TRUE; /* CURLOPT_NOPROGRESS changes these */
|
|
|
|
data->progress.flags |= PGRS_HIDE;
|
2002-04-10 10:07:03 -04:00
|
|
|
|
2004-05-11 17:17:03 -04:00
|
|
|
/* Set the default size of the SSL session ID cache */
|
|
|
|
data->set.ssl.numsessions = 5;
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2004-05-11 17:17:03 -04:00
|
|
|
data->set.proxyport = 1080;
|
|
|
|
data->set.proxytype = CURLPROXY_HTTP; /* defaults to HTTP proxy */
|
|
|
|
data->set.httpauth = CURLAUTH_BASIC; /* defaults to basic */
|
|
|
|
data->set.proxyauth = CURLAUTH_BASIC; /* defaults to basic */
|
2002-08-30 05:20:11 -04:00
|
|
|
|
2004-05-11 17:17:03 -04:00
|
|
|
/* create an array with connection data struct pointers */
|
|
|
|
data->state.numconnects = 5; /* hard-coded right now */
|
|
|
|
data->state.connects = (struct connectdata **)
|
|
|
|
malloc(sizeof(struct connectdata *) * data->state.numconnects);
|
2003-08-11 07:47:45 -04:00
|
|
|
|
2004-05-11 17:17:03 -04:00
|
|
|
if(!data->state.connects)
|
|
|
|
res = CURLE_OUT_OF_MEMORY;
|
|
|
|
else
|
|
|
|
memset(data->state.connects, 0,
|
|
|
|
sizeof(struct connectdata *)*data->state.numconnects);
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2004-05-11 17:17:03 -04:00
|
|
|
/*
|
|
|
|
* libcurl 7.10 introduced SSL verification *by default*! This needs to be
|
|
|
|
* switched off unless wanted.
|
|
|
|
*/
|
|
|
|
data->set.ssl.verifypeer = TRUE;
|
|
|
|
data->set.ssl.verifyhost = 2;
|
2002-08-30 07:09:49 -04:00
|
|
|
#ifdef CURL_CA_BUNDLE
|
2004-05-11 17:17:03 -04:00
|
|
|
/* This is our prefered CA cert bundle since install time */
|
|
|
|
data->set.ssl.CAfile = (char *)CURL_CA_BUNDLE;
|
2002-08-30 07:09:49 -04:00
|
|
|
#endif
|
2004-05-11 17:17:03 -04:00
|
|
|
}
|
2002-08-30 07:09:49 -04:00
|
|
|
|
2004-05-11 17:17:03 -04:00
|
|
|
if(res) {
|
|
|
|
#ifdef USE_ARES
|
|
|
|
ares_destroy(data->state.areschannel);
|
|
|
|
#endif
|
|
|
|
if(data->state.headerbuff)
|
|
|
|
free(data->state.headerbuff);
|
|
|
|
free(data);
|
|
|
|
data = NULL;
|
|
|
|
}
|
2001-02-20 12:35:51 -05:00
|
|
|
|
2001-10-09 02:23:26 -04:00
|
|
|
*curl = data;
|
|
|
|
return CURLE_OK;
|
2000-04-11 17:47:28 -04:00
|
|
|
}
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option, ...)
|
2000-04-11 17:47:28 -04:00
|
|
|
{
|
|
|
|
va_list param;
|
|
|
|
char *cookiefile;
|
|
|
|
|
|
|
|
va_start(param, option);
|
|
|
|
|
|
|
|
switch(option) {
|
2002-01-07 23:26:47 -05:00
|
|
|
case CURLOPT_DNS_CACHE_TIMEOUT:
|
|
|
|
data->set.dns_cache_timeout = va_arg(param, int);
|
|
|
|
break;
|
2003-03-25 09:23:12 -05:00
|
|
|
case CURLOPT_DNS_USE_GLOBAL_CACHE:
|
2002-01-07 23:26:47 -05:00
|
|
|
{
|
2002-01-07 15:52:32 -05:00
|
|
|
int use_cache = va_arg(param, int);
|
|
|
|
if (use_cache) {
|
|
|
|
Curl_global_host_cache_init();
|
|
|
|
}
|
|
|
|
|
|
|
|
data->set.global_dns_cache = use_cache;
|
|
|
|
}
|
|
|
|
break;
|
2001-09-11 18:23:16 -04:00
|
|
|
case CURLOPT_SSL_CIPHER_LIST:
|
|
|
|
/* set a list of cipher we want to use in the SSL connection */
|
|
|
|
data->set.ssl.cipher_list = va_arg(param, char *);
|
|
|
|
break;
|
|
|
|
|
2001-03-12 10:47:17 -05:00
|
|
|
case CURLOPT_RANDOM_FILE:
|
|
|
|
/*
|
|
|
|
* This is the path name to a file that contains random data to seed
|
|
|
|
* the random SSL stuff with. The file is only used for reading.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.ssl.random_file = va_arg(param, char *);
|
2001-03-12 10:47:17 -05:00
|
|
|
break;
|
|
|
|
case CURLOPT_EGDSOCKET:
|
|
|
|
/*
|
|
|
|
* The Entropy Gathering Daemon socket pathname
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.ssl.egdsocket = va_arg(param, char *);
|
2001-03-12 10:47:17 -05:00
|
|
|
break;
|
2001-03-12 10:05:54 -05:00
|
|
|
case CURLOPT_MAXCONNECTS:
|
|
|
|
/*
|
|
|
|
* Set the absolute number of maximum simultaneous alive connection that
|
|
|
|
* libcurl is allowed to have.
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
long newconnects= va_arg(param, long);
|
|
|
|
struct connectdata **newptr;
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
if(newconnects < data->state.numconnects) {
|
2001-03-12 10:05:54 -05:00
|
|
|
/* Since this number is *decreased* from the existing number, we must
|
|
|
|
close the possibly open connections that live on the indexes that
|
|
|
|
are being removed! */
|
|
|
|
int i;
|
2001-08-30 18:48:34 -04:00
|
|
|
for(i=newconnects; i< data->state.numconnects; i++)
|
|
|
|
Curl_disconnect(data->state.connects[i]);
|
2001-03-12 10:05:54 -05:00
|
|
|
}
|
|
|
|
if(newconnects) {
|
2003-02-24 09:50:20 -05:00
|
|
|
int i;
|
2001-03-12 10:05:54 -05:00
|
|
|
newptr= (struct connectdata **)
|
2001-08-30 18:48:34 -04:00
|
|
|
realloc(data->state.connects,
|
2001-03-12 10:05:54 -05:00
|
|
|
sizeof(struct connectdata *) * newconnects);
|
|
|
|
if(!newptr)
|
|
|
|
/* we closed a few connections in vain, but so what? */
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
2003-02-24 09:50:20 -05:00
|
|
|
|
|
|
|
/* nullify the newly added pointers */
|
|
|
|
for(i=data->state.numconnects; i<newconnects; i++) {
|
|
|
|
newptr[i] = NULL;
|
|
|
|
}
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
data->state.connects = newptr;
|
|
|
|
data->state.numconnects = newconnects;
|
2001-03-12 10:05:54 -05:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* zero makes NO cache at all */
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->state.connects)
|
|
|
|
free(data->state.connects);
|
|
|
|
data->state.connects=NULL;
|
|
|
|
data->state.numconnects=0;
|
2001-03-12 10:05:54 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CURLOPT_FORBID_REUSE:
|
|
|
|
/*
|
|
|
|
* When this transfer is done, it must not be left to be reused by a
|
|
|
|
* subsequent transfer but shall be closed immediately.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.reuse_forbid = va_arg(param, long)?TRUE:FALSE;
|
2001-03-12 10:05:54 -05:00
|
|
|
break;
|
|
|
|
case CURLOPT_FRESH_CONNECT:
|
|
|
|
/*
|
|
|
|
* This transfer shall not use a previously cached connection but
|
|
|
|
* should be made with a fresh new connect!
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.reuse_fresh = va_arg(param, long)?TRUE:FALSE;
|
2001-03-12 10:05:54 -05:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_VERBOSE:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Verbose means infof() calls that give a lot of information about
|
|
|
|
* the connection and transfer procedures as well as internal choices.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.verbose = va_arg(param, long)?TRUE:FALSE;
|
2000-05-22 10:12:12 -04:00
|
|
|
break;
|
|
|
|
case CURLOPT_HEADER:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Set to include the header in the general data output stream.
|
|
|
|
*/
|
2004-04-13 03:37:28 -04:00
|
|
|
data->set.include_header = va_arg(param, long)?TRUE:FALSE;
|
2000-05-22 10:12:12 -04:00
|
|
|
break;
|
|
|
|
case CURLOPT_NOPROGRESS:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Shut off the internal supported progress meter
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.hide_progress = va_arg(param, long)?TRUE:FALSE;
|
|
|
|
if(data->set.hide_progress)
|
2000-05-22 10:12:12 -04:00
|
|
|
data->progress.flags |= PGRS_HIDE;
|
2001-05-30 08:51:24 -04:00
|
|
|
else
|
|
|
|
data->progress.flags &= ~PGRS_HIDE;
|
2000-05-22 10:12:12 -04:00
|
|
|
break;
|
|
|
|
case CURLOPT_NOBODY:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Do not include the body part in the output data stream.
|
|
|
|
*/
|
2004-04-06 11:14:10 -04:00
|
|
|
data->set.opt_no_body = va_arg(param, long)?TRUE:FALSE;
|
2000-05-22 10:12:12 -04:00
|
|
|
break;
|
|
|
|
case CURLOPT_FAILONERROR:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Don't output the >=300 error code HTML-page, but instead only
|
|
|
|
* return error.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.http_fail_on_error = va_arg(param, long)?TRUE:FALSE;
|
2000-05-22 10:12:12 -04:00
|
|
|
break;
|
|
|
|
case CURLOPT_UPLOAD:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* We want to sent data to the remote host
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.upload = va_arg(param, long)?TRUE:FALSE;
|
|
|
|
if(data->set.upload)
|
2001-01-29 02:23:11 -05:00
|
|
|
/* If this is HTTP, PUT is what's needed to "upload" */
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.httpreq = HTTPREQ_PUT;
|
2000-05-22 10:12:12 -04:00
|
|
|
break;
|
2000-11-22 08:50:17 -05:00
|
|
|
case CURLOPT_FILETIME:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Try to get the file time of the remote document. The time will
|
|
|
|
* later (possibly) become available using curl_easy_getinfo().
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.get_filetime = va_arg(param, long)?TRUE:FALSE;
|
2000-11-22 08:50:17 -05:00
|
|
|
break;
|
2003-08-08 05:13:19 -04:00
|
|
|
case CURLOPT_FTP_CREATE_MISSING_DIRS:
|
|
|
|
/*
|
|
|
|
* An FTP option that modifies an upload to create missing directories on
|
|
|
|
* the server.
|
|
|
|
*/
|
|
|
|
data->set.ftp_create_missing_dirs = va_arg( param , long )?TRUE:FALSE;
|
|
|
|
break;
|
2003-09-03 18:02:40 -04:00
|
|
|
case CURLOPT_FTP_RESPONSE_TIMEOUT:
|
|
|
|
/*
|
|
|
|
* An FTP option that specifies how quickly an FTP response must be
|
|
|
|
* obtained before it is considered failure.
|
|
|
|
*/
|
|
|
|
data->set.ftp_response_timeout = va_arg( param , long );
|
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_FTPLISTONLY:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* An FTP option that changes the command to one that asks for a list
|
|
|
|
* only, no file info details.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.ftp_list_only = va_arg(param, long)?TRUE:FALSE;
|
2000-05-22 10:12:12 -04:00
|
|
|
break;
|
|
|
|
case CURLOPT_FTPAPPEND:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* We want to upload and append to an existing (FTP) file.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.ftp_append = va_arg(param, long)?TRUE:FALSE;
|
2000-05-22 10:12:12 -04:00
|
|
|
break;
|
|
|
|
case CURLOPT_NETRC:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Parse the $HOME/.netrc file
|
|
|
|
*/
|
2004-02-05 04:38:56 -05:00
|
|
|
data->set.use_netrc = (enum CURL_NETRC_OPTION)va_arg(param, long);
|
2000-05-22 10:12:12 -04:00
|
|
|
break;
|
2003-11-11 09:30:43 -05:00
|
|
|
case CURLOPT_NETRC_FILE:
|
|
|
|
/*
|
|
|
|
* Use this file instead of the $HOME/.netrc file
|
|
|
|
*/
|
|
|
|
data->set.netrc_file = va_arg(param, char *);
|
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_FOLLOWLOCATION:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Follow Location: header hints on a HTTP-server.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.http_follow_location = va_arg(param, long)?TRUE:FALSE;
|
2000-05-22 10:12:12 -04:00
|
|
|
break;
|
2003-03-30 23:41:05 -05:00
|
|
|
case CURLOPT_UNRESTRICTED_AUTH:
|
|
|
|
/*
|
|
|
|
* Send authentication (user+password) when following locations, even when
|
|
|
|
* hostname changed.
|
|
|
|
*/
|
|
|
|
data->set.http_disable_hostname_check_before_authentication =
|
|
|
|
va_arg(param, long)?TRUE:FALSE;
|
|
|
|
break;
|
2001-10-09 02:52:37 -04:00
|
|
|
case CURLOPT_HTTP_VERSION:
|
|
|
|
/*
|
|
|
|
* This sets a requested HTTP version to be used. The value is one of
|
|
|
|
* the listed enums in curl/curl.h.
|
|
|
|
*/
|
|
|
|
data->set.httpversion = va_arg(param, long);
|
|
|
|
break;
|
2001-08-22 07:24:57 -04:00
|
|
|
case CURLOPT_TRANSFERTEXT:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
2001-08-22 07:24:57 -04:00
|
|
|
* This option was previously named 'FTPASCII'. Renamed to work with
|
|
|
|
* more protocols than merely FTP.
|
|
|
|
*
|
|
|
|
* Transfer using ASCII (instead of BINARY).
|
2001-03-12 10:05:54 -05:00
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.ftp_ascii = va_arg(param, long)?TRUE:FALSE;
|
2000-05-22 10:12:12 -04:00
|
|
|
break;
|
|
|
|
case CURLOPT_PUT:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
2001-08-03 07:52:53 -04:00
|
|
|
* Use the HTTP PUT request to transfer data if this is TRUE. If this is
|
|
|
|
* FALSE, don't set the httpreq. We can't know what to revert it to!
|
2001-03-12 10:05:54 -05:00
|
|
|
*/
|
2001-08-03 07:52:53 -04:00
|
|
|
if(va_arg(param, long))
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.httpreq = HTTPREQ_PUT;
|
2000-05-22 10:12:12 -04:00
|
|
|
break;
|
|
|
|
case CURLOPT_TIMECONDITION:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Set HTTP time condition. This must be one of the defines in the
|
|
|
|
* curl/curl.h header file.
|
|
|
|
*/
|
2004-02-05 04:38:56 -05:00
|
|
|
data->set.timecondition = (curl_TimeCond)va_arg(param, long);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_TIMEVALUE:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* This is the value to compare with the remote document with the
|
|
|
|
* method set with CURLOPT_TIMECONDITION
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.timevalue = va_arg(param, long);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_SSLVERSION:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Set explicit SSL version to try to connect with, as some SSL
|
|
|
|
* implementations are lame.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.ssl.version = va_arg(param, long);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
|
|
|
|
2002-05-07 05:58:13 -04:00
|
|
|
case CURLOPT_COOKIESESSION:
|
|
|
|
/*
|
|
|
|
* Set this option to TRUE to start a new "cookie session". It will
|
|
|
|
* prevent the forthcoming read-cookies-from-file actions to accept
|
|
|
|
* cookies that are marked as being session cookies, as they belong to a
|
|
|
|
* previous session.
|
|
|
|
*
|
|
|
|
* In the original Netscape cookie spec, "session cookies" are cookies
|
|
|
|
* with no expire date set. RFC2109 describes the same action if no
|
|
|
|
* 'Max-Age' is set and RFC2965 includes the RFC2109 description and adds
|
|
|
|
* a 'Discard' action that can enforce the discard even for cookies that
|
|
|
|
* have a Max-Age.
|
|
|
|
*
|
|
|
|
* We run mostly with the original cookie spec, as hardly anyone implements
|
|
|
|
* anything else.
|
|
|
|
*/
|
|
|
|
data->set.cookiesession = (bool)va_arg(param, long);
|
|
|
|
break;
|
|
|
|
|
2002-06-11 07:13:01 -04:00
|
|
|
#ifndef CURL_DISABLE_HTTP
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_COOKIEFILE:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
2001-08-29 05:32:18 -04:00
|
|
|
* Set cookie file to read and parse. Can be used multiple times.
|
2001-03-12 10:05:54 -05:00
|
|
|
*/
|
2000-04-11 17:47:28 -04:00
|
|
|
cookiefile = (char *)va_arg(param, void *);
|
2004-05-12 09:05:01 -04:00
|
|
|
if(cookiefile) {
|
|
|
|
struct curl_slist *cl;
|
2002-10-17 03:10:39 -04:00
|
|
|
/* append the cookie file name to the list of file names, and deal with
|
|
|
|
them later */
|
2004-05-12 09:05:01 -04:00
|
|
|
cl = curl_slist_append(data->change.cookielist, cookiefile);
|
|
|
|
|
|
|
|
if(!cl)
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
data->change.cookielist = cl;
|
|
|
|
}
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2001-08-29 05:32:18 -04:00
|
|
|
|
|
|
|
case CURLOPT_COOKIEJAR:
|
|
|
|
/*
|
|
|
|
* Set cookie file name to dump all cookies to when we're done.
|
|
|
|
*/
|
2001-10-10 08:48:32 -04:00
|
|
|
data->set.cookiejar = (char *)va_arg(param, void *);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Activate the cookie parser. This may or may not already
|
|
|
|
* have been made.
|
|
|
|
*/
|
2003-08-11 05:56:06 -04:00
|
|
|
data->cookies = Curl_cookie_init(data, NULL, data->cookies,
|
2002-05-07 05:58:13 -04:00
|
|
|
data->set.cookiesession);
|
2001-08-29 05:32:18 -04:00
|
|
|
break;
|
2002-06-11 07:13:01 -04:00
|
|
|
#endif
|
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_WRITEHEADER:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
2001-08-06 04:18:15 -04:00
|
|
|
* Custom pointer to pass the header write callback function
|
2001-03-12 10:05:54 -05:00
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.writeheader = (void *)va_arg(param, void *);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_COOKIE:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Cookie string to send to the remote server in the request.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.cookie = va_arg(param, char *);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_ERRORBUFFER:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Error buffer provided by the caller to get the human readable
|
|
|
|
* error string in.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.errorbuffer = va_arg(param, char *);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_FILE:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* FILE pointer to write to or include in the data write callback
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.out = va_arg(param, FILE *);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_FTPPORT:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Use FTP PORT, this also specifies which IP address to use
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.ftpport = va_arg(param, char *);
|
|
|
|
data->set.ftp_use_port = data->set.ftpport?1:0;
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2001-11-28 18:20:14 -05:00
|
|
|
|
2003-05-09 03:39:29 -04:00
|
|
|
case CURLOPT_FTP_USE_EPRT:
|
|
|
|
data->set.ftp_use_eprt = va_arg(param, long)?TRUE:FALSE;
|
|
|
|
break;
|
|
|
|
|
2001-11-28 18:20:14 -05:00
|
|
|
case CURLOPT_FTP_USE_EPSV:
|
|
|
|
data->set.ftp_use_epsv = va_arg(param, long)?TRUE:FALSE;
|
|
|
|
break;
|
2003-05-09 03:39:29 -04:00
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_HTTPHEADER:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Set a list with HTTP headers to use (or replace internals with)
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.headers = va_arg(param, struct curl_slist *);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_CUSTOMREQUEST:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Set a custom string to use as request
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.customrequest = va_arg(param, char *);
|
2002-01-28 14:31:26 -05:00
|
|
|
|
|
|
|
/* we don't set
|
|
|
|
data->set.httpreq = HTTPREQ_CUSTOM;
|
|
|
|
here, we continue as if we were using the already set type
|
|
|
|
and this just changes the actual request keyword */
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_HTTPPOST:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Set to make us do HTTP POST
|
|
|
|
*/
|
2004-01-22 06:54:00 -05:00
|
|
|
data->set.httppost = va_arg(param, struct curl_httppost *);
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->set.httppost)
|
|
|
|
data->set.httpreq = HTTPREQ_POST_FORM;
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2001-08-03 07:52:53 -04:00
|
|
|
|
|
|
|
case CURLOPT_HTTPGET:
|
|
|
|
/*
|
|
|
|
* Set to force us do HTTP GET
|
|
|
|
*/
|
2001-12-05 01:47:01 -05:00
|
|
|
if(va_arg(param, long)) {
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.httpreq = HTTPREQ_GET;
|
2001-12-05 01:47:01 -05:00
|
|
|
data->set.upload = FALSE; /* switch off upload */
|
|
|
|
}
|
2001-08-03 07:52:53 -04:00
|
|
|
break;
|
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_INFILE:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* FILE pointer to read the file to be uploaded from. Or possibly
|
|
|
|
* used as argument to the read callback.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.in = va_arg(param, FILE *);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_INFILESIZE:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* If known, this should inform curl about the file size of the
|
|
|
|
* to-be-uploaded file.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.infilesize = va_arg(param, long);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2004-01-05 17:29:29 -05:00
|
|
|
case CURLOPT_INFILESIZE_LARGE:
|
|
|
|
/*
|
|
|
|
* If known, this should inform curl about the file size of the
|
|
|
|
* to-be-uploaded file.
|
|
|
|
*/
|
2004-01-22 07:45:50 -05:00
|
|
|
data->set.infilesize = va_arg(param, curl_off_t);
|
2004-01-05 17:29:29 -05:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_LOW_SPEED_LIMIT:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* The low speed limit that if transfers are below this for
|
|
|
|
* CURLOPT_LOW_SPEED_TIME, the transfer is aborted.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.low_speed_limit=va_arg(param, long);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_LOW_SPEED_TIME:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* The low speed time that if transfers are below the set
|
|
|
|
* CURLOPT_LOW_SPEED_LIMIT during this time, the transfer is aborted.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.low_speed_time=va_arg(param, long);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_URL:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* The URL to fetch.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->change.url_alloc) {
|
2001-08-23 10:06:38 -04:00
|
|
|
/* the already set URL is allocated, free it first! */
|
2001-08-30 18:48:34 -04:00
|
|
|
free(data->change.url);
|
|
|
|
data->change.url_alloc=FALSE;
|
2001-08-23 10:06:38 -04:00
|
|
|
}
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.set_url = va_arg(param, char *);
|
|
|
|
data->change.url = data->set.set_url;
|
2003-07-04 12:29:23 -04:00
|
|
|
data->change.url_changed = TRUE;
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_PORT:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* The port number to use when getting the URL
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.use_port = va_arg(param, long);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2001-02-19 04:29:19 -05:00
|
|
|
case CURLOPT_POST:
|
2002-03-14 09:37:16 -05:00
|
|
|
/* Does this option serve a purpose anymore? Yes it does, when
|
|
|
|
CURLOPT_POSTFIELDS isn't used and the POST data is read off the
|
|
|
|
callback! */
|
2001-08-03 07:52:53 -04:00
|
|
|
if(va_arg(param, long))
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.httpreq = HTTPREQ_POST;
|
2001-02-19 04:29:19 -05:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_POSTFIELDS:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* A string with POST data. Makes curl HTTP POST.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.postfields = va_arg(param, char *);
|
|
|
|
if(data->set.postfields)
|
|
|
|
data->set.httpreq = HTTPREQ_POST;
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-08-24 08:33:16 -04:00
|
|
|
case CURLOPT_POSTFIELDSIZE:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
2004-03-12 03:55:47 -05:00
|
|
|
* The size of the POSTFIELD data to prevent libcurl to do strlen() to
|
|
|
|
* figure it out. Enables binary posts.
|
2001-03-12 10:05:54 -05:00
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.postfieldsize = va_arg(param, long);
|
2000-08-24 08:33:16 -04:00
|
|
|
break;
|
2004-03-12 03:55:47 -05:00
|
|
|
case CURLOPT_POSTFIELDSIZE_LARGE:
|
|
|
|
/*
|
|
|
|
* The size of the POSTFIELD data to prevent libcurl to do strlen() to
|
|
|
|
* figure it out. Enables binary posts.
|
|
|
|
*/
|
|
|
|
data->set.postfieldsize = va_arg(param, curl_off_t);
|
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_REFERER:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* String to set in the HTTP Referer: field.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->change.referer_alloc) {
|
|
|
|
free(data->change.referer);
|
|
|
|
data->change.referer_alloc = FALSE;
|
|
|
|
}
|
|
|
|
data->set.set_referer = va_arg(param, char *);
|
|
|
|
data->change.referer = data->set.set_referer;
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-06-20 05:28:09 -04:00
|
|
|
case CURLOPT_AUTOREFERER:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Switch on automatic referer that gets set if curl follows locations.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.http_auto_referer = va_arg(param, long)?1:0;
|
2000-06-20 05:28:09 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_PROXY:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
2002-09-27 05:49:40 -04:00
|
|
|
* Set proxy server:port to use as HTTP proxy.
|
|
|
|
*
|
|
|
|
* If the proxy is set to "" we explicitly say that we don't want to use a
|
|
|
|
* proxy (even though there might be environment variables saying so).
|
|
|
|
*
|
|
|
|
* Setting it to NULL, means no proxy but allows the environment variables
|
|
|
|
* to decide for us.
|
2001-03-12 10:05:54 -05:00
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->change.proxy_alloc) {
|
2001-08-23 10:06:38 -04:00
|
|
|
/*
|
|
|
|
* The already set string is allocated, free that first
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->change.proxy_alloc=FALSE;;
|
|
|
|
free(data->change.proxy);
|
2001-08-23 10:06:38 -04:00
|
|
|
}
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.set_proxy = va_arg(param, char *);
|
|
|
|
data->change.proxy = data->set.set_proxy;
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-09-14 10:05:01 -04:00
|
|
|
case CURLOPT_HTTPPROXYTUNNEL:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Tunnel operations through the proxy instead of normal proxy use
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.tunnel_thru_httpproxy = va_arg(param, long)?TRUE:FALSE;
|
2000-09-14 10:05:01 -04:00
|
|
|
break;
|
2000-07-25 03:31:35 -04:00
|
|
|
case CURLOPT_PROXYPORT:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Explicitly set HTTP proxy port number.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.proxyport = va_arg(param, long);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_TIMEOUT:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* The maximum time you allow curl to use for a single transfer
|
|
|
|
* operation.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.timeout = va_arg(param, long);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2001-03-15 09:38:30 -05:00
|
|
|
case CURLOPT_CONNECTTIMEOUT:
|
|
|
|
/*
|
|
|
|
* The maximum time you allow curl to use to connect.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.connecttimeout = va_arg(param, long);
|
2001-03-15 09:38:30 -05:00
|
|
|
break;
|
2000-11-28 04:05:47 -05:00
|
|
|
case CURLOPT_MAXREDIRS:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* The maximum amount of hops you allow curl to follow Location:
|
|
|
|
* headers. This should mostly be used to detect never-ending loops.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.maxredirs = va_arg(param, long);
|
2000-11-28 04:05:47 -05:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_USERAGENT:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* String to use in the HTTP User-Agent field
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.useragent = va_arg(param, char *);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2002-09-02 18:31:18 -04:00
|
|
|
case CURLOPT_ENCODING:
|
|
|
|
/*
|
2004-05-12 03:56:01 -04:00
|
|
|
* String to use at the value of Accept-Encoding header.
|
2003-05-12 08:45:14 -04:00
|
|
|
*
|
|
|
|
* If the encoding is set to "" we use an Accept-Encoding header that
|
|
|
|
* encompasses all the encodings we support.
|
|
|
|
* If the encoding is set to NULL we don't send an Accept-Encoding header
|
|
|
|
* and ignore an received Content-Encoding header.
|
|
|
|
*
|
2002-09-02 18:31:18 -04:00
|
|
|
*/
|
|
|
|
data->set.encoding = va_arg(param, char *);
|
2003-05-12 08:45:14 -04:00
|
|
|
if(data->set.encoding && !*data->set.encoding)
|
|
|
|
data->set.encoding = (char*)ALL_CONTENT_ENCODINGS;
|
2002-09-02 18:31:18 -04:00
|
|
|
break;
|
|
|
|
|
2003-06-10 08:49:16 -04:00
|
|
|
case CURLOPT_HTTPAUTH:
|
|
|
|
/*
|
2003-06-26 07:30:59 -04:00
|
|
|
* Set HTTP Authentication type BITMASK.
|
2003-06-10 08:49:16 -04:00
|
|
|
*/
|
|
|
|
{
|
2003-06-26 07:30:59 -04:00
|
|
|
long auth = va_arg(param, long);
|
|
|
|
/* switch off bits we can't support */
|
|
|
|
#ifndef USE_SSLEAY
|
|
|
|
auth &= ~CURLAUTH_NTLM; /* no NTLM without SSL */
|
2003-06-11 09:38:55 -04:00
|
|
|
#endif
|
2003-09-19 08:56:22 -04:00
|
|
|
#ifndef HAVE_GSSAPI
|
2003-06-26 07:30:59 -04:00
|
|
|
auth &= ~CURLAUTH_GSSNEGOTIATE; /* no GSS-Negotiate without GSSAPI */
|
2003-06-10 08:22:19 -04:00
|
|
|
#endif
|
2003-06-26 07:30:59 -04:00
|
|
|
if(!auth)
|
|
|
|
return CURLE_FAILED_INIT; /* no supported types left! */
|
|
|
|
|
|
|
|
data->set.httpauth = auth;
|
2003-06-10 08:49:16 -04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2003-08-11 07:47:45 -04:00
|
|
|
case CURLOPT_PROXYAUTH:
|
|
|
|
/*
|
|
|
|
* Set HTTP Authentication type BITMASK.
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
long auth = va_arg(param, long);
|
|
|
|
/* switch off bits we can't support */
|
|
|
|
#ifndef USE_SSLEAY
|
|
|
|
auth &= ~CURLAUTH_NTLM; /* no NTLM without SSL */
|
|
|
|
#endif
|
2003-09-19 08:56:22 -04:00
|
|
|
#ifndef HAVE_GSSAPI
|
2003-08-11 07:47:45 -04:00
|
|
|
auth &= ~CURLAUTH_GSSNEGOTIATE; /* no GSS-Negotiate without GSSAPI */
|
|
|
|
#endif
|
|
|
|
if(!auth)
|
|
|
|
return CURLE_FAILED_INIT; /* no supported types left! */
|
|
|
|
|
|
|
|
data->set.proxyauth = auth;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_USERPWD:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* user:password to use in the operation
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.userpwd = va_arg(param, char *);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_POSTQUOTE:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
2003-03-25 09:23:12 -05:00
|
|
|
* List of RAW FTP commands to use after a transfer
|
2001-03-12 10:05:54 -05:00
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.postquote = va_arg(param, struct curl_slist *);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2002-02-28 18:31:23 -05:00
|
|
|
case CURLOPT_PREQUOTE:
|
|
|
|
/*
|
|
|
|
* List of RAW FTP commands to use prior to RETR (Wesley Laxton)
|
|
|
|
*/
|
|
|
|
data->set.prequote = va_arg(param, struct curl_slist *);
|
|
|
|
break;
|
2001-03-12 10:05:54 -05:00
|
|
|
case CURLOPT_QUOTE:
|
|
|
|
/*
|
2003-03-25 09:23:12 -05:00
|
|
|
* List of RAW FTP commands to use before a transfer
|
2001-03-12 10:05:54 -05:00
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.quote = va_arg(param, struct curl_slist *);
|
2001-03-12 10:05:54 -05:00
|
|
|
break;
|
2000-06-08 11:11:39 -04:00
|
|
|
case CURLOPT_PROGRESSFUNCTION:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Progress callback function
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.fprogress = va_arg(param, curl_progress_callback);
|
2002-03-13 08:10:52 -05:00
|
|
|
if(data->set.fprogress)
|
|
|
|
data->progress.callback = TRUE; /* no longer internal */
|
|
|
|
else
|
|
|
|
data->progress.callback = FALSE; /* NULL enforces internal */
|
|
|
|
|
2000-06-08 11:11:39 -04:00
|
|
|
break;
|
|
|
|
case CURLOPT_PROGRESSDATA:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Custom client data to pass to the progress callback
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.progress_client = va_arg(param, void *);
|
2000-06-08 11:11:39 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_PROXYUSERPWD:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* user:password needed to use the proxy
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.proxyuserpwd = va_arg(param, char *);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_RANGE:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* What range of the file you want to transfer
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.set_range = va_arg(param, char *);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_RESUME_FROM:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Resume transfer at the give file position
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.set_resume_from = va_arg(param, long);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2004-01-05 17:29:29 -05:00
|
|
|
case CURLOPT_RESUME_FROM_LARGE:
|
|
|
|
/*
|
|
|
|
* Resume transfer at the give file position
|
|
|
|
*/
|
2004-01-22 07:45:50 -05:00
|
|
|
data->set.set_resume_from = va_arg(param, curl_off_t);
|
2004-01-05 17:29:29 -05:00
|
|
|
break;
|
2002-04-12 03:21:11 -04:00
|
|
|
case CURLOPT_DEBUGFUNCTION:
|
|
|
|
/*
|
|
|
|
* stderr write callback.
|
|
|
|
*/
|
|
|
|
data->set.fdebug = va_arg(param, curl_debug_callback);
|
|
|
|
/*
|
|
|
|
* if the callback provided is NULL, it'll use the default callback
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
case CURLOPT_DEBUGDATA:
|
|
|
|
/*
|
|
|
|
* Set to a void * that should receive all error writes. This
|
|
|
|
* defaults to CURLOPT_STDERR for normal operations.
|
|
|
|
*/
|
|
|
|
data->set.debugdata = va_arg(param, void *);
|
2002-05-06 14:30:17 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_STDERR:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Set to a FILE * that should receive all error writes. This
|
|
|
|
* defaults to stderr for normal operations.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.err = va_arg(param, FILE *);
|
2002-04-12 03:21:11 -04:00
|
|
|
if(!data->set.err)
|
|
|
|
data->set.err = stderr;
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2001-04-10 02:51:25 -04:00
|
|
|
case CURLOPT_HEADERFUNCTION:
|
|
|
|
/*
|
|
|
|
* Set header write callback
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.fwrite_header = va_arg(param, curl_write_callback);
|
2001-04-10 02:51:25 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_WRITEFUNCTION:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Set data write callback
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.fwrite = va_arg(param, curl_write_callback);
|
2003-08-17 09:32:37 -04:00
|
|
|
if(!data->set.fwrite)
|
|
|
|
/* When set to NULL, reset to our internal default function */
|
|
|
|
data->set.fwrite = (curl_write_callback)fwrite;
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_READFUNCTION:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Read data callback
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.fread = va_arg(param, curl_read_callback);
|
2003-08-17 09:32:37 -04:00
|
|
|
if(!data->set.fread)
|
|
|
|
/* When set to NULL, reset to our internal default function */
|
|
|
|
data->set.fread = (curl_read_callback)fread;
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_SSLCERT:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* String that holds file name of the SSL certificate to use
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.cert = va_arg(param, char *);
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2001-12-17 18:01:39 -05:00
|
|
|
case CURLOPT_SSLCERTTYPE:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
2001-12-17 18:01:39 -05:00
|
|
|
* String that holds file type of the SSL certificate to use
|
2001-03-12 10:05:54 -05:00
|
|
|
*/
|
2001-12-17 18:01:39 -05:00
|
|
|
data->set.cert_type = va_arg(param, char *);
|
|
|
|
break;
|
|
|
|
case CURLOPT_SSLKEY:
|
|
|
|
/*
|
|
|
|
* String that holds file name of the SSL certificate to use
|
|
|
|
*/
|
|
|
|
data->set.key = va_arg(param, char *);
|
|
|
|
break;
|
|
|
|
case CURLOPT_SSLKEYTYPE:
|
|
|
|
/*
|
|
|
|
* String that holds file type of the SSL certificate to use
|
|
|
|
*/
|
|
|
|
data->set.key_type = va_arg(param, char *);
|
|
|
|
break;
|
|
|
|
case CURLOPT_SSLKEYPASSWD:
|
|
|
|
/*
|
|
|
|
* String that holds the SSL private key password.
|
|
|
|
*/
|
|
|
|
data->set.key_passwd = va_arg(param, char *);
|
|
|
|
break;
|
|
|
|
case CURLOPT_SSLENGINE:
|
|
|
|
/*
|
|
|
|
* String that holds the SSL crypto engine.
|
|
|
|
*/
|
|
|
|
#ifdef HAVE_OPENSSL_ENGINE_H
|
|
|
|
{
|
|
|
|
const char *cpTemp = va_arg(param, char *);
|
|
|
|
ENGINE *e;
|
|
|
|
if (cpTemp && cpTemp[0]) {
|
|
|
|
e = ENGINE_by_id(cpTemp);
|
|
|
|
if (e) {
|
|
|
|
if (data->engine) {
|
|
|
|
ENGINE_free(data->engine);
|
|
|
|
}
|
|
|
|
data->engine = e;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
failf(data, "SSL Engine '%s' not found", cpTemp);
|
|
|
|
return CURLE_SSL_ENGINE_NOTFOUND;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2004-02-05 04:38:56 -05:00
|
|
|
break;
|
2001-12-17 18:01:39 -05:00
|
|
|
#else
|
|
|
|
return CURLE_SSL_ENGINE_NOTFOUND;
|
|
|
|
#endif
|
|
|
|
case CURLOPT_SSLENGINE_DEFAULT:
|
|
|
|
/*
|
|
|
|
* flag to set engine as default.
|
|
|
|
*/
|
|
|
|
#ifdef HAVE_OPENSSL_ENGINE_H
|
|
|
|
if (data->engine) {
|
|
|
|
if (ENGINE_set_default(data->engine, ENGINE_METHOD_ALL) > 0) {
|
|
|
|
#ifdef DEBUG
|
|
|
|
fprintf(stderr,"set default crypto engine\n");
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
#ifdef DEBUG
|
|
|
|
failf(data, "set default crypto engine failed");
|
|
|
|
#endif
|
|
|
|
return CURLE_SSL_ENGINE_SETFAILED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-05-22 10:12:12 -04:00
|
|
|
case CURLOPT_CRLF:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
2001-08-30 18:48:34 -04:00
|
|
|
* Kludgy option to enable CRLF convertions. Subject for removal.
|
2001-03-12 10:05:54 -05:00
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.crlf = va_arg(param, long)?TRUE:FALSE;
|
2000-04-11 17:47:28 -04:00
|
|
|
break;
|
2000-09-18 17:54:08 -04:00
|
|
|
case CURLOPT_INTERFACE:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Set what interface to bind to when performing an operation and thus
|
|
|
|
* what from-IP your connection will use.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.device = va_arg(param, char *);
|
2000-09-18 17:54:08 -04:00
|
|
|
break;
|
2000-09-21 04:50:05 -04:00
|
|
|
case CURLOPT_KRB4LEVEL:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* A string that defines the krb4 security level.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.krb4_level = va_arg(param, char *);
|
|
|
|
data->set.krb4=data->set.krb4_level?TRUE:FALSE;
|
2000-09-21 04:50:05 -04:00
|
|
|
break;
|
2000-10-30 06:53:40 -05:00
|
|
|
case CURLOPT_SSL_VERIFYPEER:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Enable peer SSL verifying.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.ssl.verifypeer = va_arg(param, long);
|
2000-10-30 06:53:40 -05:00
|
|
|
break;
|
2001-08-08 03:16:47 -04:00
|
|
|
case CURLOPT_SSL_VERIFYHOST:
|
|
|
|
/*
|
|
|
|
* Enable verification of the CN contained in the peer certificate
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.ssl.verifyhost = va_arg(param, long);
|
2001-08-08 03:16:47 -04:00
|
|
|
break;
|
2003-07-04 12:29:23 -04:00
|
|
|
case CURLOPT_SSL_CTX_FUNCTION:
|
|
|
|
/*
|
|
|
|
* Set a SSL_CTX callback
|
|
|
|
*/
|
|
|
|
data->set.ssl.fsslctx = va_arg(param, curl_ssl_ctx_callback);
|
|
|
|
break;
|
|
|
|
case CURLOPT_SSL_CTX_DATA:
|
|
|
|
/*
|
|
|
|
* Set a SSL_CTX callback parameter pointer
|
|
|
|
*/
|
|
|
|
data->set.ssl.fsslctxp = va_arg(param, void *);
|
|
|
|
break;
|
2000-10-30 06:53:40 -05:00
|
|
|
case CURLOPT_CAINFO:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Set CA info for SSL connection. Specify file name of the CA certificate
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.ssl.CAfile = va_arg(param, char *);
|
2002-05-28 05:21:29 -04:00
|
|
|
break;
|
|
|
|
case CURLOPT_CAPATH:
|
|
|
|
/*
|
2002-08-26 19:13:25 -04:00
|
|
|
* Set CA path info for SSL connection. Specify directory name of the CA
|
|
|
|
* certificates which have been prepared using openssl c_rehash utility.
|
2002-05-28 05:21:29 -04:00
|
|
|
*/
|
2002-08-26 19:13:25 -04:00
|
|
|
/* This does not work on windows. */
|
|
|
|
data->set.ssl.CApath = va_arg(param, char *);
|
2000-10-30 06:53:40 -05:00
|
|
|
break;
|
2001-02-20 12:35:51 -05:00
|
|
|
case CURLOPT_TELNETOPTIONS:
|
2001-03-12 10:05:54 -05:00
|
|
|
/*
|
|
|
|
* Set a linked list of telnet options
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.telnet_options = va_arg(param, struct curl_slist *);
|
2001-02-20 12:35:51 -05:00
|
|
|
break;
|
2002-06-15 17:00:54 -04:00
|
|
|
|
|
|
|
case CURLOPT_BUFFERSIZE:
|
|
|
|
/*
|
|
|
|
* The application kindly asks for a differently sized receive buffer.
|
|
|
|
* If it seems reasonable, we'll use it.
|
|
|
|
*/
|
|
|
|
data->set.buffer_size = va_arg(param, long);
|
|
|
|
|
2003-08-28 07:28:55 -04:00
|
|
|
if((data->set.buffer_size> (BUFSIZE -1 )) ||
|
|
|
|
(data->set.buffer_size < 1))
|
2002-06-15 17:00:54 -04:00
|
|
|
data->set.buffer_size = 0; /* huge internal default */
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
2002-08-08 18:52:50 -04:00
|
|
|
case CURLOPT_NOSIGNAL:
|
|
|
|
/*
|
|
|
|
* The application asks not to set any signal() or alarm() handlers,
|
|
|
|
* even when using a timeout.
|
|
|
|
*/
|
|
|
|
data->set.no_signal = va_arg(param, long) ? TRUE : FALSE;
|
|
|
|
break;
|
|
|
|
|
2002-08-13 10:20:47 -04:00
|
|
|
case CURLOPT_SHARE:
|
|
|
|
{
|
2003-01-08 10:50:52 -05:00
|
|
|
struct Curl_share *set;
|
|
|
|
set = va_arg(param, struct Curl_share *);
|
2003-08-04 11:02:42 -04:00
|
|
|
|
|
|
|
/* disconnect from old share, if any */
|
|
|
|
if(data->share) {
|
2003-02-04 18:48:46 -05:00
|
|
|
Curl_share_lock(data, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE);
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2003-02-04 18:48:46 -05:00
|
|
|
if(data->share->hostcache == data->hostcache)
|
|
|
|
data->hostcache = NULL;
|
2003-08-04 11:02:42 -04:00
|
|
|
|
|
|
|
if(data->share->cookies == data->cookies)
|
|
|
|
data->cookies = NULL;
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2002-08-13 10:20:47 -04:00
|
|
|
data->share->dirty--;
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2003-02-04 18:48:46 -05:00
|
|
|
Curl_share_unlock(data, CURL_LOCK_DATA_SHARE);
|
2003-08-04 11:02:42 -04:00
|
|
|
data->share = NULL;
|
2003-02-04 18:48:46 -05:00
|
|
|
}
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2003-08-04 11:02:42 -04:00
|
|
|
/* use new share if it set */
|
2002-08-13 10:20:47 -04:00
|
|
|
data->share = set;
|
2003-08-04 11:02:42 -04:00
|
|
|
if(data->share) {
|
|
|
|
|
|
|
|
Curl_share_lock(data, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE);
|
2003-02-04 18:48:46 -05:00
|
|
|
|
2003-08-04 11:02:42 -04:00
|
|
|
data->share->dirty++;
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2003-08-04 11:02:42 -04:00
|
|
|
if(data->share->hostcache) {
|
|
|
|
/* use shared host cache, first free own one if any */
|
|
|
|
if(data->hostcache)
|
|
|
|
Curl_hash_destroy(data->hostcache);
|
2003-02-04 18:48:46 -05:00
|
|
|
|
2003-08-04 11:02:42 -04:00
|
|
|
data->hostcache = data->share->hostcache;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(data->share->cookies) {
|
|
|
|
/* use shared cookie list, first free own one if any */
|
|
|
|
if (data->cookies)
|
|
|
|
Curl_cookie_cleanup(data->cookies);
|
|
|
|
data->cookies = data->share->cookies;
|
|
|
|
}
|
|
|
|
|
|
|
|
Curl_share_unlock(data, CURL_LOCK_DATA_SHARE);
|
|
|
|
|
2003-02-04 18:48:46 -05:00
|
|
|
}
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2003-08-04 11:02:42 -04:00
|
|
|
/* check cookie list is set */
|
|
|
|
if(!data->cookies)
|
2003-08-11 05:56:06 -04:00
|
|
|
data->cookies = Curl_cookie_init(data, NULL, NULL, TRUE );
|
2003-08-04 11:02:42 -04:00
|
|
|
|
|
|
|
/* check for host cache not needed,
|
|
|
|
* it will be done by curl_easy_perform */
|
2002-08-13 10:20:47 -04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2002-08-30 05:20:11 -04:00
|
|
|
case CURLOPT_PROXYTYPE:
|
|
|
|
/*
|
|
|
|
* Set proxy type. HTTP/SOCKS4/SOCKS5
|
|
|
|
*/
|
2004-02-05 04:38:56 -05:00
|
|
|
data->set.proxytype = (curl_proxytype)va_arg(param, long);
|
2002-08-30 05:20:11 -04:00
|
|
|
break;
|
|
|
|
|
2002-11-20 14:11:22 -05:00
|
|
|
case CURLOPT_PRIVATE:
|
|
|
|
/*
|
|
|
|
* Set private data pointer.
|
|
|
|
*/
|
|
|
|
data->set.private = va_arg(param, char *);
|
|
|
|
break;
|
|
|
|
|
2003-01-07 11:15:53 -05:00
|
|
|
case CURLOPT_HTTP200ALIASES:
|
|
|
|
/*
|
|
|
|
* Set a list of aliases for HTTP 200 in response header
|
|
|
|
*/
|
|
|
|
data->set.http200aliases = va_arg(param, struct curl_slist *);
|
|
|
|
break;
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2003-10-17 09:11:00 -04:00
|
|
|
case CURLOPT_MAXFILESIZE:
|
|
|
|
/*
|
|
|
|
* Set the maximum size of a file to download.
|
|
|
|
*/
|
|
|
|
data->set.max_filesize = va_arg(param, long);
|
|
|
|
break;
|
|
|
|
|
2003-11-24 02:15:37 -05:00
|
|
|
case CURLOPT_FTP_SSL:
|
|
|
|
/*
|
|
|
|
* Make FTP transfers attempt to use SSL/TLS.
|
|
|
|
*/
|
2004-02-05 04:38:56 -05:00
|
|
|
data->set.ftp_ssl = (curl_ftpssl)va_arg(param, long);
|
2003-11-24 02:15:37 -05:00
|
|
|
break;
|
|
|
|
|
2003-12-19 03:10:09 -05:00
|
|
|
case CURLOPT_IPRESOLVE:
|
|
|
|
data->set.ip_version = va_arg(param, long);
|
|
|
|
break;
|
|
|
|
|
2004-01-05 17:29:29 -05:00
|
|
|
case CURLOPT_MAXFILESIZE_LARGE:
|
|
|
|
/*
|
|
|
|
* Set the maximum size of a file to download.
|
|
|
|
*/
|
2004-01-22 07:45:50 -05:00
|
|
|
data->set.max_filesize = va_arg(param, curl_off_t);
|
2004-01-05 17:29:29 -05:00
|
|
|
break;
|
|
|
|
|
2004-03-25 08:37:18 -05:00
|
|
|
case CURLOPT_TCP_NODELAY:
|
|
|
|
/*
|
|
|
|
* Enable or disable TCP_NODELAY, which will disable/enable the Nagle
|
|
|
|
* algorithm
|
|
|
|
*/
|
2004-04-13 06:42:32 -04:00
|
|
|
data->set.tcp_nodelay = (bool)va_arg(param, long);
|
2004-03-25 08:37:18 -05:00
|
|
|
break;
|
|
|
|
|
2000-04-11 17:47:28 -04:00
|
|
|
default:
|
|
|
|
/* unknown tag and its companion, just ignore: */
|
2002-04-10 09:44:42 -04:00
|
|
|
return CURLE_FAILED_INIT; /* correct this */
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_OK;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
|
2001-03-09 10:18:25 -05:00
|
|
|
CURLcode Curl_disconnect(struct connectdata *conn)
|
2000-05-22 10:12:12 -04:00
|
|
|
{
|
2004-05-04 03:52:53 -04:00
|
|
|
struct SessionHandle *data;
|
2001-03-12 10:05:54 -05:00
|
|
|
if(!conn)
|
|
|
|
return CURLE_OK; /* this is closed and fine already */
|
|
|
|
|
2004-05-04 03:52:53 -04:00
|
|
|
data = conn->data;
|
|
|
|
|
2001-04-18 03:25:11 -04:00
|
|
|
/*
|
|
|
|
* The range string is usually freed in curl_done(), but we might
|
|
|
|
* get here *instead* if we fail prematurely. Thus we need to be able
|
|
|
|
* to free this resource here as well.
|
|
|
|
*/
|
|
|
|
if(conn->bits.rangestringalloc) {
|
|
|
|
free(conn->range);
|
|
|
|
conn->bits.rangestringalloc = FALSE;
|
|
|
|
}
|
|
|
|
|
2003-09-15 18:33:18 -04:00
|
|
|
if((conn->ntlm.state != NTLMSTATE_NONE) ||
|
2004-05-04 03:52:53 -04:00
|
|
|
(conn->proxyntlm.state != NTLMSTATE_NONE)) {
|
2003-09-15 18:33:18 -04:00
|
|
|
/* Authentication data is a mix of connection-related and sessionhandle-
|
|
|
|
related stuff. NTLM is connection-related so when we close the shop
|
|
|
|
we shall forget. */
|
2004-05-04 03:52:53 -04:00
|
|
|
data->state.authhost.done = FALSE;
|
|
|
|
data->state.authhost.picked =
|
|
|
|
data->state.authhost.want;
|
|
|
|
|
|
|
|
data->state.authproxy.done = FALSE;
|
|
|
|
data->state.authproxy.picked =
|
|
|
|
data->state.authhost.want;
|
|
|
|
|
|
|
|
data->state.authproblem = FALSE;
|
|
|
|
}
|
2003-09-15 18:33:18 -04:00
|
|
|
|
2004-03-01 02:19:26 -05:00
|
|
|
if(conn->curl_disconnect)
|
|
|
|
/* This is set if protocol-specific cleanups should be made */
|
|
|
|
conn->curl_disconnect(conn);
|
|
|
|
|
2001-03-14 13:18:02 -05:00
|
|
|
if(-1 != conn->connectindex) {
|
2001-03-12 05:13:42 -05:00
|
|
|
/* unlink ourselves! */
|
2004-05-04 03:52:53 -04:00
|
|
|
infof(data, "Closing connection #%d\n", conn->connectindex);
|
|
|
|
data->state.connects[conn->connectindex] = NULL;
|
2001-03-14 13:18:02 -05:00
|
|
|
}
|
2001-03-12 05:13:42 -05:00
|
|
|
|
2003-07-21 09:16:30 -04:00
|
|
|
Curl_safefree(conn->proto.generic);
|
|
|
|
Curl_safefree(conn->newurl);
|
2004-04-20 03:53:24 -04:00
|
|
|
Curl_safefree(conn->pathbuffer); /* the URL path buffer */
|
2004-04-27 09:56:23 -04:00
|
|
|
|
|
|
|
Curl_safefree(conn->host.rawalloc); /* host name buffer */
|
|
|
|
Curl_safefree(conn->proxy.rawalloc); /* proxy name buffer */
|
|
|
|
if(conn->host.encalloc)
|
|
|
|
(free)(conn->host.encalloc); /* encoded host name buffer, must be freed
|
|
|
|
with free() since this was allocated by
|
|
|
|
libidn */
|
|
|
|
if(conn->proxy.encalloc)
|
|
|
|
(free)(conn->proxy.encalloc); /* encoded proxy name buffer, must be freed
|
|
|
|
with free() since this was allocated by
|
|
|
|
libidn */
|
2001-08-28 04:37:54 -04:00
|
|
|
Curl_SSL_Close(conn);
|
2001-02-20 12:35:51 -05:00
|
|
|
|
|
|
|
/* close possibly still open sockets */
|
2004-03-11 08:13:35 -05:00
|
|
|
if(CURL_SOCKET_BAD != conn->sock[SECONDARYSOCKET])
|
2003-11-24 02:15:37 -05:00
|
|
|
sclose(conn->sock[SECONDARYSOCKET]);
|
2004-03-11 08:13:35 -05:00
|
|
|
if(CURL_SOCKET_BAD != conn->sock[FIRSTSOCKET])
|
2003-11-24 02:15:37 -05:00
|
|
|
sclose(conn->sock[FIRSTSOCKET]);
|
2001-02-20 12:35:51 -05:00
|
|
|
|
2003-07-21 09:16:30 -04:00
|
|
|
Curl_safefree(conn->user);
|
|
|
|
Curl_safefree(conn->passwd);
|
|
|
|
Curl_safefree(conn->proxyuser);
|
|
|
|
Curl_safefree(conn->proxypasswd);
|
|
|
|
Curl_safefree(conn->allocptr.proxyuserpwd);
|
|
|
|
Curl_safefree(conn->allocptr.uagent);
|
|
|
|
Curl_safefree(conn->allocptr.userpwd);
|
|
|
|
Curl_safefree(conn->allocptr.accept_encoding);
|
|
|
|
Curl_safefree(conn->allocptr.rangeline);
|
|
|
|
Curl_safefree(conn->allocptr.ref);
|
|
|
|
Curl_safefree(conn->allocptr.cookie);
|
|
|
|
Curl_safefree(conn->allocptr.host);
|
|
|
|
Curl_safefree(conn->allocptr.cookiehost);
|
2004-04-27 09:56:23 -04:00
|
|
|
|
2004-04-26 03:20:11 -04:00
|
|
|
#if defined(USE_ARES) || defined(USE_THREADING_GETHOSTBYNAME) || \
|
|
|
|
defined(USE_THREADING_GETADDRINFO)
|
2003-08-05 10:40:59 -04:00
|
|
|
/* possible left-overs from the async name resolve */
|
|
|
|
Curl_safefree(conn->async.hostname);
|
2004-02-22 17:31:24 -05:00
|
|
|
Curl_safefree(conn->async.os_specific);
|
2003-08-05 10:40:59 -04:00
|
|
|
#endif
|
|
|
|
|
2003-03-31 00:13:26 -05:00
|
|
|
Curl_free_ssl_config(&conn->ssl_config);
|
2003-03-24 18:10:38 -05:00
|
|
|
|
2001-02-20 12:35:51 -05:00
|
|
|
free(conn); /* free all the connection oriented data */
|
2000-05-22 10:12:12 -04:00
|
|
|
|
|
|
|
return CURLE_OK;
|
|
|
|
}
|
|
|
|
|
2001-03-04 11:34:20 -05:00
|
|
|
/*
|
|
|
|
* This function should return TRUE if the socket is to be assumed to
|
|
|
|
* be dead. Most commonly this happens when the server has closed the
|
|
|
|
* connection due to inactivity.
|
|
|
|
*/
|
2004-03-10 11:01:47 -05:00
|
|
|
static bool SocketIsDead(curl_socket_t sock)
|
2003-03-25 09:23:12 -05:00
|
|
|
{
|
|
|
|
int sval;
|
|
|
|
bool ret_val = TRUE;
|
|
|
|
fd_set check_set;
|
|
|
|
struct timeval to;
|
2001-03-04 11:34:20 -05:00
|
|
|
|
2003-03-25 09:23:12 -05:00
|
|
|
FD_ZERO(&check_set);
|
2004-03-10 11:01:47 -05:00
|
|
|
FD_SET(sock, &check_set);
|
2001-03-04 11:34:20 -05:00
|
|
|
|
2003-03-25 09:23:12 -05:00
|
|
|
to.tv_sec = 0;
|
|
|
|
to.tv_usec = 0;
|
2001-03-04 11:34:20 -05:00
|
|
|
|
|
|
|
sval = select(sock + 1, &check_set, 0, 0, &to);
|
2001-10-31 10:14:52 -05:00
|
|
|
if(sval == 0)
|
2001-03-04 11:34:20 -05:00
|
|
|
/* timeout */
|
2001-10-30 10:21:45 -05:00
|
|
|
ret_val = FALSE;
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2001-03-04 11:34:20 -05:00
|
|
|
return ret_val;
|
|
|
|
}
|
|
|
|
|
2001-02-20 12:35:51 -05:00
|
|
|
/*
|
2001-12-02 09:16:34 -05:00
|
|
|
* Given one filled in connection struct (named needle), this function should
|
|
|
|
* detect if there already is one that have all the significant details
|
|
|
|
* exactly the same and thus should be used instead.
|
2001-02-20 12:35:51 -05:00
|
|
|
*/
|
|
|
|
static bool
|
2001-08-30 18:48:34 -04:00
|
|
|
ConnectionExists(struct SessionHandle *data,
|
2001-02-20 12:35:51 -05:00
|
|
|
struct connectdata *needle,
|
|
|
|
struct connectdata **usethis)
|
1999-12-29 09:20:26 -05:00
|
|
|
{
|
2001-08-14 04:40:06 -04:00
|
|
|
long i;
|
2001-02-20 12:35:51 -05:00
|
|
|
struct connectdata *check;
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
for(i=0; i< data->state.numconnects; i++) {
|
2002-04-04 07:23:14 -05:00
|
|
|
bool match = FALSE;
|
2001-02-20 12:35:51 -05:00
|
|
|
/*
|
|
|
|
* Note that if we use a HTTP proxy, we check connections to that
|
|
|
|
* proxy and not to the actual remote server.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
check = data->state.connects[i];
|
2001-02-20 12:35:51 -05:00
|
|
|
if(!check)
|
|
|
|
/* NULL pointer means not filled-in entry */
|
|
|
|
continue;
|
2003-03-30 22:42:01 -05:00
|
|
|
|
|
|
|
if((needle->protocol&PROT_SSL) != (check->protocol&PROT_SSL))
|
|
|
|
/* don't do mixed SSL and non-SSL connections */
|
|
|
|
continue;
|
|
|
|
|
2001-12-02 09:16:34 -05:00
|
|
|
if(!needle->bits.httpproxy || needle->protocol&PROT_SSL) {
|
|
|
|
/* The requested connection does not use a HTTP proxy or it
|
|
|
|
uses SSL. */
|
|
|
|
|
|
|
|
if(!(needle->protocol&PROT_SSL) && check->bits.httpproxy)
|
|
|
|
/* we don't do SSL but the cached connection has a proxy,
|
|
|
|
then don't match this */
|
|
|
|
continue;
|
2001-03-09 10:18:25 -05:00
|
|
|
|
|
|
|
if(strequal(needle->protostr, check->protostr) &&
|
2004-04-27 09:56:23 -04:00
|
|
|
strequal(needle->host.name, check->host.name) &&
|
2001-04-25 17:24:27 -04:00
|
|
|
(needle->remote_port == check->remote_port) ) {
|
2003-03-24 18:10:38 -05:00
|
|
|
if(needle->protocol & PROT_SSL) {
|
|
|
|
/* This is SSL, verify that we're using the same
|
|
|
|
ssl options as well */
|
2003-03-31 00:13:26 -05:00
|
|
|
if(!Curl_ssl_config_matches(&needle->ssl_config,
|
|
|
|
&check->ssl_config)) {
|
2003-03-24 18:10:38 -05:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2003-07-19 20:02:47 -04:00
|
|
|
if((needle->protocol & PROT_FTP) ||
|
|
|
|
((needle->protocol & PROT_HTTP) &&
|
2004-05-04 03:52:53 -04:00
|
|
|
(needle->data->state.authhost.want==CURLAUTH_NTLM))) {
|
2003-07-19 20:02:47 -04:00
|
|
|
/* This is FTP or HTTP+NTLM, verify that we're using the same name
|
|
|
|
and password as well */
|
2003-07-19 19:56:33 -04:00
|
|
|
if(!strequal(needle->user, check->user) ||
|
|
|
|
!strequal(needle->passwd, check->passwd)) {
|
2001-03-09 10:18:25 -05:00
|
|
|
/* one of them was different */
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2002-04-04 07:23:14 -05:00
|
|
|
match = TRUE;
|
2001-03-04 11:34:20 -05:00
|
|
|
}
|
2001-02-20 12:35:51 -05:00
|
|
|
}
|
2001-03-09 10:18:25 -05:00
|
|
|
else { /* The requested needle connection is using a proxy,
|
|
|
|
is the checked one using the same? */
|
|
|
|
if(check->bits.httpproxy &&
|
2004-04-27 09:56:23 -04:00
|
|
|
strequal(needle->proxy.name, check->proxy.name) &&
|
2001-03-09 10:18:25 -05:00
|
|
|
needle->port == check->port) {
|
|
|
|
/* This is the same proxy connection, use it! */
|
2002-04-04 07:23:14 -05:00
|
|
|
match = TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(match) {
|
2003-11-24 02:15:37 -05:00
|
|
|
bool dead = SocketIsDead(check->sock[FIRSTSOCKET]);
|
2002-04-04 07:23:14 -05:00
|
|
|
if(dead) {
|
|
|
|
/*
|
|
|
|
*/
|
|
|
|
infof(data, "Connection %d seems to be dead!\n", i);
|
|
|
|
Curl_disconnect(check); /* disconnect resources */
|
|
|
|
data->state.connects[i]=NULL; /* nothing here */
|
|
|
|
|
|
|
|
/* There's no need to continue searching, because we only store
|
|
|
|
one connection for each unique set of identifiers */
|
|
|
|
return FALSE;
|
2001-03-09 10:18:25 -05:00
|
|
|
}
|
2002-04-04 07:23:14 -05:00
|
|
|
|
|
|
|
*usethis = check;
|
|
|
|
return TRUE; /* yes, we found one to use! */
|
2001-03-09 10:18:25 -05:00
|
|
|
}
|
2001-02-20 12:35:51 -05:00
|
|
|
}
|
|
|
|
return FALSE; /* no matching connecting exists */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function frees/closes a connection in the connection cache. This
|
|
|
|
* should take the previously set policy into account when deciding which
|
|
|
|
* of the connections to kill.
|
|
|
|
*/
|
|
|
|
static int
|
2001-08-30 18:48:34 -04:00
|
|
|
ConnectionKillOne(struct SessionHandle *data)
|
2001-02-20 12:35:51 -05:00
|
|
|
{
|
2001-08-14 04:40:06 -04:00
|
|
|
long i;
|
2000-05-22 10:12:12 -04:00
|
|
|
struct connectdata *conn;
|
2001-02-20 12:35:51 -05:00
|
|
|
int highscore=-1;
|
|
|
|
int connindex=-1;
|
|
|
|
int score;
|
2001-03-13 02:54:18 -05:00
|
|
|
struct timeval now;
|
|
|
|
|
|
|
|
now = Curl_tvnow();
|
2001-02-20 12:35:51 -05:00
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
for(i=0; i< data->state.numconnects; i++) {
|
|
|
|
conn = data->state.connects[i];
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2001-02-20 12:35:51 -05:00
|
|
|
if(!conn)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* By using the set policy, we score each connection.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
switch(data->set.closepolicy) {
|
2001-03-13 02:54:18 -05:00
|
|
|
case CURLCLOSEPOLICY_LEAST_RECENTLY_USED:
|
2001-02-20 12:35:51 -05:00
|
|
|
default:
|
2001-03-13 02:54:18 -05:00
|
|
|
/*
|
|
|
|
* Set higher score for the age passed since the connection
|
|
|
|
* was used.
|
|
|
|
*/
|
2001-10-12 08:32:20 -04:00
|
|
|
score = Curl_tvdiff(now, conn->now);
|
2001-03-13 02:54:18 -05:00
|
|
|
break;
|
|
|
|
case CURLCLOSEPOLICY_OLDEST:
|
|
|
|
/*
|
|
|
|
* Set higher score for the age passed since the connection
|
|
|
|
* was created.
|
|
|
|
*/
|
2001-10-12 08:32:20 -04:00
|
|
|
score = Curl_tvdiff(now, conn->created);
|
2001-02-20 12:35:51 -05:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(score > highscore) {
|
|
|
|
highscore = score;
|
|
|
|
connindex = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(connindex >= 0) {
|
|
|
|
|
|
|
|
/* the winner gets the honour of being disconnected */
|
2004-02-12 04:48:27 -05:00
|
|
|
(void) Curl_disconnect(data->state.connects[connindex]);
|
2001-02-20 12:35:51 -05:00
|
|
|
|
|
|
|
/* clean the array entry */
|
2001-08-30 18:48:34 -04:00
|
|
|
data->state.connects[connindex] = NULL;
|
2001-02-20 12:35:51 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
return connindex; /* return the available index or -1 */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The given input connection struct pointer is to be stored. If the "cache"
|
|
|
|
* is already full, we must clean out the most suitable using the previously
|
|
|
|
* set policy.
|
|
|
|
*
|
|
|
|
* The given connection should be unique. That must've been checked prior to
|
|
|
|
* this call.
|
|
|
|
*/
|
|
|
|
static unsigned int
|
2001-08-30 18:48:34 -04:00
|
|
|
ConnectionStore(struct SessionHandle *data,
|
2001-02-20 12:35:51 -05:00
|
|
|
struct connectdata *conn)
|
|
|
|
{
|
2001-08-14 04:40:06 -04:00
|
|
|
long i;
|
2001-08-30 18:48:34 -04:00
|
|
|
for(i=0; i< data->state.numconnects; i++) {
|
|
|
|
if(!data->state.connects[i])
|
2001-02-20 12:35:51 -05:00
|
|
|
break;
|
|
|
|
}
|
2001-08-30 18:48:34 -04:00
|
|
|
if(i == data->state.numconnects) {
|
2001-02-20 12:35:51 -05:00
|
|
|
/* there was no room available, kill one */
|
|
|
|
i = ConnectionKillOne(data);
|
2001-02-22 18:51:17 -05:00
|
|
|
infof(data, "Connection (#%d) was killed to make room\n", i);
|
|
|
|
}
|
2001-02-20 12:35:51 -05:00
|
|
|
|
2001-09-12 04:00:30 -04:00
|
|
|
if(-1 != i) {
|
|
|
|
/* only do this if a true index was returned, if -1 was returned there
|
|
|
|
is no room in the cache for an unknown reason and we cannot store
|
|
|
|
this there. */
|
|
|
|
data->state.connects[i] = conn; /* fill in this */
|
|
|
|
conn->connectindex = i; /* make the child know where the pointer to this
|
|
|
|
particular data is stored */
|
|
|
|
}
|
2001-02-20 12:35:51 -05:00
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
2002-08-30 05:20:11 -04:00
|
|
|
/*
|
|
|
|
* This function logs in to a SOCKS5 proxy and sends the specifies the final
|
|
|
|
* desitination server.
|
|
|
|
*/
|
2003-11-24 02:15:37 -05:00
|
|
|
static int handleSock5Proxy(const char *proxy_name,
|
|
|
|
const char *proxy_password,
|
|
|
|
struct connectdata *conn)
|
2002-08-30 05:20:11 -04:00
|
|
|
{
|
2004-02-16 02:33:30 -05:00
|
|
|
/*
|
|
|
|
According to the RFC1928, section "6. Replies". This is what a SOCK5
|
|
|
|
replies:
|
|
|
|
|
|
|
|
+----+-----+-------+------+----------+----------+
|
|
|
|
|VER | REP | RSV | ATYP | BND.ADDR | BND.PORT |
|
|
|
|
+----+-----+-------+------+----------+----------+
|
|
|
|
| 1 | 1 | X'00' | 1 | Variable | 2 |
|
|
|
|
+----+-----+-------+------+----------+----------+
|
|
|
|
|
|
|
|
Where:
|
|
|
|
|
|
|
|
o VER protocol version: X'05'
|
|
|
|
o REP Reply field:
|
|
|
|
o X'00' succeeded
|
|
|
|
*/
|
|
|
|
|
2002-08-30 05:20:11 -04:00
|
|
|
unsigned char socksreq[600]; /* room for large user/pw (255 max each) */
|
2003-03-11 13:58:21 -05:00
|
|
|
ssize_t actualread;
|
|
|
|
ssize_t written;
|
2004-02-13 07:42:37 -05:00
|
|
|
int result;
|
|
|
|
CURLcode code;
|
2003-11-24 02:15:37 -05:00
|
|
|
int sock = conn->sock[FIRSTSOCKET];
|
2002-08-30 05:20:11 -04:00
|
|
|
|
|
|
|
Curl_nonblock(sock, FALSE);
|
|
|
|
|
|
|
|
socksreq[0] = 5; /* version */
|
2004-01-23 03:29:56 -05:00
|
|
|
socksreq[1] = (char)(proxy_name ? 2 : 1); /* number of methods (below) */
|
2002-08-30 05:20:11 -04:00
|
|
|
socksreq[2] = 0; /* no authentication */
|
|
|
|
socksreq[3] = 2; /* username/password */
|
|
|
|
|
2004-02-13 07:42:37 -05:00
|
|
|
code = Curl_write(conn, sock, (char *)socksreq, (2 + (int)socksreq[1]),
|
2002-08-30 05:20:11 -04:00
|
|
|
&written);
|
2004-02-13 07:42:37 -05:00
|
|
|
if ((code != CURLE_OK) || (written != (2 + (int)socksreq[1]))) {
|
2002-08-30 05:20:11 -04:00
|
|
|
failf(conn->data, "Unable to send initial SOCKS5 request.");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
result=Curl_read(conn, sock, (char *)socksreq, 2, &actualread);
|
|
|
|
if ((result != CURLE_OK) || (actualread != 2)) {
|
|
|
|
failf(conn->data, "Unable to receive initial SOCKS5 response.");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (socksreq[0] != 5) {
|
|
|
|
failf(conn->data, "Received invalid version in initial SOCKS5 response.");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (socksreq[1] == 0) {
|
|
|
|
/* Nothing to do, no authentication needed */
|
|
|
|
;
|
|
|
|
}
|
|
|
|
else if (socksreq[1] == 2) {
|
|
|
|
/* Needs user name and password */
|
|
|
|
int userlen, pwlen, len;
|
|
|
|
|
|
|
|
userlen = strlen(proxy_name);
|
2004-01-23 03:29:56 -05:00
|
|
|
pwlen = proxy_password?strlen(proxy_password):0;
|
2002-08-30 05:20:11 -04:00
|
|
|
|
|
|
|
/* username/password request looks like
|
|
|
|
* +----+------+----------+------+----------+
|
|
|
|
* |VER | ULEN | UNAME | PLEN | PASSWD |
|
|
|
|
* +----+------+----------+------+----------+
|
|
|
|
* | 1 | 1 | 1 to 255 | 1 | 1 to 255 |
|
|
|
|
* +----+------+----------+------+----------+
|
|
|
|
*/
|
|
|
|
len = 0;
|
|
|
|
socksreq[len++] = 1; /* username/pw subnegotiation version */
|
|
|
|
socksreq[len++] = (char) userlen;
|
|
|
|
memcpy(socksreq + len, proxy_name, (int) userlen);
|
|
|
|
len += userlen;
|
|
|
|
socksreq[len++] = (char) pwlen;
|
|
|
|
memcpy(socksreq + len, proxy_password, (int) pwlen);
|
|
|
|
len += pwlen;
|
|
|
|
|
2004-02-13 07:42:37 -05:00
|
|
|
code = Curl_write(conn, sock, (char *)socksreq, len, &written);
|
|
|
|
if ((code != CURLE_OK) || (len != written)) {
|
2002-08-30 05:20:11 -04:00
|
|
|
failf(conn->data, "Failed to send SOCKS5 sub-negotiation request.");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
result=Curl_read(conn, sock, (char *)socksreq, 2, &actualread);
|
|
|
|
if ((result != CURLE_OK) || (actualread != 2)) {
|
|
|
|
failf(conn->data, "Unable to receive SOCKS5 sub-negotiation response.");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2004-02-16 02:33:30 -05:00
|
|
|
if ((socksreq[0] != 5) || /* version */
|
2002-08-30 05:20:11 -04:00
|
|
|
(socksreq[1] != 0)) { /* status */
|
|
|
|
failf(conn->data, "User was rejected by the SOCKS5 server (%d %d).",
|
|
|
|
socksreq[0], socksreq[1]);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Everything is good so far, user was authenticated! */
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* error */
|
|
|
|
if (socksreq[1] == 1) {
|
|
|
|
failf(conn->data,
|
|
|
|
"SOCKS5 GSSAPI per-message authentication is not supported.");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
else if (socksreq[1] == 255) {
|
|
|
|
if (proxy_name[0] == 0) {
|
|
|
|
failf(conn->data,
|
|
|
|
"No authentication method was acceptable. (It is quite likely"
|
|
|
|
" that the SOCKS5 server wanted a username/password, since none"
|
|
|
|
" was supplied to the server on this connection.)");
|
|
|
|
}
|
2003-03-25 09:23:12 -05:00
|
|
|
else {
|
2002-08-30 05:20:11 -04:00
|
|
|
failf(conn->data, "No authentication method was acceptable.");
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
failf(conn->data,
|
|
|
|
"Undocumented SOCKS5 mode attempted to be used by server.");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Authentication is complete, now specify destination to the proxy */
|
|
|
|
socksreq[0] = 5; /* version (SOCKS5) */
|
|
|
|
socksreq[1] = 1; /* connect */
|
|
|
|
socksreq[2] = 0; /* must be zero */
|
|
|
|
socksreq[3] = 1; /* IPv4 = 1 */
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2002-08-30 05:20:11 -04:00
|
|
|
{
|
2002-11-05 05:51:41 -05:00
|
|
|
#ifndef ENABLE_IPV6
|
|
|
|
struct Curl_dns_entry *dns;
|
|
|
|
Curl_addrinfo *hp=NULL;
|
2004-04-27 09:56:23 -04:00
|
|
|
int rc = Curl_resolv(conn, conn->host.name, conn->remote_port, &dns);
|
2003-08-05 10:40:59 -04:00
|
|
|
|
2004-04-26 10:18:00 -04:00
|
|
|
if(rc == CURLRESOLV_ERROR)
|
2004-02-13 07:42:37 -05:00
|
|
|
return 1;
|
2003-08-05 10:40:59 -04:00
|
|
|
|
2004-04-26 10:18:00 -04:00
|
|
|
if(rc == CURLRESOLV_PENDING)
|
2003-08-05 10:40:59 -04:00
|
|
|
/* this requires that we're in "wait for resolve" state */
|
|
|
|
rc = Curl_wait_for_resolv(conn, &dns);
|
|
|
|
|
2002-08-30 05:20:11 -04:00
|
|
|
/*
|
|
|
|
* We cannot use 'hostent' as a struct that Curl_resolv() returns. It
|
|
|
|
* returns a Curl_addrinfo pointer that may not always look the same.
|
|
|
|
*/
|
2002-11-05 05:51:41 -05:00
|
|
|
if(dns)
|
|
|
|
hp=dns->addr;
|
2002-08-30 05:20:11 -04:00
|
|
|
if (hp && hp->h_addr_list[0]) {
|
|
|
|
socksreq[4] = ((char*)hp->h_addr_list[0])[0];
|
|
|
|
socksreq[5] = ((char*)hp->h_addr_list[0])[1];
|
|
|
|
socksreq[6] = ((char*)hp->h_addr_list[0])[2];
|
|
|
|
socksreq[7] = ((char*)hp->h_addr_list[0])[3];
|
2002-11-05 05:51:41 -05:00
|
|
|
|
2003-02-04 18:48:46 -05:00
|
|
|
Curl_resolv_unlock(conn->data, dns); /* not used anymore from now on */
|
2002-08-30 05:20:11 -04:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
failf(conn->data, "Failed to resolve \"%s\" for SOCKS5 connect.",
|
2004-04-27 09:56:23 -04:00
|
|
|
conn->host.name);
|
2002-08-30 05:20:11 -04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
failf(conn->data,
|
|
|
|
"%s:%d has an internal error an needs to be fixed to work",
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
*((unsigned short*)&socksreq[8]) = htons(conn->remote_port);
|
|
|
|
|
|
|
|
{
|
|
|
|
const int packetsize = 10;
|
|
|
|
|
2004-02-13 07:42:37 -05:00
|
|
|
code = Curl_write(conn, sock, (char *)socksreq, packetsize, &written);
|
|
|
|
if ((code != CURLE_OK) || (written != packetsize)) {
|
2002-08-30 05:20:11 -04:00
|
|
|
failf(conn->data, "Failed to send SOCKS5 connect request.");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
result = Curl_read(conn, sock, (char *)socksreq, packetsize, &actualread);
|
|
|
|
if ((result != CURLE_OK) || (actualread != packetsize)) {
|
|
|
|
failf(conn->data, "Failed to receive SOCKS5 connect request ack.");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (socksreq[0] != 5) { /* version */
|
|
|
|
failf(conn->data,
|
|
|
|
"SOCKS5 reply has wrong version, version should be 5.");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (socksreq[1] != 0) { /* Anything besides 0 is an error */
|
|
|
|
failf(conn->data,
|
|
|
|
"Can't complete SOCKS5 connection to %d.%d.%d.%d:%d. (%d)",
|
|
|
|
(unsigned char)socksreq[4], (unsigned char)socksreq[5],
|
|
|
|
(unsigned char)socksreq[6], (unsigned char)socksreq[7],
|
|
|
|
(unsigned int)ntohs(*(unsigned short*)(&socksreq[8])),
|
|
|
|
socksreq[1]);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Curl_nonblock(sock, TRUE);
|
|
|
|
return 0; /* Proxy was successful! */
|
|
|
|
}
|
|
|
|
|
2002-04-25 15:00:57 -04:00
|
|
|
static CURLcode ConnectPlease(struct connectdata *conn,
|
2002-11-05 05:51:41 -05:00
|
|
|
struct Curl_dns_entry *hostaddr,
|
2002-08-12 05:43:20 -04:00
|
|
|
bool *connected)
|
2001-02-20 12:35:51 -05:00
|
|
|
{
|
2001-10-02 05:40:06 -04:00
|
|
|
CURLcode result;
|
|
|
|
Curl_ipconnect *addr;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-10-01 07:27:39 -04:00
|
|
|
/*************************************************************
|
2001-10-02 05:40:06 -04:00
|
|
|
* Connect to server/proxy
|
2001-10-01 07:27:39 -04:00
|
|
|
*************************************************************/
|
2001-10-02 05:40:06 -04:00
|
|
|
result= Curl_connecthost(conn,
|
2002-04-25 15:00:57 -04:00
|
|
|
hostaddr,
|
2001-10-02 05:40:06 -04:00
|
|
|
conn->port,
|
2003-11-24 02:15:37 -05:00
|
|
|
&conn->sock[FIRSTSOCKET],
|
2002-08-12 05:43:20 -04:00
|
|
|
&addr,
|
|
|
|
connected);
|
2001-10-02 05:40:06 -04:00
|
|
|
if(CURLE_OK == result) {
|
|
|
|
/* All is cool, then we store the current information from the hostaddr
|
|
|
|
struct to the serv_addr, as it might be needed later. The address
|
|
|
|
returned from the function above is crucial here. */
|
2002-11-05 05:51:41 -05:00
|
|
|
conn->connect_addr = hostaddr;
|
|
|
|
|
2001-10-02 05:40:06 -04:00
|
|
|
#ifdef ENABLE_IPV6
|
|
|
|
conn->serv_addr = addr;
|
|
|
|
#else
|
|
|
|
memset((char *) &conn->serv_addr, '\0', sizeof(conn->serv_addr));
|
|
|
|
memcpy((char *)&(conn->serv_addr.sin_addr),
|
|
|
|
(struct in_addr *)addr, sizeof(struct in_addr));
|
2002-11-05 06:07:49 -05:00
|
|
|
conn->serv_addr.sin_family = hostaddr->addr->h_addrtype;
|
2002-08-26 13:20:29 -04:00
|
|
|
conn->serv_addr.sin_port = htons((unsigned short)conn->port);
|
2001-10-01 07:27:39 -04:00
|
|
|
#endif
|
2002-08-30 05:20:11 -04:00
|
|
|
|
|
|
|
if (conn->data->set.proxytype == CURLPROXY_SOCKS5) {
|
2003-07-21 09:16:30 -04:00
|
|
|
return handleSock5Proxy(conn->proxyuser,
|
|
|
|
conn->proxypasswd,
|
2003-11-24 02:15:37 -05:00
|
|
|
conn) ?
|
2002-08-30 05:20:11 -04:00
|
|
|
CURLE_COULDNT_CONNECT : CURLE_OK;
|
|
|
|
}
|
|
|
|
else if (conn->data->set.proxytype == CURLPROXY_HTTP) {
|
|
|
|
/* do nothing here. handled later. */
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
failf(conn->data, "unknown proxytype option given");
|
2003-03-25 09:23:12 -05:00
|
|
|
return CURLE_COULDNT_CONNECT;
|
2002-08-30 05:20:11 -04:00
|
|
|
}
|
2001-10-01 07:27:39 -04:00
|
|
|
}
|
|
|
|
|
2001-10-02 05:40:06 -04:00
|
|
|
return result;
|
2001-02-20 12:35:51 -05:00
|
|
|
}
|
|
|
|
|
2002-11-22 11:59:40 -05:00
|
|
|
/*
|
2004-04-26 03:20:11 -04:00
|
|
|
* verboseconnect() displays verbose information after a connect
|
2002-11-22 11:59:40 -05:00
|
|
|
*/
|
2004-04-26 03:20:11 -04:00
|
|
|
static void verboseconnect(struct connectdata *conn)
|
2002-04-12 04:18:38 -04:00
|
|
|
{
|
|
|
|
struct SessionHandle *data = conn->data;
|
2004-04-26 03:20:11 -04:00
|
|
|
const char *host=NULL;
|
2004-04-26 11:14:19 -04:00
|
|
|
char addrbuf[256];
|
2002-04-12 04:18:38 -04:00
|
|
|
|
2004-04-26 03:20:11 -04:00
|
|
|
/* Get a printable version of the network address. */
|
2002-04-12 04:18:38 -04:00
|
|
|
#ifdef ENABLE_IPV6
|
2004-04-26 03:20:11 -04:00
|
|
|
struct addrinfo *ai = conn->serv_addr;
|
|
|
|
host = Curl_printable_address(ai->ai_family, ai->ai_addr,
|
|
|
|
addrbuf, sizeof(addrbuf));
|
2002-04-12 04:18:38 -04:00
|
|
|
#else
|
2004-04-26 03:20:11 -04:00
|
|
|
struct in_addr in;
|
|
|
|
(void) memcpy(&in.s_addr, &conn->serv_addr.sin_addr, sizeof (in.s_addr));
|
|
|
|
host = Curl_inet_ntop(AF_INET, &in, addrbuf, sizeof(addrbuf));
|
2002-04-12 04:18:38 -04:00
|
|
|
#endif
|
2004-04-26 03:20:11 -04:00
|
|
|
infof(data, "Connected to %s (%s) port %d\n",
|
2004-04-27 09:56:23 -04:00
|
|
|
conn->bits.httpproxy?conn->proxy.dispname:conn->host.dispname,
|
2004-04-26 11:19:55 -04:00
|
|
|
host?host:"", conn->port);
|
2002-04-12 04:18:38 -04:00
|
|
|
}
|
|
|
|
|
2002-08-12 05:43:20 -04:00
|
|
|
/*
|
|
|
|
* We have discovered that the TCP connection has been successful, we can now
|
|
|
|
* proceed with some action.
|
|
|
|
*
|
|
|
|
* If we're using the multi interface, this host address pointer is most
|
|
|
|
* likely NULL at this point as we can't keep the resolved info around. This
|
|
|
|
* may call for some reworking, like a reference counter in the struct or
|
2004-04-26 03:20:11 -04:00
|
|
|
* something.
|
2002-08-12 05:43:20 -04:00
|
|
|
*/
|
2004-04-26 03:20:11 -04:00
|
|
|
CURLcode Curl_protocol_connect(struct connectdata *conn)
|
2002-08-12 05:43:20 -04:00
|
|
|
{
|
|
|
|
struct SessionHandle *data = conn->data;
|
2002-09-25 07:27:06 -04:00
|
|
|
CURLcode result=CURLE_OK;
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2002-12-13 11:15:19 -05:00
|
|
|
if(conn->bits.tcpconnect)
|
|
|
|
/* We already are connected, get back. This may happen when the connect
|
|
|
|
worked fine in the first call, like when we connect to a local server
|
|
|
|
or proxy. */
|
|
|
|
return CURLE_OK;
|
|
|
|
|
2002-08-12 05:43:20 -04:00
|
|
|
Curl_pgrsTime(data, TIMER_CONNECT); /* connect done */
|
|
|
|
|
|
|
|
if(data->set.verbose)
|
2004-04-26 03:20:11 -04:00
|
|
|
verboseconnect(conn);
|
2002-08-12 05:43:20 -04:00
|
|
|
|
|
|
|
if(conn->curl_connect) {
|
|
|
|
/* is there a protocol-specific connect() procedure? */
|
|
|
|
|
|
|
|
/* set start time here for timeout purposes in the
|
|
|
|
* connect procedure, it is later set again for the
|
|
|
|
* progress meter purpose */
|
|
|
|
conn->now = Curl_tvnow();
|
|
|
|
|
|
|
|
/* Call the protocol-specific connect function */
|
|
|
|
result = conn->curl_connect(conn);
|
|
|
|
}
|
|
|
|
|
|
|
|
return result; /* pass back status */
|
|
|
|
}
|
|
|
|
|
2004-04-27 09:56:23 -04:00
|
|
|
/*
|
|
|
|
* Helpers for IDNA convertions.
|
|
|
|
*/
|
|
|
|
#ifdef USE_LIBIDN
|
|
|
|
static bool is_ASCII_name (const char *hostname)
|
|
|
|
{
|
|
|
|
const unsigned char *ch = (const unsigned char*)hostname;
|
|
|
|
|
|
|
|
while (*ch) {
|
|
|
|
if (*ch++ & 0x80)
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void fix_hostname(struct connectdata *conn, struct hostname *host)
|
|
|
|
{
|
|
|
|
/* set the name we use to display the host name */
|
2004-04-29 07:57:52 -04:00
|
|
|
host->dispname = host->name;
|
2004-04-27 09:56:23 -04:00
|
|
|
|
|
|
|
#ifdef USE_LIBIDN
|
|
|
|
/*************************************************************
|
|
|
|
* Check name for non-ASCII and convert hostname to ACE form.
|
|
|
|
*************************************************************/
|
|
|
|
if (!is_ASCII_name(host->name)) {
|
|
|
|
char *ace_hostname = NULL;
|
|
|
|
struct SessionHandle *data = conn->data;
|
|
|
|
int rc = idna_to_ascii_lz(host->name, &ace_hostname, 0);
|
|
|
|
infof (data, "Input domain encoded as `%s'\n",
|
|
|
|
stringprep_locale_charset ());
|
|
|
|
if (rc != IDNA_SUCCESS)
|
|
|
|
infof(data, "Failed to convert %s to ACE; IDNA error %d\n",
|
|
|
|
host->name, rc);
|
|
|
|
else {
|
|
|
|
host->encalloc = ace_hostname;
|
|
|
|
/* change the name pointer to point to the encoded hostname */
|
|
|
|
host->name = host->encalloc;
|
|
|
|
}
|
|
|
|
}
|
2004-05-05 03:08:31 -04:00
|
|
|
#else
|
|
|
|
(void)conn; /* never used */
|
2004-04-27 09:56:23 -04:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-04-13 03:16:26 -04:00
|
|
|
/**
|
2003-08-05 10:40:59 -04:00
|
|
|
* CreateConnection() sets up a new connectdata struct, or re-uses an already
|
|
|
|
* existing one, and resolves host name.
|
|
|
|
*
|
|
|
|
* if this function returns CURLE_OK and *async is set to TRUE, the resolve
|
|
|
|
* response will be coming asynchronously. If *async is FALSE, the name is
|
|
|
|
* already resolved.
|
2004-04-13 03:16:26 -04:00
|
|
|
*
|
|
|
|
* @param data The sessionhandle pointer
|
|
|
|
* @param in_connect is set to the next connection data pointer
|
|
|
|
* @param addr is set to the new dns entry for this connection
|
|
|
|
* @param async is set TRUE/FALSE depending on the nature of this lookup
|
|
|
|
* @return CURLcode
|
|
|
|
* @see SetupConnection()
|
2003-08-05 10:40:59 -04:00
|
|
|
*/
|
|
|
|
|
2001-10-01 04:59:17 -04:00
|
|
|
static CURLcode CreateConnection(struct SessionHandle *data,
|
2003-08-05 10:40:59 -04:00
|
|
|
struct connectdata **in_connect,
|
|
|
|
struct Curl_dns_entry **addr,
|
|
|
|
bool *async)
|
2001-02-20 12:35:51 -05:00
|
|
|
{
|
|
|
|
char *tmp;
|
2001-11-07 09:13:29 -05:00
|
|
|
CURLcode result=CURLE_OK;
|
2001-02-20 12:35:51 -05:00
|
|
|
struct connectdata *conn;
|
|
|
|
struct connectdata *conn_temp;
|
|
|
|
int urllen;
|
2002-11-05 05:51:41 -05:00
|
|
|
struct Curl_dns_entry *hostaddr;
|
2001-11-06 14:33:13 -05:00
|
|
|
#ifdef HAVE_ALARM
|
2002-10-28 14:20:59 -05:00
|
|
|
unsigned int prev_alarm=0;
|
2001-11-06 14:33:13 -05:00
|
|
|
#endif
|
2002-08-05 12:50:55 -04:00
|
|
|
char endbracket;
|
2003-07-19 19:56:33 -04:00
|
|
|
char user[MAX_CURL_USER_LENGTH];
|
|
|
|
char passwd[MAX_CURL_PASSWORD_LENGTH];
|
2003-08-05 10:40:59 -04:00
|
|
|
int rc;
|
2004-03-01 04:43:42 -05:00
|
|
|
bool reuse;
|
2001-11-06 14:33:13 -05:00
|
|
|
|
|
|
|
#ifdef HAVE_SIGACTION
|
|
|
|
struct sigaction keep_sigact; /* store the old struct here */
|
2002-10-28 14:20:59 -05:00
|
|
|
bool keep_copysig=FALSE; /* did copy it? */
|
2001-11-07 09:13:29 -05:00
|
|
|
#else
|
|
|
|
#ifdef HAVE_SIGNAL
|
|
|
|
void *keep_sigact; /* store the old handler here */
|
|
|
|
#endif
|
2001-11-06 14:33:13 -05:00
|
|
|
#endif
|
2000-11-01 03:19:10 -05:00
|
|
|
|
2003-08-05 10:40:59 -04:00
|
|
|
*addr = NULL; /* nothing yet */
|
|
|
|
*async = FALSE;
|
|
|
|
|
2001-02-20 12:35:51 -05:00
|
|
|
/*************************************************************
|
|
|
|
* Check input data
|
|
|
|
*************************************************************/
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
if(!data->change.url)
|
2001-02-20 12:35:51 -05:00
|
|
|
return CURLE_URL_MALFORMAT;
|
|
|
|
|
|
|
|
/* First, split up the current URL in parts so that we can use the
|
|
|
|
parts for checking against the already present connections. In order
|
|
|
|
to not have to modify everything at once, we allocate a temporary
|
|
|
|
connection data struct and fill in for comparison purposes. */
|
|
|
|
|
|
|
|
conn = (struct connectdata *)malloc(sizeof(struct connectdata));
|
|
|
|
if(!conn) {
|
|
|
|
*in_connect = NULL; /* clear the pointer */
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
}
|
2001-03-05 08:39:01 -05:00
|
|
|
/* We must set the return variable as soon as possible, so that our
|
|
|
|
parent can cleanup any possible allocs we may have done before
|
|
|
|
any failure */
|
|
|
|
*in_connect = conn;
|
|
|
|
|
2001-02-20 12:35:51 -05:00
|
|
|
/* we have to init the struct */
|
|
|
|
memset(conn, 0, sizeof(struct connectdata));
|
|
|
|
|
|
|
|
/* and we setup a few fields in case we end up actually using this struct */
|
|
|
|
conn->data = data; /* remember our daddy */
|
2004-03-11 08:13:35 -05:00
|
|
|
conn->sock[FIRSTSOCKET] = CURL_SOCKET_BAD; /* no file descriptor */
|
|
|
|
conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD; /* no file descriptor */
|
2001-02-20 12:35:51 -05:00
|
|
|
conn->connectindex = -1; /* no index */
|
2002-10-10 04:00:49 -04:00
|
|
|
conn->bits.httpproxy = (data->change.proxy && *data->change.proxy &&
|
|
|
|
(data->set.proxytype == CURLPROXY_HTTP))?
|
|
|
|
TRUE:FALSE; /* http proxy or not */
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-03-13 02:54:18 -05:00
|
|
|
/* Default protocol-independent behavior doesn't support persistant
|
2001-03-05 08:39:01 -05:00
|
|
|
connections, so we set this to force-close. Protocols that support
|
|
|
|
this need to set this to FALSE in their "curl_do" functions. */
|
|
|
|
conn->bits.close = TRUE;
|
2002-05-21 18:17:19 -04:00
|
|
|
|
2001-04-27 04:02:10 -04:00
|
|
|
/* maxdownload must be -1 on init, as 0 is a valid value! */
|
|
|
|
conn->maxdownload = -1; /* might have been used previously! */
|
|
|
|
|
2001-03-13 02:54:18 -05:00
|
|
|
/* Store creation time to help future close decision making */
|
|
|
|
conn->created = Curl_tvnow();
|
2001-03-05 08:39:01 -05:00
|
|
|
|
2003-03-21 03:09:48 -05:00
|
|
|
conn->bits.use_range = data->set.set_range?TRUE:FALSE; /* range status */
|
|
|
|
conn->range = data->set.set_range; /* clone the range setting */
|
|
|
|
conn->resume_from = data->set.set_resume_from; /* inherite resume_from */
|
|
|
|
|
2002-11-07 03:45:10 -05:00
|
|
|
/* Set the start time temporary to this creation time to allow easier
|
|
|
|
timeout checks before the transfer has started for real. The start time
|
|
|
|
is later set "for real" using Curl_pgrsStartNow(). */
|
2003-03-25 09:23:12 -05:00
|
|
|
conn->data->progress.start = conn->created;
|
2001-03-14 09:11:11 -05:00
|
|
|
|
2003-03-21 03:09:48 -05:00
|
|
|
conn->bits.user_passwd = data->set.userpwd?1:0;
|
|
|
|
conn->bits.proxy_user_passwd = data->set.proxyuserpwd?1:0;
|
2004-04-06 11:14:10 -04:00
|
|
|
conn->bits.no_body = data->set.opt_no_body;
|
2002-11-11 03:40:37 -05:00
|
|
|
|
2003-03-21 03:09:48 -05:00
|
|
|
/* This initing continues below, see the comment "Continue connectdata
|
|
|
|
* initialization here" */
|
2002-12-09 10:37:54 -05:00
|
|
|
|
2001-01-24 07:32:34 -05:00
|
|
|
/***********************************************************
|
|
|
|
* We need to allocate memory to store the path in. We get the size of the
|
|
|
|
* full URL to be sure, and we need to make it at least 256 bytes since
|
|
|
|
* other parts of the code will rely on this fact
|
|
|
|
***********************************************************/
|
2000-11-20 03:53:21 -05:00
|
|
|
#define LEAST_PATH_ALLOC 256
|
2001-08-30 18:48:34 -04:00
|
|
|
urllen=strlen(data->change.url);
|
2000-11-20 03:53:21 -05:00
|
|
|
if(urllen < LEAST_PATH_ALLOC)
|
|
|
|
urllen=LEAST_PATH_ALLOC;
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2004-04-20 03:53:24 -04:00
|
|
|
conn->pathbuffer=(char *)malloc(urllen);
|
|
|
|
if(NULL == conn->pathbuffer)
|
2000-11-20 03:53:21 -05:00
|
|
|
return CURLE_OUT_OF_MEMORY; /* really bad error */
|
2004-04-20 03:53:24 -04:00
|
|
|
conn->path = conn->pathbuffer;
|
|
|
|
|
2004-04-27 09:56:23 -04:00
|
|
|
conn->host.rawalloc=(char *)malloc(urllen);
|
|
|
|
if(NULL == conn->host.rawalloc)
|
2004-04-20 03:53:24 -04:00
|
|
|
return CURLE_OUT_OF_MEMORY;
|
2004-04-27 09:56:23 -04:00
|
|
|
conn->host.name = conn->host.rawalloc;
|
2000-11-20 03:53:21 -05:00
|
|
|
|
2001-01-24 07:32:34 -05:00
|
|
|
/*************************************************************
|
|
|
|
* Parse the URL.
|
|
|
|
*
|
|
|
|
* We need to parse the url even when using the proxy, because we will need
|
|
|
|
* the hostname and port in case we are trying to SSL connect through the
|
|
|
|
* proxy -- and we don't know if we will need to use SSL until we parse the
|
|
|
|
* url ...
|
|
|
|
************************************************************/
|
2004-05-07 14:46:28 -04:00
|
|
|
if((2 == sscanf(data->change.url, "%15[^:]:%[^\n]",
|
2001-02-20 12:35:51 -05:00
|
|
|
conn->protostr,
|
|
|
|
conn->path)) && strequal(conn->protostr, "file")) {
|
2003-10-29 04:53:21 -05:00
|
|
|
if(conn->path[0] == '/' && conn->path[1] == '/') {
|
|
|
|
/* Allow omitted hostname (e.g. file:/<path>). This is not strictly
|
|
|
|
* speaking a valid file: URL by RFC 1738, but treating file:/<path> as
|
|
|
|
* file://localhost/<path> is similar to how other schemes treat missing
|
|
|
|
* hostnames. See RFC 1808. */
|
|
|
|
|
|
|
|
/* This cannot be done with strcpy() in a portable manner, since the
|
|
|
|
memory areas overlap! */
|
|
|
|
memmove(conn->path, conn->path + 2, strlen(conn->path + 2)+1);
|
|
|
|
}
|
2001-01-24 07:32:34 -05:00
|
|
|
/*
|
|
|
|
* we deal with file://<host>/<path> differently since it supports no
|
|
|
|
* hostname other than "localhost" and "127.0.0.1", which is unique among
|
|
|
|
* the URL protocols specified in RFC 1738
|
|
|
|
*/
|
2001-08-06 08:14:53 -04:00
|
|
|
if(conn->path[0] != '/') {
|
|
|
|
/* the URL included a host name, we ignore host names in file:// URLs
|
|
|
|
as the standards don't define what to do with them */
|
|
|
|
char *ptr=strchr(conn->path, '/');
|
|
|
|
if(ptr) {
|
|
|
|
/* there was a slash present
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2001-08-06 08:14:53 -04:00
|
|
|
RFC1738 (section 3.1, page 5) says:
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2001-08-06 08:14:53 -04:00
|
|
|
The rest of the locator consists of data specific to the scheme,
|
|
|
|
and is known as the "url-path". It supplies the details of how the
|
|
|
|
specified resource can be accessed. Note that the "/" between the
|
|
|
|
host (or port) and the url-path is NOT part of the url-path.
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2001-08-06 08:14:53 -04:00
|
|
|
As most agents use file://localhost/foo to get '/foo' although the
|
|
|
|
slash preceeding foo is a separator and not a slash for the path,
|
|
|
|
a URL as file://localhost//foo must be valid as well, to refer to
|
|
|
|
the same file with an absolute path.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if(ptr[1] && ('/' == ptr[1]))
|
|
|
|
/* if there was two slashes, we skip the first one as that is then
|
|
|
|
used truly as a separator */
|
2003-03-25 09:23:12 -05:00
|
|
|
ptr++;
|
|
|
|
|
2003-10-28 04:17:15 -05:00
|
|
|
/* This cannot be made with strcpy, as the memory chunks overlap! */
|
|
|
|
memmove(conn->path, ptr, strlen(ptr)+1);
|
2001-08-06 08:14:53 -04:00
|
|
|
}
|
|
|
|
}
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2001-02-20 12:35:51 -05:00
|
|
|
strcpy(conn->protostr, "file"); /* store protocol string lowercase */
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2000-05-22 10:12:12 -04:00
|
|
|
else {
|
2004-04-27 09:56:23 -04:00
|
|
|
/* Set default path */
|
2000-05-22 10:12:12 -04:00
|
|
|
strcpy(conn->path, "/");
|
2004-04-27 09:56:23 -04:00
|
|
|
|
2003-04-10 05:44:39 -04:00
|
|
|
/* We need to search for '/' OR '?' - whichever comes first after host
|
|
|
|
* name but before the path. We need to change that to handle things like
|
|
|
|
* http://example.com?param= (notice the missing '/'). Later we'll insert
|
|
|
|
* that missing slash at the beginning of the path.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
if (2 > sscanf(data->change.url,
|
2004-05-07 14:46:28 -04:00
|
|
|
"%15[^\n:]://%[^\n/?]%[^\n]",
|
2004-04-20 03:53:24 -04:00
|
|
|
conn->protostr,
|
2004-04-27 09:56:23 -04:00
|
|
|
conn->host.name, conn->path)) {
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2001-01-24 07:32:34 -05:00
|
|
|
/*
|
|
|
|
* The URL was badly formatted, let's try the browser-style _without_
|
|
|
|
* protocol specified like 'http://'.
|
|
|
|
*/
|
2004-04-20 03:53:24 -04:00
|
|
|
if((1 > sscanf(data->change.url, "%[^\n/?]%[^\n]",
|
2004-04-27 09:56:23 -04:00
|
|
|
conn->host.name, conn->path)) ) {
|
2001-01-24 07:32:34 -05:00
|
|
|
/*
|
|
|
|
* We couldn't even get this format.
|
|
|
|
*/
|
2000-05-22 10:12:12 -04:00
|
|
|
failf(data, "<url> malformed");
|
|
|
|
return CURLE_URL_MALFORMAT;
|
|
|
|
}
|
2001-01-24 07:32:34 -05:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Since there was no protocol part specified, we guess what protocol it
|
|
|
|
* is based on the first letters of the server name.
|
|
|
|
*/
|
|
|
|
|
2002-09-25 03:08:41 -04:00
|
|
|
/* Note: if you add a new protocol, please update the list in
|
|
|
|
* lib/version.c too! */
|
|
|
|
|
2004-04-27 09:56:23 -04:00
|
|
|
if(checkprefix("GOPHER", conn->host.name))
|
2001-02-20 12:35:51 -05:00
|
|
|
strcpy(conn->protostr, "gopher");
|
1999-12-29 09:20:26 -05:00
|
|
|
#ifdef USE_SSLEAY
|
2004-04-27 09:56:23 -04:00
|
|
|
else if(checkprefix("HTTPS", conn->host.name))
|
2001-02-20 12:35:51 -05:00
|
|
|
strcpy(conn->protostr, "https");
|
2004-04-27 09:56:23 -04:00
|
|
|
else if(checkprefix("FTPS", conn->host.name))
|
2001-03-29 03:16:55 -05:00
|
|
|
strcpy(conn->protostr, "ftps");
|
1999-12-29 09:20:26 -05:00
|
|
|
#endif /* USE_SSLEAY */
|
2004-04-27 09:56:23 -04:00
|
|
|
else if(checkprefix("FTP", conn->host.name))
|
2003-12-02 01:25:41 -05:00
|
|
|
strcpy(conn->protostr, "ftp");
|
2004-04-27 09:56:23 -04:00
|
|
|
else if(checkprefix("TELNET", conn->host.name))
|
2001-02-20 12:35:51 -05:00
|
|
|
strcpy(conn->protostr, "telnet");
|
2004-04-27 09:56:23 -04:00
|
|
|
else if (checkprefix("DICT", conn->host.name))
|
2001-02-20 12:35:51 -05:00
|
|
|
strcpy(conn->protostr, "DICT");
|
2004-04-27 09:56:23 -04:00
|
|
|
else if (checkprefix("LDAP", conn->host.name))
|
2001-02-20 12:35:51 -05:00
|
|
|
strcpy(conn->protostr, "LDAP");
|
2000-05-22 10:12:12 -04:00
|
|
|
else {
|
2001-02-20 12:35:51 -05:00
|
|
|
strcpy(conn->protostr, "http");
|
2000-05-22 10:12:12 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
conn->protocol |= PROT_MISSING; /* not given in URL */
|
|
|
|
}
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
|
2003-04-10 05:44:39 -04:00
|
|
|
/* If the URL is malformatted (missing a '/' after hostname before path) we
|
|
|
|
* insert a slash here. The only letter except '/' we accept to start a path
|
|
|
|
* is '?'.
|
|
|
|
*/
|
|
|
|
if(conn->path[0] == '?') {
|
|
|
|
/* We need this function to deal with overlapping memory areas. We know
|
|
|
|
that the memory area 'path' points to is 'urllen' bytes big and that
|
2003-04-11 12:23:06 -04:00
|
|
|
is bigger than the path. Use +1 to move the zero byte too. */
|
|
|
|
memmove(&conn->path[1], conn->path, strlen(conn->path)+1);
|
2003-04-10 05:44:39 -04:00
|
|
|
conn->path[0] = '/';
|
|
|
|
}
|
2001-02-20 12:35:51 -05:00
|
|
|
|
2002-05-21 18:17:19 -04:00
|
|
|
/*
|
|
|
|
* So if the URL was A://B/C,
|
|
|
|
* conn->protostr is A
|
2004-04-27 09:56:23 -04:00
|
|
|
* conn->host.name is B
|
2002-05-21 18:17:19 -04:00
|
|
|
* conn->path is /C
|
|
|
|
*/
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-01-24 07:32:34 -05:00
|
|
|
/*************************************************************
|
|
|
|
* Take care of proxy authentication stuff
|
|
|
|
*************************************************************/
|
2001-03-14 09:11:11 -05:00
|
|
|
if(conn->bits.proxy_user_passwd) {
|
2003-07-21 09:16:30 -04:00
|
|
|
char proxyuser[MAX_CURL_USER_LENGTH]="";
|
|
|
|
char proxypasswd[MAX_CURL_PASSWORD_LENGTH]="";
|
2000-08-08 09:46:26 -04:00
|
|
|
|
2003-10-17 05:28:00 -04:00
|
|
|
sscanf(data->set.proxyuserpwd,
|
|
|
|
"%" MAX_CURL_USER_LENGTH_TXT "[^:]:"
|
|
|
|
"%" MAX_CURL_PASSWORD_LENGTH_TXT "[^\n]",
|
2003-10-16 10:08:59 -04:00
|
|
|
proxyuser, proxypasswd);
|
2000-08-08 09:46:26 -04:00
|
|
|
|
2003-07-21 09:16:30 -04:00
|
|
|
conn->proxyuser = strdup(proxyuser);
|
|
|
|
if(!conn->proxyuser)
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
conn->proxypasswd = strdup(proxypasswd);
|
|
|
|
if(!conn->proxypasswd)
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
|
2001-01-24 07:32:34 -05:00
|
|
|
/*************************************************************
|
|
|
|
* Detect what (if any) proxy to use
|
|
|
|
*************************************************************/
|
2001-08-30 18:48:34 -04:00
|
|
|
if(!data->change.proxy) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* If proxy was not specified, we check for default proxy environment
|
2001-01-24 07:32:34 -05:00
|
|
|
* variables, to enable i.e Lynx compliance:
|
|
|
|
*
|
|
|
|
* http_proxy=http://some.server.dom:port/
|
|
|
|
* https_proxy=http://some.server.dom:port/
|
|
|
|
* ftp_proxy=http://some.server.dom:port/
|
|
|
|
* gopher_proxy=http://some.server.dom:port/
|
|
|
|
* no_proxy=domain1.dom,host.domain2.dom
|
|
|
|
* (a comma-separated list of hosts which should
|
|
|
|
* not be proxied, or an asterisk to override
|
|
|
|
* all proxy variables)
|
|
|
|
* all_proxy=http://some.server.dom:port/
|
|
|
|
* (seems to exist for the CERN www lib. Probably
|
|
|
|
* the first to check for.)
|
|
|
|
*
|
|
|
|
* For compatibility, the all-uppercase versions of these variables are
|
|
|
|
* checked if the lowercase versions don't exist.
|
|
|
|
*/
|
2000-11-20 02:35:21 -05:00
|
|
|
char *no_proxy=NULL;
|
2001-05-29 15:17:39 -04:00
|
|
|
char *no_proxy_tok_buf;
|
1999-12-29 09:20:26 -05:00
|
|
|
char *proxy=NULL;
|
|
|
|
char proxy_env[128];
|
|
|
|
|
2001-01-05 05:11:41 -05:00
|
|
|
no_proxy=curl_getenv("no_proxy");
|
2000-11-20 02:35:21 -05:00
|
|
|
if(!no_proxy)
|
2001-01-05 05:11:41 -05:00
|
|
|
no_proxy=curl_getenv("NO_PROXY");
|
2000-11-20 02:35:21 -05:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
if(!no_proxy || !strequal("*", no_proxy)) {
|
|
|
|
/* NO_PROXY wasn't specified or it wasn't just an asterisk */
|
|
|
|
char *nope;
|
|
|
|
|
2001-05-29 15:17:39 -04:00
|
|
|
nope=no_proxy?strtok_r(no_proxy, ", ", &no_proxy_tok_buf):NULL;
|
1999-12-29 09:20:26 -05:00
|
|
|
while(nope) {
|
2002-04-23 10:57:37 -04:00
|
|
|
unsigned int namelen;
|
2004-04-27 09:56:23 -04:00
|
|
|
char *endptr = strchr(conn->host.name, ':');
|
2002-04-23 09:34:28 -04:00
|
|
|
if(endptr)
|
2004-04-27 09:56:23 -04:00
|
|
|
namelen=endptr-conn->host.name;
|
2002-04-23 09:34:28 -04:00
|
|
|
else
|
2004-04-27 09:56:23 -04:00
|
|
|
namelen=strlen(conn->host.name);
|
2002-04-23 09:34:28 -04:00
|
|
|
|
|
|
|
if(strlen(nope) <= namelen) {
|
1999-12-29 09:20:26 -05:00
|
|
|
char *checkn=
|
2004-04-27 09:56:23 -04:00
|
|
|
conn->host.name + namelen - strlen(nope);
|
2002-10-28 16:52:00 -05:00
|
|
|
if(checkprefix(nope, checkn)) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* no proxy for this host! */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2001-05-29 15:17:39 -04:00
|
|
|
nope=strtok_r(NULL, ", ", &no_proxy_tok_buf);
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
if(!nope) {
|
|
|
|
/* It was not listed as without proxy */
|
2001-02-20 12:35:51 -05:00
|
|
|
char *protop = conn->protostr;
|
1999-12-29 09:20:26 -05:00
|
|
|
char *envp = proxy_env;
|
|
|
|
char *prox;
|
|
|
|
|
2000-11-20 02:35:21 -05:00
|
|
|
/* Now, build <protocol>_proxy and check for such a one to use */
|
|
|
|
while(*protop)
|
2004-04-21 07:15:02 -04:00
|
|
|
*envp++ = tolower((int)*protop++);
|
2000-11-20 02:35:21 -05:00
|
|
|
|
|
|
|
/* append _proxy */
|
|
|
|
strcpy(envp, "_proxy");
|
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
/* read the protocol proxy: */
|
2001-01-05 05:11:41 -05:00
|
|
|
prox=curl_getenv(proxy_env);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-04-11 10:13:52 -04:00
|
|
|
/*
|
|
|
|
* We don't try the uppercase version of HTTP_PROXY because of
|
|
|
|
* security reasons:
|
|
|
|
*
|
|
|
|
* When curl is used in a webserver application
|
|
|
|
* environment (cgi or php), this environment variable can
|
|
|
|
* be controlled by the web server user by setting the
|
|
|
|
* http header 'Proxy:' to some value.
|
2003-03-25 09:23:12 -05:00
|
|
|
*
|
2001-04-11 10:13:52 -04:00
|
|
|
* This can cause 'internal' http/ftp requests to be
|
|
|
|
* arbitrarily redirected by any external attacker.
|
|
|
|
*/
|
|
|
|
if(!prox && !strequal("http_proxy", proxy_env)) {
|
2000-11-20 02:35:21 -05:00
|
|
|
/* There was no lowercase variable, try the uppercase version: */
|
|
|
|
for(envp = proxy_env; *envp; envp++)
|
2004-04-21 07:15:02 -04:00
|
|
|
*envp = toupper((int)*envp);
|
2001-01-05 05:11:41 -05:00
|
|
|
prox=curl_getenv(proxy_env);
|
2000-11-20 02:35:21 -05:00
|
|
|
}
|
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
if(prox && *prox) { /* don't count "" strings */
|
|
|
|
proxy = prox; /* use this */
|
2000-11-20 02:35:21 -05:00
|
|
|
}
|
|
|
|
else {
|
2001-01-05 05:11:41 -05:00
|
|
|
proxy = curl_getenv("all_proxy"); /* default proxy to use */
|
2000-11-20 02:35:21 -05:00
|
|
|
if(!proxy)
|
2001-01-05 05:11:41 -05:00
|
|
|
proxy=curl_getenv("ALL_PROXY");
|
2000-11-20 02:35:21 -05:00
|
|
|
}
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
if(proxy && *proxy) {
|
|
|
|
/* we have a proxy here to set */
|
2003-05-21 04:08:48 -04:00
|
|
|
char *ptr;
|
2003-10-18 16:14:33 -04:00
|
|
|
char proxyuser[MAX_CURL_USER_LENGTH];
|
|
|
|
char proxypasswd[MAX_CURL_PASSWORD_LENGTH];
|
2003-05-21 04:08:48 -04:00
|
|
|
|
2004-03-31 05:46:06 -05:00
|
|
|
char *fineptr;
|
|
|
|
|
2003-05-21 04:08:48 -04:00
|
|
|
/* skip the possible protocol piece */
|
|
|
|
ptr=strstr(proxy, "://");
|
|
|
|
if(ptr)
|
|
|
|
ptr += 3;
|
|
|
|
else
|
|
|
|
ptr = proxy;
|
|
|
|
|
2004-03-31 05:46:06 -05:00
|
|
|
fineptr = ptr;
|
|
|
|
|
2003-05-21 04:08:48 -04:00
|
|
|
/* check for an @-letter */
|
|
|
|
ptr = strchr(ptr, '@');
|
2004-03-31 05:46:06 -05:00
|
|
|
if(ptr && (2 == sscanf(fineptr,
|
|
|
|
"%" MAX_CURL_USER_LENGTH_TXT"[^:]:"
|
2003-05-21 04:08:48 -04:00
|
|
|
"%" MAX_CURL_PASSWORD_LENGTH_TXT "[^@]",
|
2003-10-18 16:14:33 -04:00
|
|
|
proxyuser, proxypasswd))) {
|
2004-05-12 09:05:01 -04:00
|
|
|
CURLcode res = CURLE_OK;
|
|
|
|
|
2003-05-21 04:08:48 -04:00
|
|
|
/* found user and password, rip them out */
|
2003-08-11 08:30:21 -04:00
|
|
|
Curl_safefree(conn->proxyuser);
|
2003-10-18 16:14:33 -04:00
|
|
|
conn->proxyuser = strdup(proxyuser);
|
2003-07-21 09:16:30 -04:00
|
|
|
|
|
|
|
if(!conn->proxyuser)
|
2004-05-12 09:05:01 -04:00
|
|
|
res = CURLE_OUT_OF_MEMORY;
|
|
|
|
else {
|
|
|
|
Curl_safefree(conn->proxypasswd);
|
|
|
|
conn->proxypasswd = strdup(proxypasswd);
|
|
|
|
|
|
|
|
if(!conn->proxypasswd)
|
|
|
|
res = CURLE_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(CURLE_OK == res) {
|
|
|
|
conn->bits.proxy_user_passwd = TRUE; /* enable it */
|
|
|
|
ptr = strdup(ptr+1); /* the right side of the @-letter */
|
|
|
|
|
|
|
|
if(ptr) {
|
|
|
|
free(proxy); /* free the former proxy string */
|
|
|
|
proxy = ptr; /* now use this instead */
|
|
|
|
}
|
|
|
|
else
|
|
|
|
res = CURLE_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(res) {
|
|
|
|
free(proxy); /* free the allocated proxy string */
|
|
|
|
return res;
|
|
|
|
}
|
2003-05-21 04:08:48 -04:00
|
|
|
}
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
data->change.proxy = proxy;
|
|
|
|
data->change.proxy_alloc=TRUE; /* this needs to be freed later */
|
2001-12-20 10:58:22 -05:00
|
|
|
conn->bits.httpproxy = TRUE;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2000-11-20 02:35:21 -05:00
|
|
|
} /* if (!nope) - it wasn't specified non-proxy */
|
1999-12-29 09:20:26 -05:00
|
|
|
} /* NO_PROXY wasn't specified or '*' */
|
2000-05-29 19:07:22 -04:00
|
|
|
if(no_proxy)
|
|
|
|
free(no_proxy);
|
1999-12-29 09:20:26 -05:00
|
|
|
} /* if not using proxy */
|
|
|
|
|
2001-01-24 07:32:34 -05:00
|
|
|
/*************************************************************
|
2001-09-18 14:33:25 -04:00
|
|
|
* No protocol part in URL was used, add it!
|
2001-01-24 07:32:34 -05:00
|
|
|
*************************************************************/
|
2001-09-18 14:33:25 -04:00
|
|
|
if(conn->protocol&PROT_MISSING) {
|
|
|
|
/* We're guessing prefixes here and if we're told to use a proxy or if
|
|
|
|
we're gonna follow a Location: later or... then we need the protocol
|
|
|
|
part added so that we have a valid URL. */
|
1999-12-29 09:20:26 -05:00
|
|
|
char *reurl;
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
reurl = aprintf("%s://%s", conn->protostr, data->change.url);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
if(!reurl)
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_OUT_OF_MEMORY;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
data->change.url = reurl;
|
|
|
|
data->change.url_alloc = TRUE; /* free this later */
|
2000-05-22 10:12:12 -04:00
|
|
|
conn->protocol &= ~PROT_MISSING; /* switch that one off again */
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
|
2002-06-11 07:13:01 -04:00
|
|
|
#ifndef CURL_DISABLE_HTTP
|
2001-01-24 07:32:34 -05:00
|
|
|
/************************************************************
|
|
|
|
* RESUME on a HTTP page is a tricky business. First, let's just check that
|
|
|
|
* 'range' isn't used, then set the range parameter and leave the resume as
|
|
|
|
* it is to inform about this situation for later use. We will then
|
|
|
|
* "attempt" to resume, and if we're talking to a HTTP/1.1 (or later)
|
|
|
|
* server, we will get the document resumed. If we talk to a HTTP/1.0
|
|
|
|
* server, we just fail since we can't rewind the file writing from within
|
|
|
|
* this function.
|
|
|
|
***********************************************************/
|
2001-04-18 03:25:11 -04:00
|
|
|
if(conn->resume_from) {
|
|
|
|
if(!conn->bits.use_range) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* if it already was in use, we just skip this */
|
2004-05-12 04:26:56 -04:00
|
|
|
conn->range = aprintf("%" FORMAT_OFF_T "-", conn->resume_from);
|
|
|
|
if(!conn->range)
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
2001-04-18 03:25:11 -04:00
|
|
|
conn->bits.rangestringalloc = TRUE; /* mark as allocated */
|
|
|
|
conn->bits.use_range = 1; /* switch on range usage */
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
}
|
2002-06-11 07:13:01 -04:00
|
|
|
#endif
|
2001-01-24 07:32:34 -05:00
|
|
|
/*************************************************************
|
|
|
|
* Setup internals depending on protocol
|
|
|
|
*************************************************************/
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-02-20 12:35:51 -05:00
|
|
|
if (strequal(conn->protostr, "HTTP")) {
|
2002-06-11 07:13:01 -04:00
|
|
|
#ifndef CURL_DISABLE_HTTP
|
2002-01-03 10:01:22 -05:00
|
|
|
conn->port = (data->set.use_port && data->state.allow_port)?
|
|
|
|
data->set.use_port:PORT_HTTP;
|
2001-03-02 10:34:15 -05:00
|
|
|
conn->remote_port = PORT_HTTP;
|
2000-05-22 10:12:12 -04:00
|
|
|
conn->protocol |= PROT_HTTP;
|
2001-01-05 05:11:41 -05:00
|
|
|
conn->curl_do = Curl_http;
|
2002-08-12 05:43:20 -04:00
|
|
|
conn->curl_do_more = NULL;
|
2001-01-05 05:11:41 -05:00
|
|
|
conn->curl_done = Curl_http_done;
|
2001-11-12 09:08:41 -05:00
|
|
|
conn->curl_connect = Curl_http_connect;
|
2002-06-11 07:13:01 -04:00
|
|
|
#else
|
|
|
|
failf(data, LIBCURL_NAME
|
|
|
|
" was built with HTTP disabled, http: not supported!");
|
|
|
|
return CURLE_UNSUPPORTED_PROTOCOL;
|
|
|
|
#endif
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2001-02-20 12:35:51 -05:00
|
|
|
else if (strequal(conn->protostr, "HTTPS")) {
|
2002-06-11 07:13:01 -04:00
|
|
|
#if defined(USE_SSLEAY) && !defined(CURL_DISABLE_HTTP)
|
2001-03-02 10:34:15 -05:00
|
|
|
|
2002-01-03 10:01:22 -05:00
|
|
|
conn->port = (data->set.use_port && data->state.allow_port)?
|
|
|
|
data->set.use_port:PORT_HTTPS;
|
2001-03-02 10:34:15 -05:00
|
|
|
conn->remote_port = PORT_HTTPS;
|
2001-12-02 09:16:34 -05:00
|
|
|
conn->protocol |= PROT_HTTP|PROT_HTTPS|PROT_SSL;
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2001-01-05 05:11:41 -05:00
|
|
|
conn->curl_do = Curl_http;
|
2002-08-12 05:43:20 -04:00
|
|
|
conn->curl_do_more = NULL;
|
2001-01-05 05:11:41 -05:00
|
|
|
conn->curl_done = Curl_http_done;
|
|
|
|
conn->curl_connect = Curl_http_connect;
|
2000-05-22 10:12:12 -04:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
#else /* USE_SSLEAY */
|
2001-09-03 03:01:49 -04:00
|
|
|
failf(data, LIBCURL_NAME
|
|
|
|
" was built with SSL disabled, https: not supported!");
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_UNSUPPORTED_PROTOCOL;
|
1999-12-29 09:20:26 -05:00
|
|
|
#endif /* !USE_SSLEAY */
|
|
|
|
}
|
2001-02-20 12:35:51 -05:00
|
|
|
else if (strequal(conn->protostr, "GOPHER")) {
|
2002-06-11 07:13:01 -04:00
|
|
|
#ifndef CURL_DISABLE_GOPHER
|
2002-01-03 10:01:22 -05:00
|
|
|
conn->port = (data->set.use_port && data->state.allow_port)?
|
|
|
|
data->set.use_port:PORT_GOPHER;
|
2001-03-02 10:34:15 -05:00
|
|
|
conn->remote_port = PORT_GOPHER;
|
1999-12-29 09:20:26 -05:00
|
|
|
/* Skip /<item-type>/ in path if present */
|
2000-05-22 10:12:12 -04:00
|
|
|
if (isdigit((int)conn->path[1])) {
|
2004-04-20 03:53:24 -04:00
|
|
|
conn->path = strchr(&conn->path[1], '/');
|
|
|
|
if (conn->path == NULL)
|
|
|
|
conn->path = conn->pathbuffer;
|
|
|
|
}
|
2000-05-22 10:12:12 -04:00
|
|
|
conn->protocol |= PROT_GOPHER;
|
2001-01-05 05:11:41 -05:00
|
|
|
conn->curl_do = Curl_http;
|
2002-08-12 05:43:20 -04:00
|
|
|
conn->curl_do_more = NULL;
|
2001-01-05 05:11:41 -05:00
|
|
|
conn->curl_done = Curl_http_done;
|
2002-06-11 07:13:01 -04:00
|
|
|
#else
|
|
|
|
failf(data, LIBCURL_NAME
|
|
|
|
" was built with GOPHER disabled, gopher: not supported!");
|
|
|
|
#endif
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2001-03-29 03:16:55 -05:00
|
|
|
else if(strequal(conn->protostr, "FTP") ||
|
|
|
|
strequal(conn->protostr, "FTPS")) {
|
2002-06-11 07:13:01 -04:00
|
|
|
|
|
|
|
#ifndef CURL_DISABLE_FTP
|
1999-12-29 09:20:26 -05:00
|
|
|
char *type;
|
2004-01-11 17:56:36 -05:00
|
|
|
int port = PORT_FTP;
|
2001-03-29 03:16:55 -05:00
|
|
|
|
|
|
|
if(strequal(conn->protostr, "FTPS")) {
|
|
|
|
#ifdef USE_SSLEAY
|
2001-12-02 09:16:34 -05:00
|
|
|
conn->protocol |= PROT_FTPS|PROT_SSL;
|
2003-11-24 02:15:37 -05:00
|
|
|
conn->ssl[SECONDARYSOCKET].use = TRUE; /* send data securely */
|
2004-01-11 17:56:36 -05:00
|
|
|
port = PORT_FTPS;
|
2001-03-29 03:16:55 -05:00
|
|
|
#else
|
2001-09-03 03:01:49 -04:00
|
|
|
failf(data, LIBCURL_NAME
|
|
|
|
" was built with SSL disabled, ftps: not supported!");
|
2001-03-29 03:16:55 -05:00
|
|
|
return CURLE_UNSUPPORTED_PROTOCOL;
|
|
|
|
#endif /* !USE_SSLEAY */
|
|
|
|
}
|
|
|
|
|
2002-01-03 10:01:22 -05:00
|
|
|
conn->port = (data->set.use_port && data->state.allow_port)?
|
2004-01-11 17:56:36 -05:00
|
|
|
data->set.use_port:port;
|
|
|
|
conn->remote_port = port;
|
2000-05-22 10:12:12 -04:00
|
|
|
conn->protocol |= PROT_FTP;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->change.proxy &&
|
2002-09-27 05:49:40 -04:00
|
|
|
*data->change.proxy &&
|
2001-08-30 18:48:34 -04:00
|
|
|
!data->set.tunnel_thru_httpproxy) {
|
2000-09-14 10:05:01 -04:00
|
|
|
/* Unless we have asked to tunnel ftp operations through the proxy, we
|
|
|
|
switch and use HTTP operations only */
|
2001-03-29 03:16:55 -05:00
|
|
|
if(conn->protocol & PROT_FTPS) {
|
|
|
|
/* FTPS is a hacked protocol and does not work through your
|
|
|
|
ordinary http proxy! */
|
|
|
|
failf(data, "ftps does not work through http proxy!");
|
|
|
|
return CURLE_UNSUPPORTED_PROTOCOL;
|
|
|
|
}
|
2002-06-11 07:13:01 -04:00
|
|
|
#ifndef CURL_DISABLE_HTTP
|
2001-01-05 05:11:41 -05:00
|
|
|
conn->curl_do = Curl_http;
|
|
|
|
conn->curl_done = Curl_http_done;
|
2002-06-11 07:13:01 -04:00
|
|
|
#else
|
|
|
|
failf(data, "FTP over http proxy requires HTTP support built-in!");
|
|
|
|
return CURLE_UNSUPPORTED_PROTOCOL;
|
|
|
|
#endif
|
2000-05-22 10:12:12 -04:00
|
|
|
}
|
|
|
|
else {
|
2001-01-05 05:11:41 -05:00
|
|
|
conn->curl_do = Curl_ftp;
|
2002-08-12 05:43:20 -04:00
|
|
|
conn->curl_do_more = Curl_ftp_nextconnect;
|
2001-01-05 05:11:41 -05:00
|
|
|
conn->curl_done = Curl_ftp_done;
|
|
|
|
conn->curl_connect = Curl_ftp_connect;
|
2001-03-02 02:43:20 -05:00
|
|
|
conn->curl_disconnect = Curl_ftp_disconnect;
|
2000-05-22 10:12:12 -04:00
|
|
|
}
|
|
|
|
|
2004-04-20 03:53:24 -04:00
|
|
|
conn->path++; /* don't include the initial slash */
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
/* FTP URLs support an extension like ";type=<typecode>" that
|
2001-01-24 07:32:34 -05:00
|
|
|
* we'll try to get now! */
|
2004-04-20 03:53:24 -04:00
|
|
|
type=strstr(conn->path, ";type=");
|
1999-12-29 09:20:26 -05:00
|
|
|
if(!type) {
|
2004-04-27 09:56:23 -04:00
|
|
|
type=strstr(conn->host.rawalloc, ";type=");
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
if(type) {
|
|
|
|
char command;
|
2002-05-21 18:17:19 -04:00
|
|
|
*type=0; /* it was in the middle of the hostname */
|
2004-04-21 07:15:02 -04:00
|
|
|
command = toupper((int)type[6]);
|
1999-12-29 09:20:26 -05:00
|
|
|
switch(command) {
|
|
|
|
case 'A': /* ASCII mode */
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.ftp_ascii = 1;
|
1999-12-29 09:20:26 -05:00
|
|
|
break;
|
|
|
|
case 'D': /* directory mode */
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.ftp_list_only = 1;
|
1999-12-29 09:20:26 -05:00
|
|
|
break;
|
|
|
|
case 'I': /* binary mode */
|
|
|
|
default:
|
|
|
|
/* switch off ASCII */
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.ftp_ascii = 0;
|
1999-12-29 09:20:26 -05:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2002-06-11 07:13:01 -04:00
|
|
|
#else /* CURL_DISABLE_FTP */
|
|
|
|
failf(data, LIBCURL_NAME
|
|
|
|
" was built with FTP disabled, ftp/ftps: not supported!");
|
|
|
|
return CURLE_UNSUPPORTED_PROTOCOL;
|
|
|
|
#endif
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2001-02-20 12:35:51 -05:00
|
|
|
else if(strequal(conn->protostr, "TELNET")) {
|
2002-06-11 07:13:01 -04:00
|
|
|
#ifndef CURL_DISABLE_TELNET
|
1999-12-29 09:20:26 -05:00
|
|
|
/* telnet testing factory */
|
2000-05-22 10:12:12 -04:00
|
|
|
conn->protocol |= PROT_TELNET;
|
|
|
|
|
2002-01-03 10:01:22 -05:00
|
|
|
conn->port = (data->set.use_port && data->state.allow_port)?
|
|
|
|
data->set.use_port: PORT_TELNET;
|
2001-03-02 10:34:15 -05:00
|
|
|
conn->remote_port = PORT_TELNET;
|
2001-01-05 05:11:41 -05:00
|
|
|
conn->curl_do = Curl_telnet;
|
|
|
|
conn->curl_done = Curl_telnet_done;
|
2002-06-11 07:13:01 -04:00
|
|
|
#else
|
|
|
|
failf(data, LIBCURL_NAME
|
|
|
|
" was built with TELNET disabled!");
|
|
|
|
#endif
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2001-02-20 12:35:51 -05:00
|
|
|
else if (strequal(conn->protostr, "DICT")) {
|
2002-06-11 07:13:01 -04:00
|
|
|
#ifndef CURL_DISABLE_DICT
|
2000-05-22 10:12:12 -04:00
|
|
|
conn->protocol |= PROT_DICT;
|
2002-01-03 10:01:22 -05:00
|
|
|
conn->port = (data->set.use_port && data->state.allow_port)?
|
|
|
|
data->set.use_port:PORT_DICT;
|
2001-03-02 10:34:15 -05:00
|
|
|
conn->remote_port = PORT_DICT;
|
2001-01-05 05:11:41 -05:00
|
|
|
conn->curl_do = Curl_dict;
|
2001-08-14 04:40:06 -04:00
|
|
|
conn->curl_done = NULL; /* no DICT-specific done */
|
2002-06-11 07:13:01 -04:00
|
|
|
#else
|
|
|
|
failf(data, LIBCURL_NAME
|
|
|
|
" was built with DICT disabled!");
|
|
|
|
#endif
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2001-02-20 12:35:51 -05:00
|
|
|
else if (strequal(conn->protostr, "LDAP")) {
|
2002-06-11 07:13:01 -04:00
|
|
|
#ifndef CURL_DISABLE_LDAP
|
2000-05-22 10:12:12 -04:00
|
|
|
conn->protocol |= PROT_LDAP;
|
2002-01-03 10:01:22 -05:00
|
|
|
conn->port = (data->set.use_port && data->state.allow_port)?
|
|
|
|
data->set.use_port:PORT_LDAP;
|
2001-03-02 10:34:15 -05:00
|
|
|
conn->remote_port = PORT_LDAP;
|
2001-01-05 05:11:41 -05:00
|
|
|
conn->curl_do = Curl_ldap;
|
2001-08-14 04:40:06 -04:00
|
|
|
conn->curl_done = NULL; /* no LDAP-specific done */
|
2002-06-11 07:13:01 -04:00
|
|
|
#else
|
|
|
|
failf(data, LIBCURL_NAME
|
|
|
|
" was built with LDAP disabled!");
|
|
|
|
#endif
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2001-02-20 12:35:51 -05:00
|
|
|
else if (strequal(conn->protostr, "FILE")) {
|
2002-06-11 07:13:01 -04:00
|
|
|
#ifndef CURL_DISABLE_FILE
|
2000-05-22 10:12:12 -04:00
|
|
|
conn->protocol |= PROT_FILE;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-03-05 08:39:01 -05:00
|
|
|
conn->curl_do = Curl_file;
|
2000-05-22 10:12:12 -04:00
|
|
|
/* no done() function */
|
2000-09-14 06:41:07 -04:00
|
|
|
|
2001-03-05 08:39:01 -05:00
|
|
|
/* anyway, this is supposed to be the connect function so we better
|
|
|
|
at least check that the file is present here! */
|
|
|
|
result = Curl_file_connect(conn);
|
2000-09-14 06:41:07 -04:00
|
|
|
|
2001-03-05 08:39:01 -05:00
|
|
|
/* Setup a "faked" transfer that'll do nothing */
|
|
|
|
if(CURLE_OK == result) {
|
2002-12-13 11:15:19 -05:00
|
|
|
conn->bits.tcpconnect = TRUE; /* we are "connected */
|
2001-03-05 08:39:01 -05:00
|
|
|
result = Curl_Transfer(conn, -1, -1, FALSE, NULL, /* no download */
|
|
|
|
-1, NULL); /* no upload */
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
2002-06-11 07:13:01 -04:00
|
|
|
#else
|
|
|
|
failf(data, LIBCURL_NAME
|
|
|
|
" was built with FILE disabled!");
|
|
|
|
#endif
|
2000-05-22 10:12:12 -04:00
|
|
|
}
|
1999-12-29 09:20:26 -05:00
|
|
|
else {
|
2001-01-24 07:32:34 -05:00
|
|
|
/* We fell through all checks and thus we don't support the specified
|
|
|
|
protocol */
|
2001-02-20 12:35:51 -05:00
|
|
|
failf(data, "Unsupported protocol: %s", conn->protostr);
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_UNSUPPORTED_PROTOCOL;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
|
2001-01-24 07:32:34 -05:00
|
|
|
/*************************************************************
|
|
|
|
* Figure out the remote port number
|
|
|
|
*
|
|
|
|
* No matter if we use a proxy or not, we have to figure out the remote
|
|
|
|
* port number of various reasons.
|
|
|
|
*
|
|
|
|
* To be able to detect port number flawlessly, we must not confuse them
|
2001-10-02 05:40:06 -04:00
|
|
|
* IPv6-specified addresses in the [0::1] style. (RFC2732)
|
2002-05-21 18:17:19 -04:00
|
|
|
*
|
2004-04-27 09:56:23 -04:00
|
|
|
* The conn->host.name is currently [user:passwd@]host[:port] where host
|
2004-04-20 03:53:24 -04:00
|
|
|
* could be a hostname, IPv4 address or IPv6 address.
|
2001-01-24 07:32:34 -05:00
|
|
|
*************************************************************/
|
2004-04-27 09:56:23 -04:00
|
|
|
if((1 == sscanf(conn->host.name, "[%*39[0-9a-fA-F:.]%c", &endbracket)) &&
|
2002-08-05 12:50:55 -04:00
|
|
|
(']' == endbracket)) {
|
|
|
|
/* this is a RFC2732-style specified IP-address */
|
2002-09-11 06:32:37 -04:00
|
|
|
conn->bits.ipv6_ip = TRUE;
|
2002-08-05 12:50:55 -04:00
|
|
|
|
2004-04-27 09:56:23 -04:00
|
|
|
conn->host.name++; /* pass the starting bracket */
|
|
|
|
tmp = strchr(conn->host.name, ']');
|
2002-08-05 12:50:55 -04:00
|
|
|
*tmp = 0; /* zero terminate */
|
|
|
|
tmp++; /* pass the ending bracket */
|
|
|
|
if(':' != *tmp)
|
|
|
|
tmp = NULL; /* no port number available */
|
|
|
|
}
|
|
|
|
else
|
2004-04-27 09:56:23 -04:00
|
|
|
tmp = strrchr(conn->host.name, ':');
|
2001-08-15 17:40:09 -04:00
|
|
|
|
2002-05-21 18:17:19 -04:00
|
|
|
if (tmp) {
|
|
|
|
char *rest;
|
|
|
|
unsigned long port;
|
2001-01-23 05:21:30 -05:00
|
|
|
|
2002-05-21 18:17:19 -04:00
|
|
|
port=strtoul(tmp+1, &rest, 10); /* Port number must be decimal */
|
2001-01-23 05:21:30 -05:00
|
|
|
|
2002-05-21 18:17:19 -04:00
|
|
|
if (rest != (tmp+1) && *rest == '\0') {
|
|
|
|
/* The colon really did have only digits after it,
|
|
|
|
* so it is either a port number or a mistake */
|
|
|
|
|
|
|
|
if (port > 0xffff) { /* Single unix standard says port numbers are
|
|
|
|
* 16 bits long */
|
|
|
|
failf(data, "Port number too large: %lu", port);
|
|
|
|
return CURLE_URL_MALFORMAT;
|
|
|
|
}
|
|
|
|
|
|
|
|
*tmp = '\0'; /* cut off the name there */
|
2002-08-26 13:20:29 -04:00
|
|
|
conn->remote_port = (unsigned short)port;
|
2002-05-21 18:17:19 -04:00
|
|
|
}
|
2001-01-23 05:21:30 -05:00
|
|
|
}
|
|
|
|
|
2002-09-27 05:49:40 -04:00
|
|
|
if(data->change.proxy && *data->change.proxy) {
|
2001-03-09 10:18:25 -05:00
|
|
|
/* If this is supposed to use a proxy, we need to figure out the proxy
|
|
|
|
host name name, so that we can re-use an existing connection
|
|
|
|
that may exist registered to the same proxy host. */
|
|
|
|
|
|
|
|
char *prox_portno;
|
|
|
|
char *endofprot;
|
|
|
|
|
|
|
|
/* We need to make a duplicate of the proxy so that we can modify the
|
|
|
|
string safely. */
|
2001-08-30 18:48:34 -04:00
|
|
|
char *proxydup=strdup(data->change.proxy);
|
2001-03-09 10:18:25 -05:00
|
|
|
|
|
|
|
/* We use 'proxyptr' to point to the proxy name from now on... */
|
|
|
|
char *proxyptr=proxydup;
|
|
|
|
|
|
|
|
if(NULL == proxydup) {
|
|
|
|
failf(data, "memory shortage");
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Daniel Dec 10, 1998:
|
|
|
|
We do the proxy host string parsing here. We want the host name and the
|
|
|
|
port name. Accept a protocol:// prefix, even though it should just be
|
|
|
|
ignored. */
|
|
|
|
|
|
|
|
/* 1. skip the protocol part if present */
|
|
|
|
endofprot=strstr(proxyptr, "://");
|
|
|
|
if(endofprot) {
|
|
|
|
proxyptr = endofprot+3;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* allow user to specify proxy.server.com:1080 if desired */
|
|
|
|
prox_portno = strchr (proxyptr, ':');
|
|
|
|
if (prox_portno) {
|
|
|
|
*prox_portno = 0x0; /* cut off number from host name */
|
|
|
|
prox_portno ++;
|
|
|
|
/* now set the local port number */
|
|
|
|
conn->port = atoi(prox_portno);
|
|
|
|
}
|
2001-08-30 18:48:34 -04:00
|
|
|
else if(data->set.proxyport) {
|
2001-03-09 10:18:25 -05:00
|
|
|
/* None given in the proxy string, then get the default one if it is
|
|
|
|
given */
|
2001-08-30 18:48:34 -04:00
|
|
|
conn->port = data->set.proxyport;
|
2001-03-09 10:18:25 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/* now, clone the cleaned proxy host name */
|
2004-04-27 09:56:23 -04:00
|
|
|
conn->proxy.rawalloc = strdup(proxyptr);
|
|
|
|
conn->proxy.name = conn->proxy.rawalloc;
|
2001-03-09 10:18:25 -05:00
|
|
|
|
|
|
|
free(proxydup); /* free the duplicate pointer and not the modified */
|
|
|
|
}
|
|
|
|
|
2002-05-21 18:17:19 -04:00
|
|
|
/*************************************************************
|
|
|
|
* Take care of user and password authentication stuff
|
|
|
|
*************************************************************/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Inputs: data->set.userpwd (CURLOPT_USERPWD)
|
|
|
|
* data->set.fpasswd (CURLOPT_PASSWDFUNCTION)
|
|
|
|
* data->set.use_netrc (CURLOPT_NETRC)
|
2004-04-27 09:56:23 -04:00
|
|
|
* conn->host.name
|
2002-05-21 18:17:19 -04:00
|
|
|
* netrc file
|
|
|
|
* hard-coded defaults
|
|
|
|
*
|
|
|
|
* Outputs: (almost :- all currently undefined)
|
|
|
|
* conn->bits.user_passwd - non-zero if non-default passwords exist
|
2003-07-19 19:56:33 -04:00
|
|
|
* conn->user - non-zero length if defined
|
|
|
|
* conn->passwd - ditto
|
2004-04-27 09:56:23 -04:00
|
|
|
* conn->host.name - remove user name and password
|
2002-05-21 18:17:19 -04:00
|
|
|
*/
|
|
|
|
|
|
|
|
/* At this point, we're hoping all the other special cases have
|
2004-04-27 09:56:23 -04:00
|
|
|
* been taken care of, so conn->host.name is at most
|
2002-05-21 18:17:19 -04:00
|
|
|
* [user[:password]]@]hostname
|
|
|
|
*
|
|
|
|
* We need somewhere to put the embedded details, so do that first.
|
|
|
|
*/
|
|
|
|
|
2003-07-19 19:56:33 -04:00
|
|
|
user[0] =0; /* to make everything well-defined */
|
|
|
|
passwd[0]=0;
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2002-05-21 18:17:19 -04:00
|
|
|
if (conn->protocol & (PROT_FTP|PROT_HTTP)) {
|
|
|
|
/* This is a FTP or HTTP URL, we will now try to extract the possible
|
|
|
|
* user+password pair in a string like:
|
|
|
|
* ftp://user:password@ftp.my.site:8021/README */
|
2004-04-27 09:56:23 -04:00
|
|
|
char *ptr=strchr(conn->host.name, '@');
|
|
|
|
char *userpass = conn->host.name;
|
2002-05-21 18:17:19 -04:00
|
|
|
if(ptr != NULL) {
|
|
|
|
/* there's a user+password given here, to the left of the @ */
|
|
|
|
|
2004-04-27 09:56:23 -04:00
|
|
|
conn->host.name = ++ptr;
|
2002-05-21 18:17:19 -04:00
|
|
|
|
|
|
|
/* So the hostname is sane. Only bother interpreting the
|
|
|
|
* results if we could care. It could still be wasted
|
|
|
|
* work because it might be overtaken by the programmatically
|
|
|
|
* set user/passwd, but doing that first adds more cases here :-(
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (data->set.use_netrc != CURL_NETRC_REQUIRED) {
|
|
|
|
/* We could use the one in the URL */
|
|
|
|
|
|
|
|
conn->bits.user_passwd = 1; /* enable user+password */
|
|
|
|
|
|
|
|
if(*userpass != ':') {
|
|
|
|
/* the name is given, get user+password */
|
|
|
|
sscanf(userpass, "%127[^:@]:%127[^@]",
|
2003-07-19 19:56:33 -04:00
|
|
|
user, passwd);
|
2002-05-21 18:17:19 -04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
/* no name given, get the password only */
|
2003-07-19 19:56:33 -04:00
|
|
|
sscanf(userpass, ":%127[^@]", passwd);
|
2002-05-21 18:17:19 -04:00
|
|
|
|
2003-07-19 19:56:33 -04:00
|
|
|
if(user[0]) {
|
|
|
|
char *newname=curl_unescape(user, 0);
|
2004-05-13 10:12:49 -04:00
|
|
|
if(!newname)
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
if(strlen(newname) < sizeof(user))
|
2003-07-19 19:56:33 -04:00
|
|
|
strcpy(user, newname);
|
2004-05-13 10:12:49 -04:00
|
|
|
|
2002-05-21 18:17:19 -04:00
|
|
|
/* if the new name is longer than accepted, then just use
|
|
|
|
the unconverted name, it'll be wrong but what the heck */
|
|
|
|
free(newname);
|
|
|
|
}
|
2003-07-19 19:56:33 -04:00
|
|
|
if (passwd[0]) {
|
2002-05-21 18:17:19 -04:00
|
|
|
/* we have a password found in the URL, decode it! */
|
2003-07-19 19:56:33 -04:00
|
|
|
char *newpasswd=curl_unescape(passwd, 0);
|
2004-05-13 10:12:49 -04:00
|
|
|
if(!newpasswd)
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
if(strlen(newpasswd) < sizeof(passwd))
|
2003-07-19 19:56:33 -04:00
|
|
|
strcpy(passwd, newpasswd);
|
2004-05-13 10:12:49 -04:00
|
|
|
|
2002-05-21 18:17:19 -04:00
|
|
|
free(newpasswd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Programmatically set password:
|
|
|
|
* - always applies, if available
|
|
|
|
* - takes precedence over the values we just set above
|
|
|
|
* so scribble it over the top.
|
|
|
|
* User-supplied passwords are assumed not to need unescaping.
|
|
|
|
*
|
|
|
|
* user_password is set in "inherite initial knowledge' above,
|
|
|
|
* so it doesn't have to be set in this block
|
|
|
|
*/
|
|
|
|
if (data->set.userpwd != NULL) {
|
2003-10-16 10:08:59 -04:00
|
|
|
/* the name is given, get user+password */
|
2003-10-17 05:28:00 -04:00
|
|
|
sscanf(data->set.userpwd,
|
|
|
|
"%" MAX_CURL_USER_LENGTH_TXT "[^:]:"
|
|
|
|
"%" MAX_CURL_PASSWORD_LENGTH_TXT "[^\n]",
|
2003-10-16 10:08:59 -04:00
|
|
|
user, passwd);
|
2002-05-21 18:17:19 -04:00
|
|
|
}
|
|
|
|
|
2003-10-16 10:08:59 -04:00
|
|
|
if (data->set.use_netrc != CURL_NETRC_IGNORED) {
|
2004-04-27 09:56:23 -04:00
|
|
|
if(Curl_parsenetrc(conn->host.name,
|
2003-11-11 09:30:43 -05:00
|
|
|
user, passwd,
|
|
|
|
data->set.netrc_file)) {
|
2003-12-19 03:03:15 -05:00
|
|
|
infof(data, "Couldn't find host %s in the .netrc file, using defaults\n",
|
2004-04-27 09:56:23 -04:00
|
|
|
conn->host.name);
|
2003-01-20 07:00:46 -05:00
|
|
|
}
|
2003-10-16 10:08:59 -04:00
|
|
|
else
|
2002-05-21 18:17:19 -04:00
|
|
|
conn->bits.user_passwd = 1; /* enable user+password */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If our protocol needs a password and we have none, use the defaults */
|
2003-10-17 05:28:00 -04:00
|
|
|
if ( (conn->protocol & PROT_FTP) &&
|
2003-10-16 10:08:59 -04:00
|
|
|
!conn->bits.user_passwd) {
|
2003-01-09 11:47:09 -05:00
|
|
|
|
2003-10-17 05:28:00 -04:00
|
|
|
conn->user = strdup(CURL_DEFAULT_USER);
|
|
|
|
conn->passwd = strdup(CURL_DEFAULT_PASSWORD);
|
2003-01-09 11:47:09 -05:00
|
|
|
|
2002-05-21 18:17:19 -04:00
|
|
|
/* This is the default password, so DON'T set conn->bits.user_passwd */
|
|
|
|
}
|
2003-10-17 05:28:00 -04:00
|
|
|
else {
|
2003-10-21 02:34:15 -04:00
|
|
|
/* store user + password, zero-length if not set */
|
|
|
|
conn->user = strdup(user);
|
|
|
|
conn->passwd = strdup(passwd);
|
2003-10-17 05:28:00 -04:00
|
|
|
}
|
2003-07-19 19:56:33 -04:00
|
|
|
|
2001-02-20 12:35:51 -05:00
|
|
|
/*************************************************************
|
|
|
|
* Check the current list of connections to see if we can
|
|
|
|
* re-use an already existing one or if we have to create a
|
|
|
|
* new one.
|
|
|
|
*************************************************************/
|
|
|
|
|
2003-03-31 16:43:05 -05:00
|
|
|
/* get a cloned copy of the SSL config situation stored in the
|
|
|
|
connection struct */
|
|
|
|
if(!Curl_clone_ssl_config(&data->set.ssl, &conn->ssl_config))
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
|
2004-03-01 04:43:42 -05:00
|
|
|
/* reuse_fresh is TRUE if we are told to use a new connection by force, but
|
|
|
|
we only acknowledge this option if this is not a re-used connection
|
|
|
|
already (which happens due to follow-location or during a HTTP
|
|
|
|
authentication phase). */
|
2004-03-02 09:00:44 -05:00
|
|
|
if(data->set.reuse_fresh && !data->state.this_is_a_follow)
|
2004-03-01 04:43:42 -05:00
|
|
|
reuse = FALSE;
|
|
|
|
else
|
|
|
|
reuse = ConnectionExists(data, conn, &conn_temp);
|
|
|
|
|
|
|
|
if(reuse) {
|
2001-02-20 12:35:51 -05:00
|
|
|
/*
|
|
|
|
* We already have a connection for this, we got the former connection
|
|
|
|
* in the conn_temp variable and thus we need to cleanup the one we
|
|
|
|
* just allocated before we can move along and use the previously
|
|
|
|
* existing one.
|
|
|
|
*/
|
2001-03-09 11:50:08 -05:00
|
|
|
struct connectdata *old_conn = conn;
|
2004-04-20 03:53:24 -04:00
|
|
|
|
2004-04-27 09:56:23 -04:00
|
|
|
if(old_conn->proxy.rawalloc)
|
|
|
|
free(old_conn->proxy.rawalloc);
|
2003-03-21 03:09:48 -05:00
|
|
|
|
2003-03-31 16:43:05 -05:00
|
|
|
/* free the SSL config struct from this connection struct as this was
|
|
|
|
allocated in vain and is targeted for destruction */
|
|
|
|
Curl_free_ssl_config(&conn->ssl_config);
|
|
|
|
|
2001-02-20 12:35:51 -05:00
|
|
|
conn = conn_temp; /* use this connection from now on */
|
2001-03-09 11:50:08 -05:00
|
|
|
|
2003-03-21 03:09:48 -05:00
|
|
|
/* get the user+password information from the old_conn struct since it may
|
|
|
|
* be new for this request even when we re-use an existing connection */
|
|
|
|
conn->bits.user_passwd = old_conn->bits.user_passwd;
|
2004-01-23 03:36:03 -05:00
|
|
|
conn->bits.proxy_user_passwd = old_conn->bits.proxy_user_passwd;
|
2003-03-21 03:09:48 -05:00
|
|
|
|
2004-04-06 11:14:10 -04:00
|
|
|
/* get the newly set value, not the old one */
|
|
|
|
conn->bits.no_body = old_conn->bits.no_body;
|
|
|
|
|
2004-04-29 09:41:48 -04:00
|
|
|
free(old_conn->host.rawalloc); /* free the newly allocated name buffer */
|
2001-05-10 05:31:48 -04:00
|
|
|
|
2004-04-20 03:53:24 -04:00
|
|
|
free(conn->pathbuffer); /* free the newly allocated path pointer */
|
|
|
|
conn->pathbuffer = old_conn->pathbuffer; /* use the old one */
|
|
|
|
conn->path = old_conn->path;
|
2001-02-22 18:32:02 -05:00
|
|
|
|
|
|
|
/* re-use init */
|
2001-03-02 02:43:20 -05:00
|
|
|
conn->bits.reuse = TRUE; /* yes, we're re-using here */
|
2001-05-11 02:40:04 -04:00
|
|
|
conn->bits.chunk = FALSE; /* always assume not chunked unless told
|
|
|
|
otherwise */
|
2001-04-27 04:02:10 -04:00
|
|
|
conn->maxdownload = -1; /* might have been used previously! */
|
2001-02-22 18:32:02 -05:00
|
|
|
|
2003-10-17 05:28:00 -04:00
|
|
|
Curl_safefree(old_conn->user);
|
|
|
|
Curl_safefree(old_conn->passwd);
|
2003-08-11 08:30:21 -04:00
|
|
|
Curl_safefree(old_conn->proxyuser);
|
|
|
|
Curl_safefree(old_conn->proxypasswd);
|
2003-07-19 19:56:33 -04:00
|
|
|
|
2003-11-24 02:10:02 -05:00
|
|
|
if(old_conn->bits.rangestringalloc)
|
|
|
|
free(old_conn->range);
|
|
|
|
|
2001-03-09 11:50:08 -05:00
|
|
|
free(old_conn); /* we don't need this anymore */
|
|
|
|
|
2001-05-15 03:21:13 -04:00
|
|
|
/*
|
|
|
|
* If we're doing a resumed transfer, we need to setup our stuff
|
|
|
|
* properly.
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
conn->resume_from = data->set.set_resume_from;
|
2001-05-15 03:21:13 -04:00
|
|
|
if (conn->resume_from) {
|
2003-11-24 02:10:02 -05:00
|
|
|
if (conn->bits.rangestringalloc == TRUE)
|
|
|
|
free(conn->range);
|
2004-05-12 04:26:56 -04:00
|
|
|
conn->range = aprintf("%" FORMAT_OFF_T "-", conn->resume_from);
|
|
|
|
if(!conn->range)
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
2003-11-24 02:10:02 -05:00
|
|
|
|
|
|
|
/* tell ourselves to fetch this range */
|
|
|
|
conn->bits.use_range = TRUE; /* enable range download */
|
|
|
|
conn->bits.rangestringalloc = TRUE; /* mark range string allocated */
|
2001-05-15 03:21:13 -04:00
|
|
|
}
|
2001-08-30 18:48:34 -04:00
|
|
|
else if (data->set.set_range) {
|
2001-06-12 05:21:37 -04:00
|
|
|
/* There is a range, but is not a resume, useful for random ftp access */
|
2001-08-30 18:48:34 -04:00
|
|
|
conn->range = strdup(data->set.set_range);
|
2004-05-12 04:26:56 -04:00
|
|
|
if(!conn->range)
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
2001-06-12 05:21:37 -04:00
|
|
|
conn->bits.rangestringalloc = TRUE; /* mark range string allocated */
|
|
|
|
conn->bits.use_range = TRUE; /* enable range download */
|
|
|
|
}
|
2003-10-09 16:04:47 -04:00
|
|
|
else
|
|
|
|
conn->bits.use_range = FALSE; /* disable range download */
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2001-03-09 10:18:25 -05:00
|
|
|
*in_connect = conn; /* return this instead! */
|
|
|
|
|
2004-04-29 09:41:48 -04:00
|
|
|
infof(data, "Re-using existing connection! (#%d) with host %s\n",
|
|
|
|
conn->connectindex, conn->host.dispname);
|
2001-02-20 12:35:51 -05:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
/*
|
|
|
|
* This is a brand new connection, so let's store it in the connection
|
|
|
|
* cache of ours!
|
|
|
|
*/
|
|
|
|
ConnectionStore(data, conn);
|
|
|
|
}
|
|
|
|
|
2003-03-21 03:09:48 -05:00
|
|
|
/* Continue connectdata initialization here.
|
2003-03-25 09:23:12 -05:00
|
|
|
*
|
2003-03-21 03:09:48 -05:00
|
|
|
* Inherit the proper values from the urldata struct AFTER we have arranged
|
|
|
|
* the persistant conncetion stuff */
|
|
|
|
conn->fread = data->set.fread;
|
|
|
|
conn->fread_in = data->set.in;
|
|
|
|
|
|
|
|
conn->bits.upload_chunky =
|
|
|
|
((conn->protocol&PROT_HTTP) &&
|
|
|
|
data->set.upload &&
|
|
|
|
(data->set.infilesize == -1) &&
|
|
|
|
(data->set.httpversion != CURL_HTTP_VERSION_1_0))?
|
|
|
|
/* HTTP, upload, unknown file size and not HTTP 1.0 */
|
|
|
|
TRUE:
|
|
|
|
/* else, no chunky upload */
|
|
|
|
FALSE;
|
|
|
|
|
2003-08-05 10:40:59 -04:00
|
|
|
#ifndef USE_ARES
|
2001-10-01 07:27:39 -04:00
|
|
|
/*************************************************************
|
2003-08-05 10:40:59 -04:00
|
|
|
* Set timeout if that is being used, and we're not using an asynchronous
|
|
|
|
* name resolve.
|
2001-10-01 07:27:39 -04:00
|
|
|
*************************************************************/
|
2002-08-08 18:52:50 -04:00
|
|
|
if((data->set.timeout || data->set.connecttimeout) && !data->set.no_signal) {
|
2001-11-06 14:33:13 -05:00
|
|
|
/*************************************************************
|
|
|
|
* Set signal handler to catch SIGALRM
|
|
|
|
* Store the old value to be able to set it back later!
|
|
|
|
*************************************************************/
|
|
|
|
|
2004-02-11 16:11:08 -05:00
|
|
|
#ifdef SIGALRM
|
2001-11-06 14:33:13 -05:00
|
|
|
#ifdef HAVE_SIGACTION
|
|
|
|
struct sigaction sigact;
|
|
|
|
sigaction(SIGALRM, NULL, &sigact);
|
2001-11-07 07:56:13 -05:00
|
|
|
keep_sigact = sigact;
|
2001-11-29 07:49:10 -05:00
|
|
|
keep_copysig = TRUE; /* yes, we have a copy */
|
2001-11-06 14:33:13 -05:00
|
|
|
sigact.sa_handler = alarmfunc;
|
|
|
|
#ifdef SA_RESTART
|
|
|
|
/* HPUX doesn't have SA_RESTART but defaults to that behaviour! */
|
|
|
|
sigact.sa_flags &= ~SA_RESTART;
|
|
|
|
#endif
|
|
|
|
/* now set the new struct */
|
|
|
|
sigaction(SIGALRM, &sigact, NULL);
|
2004-02-11 16:11:08 -05:00
|
|
|
#else /* HAVE_SIGACTION */
|
2001-11-06 14:33:13 -05:00
|
|
|
/* no sigaction(), revert to the much lamer signal() */
|
|
|
|
#ifdef HAVE_SIGNAL
|
2001-11-07 09:13:29 -05:00
|
|
|
keep_sigact = signal(SIGALRM, alarmfunc);
|
2001-11-06 14:33:13 -05:00
|
|
|
#endif
|
2004-02-11 16:11:08 -05:00
|
|
|
#endif /* HAVE_SIGACTION */
|
2001-11-06 14:33:13 -05:00
|
|
|
|
2001-10-01 07:27:39 -04:00
|
|
|
/* We set the timeout on the name resolving phase first, separately from
|
|
|
|
* the download/upload part to allow a maximum time on everything. This is
|
|
|
|
* a signal-based timeout, why it won't work and shouldn't be used in
|
|
|
|
* multi-threaded environments. */
|
|
|
|
|
2001-11-06 14:33:13 -05:00
|
|
|
#ifdef HAVE_ALARM
|
|
|
|
/* alarm() makes a signal get sent when the timeout fires off, and that
|
2001-10-01 07:27:39 -04:00
|
|
|
will abort system calls */
|
2001-11-06 14:33:13 -05:00
|
|
|
prev_alarm = alarm(data->set.connecttimeout?
|
|
|
|
data->set.connecttimeout:
|
|
|
|
data->set.timeout);
|
|
|
|
/* We can expect the conn->created time to be "now", as that was just
|
|
|
|
recently set in the beginning of this function and nothing slow
|
|
|
|
has been done since then until now. */
|
|
|
|
#endif
|
2004-02-11 16:11:08 -05:00
|
|
|
#endif /* SIGALRM */
|
2001-10-01 07:27:39 -04:00
|
|
|
}
|
2004-02-11 16:11:08 -05:00
|
|
|
#endif /* USE_ARES */
|
2003-08-05 10:40:59 -04:00
|
|
|
|
2001-01-24 07:32:34 -05:00
|
|
|
/*************************************************************
|
|
|
|
* Resolve the name of the server or proxy
|
|
|
|
*************************************************************/
|
2002-04-25 15:18:19 -04:00
|
|
|
if(conn->bits.reuse) {
|
|
|
|
/* re-used connection, no resolving is necessary */
|
|
|
|
hostaddr = NULL;
|
2003-07-23 13:06:21 -04:00
|
|
|
conn->connect_addr = NULL; /* we don't connect now so we don't have any
|
|
|
|
fresh connect_addr struct to point to */
|
2002-04-25 15:18:19 -04:00
|
|
|
}
|
2004-04-27 09:56:23 -04:00
|
|
|
else {
|
|
|
|
/* this is a fresh connect */
|
2000-10-20 09:48:38 -04:00
|
|
|
|
2004-04-27 09:56:23 -04:00
|
|
|
/* set a pointer to the hostname we display */
|
|
|
|
fix_hostname(conn, &conn->host);
|
|
|
|
|
|
|
|
if(!data->change.proxy || !*data->change.proxy) {
|
|
|
|
/* If not connecting via a proxy, extract the port from the URL, if it is
|
|
|
|
* there, thus overriding any defaults that might have been set above. */
|
|
|
|
conn->port = conn->remote_port; /* it is the same port */
|
|
|
|
|
|
|
|
/* Resolve target host right on */
|
|
|
|
rc = Curl_resolv(conn, conn->host.name, conn->port, &hostaddr);
|
|
|
|
if(rc == CURLRESOLV_PENDING)
|
|
|
|
*async = TRUE;
|
2002-04-25 15:00:57 -04:00
|
|
|
|
2004-04-27 09:56:23 -04:00
|
|
|
else if(!hostaddr) {
|
|
|
|
failf(data, "Couldn't resolve host '%s'", conn->host.dispname);
|
|
|
|
result = CURLE_COULDNT_RESOLVE_HOST;
|
|
|
|
/* don't return yet, we need to clean up the timeout first */
|
|
|
|
}
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2004-04-27 09:56:23 -04:00
|
|
|
else {
|
|
|
|
/* This is a proxy that hasn't been resolved yet. */
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2004-04-29 07:57:52 -04:00
|
|
|
/* IDN-fix the proxy name */
|
2004-04-27 09:56:23 -04:00
|
|
|
fix_hostname(conn, &conn->proxy);
|
2003-08-05 10:40:59 -04:00
|
|
|
|
2004-04-27 09:56:23 -04:00
|
|
|
/* resolve proxy */
|
|
|
|
rc = Curl_resolv(conn, conn->proxy.name, conn->port, &hostaddr);
|
2001-09-28 03:05:26 -04:00
|
|
|
|
2004-04-27 09:56:23 -04:00
|
|
|
if(rc == CURLRESOLV_PENDING)
|
|
|
|
*async = TRUE;
|
|
|
|
|
|
|
|
else if(!hostaddr) {
|
|
|
|
failf(data, "Couldn't resolve proxy '%s'", conn->proxy.dispname);
|
|
|
|
result = CURLE_COULDNT_RESOLVE_PROXY;
|
|
|
|
/* don't return yet, we need to clean up the timeout first */
|
|
|
|
}
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
}
|
2003-08-05 10:40:59 -04:00
|
|
|
*addr = hostaddr;
|
|
|
|
|
2004-02-11 16:11:08 -05:00
|
|
|
#if defined(HAVE_ALARM) && defined(SIGALRM)
|
2002-08-08 18:52:50 -04:00
|
|
|
if((data->set.timeout || data->set.connecttimeout) && !data->set.no_signal) {
|
2001-11-06 14:33:13 -05:00
|
|
|
#ifdef HAVE_SIGACTION
|
|
|
|
if(keep_copysig) {
|
|
|
|
/* we got a struct as it looked before, now put that one back nice
|
|
|
|
and clean */
|
|
|
|
sigaction(SIGALRM, &keep_sigact, NULL); /* put it back */
|
|
|
|
}
|
2001-11-07 09:13:29 -05:00
|
|
|
#else
|
|
|
|
#ifdef HAVE_SIGNAL
|
|
|
|
/* restore the previous SIGALRM handler */
|
|
|
|
signal(SIGALRM, keep_sigact);
|
|
|
|
#endif
|
2004-02-11 16:11:08 -05:00
|
|
|
#endif /* HAVE_SIGACTION */
|
|
|
|
|
2001-11-06 14:33:13 -05:00
|
|
|
/* switch back the alarm() to either zero or to what it was before minus
|
|
|
|
the time we spent until now! */
|
|
|
|
if(prev_alarm) {
|
|
|
|
/* there was an alarm() set before us, now put it back */
|
2004-05-05 03:17:37 -04:00
|
|
|
unsigned long elapsed_ms = Curl_tvdiff(Curl_tvnow(), conn->created);
|
|
|
|
unsigned long alarm_set;
|
2001-11-06 14:33:13 -05:00
|
|
|
|
|
|
|
/* the alarm period is counted in even number of seconds */
|
|
|
|
alarm_set = prev_alarm - elapsed_ms/1000;
|
2004-05-05 03:17:37 -04:00
|
|
|
|
|
|
|
if(!alarm_set ||
|
|
|
|
((alarm_set >= 0x80000000) && (prev_alarm < 0x80000000)) ) {
|
|
|
|
/* if the alarm time-left reached zero or turned "negative" (counted
|
|
|
|
with unsigned values), we should fire off a SIGALRM here, but we
|
2001-11-06 14:33:13 -05:00
|
|
|
won't, and zero would be to switch it off so we never set it to
|
|
|
|
less than 1! */
|
|
|
|
alarm(1);
|
|
|
|
result = CURLE_OPERATION_TIMEOUTED;
|
|
|
|
failf(data, "Previous alarm fired off!");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
alarm(alarm_set);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
alarm(0); /* just shut it off */
|
|
|
|
}
|
|
|
|
#endif
|
2003-08-05 10:40:59 -04:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* SetupConnection() should be called after the name resolve initiated in
|
|
|
|
* CreateConnection() is all done.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static CURLcode SetupConnection(struct connectdata *conn,
|
|
|
|
struct Curl_dns_entry *hostaddr)
|
|
|
|
{
|
|
|
|
struct SessionHandle *data = conn->data;
|
|
|
|
CURLcode result=CURLE_OK;
|
|
|
|
|
|
|
|
Curl_pgrsTime(data, TIMER_NAMELOOKUP);
|
|
|
|
|
|
|
|
if(conn->protocol & PROT_FILE)
|
|
|
|
/* There's nothing in this function to setup if we're only doing
|
|
|
|
a file:// transfer */
|
2001-11-06 14:33:13 -05:00
|
|
|
return result;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-01-24 07:32:34 -05:00
|
|
|
/*************************************************************
|
|
|
|
* Send user-agent to HTTP proxies even if the target protocol
|
|
|
|
* isn't HTTP.
|
|
|
|
*************************************************************/
|
2002-09-27 05:49:40 -04:00
|
|
|
if((conn->protocol&PROT_HTTP) ||
|
|
|
|
(data->change.proxy && *data->change.proxy)) {
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->set.useragent) {
|
2003-08-05 10:40:59 -04:00
|
|
|
Curl_safefree(conn->allocptr.uagent);
|
2001-02-22 18:32:02 -05:00
|
|
|
conn->allocptr.uagent =
|
2001-08-30 18:48:34 -04:00
|
|
|
aprintf("User-Agent: %s\015\012", data->set.useragent);
|
2004-05-12 08:06:39 -04:00
|
|
|
if(!conn->allocptr.uagent)
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-09-09 07:23:34 -04:00
|
|
|
if(data->set.encoding) {
|
2003-08-05 10:40:59 -04:00
|
|
|
Curl_safefree(conn->allocptr.accept_encoding);
|
2002-09-09 07:23:34 -04:00
|
|
|
conn->allocptr.accept_encoding =
|
|
|
|
aprintf("Accept-Encoding: %s\015\012", data->set.encoding);
|
2004-05-12 08:06:39 -04:00
|
|
|
if(!conn->allocptr.accept_encoding)
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
2002-09-09 07:23:34 -04:00
|
|
|
}
|
|
|
|
|
2002-04-12 04:18:38 -04:00
|
|
|
conn->bytecount = 0;
|
|
|
|
conn->headerbytecount = 0;
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2004-03-11 08:13:35 -05:00
|
|
|
if(CURL_SOCKET_BAD == conn->sock[FIRSTSOCKET]) {
|
2002-08-12 05:43:20 -04:00
|
|
|
bool connected;
|
|
|
|
|
2001-03-02 02:43:20 -05:00
|
|
|
/* Connect only if not already connected! */
|
2002-08-12 05:43:20 -04:00
|
|
|
result = ConnectPlease(conn, hostaddr, &connected);
|
|
|
|
|
2002-12-13 11:15:19 -05:00
|
|
|
if(connected) {
|
2004-04-26 03:20:11 -04:00
|
|
|
result = Curl_protocol_connect(conn);
|
2002-12-13 11:15:19 -05:00
|
|
|
if(CURLE_OK == result)
|
|
|
|
conn->bits.tcpconnect = TRUE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
conn->bits.tcpconnect = FALSE;
|
|
|
|
|
2002-04-12 06:03:59 -04:00
|
|
|
|
2001-03-02 02:43:20 -05:00
|
|
|
if(CURLE_OK != result)
|
|
|
|
return result;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2002-04-12 04:18:38 -04:00
|
|
|
else {
|
|
|
|
Curl_pgrsTime(data, TIMER_CONNECT); /* we're connected already */
|
2002-12-13 11:15:19 -05:00
|
|
|
conn->bits.tcpconnect = TRUE;
|
2002-04-12 04:18:38 -04:00
|
|
|
if(data->set.verbose)
|
2004-04-26 03:20:11 -04:00
|
|
|
verboseconnect(conn);
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2002-04-12 04:18:38 -04:00
|
|
|
|
|
|
|
conn->now = Curl_tvnow(); /* time this *after* the connect is done, we
|
|
|
|
set this here perhaps a second time */
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2000-04-04 13:44:24 -04:00
|
|
|
#ifdef __EMX__
|
|
|
|
/* 20000330 mgs
|
|
|
|
* the check is quite a hack...
|
|
|
|
* we're calling _fsetmode to fix the problem with fwrite converting newline
|
|
|
|
* characters (you get mangled text files, and corrupted binary files when
|
|
|
|
* you download to stdout and redirect it to a file). */
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
if ((data->set.out)->_handle == NULL) {
|
2000-04-04 13:44:24 -04:00
|
|
|
_fsetmode(stdout, "b");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_OK;
|
|
|
|
}
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
CURLcode Curl_connect(struct SessionHandle *data,
|
2003-08-05 10:40:59 -04:00
|
|
|
struct connectdata **in_connect,
|
|
|
|
bool *asyncp)
|
2000-11-17 09:03:58 -05:00
|
|
|
{
|
|
|
|
CURLcode code;
|
2003-08-05 10:40:59 -04:00
|
|
|
struct Curl_dns_entry *dns;
|
2000-11-17 09:03:58 -05:00
|
|
|
|
2003-08-05 10:40:59 -04:00
|
|
|
*asyncp = FALSE; /* assume synchronous resolves by default */
|
|
|
|
|
2000-11-17 09:03:58 -05:00
|
|
|
/* call the stuff that needs to be called */
|
2003-08-05 10:40:59 -04:00
|
|
|
code = CreateConnection(data, in_connect, &dns, asyncp);
|
|
|
|
|
|
|
|
if(CURLE_OK == code) {
|
|
|
|
/* no error */
|
|
|
|
if(dns || !*asyncp)
|
|
|
|
/* If an address is available it means that we already have the name
|
|
|
|
resolved, OR it isn't async.
|
|
|
|
If so => continue connecting from here */
|
|
|
|
code = SetupConnection(*in_connect, dns);
|
|
|
|
/* else
|
|
|
|
response will be received and treated async wise */
|
|
|
|
}
|
|
|
|
|
2000-11-17 09:03:58 -05:00
|
|
|
if(CURLE_OK != code) {
|
|
|
|
/* We're not allowed to return failure with memory left allocated
|
|
|
|
in the connectdata struct, free those here */
|
2003-08-05 10:40:59 -04:00
|
|
|
if(*in_connect) {
|
|
|
|
Curl_disconnect(*in_connect); /* close the connection */
|
|
|
|
*in_connect = NULL; /* return a NULL */
|
2001-04-03 06:20:23 -04:00
|
|
|
}
|
2000-11-17 09:03:58 -05:00
|
|
|
}
|
2003-08-05 10:40:59 -04:00
|
|
|
|
2000-11-17 09:03:58 -05:00
|
|
|
return code;
|
|
|
|
}
|
|
|
|
|
2003-08-05 10:40:59 -04:00
|
|
|
/* Call this function after Curl_connect() has returned async=TRUE and
|
|
|
|
then a successful name resolve has been received */
|
|
|
|
CURLcode Curl_async_resolved(struct connectdata *conn)
|
|
|
|
{
|
2004-04-26 03:20:11 -04:00
|
|
|
#if defined(USE_ARES) || defined(USE_THREADING_GETHOSTBYNAME) || \
|
|
|
|
defined(USE_THREADING_GETADDRINFO)
|
2003-08-05 10:40:59 -04:00
|
|
|
CURLcode code = SetupConnection(conn, conn->async.dns);
|
|
|
|
|
|
|
|
if(code)
|
|
|
|
/* We're not allowed to return failure with memory left allocated
|
|
|
|
in the connectdata struct, free those here */
|
|
|
|
Curl_disconnect(conn); /* close the connection */
|
|
|
|
|
|
|
|
return code;
|
|
|
|
#else
|
|
|
|
(void)conn;
|
|
|
|
return CURLE_OK;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-05-17 04:05:46 -04:00
|
|
|
CURLcode Curl_done(struct connectdata **connp,
|
2004-05-12 08:06:39 -04:00
|
|
|
CURLcode status) /* an error if this is called after an
|
|
|
|
error was detected */
|
2000-05-22 10:12:12 -04:00
|
|
|
{
|
|
|
|
CURLcode result;
|
2004-05-17 04:05:46 -04:00
|
|
|
struct connectdata *conn = *connp;
|
|
|
|
struct SessionHandle *data=conn->data;
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2001-04-18 03:25:11 -04:00
|
|
|
/* cleanups done even if the connection is re-used */
|
|
|
|
|
|
|
|
if(conn->bits.rangestringalloc) {
|
|
|
|
free(conn->range);
|
|
|
|
conn->bits.rangestringalloc = FALSE;
|
|
|
|
}
|
|
|
|
|
2001-05-11 02:10:48 -04:00
|
|
|
/* Cleanup possible redirect junk */
|
|
|
|
if(conn->newurl) {
|
|
|
|
free(conn->newurl);
|
|
|
|
conn->newurl = NULL;
|
|
|
|
}
|
2002-11-05 05:51:41 -05:00
|
|
|
|
|
|
|
if(conn->connect_addr)
|
2003-02-04 18:48:46 -05:00
|
|
|
Curl_resolv_unlock(conn->data, conn->connect_addr); /* done with this */
|
2002-11-05 05:51:41 -05:00
|
|
|
|
2003-06-26 07:30:59 -04:00
|
|
|
#if defined(CURLDEBUG) && defined(AGGRESIVE_TEST)
|
2002-11-05 05:51:41 -05:00
|
|
|
/* scan for DNS cache entries still marked as in use */
|
|
|
|
Curl_hash_apply(data->hostcache,
|
|
|
|
NULL, Curl_scan_cache_used);
|
|
|
|
#endif
|
|
|
|
|
2003-12-15 12:33:49 -05:00
|
|
|
Curl_hostcache_prune(data); /* kill old DNS cache entries */
|
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
/* this calls the protocol-specific function pointer previously set */
|
|
|
|
if(conn->curl_done)
|
2004-05-12 08:06:39 -04:00
|
|
|
result = conn->curl_done(conn, status);
|
2000-05-22 10:12:12 -04:00
|
|
|
else
|
|
|
|
result = CURLE_OK;
|
|
|
|
|
2001-04-18 03:25:11 -04:00
|
|
|
Curl_pgrsDone(conn); /* done with the operation */
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
/* if data->set.reuse_forbid is TRUE, it means the libcurl client has
|
2001-03-12 10:05:54 -05:00
|
|
|
forced us to close this no matter what we think.
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2001-03-12 10:05:54 -05:00
|
|
|
if conn->bits.close is TRUE, it means that the connection should be
|
|
|
|
closed in spite of all our efforts to be nice, due to protocol
|
|
|
|
restrictions in our or the server's end */
|
2003-11-19 09:35:40 -05:00
|
|
|
if(data->set.reuse_forbid || conn->bits.close) {
|
|
|
|
CURLcode res2;
|
|
|
|
res2 = Curl_disconnect(conn); /* close the connection */
|
|
|
|
|
2004-05-17 04:05:46 -04:00
|
|
|
*connp = NULL; /* to make the caller of this function better detect that
|
|
|
|
this was actually killed here */
|
|
|
|
|
2003-11-19 09:35:40 -05:00
|
|
|
/* If we had an error already, make sure we return that one. But
|
|
|
|
if we got a new error, return that. */
|
|
|
|
if(!result && res2)
|
|
|
|
result = res2;
|
|
|
|
}
|
2001-03-12 08:58:03 -05:00
|
|
|
else
|
2004-04-29 09:41:48 -04:00
|
|
|
infof(data, "Connection #%d to host %s left intact\n",
|
|
|
|
conn->connectindex, conn->host.dispname);
|
2001-02-20 12:35:51 -05:00
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2002-01-03 10:01:22 -05:00
|
|
|
CURLcode Curl_do(struct connectdata **connp)
|
2000-05-22 10:12:12 -04:00
|
|
|
{
|
2001-03-09 10:18:25 -05:00
|
|
|
CURLcode result=CURLE_OK;
|
2002-01-03 10:01:22 -05:00
|
|
|
struct connectdata *conn = *connp;
|
|
|
|
struct SessionHandle *data=conn->data;
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2002-11-11 18:03:03 -05:00
|
|
|
conn->bits.do_more = FALSE; /* by default there's no curl_do_more() to use */
|
2002-08-12 05:43:20 -04:00
|
|
|
|
2002-01-03 10:01:22 -05:00
|
|
|
if(conn->curl_do) {
|
2000-05-22 10:12:12 -04:00
|
|
|
/* generic protocol-specific function pointer set in curl_connect() */
|
|
|
|
result = conn->curl_do(conn);
|
|
|
|
|
2002-01-03 10:01:22 -05:00
|
|
|
/* This was formerly done in transfer.c, but we better do it here */
|
2003-03-25 09:23:12 -05:00
|
|
|
|
2002-04-10 09:44:42 -04:00
|
|
|
if((CURLE_SEND_ERROR == result) && conn->bits.reuse) {
|
2002-01-03 10:01:22 -05:00
|
|
|
/* This was a re-use of a connection and we got a write error in the
|
|
|
|
* DO-phase. Then we DISCONNECT this connection and have another attempt
|
|
|
|
* to CONNECT and then DO again! The retry cannot possibly find another
|
|
|
|
* connection to re-use, since we only keep one possible connection for
|
|
|
|
* each. */
|
|
|
|
|
|
|
|
infof(data, "Re-used connection seems dead, get a new one\n");
|
|
|
|
|
2003-12-19 03:03:15 -05:00
|
|
|
conn->bits.close = TRUE; /* enforce close of this connection */
|
2004-05-17 04:05:46 -04:00
|
|
|
result = Curl_done(&conn, result); /* we are so done with this */
|
2003-12-15 09:48:37 -05:00
|
|
|
|
2004-05-17 04:05:46 -04:00
|
|
|
/* conn may no longer be a good pointer */
|
2003-12-15 09:48:37 -05:00
|
|
|
|
2002-01-03 10:01:22 -05:00
|
|
|
if(CURLE_OK == result) {
|
2003-08-05 10:40:59 -04:00
|
|
|
bool async;
|
2002-01-03 10:01:22 -05:00
|
|
|
/* Now, redo the connect and get a new connection */
|
2003-08-05 10:40:59 -04:00
|
|
|
result = Curl_connect(data, connp, &async);
|
|
|
|
if(CURLE_OK == result) {
|
|
|
|
/* We have connected or sent away a name resolve query fine */
|
|
|
|
|
2003-12-15 09:48:37 -05:00
|
|
|
conn = *connp; /* setup conn to again point to something nice */
|
2003-08-05 10:40:59 -04:00
|
|
|
if(async) {
|
|
|
|
/* Now, if async is TRUE here, we need to wait for the name
|
|
|
|
to resolve */
|
|
|
|
result = Curl_wait_for_resolv(conn, NULL);
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
/* Resolved, continue with the connection */
|
|
|
|
result = Curl_async_resolved(conn);
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2002-01-03 10:01:22 -05:00
|
|
|
/* ... finally back to actually retry the DO phase */
|
2003-08-05 10:40:59 -04:00
|
|
|
result = conn->curl_do(conn);
|
|
|
|
}
|
2002-01-03 10:01:22 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2001-03-09 10:18:25 -05:00
|
|
|
return result;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
|
2002-08-12 05:43:20 -04:00
|
|
|
CURLcode Curl_do_more(struct connectdata *conn)
|
|
|
|
{
|
|
|
|
CURLcode result=CURLE_OK;
|
|
|
|
|
|
|
|
if(conn->curl_do_more)
|
|
|
|
result = conn->curl_do_more(conn);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2003-03-24 18:10:38 -05:00
|
|
|
|
|
|
|
static bool safe_strequal(char* str1, char* str2)
|
|
|
|
{
|
|
|
|
if(str1 && str2)
|
|
|
|
/* both pointers point to something then compare them */
|
|
|
|
return strequal(str1, str2);
|
|
|
|
else
|
|
|
|
/* if both pointers are NULL then treat them as equal */
|
|
|
|
return (!str1 && !str2);
|
|
|
|
}
|
|
|
|
|
2003-03-31 00:13:26 -05:00
|
|
|
bool
|
|
|
|
Curl_ssl_config_matches(struct ssl_config_data* data,
|
|
|
|
struct ssl_config_data* needle)
|
2003-03-24 18:10:38 -05:00
|
|
|
{
|
|
|
|
if((data->version == needle->version) &&
|
|
|
|
(data->verifypeer == needle->verifypeer) &&
|
|
|
|
(data->verifyhost == needle->verifyhost) &&
|
|
|
|
safe_strequal(data->CApath, needle->CApath) &&
|
|
|
|
safe_strequal(data->CAfile, needle->CAfile) &&
|
|
|
|
safe_strequal(data->random_file, needle->random_file) &&
|
|
|
|
safe_strequal(data->egdsocket, needle->egdsocket) &&
|
|
|
|
safe_strequal(data->cipher_list, needle->cipher_list))
|
2003-03-25 09:23:12 -05:00
|
|
|
return TRUE;
|
2003-03-24 18:10:38 -05:00
|
|
|
|
2003-03-25 09:23:12 -05:00
|
|
|
return FALSE;
|
2003-03-24 18:10:38 -05:00
|
|
|
}
|
|
|
|
|
2003-03-31 00:13:26 -05:00
|
|
|
bool
|
|
|
|
Curl_clone_ssl_config(struct ssl_config_data *source,
|
|
|
|
struct ssl_config_data *dest)
|
2003-03-24 18:10:38 -05:00
|
|
|
{
|
2003-03-31 00:13:26 -05:00
|
|
|
dest->verifyhost = source->verifyhost;
|
|
|
|
dest->verifypeer = source->verifypeer;
|
|
|
|
dest->version = source->version;
|
2003-03-24 18:10:38 -05:00
|
|
|
|
2003-03-31 00:13:26 -05:00
|
|
|
if(source->CAfile) {
|
|
|
|
dest->CAfile = strdup(source->CAfile);
|
|
|
|
if(!dest->CAfile)
|
2003-03-25 09:23:12 -05:00
|
|
|
return FALSE;
|
2003-03-24 18:10:38 -05:00
|
|
|
}
|
|
|
|
|
2003-03-31 00:13:26 -05:00
|
|
|
if(source->CApath) {
|
|
|
|
dest->CApath = strdup(source->CApath);
|
|
|
|
if(!dest->CApath)
|
2003-03-25 09:23:12 -05:00
|
|
|
return FALSE;
|
2003-03-24 18:10:38 -05:00
|
|
|
}
|
|
|
|
|
2003-03-31 00:13:26 -05:00
|
|
|
if(source->cipher_list) {
|
|
|
|
dest->cipher_list = strdup(source->cipher_list);
|
|
|
|
if(!dest->cipher_list)
|
2003-03-25 09:23:12 -05:00
|
|
|
return FALSE;
|
2003-03-24 18:10:38 -05:00
|
|
|
}
|
|
|
|
|
2003-03-31 00:13:26 -05:00
|
|
|
if(source->egdsocket) {
|
|
|
|
dest->egdsocket = strdup(source->egdsocket);
|
|
|
|
if(!dest->egdsocket)
|
2003-03-25 09:23:12 -05:00
|
|
|
return FALSE;
|
2003-03-24 18:10:38 -05:00
|
|
|
}
|
|
|
|
|
2003-03-31 00:13:26 -05:00
|
|
|
if(source->random_file) {
|
|
|
|
dest->random_file = strdup(source->random_file);
|
|
|
|
if(!dest->random_file)
|
2003-03-25 09:23:12 -05:00
|
|
|
return FALSE;
|
2003-03-24 18:10:38 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2003-03-31 00:13:26 -05:00
|
|
|
void Curl_free_ssl_config(struct ssl_config_data* sslc)
|
2003-03-24 18:10:38 -05:00
|
|
|
{
|
|
|
|
if(sslc->CAfile)
|
|
|
|
free(sslc->CAfile);
|
|
|
|
|
|
|
|
if(sslc->CApath)
|
|
|
|
free(sslc->CApath);
|
|
|
|
|
|
|
|
if(sslc->cipher_list)
|
|
|
|
free(sslc->cipher_list);
|
|
|
|
|
|
|
|
if(sslc->egdsocket)
|
|
|
|
free(sslc->egdsocket);
|
|
|
|
|
|
|
|
if(sslc->random_file)
|
|
|
|
free(sslc->random_file);
|
|
|
|
}
|
2004-04-26 03:20:11 -04:00
|
|
|
|