#include "setup.h"
#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 <winsock.h>
#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>
#include <sys/resource.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
#ifndef HAVE_SELECT
#error "We can't compile without select() support!"
#endif
#ifndef HAVE_SOCKET
#error "We can't compile without socket() support!"
#endif
#endif
#include "urldata.h"
#include "netrc.h"
#include "formdata.h"
#include "base64.h"
#include "ssluse.h"
#include "hostip.h"
#include "if2ip.h"
#include "transfer.h"
#include "sendf.h"
#include "getpass.h"
#include "progress.h"
#include "cookie.h"
#include "strequal.h"
#include "escape.h"
#include "ftp.h"
#include "dict.h"
#include "telnet.h"
#include "http.h"
#include "file.h"
#include "ldap.h"
#include <curl/types.h>
#define _MPRINTF_REPLACE
#include <curl/mprintf.h>
#ifdef KRB4
#include "security.h"
#endif
#ifdef MALLOCDEBUG
#include "memdebug.h"
#endif
static int ConnectionKillOne(struct UrlData *data);
static bool ConnectionExists(struct UrlData *data,
struct connectdata *needle,
struct connectdata **usethis);
static unsigned int ConnectionStore(struct UrlData *data,
struct connectdata *conn);
#if !defined(WIN32)||defined(__CYGWIN32__)
#ifndef RETSIGTYPE
#define RETSIGTYPE void
#endif
static
RETSIGTYPE alarmfunc(int signal)
{
(void)signal;
return;
}
#endif
CURLcode Curl_close(CURL *curl)
{
struct UrlData *data=(struct UrlData *)curl;
while(-1 != ConnectionKillOne(data));
if(data->bits.proxystringalloc) {
data->bits.proxystringalloc=FALSE;;
free(data->proxy);
data->proxy=NULL;
data->bits.httpproxy=FALSE;
}
if(data->freethis)
free(data->freethis);
if(data->headerbuff)
free(data->headerbuff);
if(data->free_referer)
free(data->referer);
if(data->bits.urlstringalloc)
free(data->url);
Curl_cookie_cleanup(data->cookies);
free(data->connects);
free(data);
return CURLE_OK;
}
static
int my_getpass(void *clientp, char *prompt, char* buffer, int buflen )
{
char *retbuf;
retbuf = getpass_r(prompt, buffer, buflen);
if(NULL == retbuf)
return 1;
else
return 0;
}
CURLcode Curl_open(CURL **curl, char *url)
{
struct UrlData *data;
#ifdef HAVE_SIGACTION
struct sigaction sigact;
#endif
data = (struct UrlData *)malloc(sizeof(struct UrlData));
if(data) {
memset(data, 0, sizeof(struct UrlData));
data-> headerbuff=(char*)malloc(HEADERSIZE);
if(!data->headerbuff) {
free(data);
return CURLE_OUT_OF_MEMORY;
}
data->headersize=HEADERSIZE;
data->out = stdout;
data->in = stdin;
data->err = stderr;
data->fwrite = (size_t (*)(char *, size_t, size_t, FILE *))fwrite;
data->fread = (size_t (*)(char *, size_t, size_t, FILE *))fread;
data->fpasswd = my_getpass;
data->infilesize = -1;
data->current_speed = -1;
data->httpreq = HTTPREQ_GET;
data->numconnects = 5;
data->connects = (struct connectdata **)
malloc(sizeof(struct connectdata *) * data->numconnects);
if(!data->connects) {
free(data);
return CURLE_OUT_OF_MEMORY;
}
memset(data->connects, 0, sizeof(struct connectdata *)*data->numconnects);
*curl = data;
#ifdef HAVE_SIGACTION
sigaction(SIGALRM, NULL, &sigact);
sigact.sa_handler = alarmfunc;
#ifdef SA_RESTART
sigact.sa_flags &= ~SA_RESTART;
#endif
sigaction(SIGALRM, &sigact, NULL);
#else
#ifdef HAVE_SIGNAL
signal(SIGALRM, alarmfunc);
#endif
#endif
return CURLE_OK;
}
return CURLE_OUT_OF_MEMORY;
}
CURLcode Curl_setopt(CURL *curl, CURLoption option, ...)
{
struct UrlData *data = curl;
va_list param;
char *cookiefile;
va_start(param, option);
switch(option) {
case CURLOPT_RANDOM_FILE:
data->ssl.random_file = va_arg(param, char *);
break;
case CURLOPT_EGDSOCKET:
data->ssl.egdsocket = va_arg(param, char *);
break;
case CURLOPT_MAXCONNECTS:
{
long newconnects= va_arg(param, long);
struct connectdata **newptr;
if(newconnects < data->numconnects) {
int i;
for(i=newconnects; i< data->numconnects; i++)
Curl_disconnect(data->connects[i]);
}
if(newconnects) {
newptr= (struct connectdata **)
realloc(data->connects,
sizeof(struct connectdata *) * newconnects);
if(!newptr)
return CURLE_OUT_OF_MEMORY;
data->connects = newptr;
data->numconnects = newconnects;
}
else {
if(data->connects)
free(data->connects);
data->connects=NULL;
data->numconnects=0;
}
}
break;
case CURLOPT_FORBID_REUSE:
data->bits.reuse_forbid = va_arg(param, long)?TRUE:FALSE;
break;
case CURLOPT_FRESH_CONNECT:
data->bits.reuse_fresh = va_arg(param, long)?TRUE:FALSE;
break;
case CURLOPT_VERBOSE:
data->bits.verbose = va_arg(param, long)?TRUE:FALSE;
break;
case CURLOPT_HEADER:
data->bits.http_include_header = va_arg(param, long)?TRUE:FALSE;
break;
case CURLOPT_NOPROGRESS:
data->bits.hide_progress = va_arg(param, long)?TRUE:FALSE;
if(data->bits.hide_progress)
data->progress.flags |= PGRS_HIDE;
break;
case CURLOPT_NOBODY:
data->bits.no_body = va_arg(param, long)?TRUE:FALSE;
break;
case CURLOPT_FAILONERROR:
data->bits.http_fail_on_error = va_arg(param, long)?TRUE:FALSE;
break;
case CURLOPT_UPLOAD:
data->bits.upload = va_arg(param, long)?TRUE:FALSE;
if(data->bits.upload)
data->httpreq = HTTPREQ_PUT;
break;
case CURLOPT_FILETIME:
data->bits.get_filetime = va_arg(param, long)?TRUE:FALSE;
break;
case CURLOPT_FTPLISTONLY:
data->bits.ftp_list_only = va_arg(param, long)?TRUE:FALSE;
break;
case CURLOPT_FTPAPPEND:
data->bits.ftp_append = va_arg(param, long)?TRUE:FALSE;
break;
case CURLOPT_NETRC:
data->bits.use_netrc = va_arg(param, long)?TRUE:FALSE;
break;
case CURLOPT_FOLLOWLOCATION:
data->bits.http_follow_location = va_arg(param, long)?TRUE:FALSE;
break;
case CURLOPT_FTPASCII:
data->bits.ftp_ascii = va_arg(param, long)?TRUE:FALSE;
break;
case CURLOPT_PUT:
data->bits.http_put = va_arg(param, long)?TRUE:FALSE;
if(data->bits.http_put)
data->httpreq = HTTPREQ_PUT;
break;
case CURLOPT_MUTE:
data->bits.mute = va_arg(param, long)?TRUE:FALSE;
break;
case CURLOPT_TIMECONDITION:
data->timecondition = va_arg(param, long);
break;
case CURLOPT_TIMEVALUE:
data->timevalue = va_arg(param, long);
break;
case CURLOPT_SSLVERSION:
data->ssl.version = va_arg(param, long);
break;
case CURLOPT_COOKIEFILE:
cookiefile = (char *)va_arg(param, void *);
if(cookiefile) {
data->cookies = Curl_cookie_init(cookiefile);
}
break;
case CURLOPT_WRITEHEADER:
data->writeheader = (FILE *)va_arg(param, FILE *);
break;
case CURLOPT_COOKIE:
data->cookie = va_arg(param, char *);
break;
case CURLOPT_ERRORBUFFER:
data->errorbuffer = va_arg(param, char *);
break;
case CURLOPT_FILE:
data->out = va_arg(param, FILE *);
break;
case CURLOPT_FTPPORT:
data->ftpport = va_arg(param, char *);
data->bits.ftp_use_port = data->ftpport?1:0;
break;
case CURLOPT_HTTPHEADER:
data->headers = va_arg(param, struct curl_slist *);
break;
case CURLOPT_CUSTOMREQUEST:
data->customrequest = va_arg(param, char *);
if(data->customrequest)
data->httpreq = HTTPREQ_CUSTOM;
break;
case CURLOPT_HTTPPOST:
data->httppost = va_arg(param, struct HttpPost *);
data->bits.http_formpost = data->httppost?1:0;
if(data->bits.http_formpost)
data->httpreq = HTTPREQ_POST_FORM;
break;
case CURLOPT_INFILE:
data->in = va_arg(param, FILE *);
break;
case CURLOPT_INFILESIZE:
data->infilesize = va_arg(param, long);
break;
case CURLOPT_LOW_SPEED_LIMIT:
data->low_speed_limit=va_arg(param, long);
break;
case CURLOPT_LOW_SPEED_TIME:
data->low_speed_time=va_arg(param, long);
break;
case CURLOPT_URL:
data->url = va_arg(param, char *);
break;
case CURLOPT_PORT:
data->use_port = va_arg(param, long);
break;
case CURLOPT_POST:
data->bits.http_post = va_arg(param, long)?TRUE:FALSE;
if(data->bits.http_post)
data->httpreq = HTTPREQ_POST;
break;
case CURLOPT_POSTFIELDS:
data->postfields = va_arg(param, char *);
data->bits.http_post = data->postfields?TRUE:FALSE;
if(data->bits.http_post)
data->httpreq = HTTPREQ_POST;
break;
case CURLOPT_POSTFIELDSIZE:
data->postfieldsize = va_arg(param, long);
break;
case CURLOPT_REFERER:
data->referer = va_arg(param, char *);
data->bits.http_set_referer = (data->referer && *data->referer)?1:0;
break;
case CURLOPT_AUTOREFERER:
data->bits.http_auto_referer = va_arg(param, long)?1:0;
break;
case CURLOPT_PROXY:
data->proxy = va_arg(param, char *);
data->bits.httpproxy = data->proxy?1:0;
break;
case CURLOPT_HTTPPROXYTUNNEL:
data->bits.tunnel_thru_httpproxy = va_arg(param, long)?TRUE:FALSE;
break;
case CURLOPT_PROXYPORT:
data->proxyport = va_arg(param, long);
break;
case CURLOPT_TIMEOUT:
data->timeout = va_arg(param, long);
break;
case CURLOPT_CONNECTTIMEOUT:
data->connecttimeout = va_arg(param, long);
break;
case CURLOPT_MAXREDIRS:
data->maxredirs = va_arg(param, long);
break;
case CURLOPT_USERAGENT:
data->useragent = va_arg(param, char *);
break;
case CURLOPT_USERPWD:
data->userpwd = va_arg(param, char *);
break;
case CURLOPT_POSTQUOTE:
data->postquote = va_arg(param, struct curl_slist *);
break;
case CURLOPT_QUOTE:
data->quote = va_arg(param, struct curl_slist *);
break;
case CURLOPT_PROGRESSFUNCTION:
data->fprogress = va_arg(param, curl_progress_callback);
data->progress.callback = TRUE;
break;
case CURLOPT_PROGRESSDATA:
data->progress_client = va_arg(param, void *);
break;
case CURLOPT_PASSWDFUNCTION:
data->fpasswd = va_arg(param, curl_passwd_callback);
break;
case CURLOPT_PASSWDDATA:
data->passwd_client = va_arg(param, void *);
break;
case CURLOPT_PROXYUSERPWD:
data->proxyuserpwd = va_arg(param, char *);
break;
case CURLOPT_RANGE:
data->set_range = va_arg(param, char *);
data->bits.set_range = data->set_range?1:0;
break;
case CURLOPT_RESUME_FROM:
data->set_resume_from = va_arg(param, long);
break;
case CURLOPT_STDERR:
data->err = va_arg(param, FILE *);
break;
case CURLOPT_HEADERFUNCTION:
data->fwrite_header = va_arg(param, curl_write_callback);
break;
case CURLOPT_WRITEFUNCTION:
data->fwrite = va_arg(param, curl_write_callback);
break;
case CURLOPT_READFUNCTION:
data->fread = va_arg(param, curl_read_callback);
break;
case CURLOPT_SSLCERT:
data->cert = va_arg(param, char *);
break;
case CURLOPT_SSLCERTPASSWD:
data->cert_passwd = va_arg(param, char *);
break;
case CURLOPT_CRLF:
data->crlf = va_arg(param, long);
break;
case CURLOPT_INTERFACE:
data->device = va_arg(param, char *);
break;
case CURLOPT_KRB4LEVEL:
data->krb4_level = va_arg(param, char *);
data->bits.krb4=data->krb4_level?TRUE:FALSE;
break;
case CURLOPT_SSL_VERIFYPEER:
data->ssl.verifypeer = va_arg(param, long);
break;
case CURLOPT_CAINFO:
data->ssl.CAfile = va_arg(param, char *);
data->ssl.CApath = NULL;
break;
case CURLOPT_TELNETOPTIONS:
data->telnet_options = va_arg(param, struct curl_slist *);
break;
default:
return CURLE_READ_ERROR;
}
return CURLE_OK;
}
CURLcode Curl_disconnect(struct connectdata *conn)
{
if(!conn)
return CURLE_OK;
if(conn->bits.rangestringalloc) {
free(conn->range);
conn->bits.rangestringalloc = FALSE;
}
if(-1 != conn->connectindex) {
infof(conn->data, "Closing live connection (#%d)\n", conn->connectindex);
conn->data->connects[conn->connectindex] = NULL;
}
if(conn->curl_disconnect)
conn->curl_disconnect(conn);
if(conn->proto.generic)
free(conn->proto.generic);
#ifdef ENABLE_IPV6
if(conn->hp)
freeaddrinfo(conn->hp);
#else
if(conn->hostent_buf)
free(conn->hostent_buf);
#endif
if(conn->newurl)
free(conn->newurl);
if(conn->path)
free(conn->path);
#ifdef USE_SSLEAY
if (conn->ssl.use) {
if(conn->ssl.handle) {
(void)SSL_shutdown(conn->ssl.handle);
SSL_set_connect_state(conn->ssl.handle);
SSL_free (conn->ssl.handle);
conn->ssl.handle = NULL;
}
if(conn->ssl.ctx) {
SSL_CTX_free (conn->ssl.ctx);
conn->ssl.ctx = NULL;
}
conn->ssl.use = FALSE;
}
#endif
if(-1 != conn->secondarysocket)
sclose(conn->secondarysocket);
if(-1 != conn->firstsocket)
sclose(conn->firstsocket);
if(conn->allocptr.proxyuserpwd)
free(conn->allocptr.proxyuserpwd);
if(conn->allocptr.uagent)
free(conn->allocptr.uagent);
if(conn->allocptr.userpwd)
free(conn->allocptr.userpwd);
if(conn->allocptr.rangeline)
free(conn->allocptr.rangeline);
if(conn->allocptr.ref)
free(conn->allocptr.ref);
if(conn->allocptr.cookie)
free(conn->allocptr.cookie);
if(conn->allocptr.host)
free(conn->allocptr.host);
if(conn->proxyhost)
free(conn->proxyhost);
free(conn);
return CURLE_OK;
}
static bool SocketIsDead(int sock)
{
int sval;
bool ret_val = TRUE;
fd_set check_set;
struct timeval to;
FD_ZERO(&check_set);
FD_SET(sock,&check_set);
to.tv_sec = 0;
to.tv_usec = 1;
sval = select(sock + 1, &check_set, 0, 0, &to);
if(sval == 0)
ret_val = FALSE;
return ret_val;
}
static bool
ConnectionExists(struct UrlData *data,
struct connectdata *needle,
struct connectdata **usethis)
{
size_t i;
struct connectdata *check;
for(i=0; i< data->numconnects; i++) {
check = data->connects[i];
if(!check)
continue;
if(!needle->bits.httpproxy) {
if(strequal(needle->protostr, check->protostr) &&
strequal(needle->name, check->name) &&
(needle->port == check->port) ) {
bool dead;
if(strequal(needle->protostr, "FTP")) {
if(!strequal(needle->data->user, check->proto.ftp->user) ||
!strequal(needle->data->passwd, check->proto.ftp->passwd)) {
continue;
}
}
dead = SocketIsDead(check->firstsocket);
if(dead) {
infof(data, "Connection %d seems to be dead!\n", i);
Curl_disconnect(check);
data->connects[i]=NULL;
continue;
}
*usethis = check;
return TRUE;
}
}
else {
if(check->bits.httpproxy &&
strequal(needle->proxyhost, check->proxyhost) &&
needle->port == check->port) {
*usethis = check;
return TRUE;
}
}
}
return FALSE;
}
static int
ConnectionKillOne(struct UrlData *data)
{
size_t i;
struct connectdata *conn;
int highscore=-1;
int connindex=-1;
int score;
CURLcode result;
struct timeval now;
now = Curl_tvnow();
for(i=0; i< data->numconnects; i++) {
conn = data->connects[i];
if(!conn)
continue;
switch(data->closepolicy) {
case CURLCLOSEPOLICY_LEAST_RECENTLY_USED:
default:
score = Curl_tvlong(now) - Curl_tvlong(conn->now);
break;
case CURLCLOSEPOLICY_OLDEST:
score = Curl_tvlong(now) - Curl_tvlong(conn->created);
break;
}
if(score > highscore) {
highscore = score;
connindex = i;
}
}
if(connindex >= 0) {
result = Curl_disconnect(data->connects[connindex]);
data->connects[connindex] = NULL;
}
return connindex;
}
static unsigned int
ConnectionStore(struct UrlData *data,
struct connectdata *conn)
{
size_t i;
for(i=0; i< data->numconnects; i++) {
if(!data->connects[i])
break;
}
if(i == data->numconnects) {
i = ConnectionKillOne(data);
infof(data, "Connection (#%d) was killed to make room\n", i);
}
data->connects[i] = conn;
conn->connectindex = i;
return i;
}
static CURLcode ConnectPlease(struct UrlData *data,
struct connectdata *conn)
{
#if defined(WIN32)
unsigned long nonblock = 0;
fd_set connectfd;
struct timeval conntimeout;
#endif
#ifndef ENABLE_IPV6
conn->firstsocket = socket(AF_INET, SOCK_STREAM, 0);
memset((char *) &conn->serv_addr, '\0', sizeof(conn->serv_addr));
memcpy((char *)&(conn->serv_addr.sin_addr),
conn->hp->h_addr, conn->hp->h_length);
conn->serv_addr.sin_family = conn->hp->h_addrtype;
conn->serv_addr.sin_port = htons(conn->port);
#else
struct addrinfo *ai;
#endif
#if !defined(WIN32)||defined(__CYGWIN32__)
#ifdef HAVE_INET_NTOA
#ifndef INADDR_NONE
#define INADDR_NONE (unsigned long) ~0
#endif
#ifndef ENABLE_IPV6
if (data->device && (strlen(data->device)<255)) {
struct sockaddr_in sa;
struct hostent *h=NULL;
char *hostdataptr=NULL;
size_t size;
char myhost[256] = "";
unsigned long in;
if(Curl_if2ip(data->device, myhost, sizeof(myhost))) {
h = Curl_gethost(data, myhost, &hostdataptr);
}
else {
if(strlen(data->device)>1) {
h = Curl_gethost(data, data->device, &hostdataptr);
}
if(h) {
strcpy(myhost, data->device);
}
}
if(! *myhost) {
printf("in here\n");
}
infof(data, "We connect from %s\n", myhost);
if ( (in=inet_addr(myhost)) != INADDR_NONE ) {
if ( h ) {
memset((char *)&sa, 0, sizeof(sa));
memcpy((char *)&sa.sin_addr,
h->h_addr,
h->h_length);
sa.sin_family = AF_INET;
sa.sin_addr.s_addr = in;
sa.sin_port = 0;
if( bind(conn->firstsocket, (struct sockaddr *)&sa, sizeof(sa)) >= 0) {
struct sockaddr_in add;
size = sizeof(add);
if(getsockname(conn->firstsocket, (struct sockaddr *) &add,
(socklen_t *)&size)<0) {
failf(data, "getsockname() failed");
return CURLE_HTTP_PORT_FAILED;
}
}
else {
switch(errno) {
case EBADF:
failf(data, "Invalid descriptor: %d", errno);
break;
case EINVAL:
failf(data, "Invalid request: %d", errno);
break;
case EACCES:
failf(data, "Address is protected, user not superuser: %d", errno);
break;
case ENOTSOCK:
failf(data,
"Argument is a descriptor for a file, not a socket: %d",
errno);
break;
case EFAULT:
failf(data, "Inaccessable memory error: %d", errno);
break;
case ENAMETOOLONG:
failf(data, "Address too long: %d", errno);
break;
case ENOMEM:
failf(data, "Insufficient kernel memory was available: %d", errno);
break;
default:
failf(data,"errno %d\n");
}
return CURLE_HTTP_PORT_FAILED;
}
}
else {
failf(data,"could't find my own IP address (%s)", myhost);
return CURLE_HTTP_PORT_FAILED;
}
}
else {
failf(data, "could't find my own IP address (%s)", myhost);
return CURLE_HTTP_PORT_FAILED;
}
if(hostdataptr)
free(hostdataptr);
}
#endif
#endif
#endif
#ifdef ENABLE_IPV6
conn->firstsocket = -1;
for (ai = conn->hp; ai; ai = ai->ai_next) {
conn->firstsocket = socket(ai->ai_family,
ai->ai_socktype,
ai->ai_protocol);
if (conn->firstsocket < 0)
continue;
if (connect(conn->firstsocket, ai->ai_addr, ai->ai_addrlen) < 0) {
sclose(conn->firstsocket);
conn->firstsocket = -1;
continue;
}
break;
}
conn->ai = ai;
if (conn->firstsocket < 0) {
failf(data, strerror(errno));
return CURLE_COULDNT_CONNECT;
}
#else
#if defined(WIN32)
FD_ZERO (&connectfd);
FD_SET(conn->firstsocket, &connectfd);
if (conn->data->connecttimeout > 0) {
nonblock = 1;
}
ioctlsocket(conn->firstsocket, FIONBIO, &nonblock);
#endif
if (connect(conn->firstsocket,
(struct sockaddr *) &(conn->serv_addr),
sizeof(conn->serv_addr)
) < 0) {
#if defined(WIN32)
conntimeout.tv_sec = conn->data->connecttimeout;
conntimeout.tv_usec = 0;
if(-1 != select (conn->firstsocket + 1, NULL, &connectfd, NULL, &conntimeout)) {
if (FD_ISSET(conn->firstsocket, &connectfd)) {
nonblock = 0;
ioctlsocket(conn->firstsocket, FIONBIO, &nonblock);
return CURLE_OK;
}
else
errno = EINTR;
}
#endif
switch(errno) {
#ifdef ECONNREFUSED
case ECONNREFUSED:
failf(data, "Connection refused");
break;
case EFAULT:
failf(data, "Invalid socket address: %d",errno);
break;
case EISCONN:
failf(data, "Socket already connected: %d",errno);
break;
case ETIMEDOUT:
failf(data, "Timeout while accepting connection, server busy: %d",errno);
break;
case ENETUNREACH:
failf(data, "Network is unreachable: %d",errno);
break;
case EADDRINUSE:
failf(data, "Local address already in use: %d",errno);
break;
case EINPROGRESS:
failf(data, "Socket is nonblocking and connection can not be completed immediately: %d",errno);
break;
case EALREADY:
failf(data, "Socket is nonblocking and a previous connection attempt not completed: %d",errno);
break;
case EAGAIN:
failf(data, "No more free local ports: %d",errno);
break;
case EACCES:
case EPERM:
failf(data, "Attempt to connect to broadcast address without socket broadcast flag or local firewall rule violated: %d",errno);
break;
#endif
case EINTR:
failf(data, "Connection timed out");
break;
default:
failf(data, "Can't connect to server: %d", errno);
break;
}
return CURLE_COULDNT_CONNECT;
}
#endif
return CURLE_OK;
}
static CURLcode Connect(struct UrlData *data,
struct connectdata **in_connect,
bool allow_port)
{
char *tmp;
char *buf;
CURLcode result;
char resumerange[40]="";
struct connectdata *conn;
struct connectdata *conn_temp;
char endbracket;
int urllen;
if(!data->url)
return CURLE_URL_MALFORMAT;
conn = (struct connectdata *)malloc(sizeof(struct connectdata));
if(!conn) {
*in_connect = NULL;
return CURLE_OUT_OF_MEMORY;
}
*in_connect = conn;
memset(conn, 0, sizeof(struct connectdata));
conn->data = data;
conn->upload_bufsize = UPLOAD_BUFSIZE;
conn->firstsocket = -1;
conn->secondarysocket = -1;
conn->connectindex = -1;
conn->bits.httpproxy = data->bits.httpproxy;
conn->bits.use_range = data->bits.set_range;
conn->range = data->set_range;
conn->resume_from = data->set_resume_from;
conn->bits.close = TRUE;
conn->bits.user_passwd = data->userpwd?1:0;
conn->bits.proxy_user_passwd = data->proxyuserpwd?1:0;
conn->created = Curl_tvnow();
#define LEAST_PATH_ALLOC 256
urllen=strlen(data->url);
if(urllen < LEAST_PATH_ALLOC)
urllen=LEAST_PATH_ALLOC;
conn->path=(char *)malloc(urllen);
if(NULL == conn->path)
return CURLE_OUT_OF_MEMORY;
if((2 == sscanf(data->url, "%64[^:]://%[^\n]",
conn->protostr,
conn->path)) && strequal(conn->protostr, "file")) {
if (strnequal(conn->path, "localhost/", 10) ||
strnequal(conn->path, "127.0.0.1/", 10))
strcpy(conn->path, &conn->path[10]);
strcpy(conn->protostr, "file");
}
else {
strcpy(conn->gname, "curl.haxx.se");
strcpy(conn->path, "/");
if (2 > sscanf(data->url,
"%64[^\n:]://%256[^\n/]%[^\n]",
conn->protostr, conn->gname, conn->path)) {
if((1 > sscanf(data->url, "%256[^\n/]%[^\n]",
conn->gname, conn->path)) ) {
failf(data, "<url> malformed");
return CURLE_URL_MALFORMAT;
}
if(strnequal(conn->gname, "FTP", 3)) {
strcpy(conn->protostr, "ftp");
}
else if(strnequal(conn->gname, "GOPHER", 6))
strcpy(conn->protostr, "gopher");
#ifdef USE_SSLEAY
else if(strnequal(conn->gname, "HTTPS", 5))
strcpy(conn->protostr, "https");
else if(strnequal(conn->gname, "FTPS", 4))
strcpy(conn->protostr, "ftps");
#endif
else if(strnequal(conn->gname, "TELNET", 6))
strcpy(conn->protostr, "telnet");
else if (strnequal(conn->gname, "DICT", sizeof("DICT")-1))
strcpy(conn->protostr, "DICT");
else if (strnequal(conn->gname, "LDAP", sizeof("LDAP")-1))
strcpy(conn->protostr, "LDAP");
else {
strcpy(conn->protostr, "http");
}
conn->protocol |= PROT_MISSING;
}
}
buf = data->buffer;
if(conn->bits.user_passwd && !data->bits.use_netrc) {
data->user[0] =0;
data->passwd[0]=0;
if(*data->userpwd != ':') {
sscanf(data->userpwd, "%127[^:]:%127[^\n]",
data->user, data->passwd);
}
else
sscanf(data->userpwd+1, "%127[^\n]", data->passwd);
if( !data->passwd[0] ) {
if(!data->fpasswd ||
data->fpasswd(data->passwd_client,
"password:", data->passwd, sizeof(data->passwd)))
return CURLE_BAD_PASSWORD_ENTERED;
}
}
if(conn->bits.proxy_user_passwd) {
data->proxyuser[0] =0;
data->proxypasswd[0]=0;
if(*data->proxyuserpwd != ':') {
sscanf(data->proxyuserpwd, "%127[^:]:%127[^\n]",
data->proxyuser, data->proxypasswd);
}
else
sscanf(data->proxyuserpwd+1, "%127[^\n]", data->proxypasswd);
if( !data->proxypasswd[0] ) {
if(!data->fpasswd ||
data->fpasswd( data->passwd_client,
"proxy password:",
data->proxypasswd,
sizeof(data->proxypasswd)))
return CURLE_BAD_PASSWORD_ENTERED;
}
}
conn->name = conn->gname;
conn->ppath = conn->path;
conn->hostname = conn->name;
if(!data->bits.httpproxy) {
char *no_proxy=NULL;
char *proxy=NULL;
char proxy_env[128];
no_proxy=curl_getenv("no_proxy");
if(!no_proxy)
no_proxy=curl_getenv("NO_PROXY");
if(!no_proxy || !strequal("*", no_proxy)) {
char *nope;
nope=no_proxy?strtok(no_proxy, ", "):NULL;
while(nope) {
if(strlen(nope) <= strlen(conn->name)) {
char *checkn=
conn->name + strlen(conn->name) - strlen(nope);
if(strnequal(nope, checkn, strlen(nope))) {
break;
}
}
nope=strtok(NULL, ", ");
}
if(!nope) {
char *protop = conn->protostr;
char *envp = proxy_env;
char *prox;
while(*protop)
*envp++ = tolower(*protop++);
strcpy(envp, "_proxy");
prox=curl_getenv(proxy_env);
if(!prox && !strequal("http_proxy", proxy_env)) {
for(envp = proxy_env; *envp; envp++)
*envp = toupper(*envp);
prox=curl_getenv(proxy_env);
}
if(prox && *prox) {
proxy = prox;
}
else {
proxy = curl_getenv("all_proxy");
if(!proxy)
proxy=curl_getenv("ALL_PROXY");
}
if(proxy && *proxy) {
data->proxy = proxy;
data->bits.proxystringalloc=1;
data->bits.httpproxy=1;
}
}
}
if(no_proxy)
free(no_proxy);
}
if((conn->protocol&PROT_MISSING) && data->bits.httpproxy ) {
char *reurl;
reurl = aprintf("%s://%s", conn->protostr, data->url);
if(!reurl)
return CURLE_OUT_OF_MEMORY;
data->url = reurl;
if(data->freethis)
free(data->freethis);
data->freethis = reurl;
conn->protocol &= ~PROT_MISSING;
}
if(conn->resume_from) {
if(!conn->bits.use_range) {
snprintf(resumerange, sizeof(resumerange), "%d-", conn->resume_from);
conn->range=strdup(resumerange);
conn->bits.rangestringalloc = TRUE;
conn->bits.use_range = 1;
}
}
if(data->timeout || data->connecttimeout) {
if(data->connecttimeout)
myalarm(data->connecttimeout);
else
myalarm(data->timeout);
}
if (strequal(conn->protostr, "HTTP")) {
conn->port = (data->use_port && allow_port)?data->use_port:PORT_HTTP;
conn->remote_port = PORT_HTTP;
conn->protocol |= PROT_HTTP;
conn->curl_do = Curl_http;
conn->curl_done = Curl_http_done;
conn->curl_close = Curl_http_close;
}
else if (strequal(conn->protostr, "HTTPS")) {
#ifdef USE_SSLEAY
conn->port = (data->use_port && allow_port)?data->use_port:PORT_HTTPS;
conn->remote_port = PORT_HTTPS;
conn->protocol |= PROT_HTTP;
conn->protocol |= PROT_HTTPS;
conn->curl_do = Curl_http;
conn->curl_done = Curl_http_done;
conn->curl_connect = Curl_http_connect;
conn->curl_close = Curl_http_close;
#else
failf(data, "libcurl was built with SSL disabled, https: not supported!");
return CURLE_UNSUPPORTED_PROTOCOL;
#endif
}
else if (strequal(conn->protostr, "GOPHER")) {
conn->port = (data->use_port && allow_port)?data->use_port:PORT_GOPHER;
conn->remote_port = PORT_GOPHER;
if (isdigit((int)conn->path[1])) {
conn->ppath = strchr(&conn->path[1], '/');
if (conn->ppath == NULL)
conn->ppath = conn->path;
}
conn->protocol |= PROT_GOPHER;
conn->curl_do = Curl_http;
conn->curl_done = Curl_http_done;
conn->curl_close = Curl_http_close;
}
else if(strequal(conn->protostr, "FTP") ||
strequal(conn->protostr, "FTPS")) {
char *type;
if(strequal(conn->protostr, "FTPS")) {
#ifdef USE_SSLEAY
conn->protocol |= PROT_FTPS;
#else
failf(data, "libcurl was built with SSL disabled, ftps: not supported!");
return CURLE_UNSUPPORTED_PROTOCOL;
#endif
}
conn->port = (data->use_port && allow_port)?data->use_port:PORT_FTP;
conn->remote_port = PORT_FTP;
conn->protocol |= PROT_FTP;
if(data->bits.httpproxy &&
!data->bits.tunnel_thru_httpproxy) {
if(conn->protocol & PROT_FTPS) {
failf(data, "ftps does not work through http proxy!");
return CURLE_UNSUPPORTED_PROTOCOL;
}
conn->curl_do = Curl_http;
conn->curl_done = Curl_http_done;
conn->curl_close = Curl_http_close;
}
else {
conn->curl_do = Curl_ftp;
conn->curl_done = Curl_ftp_done;
conn->curl_connect = Curl_ftp_connect;
conn->curl_disconnect = Curl_ftp_disconnect;
}
conn->ppath++;
type=strstr(conn->ppath, ";type=");
if(!type) {
type=strstr(conn->gname, ";type=");
}
if(type) {
char command;
*type=0;
command = toupper(type[6]);
switch(command) {
case 'A':
data->bits.ftp_ascii = 1;
break;
case 'D':
data->bits.ftp_list_only = 1;
break;
case 'I':
default:
data->bits.ftp_ascii = 0;
break;
}
}
}
else if(strequal(conn->protostr, "TELNET")) {
conn->protocol |= PROT_TELNET;
conn->port = (data->use_port && allow_port)?data->use_port: PORT_TELNET;
conn->remote_port = PORT_TELNET;
conn->curl_do = Curl_telnet;
conn->curl_done = Curl_telnet_done;
}
else if (strequal(conn->protostr, "DICT")) {
conn->protocol |= PROT_DICT;
conn->port = (data->use_port && allow_port)?data->use_port:PORT_DICT;
conn->remote_port = PORT_DICT;
conn->curl_do = Curl_dict;
conn->curl_done = Curl_dict_done;
}
else if (strequal(conn->protostr, "LDAP")) {
conn->protocol |= PROT_LDAP;
conn->port = (data->use_port && allow_port)?data->use_port:PORT_LDAP;
conn->remote_port = PORT_LDAP;
conn->curl_do = Curl_ldap;
conn->curl_done = Curl_ldap_done;
}
else if (strequal(conn->protostr, "FILE")) {
conn->protocol |= PROT_FILE;
conn->curl_do = Curl_file;
result = Curl_file_connect(conn);
if(CURLE_OK == result) {
result = Curl_Transfer(conn, -1, -1, FALSE, NULL,
-1, NULL);
}
return result;
}
else {
failf(data, "Unsupported protocol: %s", conn->protostr);
return CURLE_UNSUPPORTED_PROTOCOL;
}
if(data->bits.use_netrc) {
if(Curl_parsenetrc(conn->hostname, data->user, data->passwd)) {
infof(data, "Couldn't find host %s in the .netrc file, using defaults",
conn->hostname);
}
else
conn->bits.user_passwd = 1;
if(!data->user[0])
strcpy(data->user, CURL_DEFAULT_USER);
if(!data->passwd[0])
strcpy(data->passwd, CURL_DEFAULT_PASSWORD);
}
else if(!(conn->bits.user_passwd) &&
(conn->protocol & (PROT_FTP|PROT_HTTP)) ) {
char *ptr=NULL;
if((ptr=strchr(conn->name, '@'))) {
data->user[0] =0;
data->passwd[0]=0;
if(*conn->name != ':') {
sscanf(conn->name, "%127[^:@]:%127[^@]",
data->user, data->passwd);
}
else
sscanf(conn->name+1, "%127[^@]", data->passwd);
if(data->user[0]) {
char *newname=curl_unescape(data->user, 0);
if(strlen(newname) < sizeof(data->user)) {
strcpy(data->user, newname);
}
free(newname);
}
if( !data->passwd[0] ) {
if(!data->fpasswd ||
data->fpasswd(data->passwd_client,
"password:",data->passwd,sizeof(data->passwd)))
return CURLE_BAD_PASSWORD_ENTERED;
}
else {
char *newpasswd=curl_unescape(data->passwd, 0);
if(strlen(newpasswd) < sizeof(data->passwd)) {
strcpy(data->passwd, newpasswd);
}
free(newpasswd);
}
conn->name = ++ptr;
conn->bits.user_passwd=TRUE;
}
else {
strcpy(data->user, CURL_DEFAULT_USER);
strcpy(data->passwd, CURL_DEFAULT_PASSWORD);
}
}
if((1 == sscanf(conn->name, "[%*39[0-9a-fA-F:]%c", &endbracket)) &&
(']' == endbracket)) {
#ifndef ENABLE_IPV6
failf(data, "You haven't enabled IPv6 support");
return CURLE_URL_MALFORMAT;
#else
tmp = strchr(conn->name, ']');
tmp++;
if(':' != *tmp)
tmp = NULL;
#endif
}
else {
tmp = strchr(conn->name, ':');
}
if (tmp) {
*tmp++ = '\0';
conn->remote_port = atoi(tmp);
}
if(data->bits.httpproxy) {
char *prox_portno;
char *endofprot;
char *proxydup=strdup(data->proxy);
char *proxyptr=proxydup;
if(NULL == proxydup) {
failf(data, "memory shortage");
return CURLE_OUT_OF_MEMORY;
}
endofprot=strstr(proxyptr, "://");
if(endofprot) {
proxyptr = endofprot+3;
}
prox_portno = strchr (proxyptr, ':');
if (prox_portno) {
*prox_portno = 0x0;
prox_portno ++;
conn->port = atoi(prox_portno);
}
else if(data->proxyport) {
conn->port = data->proxyport;
}
conn->proxyhost = strdup(proxyptr);
free(proxydup);
}
if(!data->bits.reuse_fresh &&
ConnectionExists(data, conn, &conn_temp)) {
struct connectdata *old_conn = conn;
char *path = old_conn->path;
if(old_conn->proxyhost)
free(old_conn->proxyhost);
conn = conn_temp;
free(conn->path);
conn->name = conn->gname;
conn->hostname = old_conn->gname;
conn->path = path;
conn->ppath = path;
conn->maxdownload = 0;
conn->bits.reuse = TRUE;
free(old_conn);
*in_connect = conn;
infof(data, "Re-using existing connection! (#%d)\n", conn->connectindex);
}
else {
ConnectionStore(data, conn);
}
if(!data->bits.httpproxy) {
conn->port = conn->remote_port;
if(!conn->hp) {
#ifdef ENABLE_IPV6
conn->hp = Curl_getaddrinfo(data, conn->name, conn->port);
#else
conn->hp = Curl_gethost(data, conn->name, &conn->hostent_buf);
#endif
}
if(!conn->hp)
{
failf(data, "Couldn't resolve host '%s'", conn->name);
return CURLE_COULDNT_RESOLVE_HOST;
}
}
else if(!conn->hp) {
#ifdef ENABLE_IPV6
conn->hp = Curl_getaddrinfo(data, conn->proxyhost, conn->port);
#else
conn->hp = Curl_gethost(data, conn->proxyhost, &conn->hostent_buf);
#endif
if(!conn->hp) {
failf(data, "Couldn't resolve proxy '%s'", conn->proxyhost);
return CURLE_COULDNT_RESOLVE_PROXY;
}
}
Curl_pgrsTime(data, TIMER_NAMELOOKUP);
if(conn->bits.proxy_user_passwd) {
char *authorization;
snprintf(data->buffer, BUFSIZE, "%s:%s",
data->proxyuser, data->proxypasswd);
if(Curl_base64_encode(data->buffer, strlen(data->buffer),
&authorization) >= 0) {
if(conn->allocptr.proxyuserpwd)
free(conn->allocptr.proxyuserpwd);
conn->allocptr.proxyuserpwd =
aprintf("Proxy-authorization: Basic %s\015\012", authorization);
free(authorization);
}
}
if((conn->protocol&PROT_HTTP) || data->bits.httpproxy) {
if(data->useragent) {
if(conn->allocptr.uagent)
free(conn->allocptr.uagent);
conn->allocptr.uagent =
aprintf("User-Agent: %s\015\012", data->useragent);
}
}
if(-1 == conn->firstsocket) {
result = ConnectPlease(data, conn);
if(CURLE_OK != result)
return result;
if(conn->curl_connect) {
conn->now = Curl_tvnow();
result = conn->curl_connect(conn);
if(result != CURLE_OK)
return result;
}
}
Curl_pgrsTime(data, TIMER_CONNECT);
conn->now = Curl_tvnow();
conn->bytecount = 0;
#ifdef ENABLE_IPV6
{
char hbuf[NI_MAXHOST];
#ifdef NI_WITHSCOPEID
const int niflags = NI_NUMERICHOST | NI_WITHSCOPEID;
#else
const int niflags = NI_NUMERICHOST;
#endif
struct addrinfo *ai = conn->ai;
if (getnameinfo(ai->ai_addr, ai->ai_addrlen, hbuf, sizeof(hbuf), NULL, 0,
niflags)) {
snprintf(hbuf, sizeof(hbuf), "?");
}
if (ai->ai_canonname) {
infof(data, "Connected to %s (%s)\n", ai->ai_canonname, hbuf);
} else {
infof(data, "Connected to %s\n", hbuf);
}
}
#else
{
struct in_addr in;
(void) memcpy(&in.s_addr, *conn->hp->h_addr_list, sizeof (in.s_addr));
infof(data, "Connected to %s (%s)\n", conn->hp->h_name, inet_ntoa(in));
}
#endif
#ifdef __EMX__
if ((data->out)->_handle == NULL) {
_fsetmode(stdout, "b");
}
#endif
return CURLE_OK;
}
CURLcode Curl_connect(struct UrlData *data,
struct connectdata **in_connect,
bool allow_port)
{
CURLcode code;
struct connectdata *conn;
code = Connect(data, in_connect, allow_port);
if(CURLE_OK != code) {
conn = (struct connectdata *)*in_connect;
if(conn) {
Curl_disconnect(conn);
*in_connect = NULL;
}
}
return code;
}
CURLcode Curl_done(struct connectdata *conn)
{
struct UrlData *data=conn->data;
CURLcode result;
if(conn->bits.rangestringalloc) {
free(conn->range);
conn->bits.rangestringalloc = FALSE;
}
if(conn->curl_done)
result = conn->curl_done(conn);
else
result = CURLE_OK;
Curl_pgrsDone(conn);
if(data->bits.reuse_forbid ||
((CURLE_OK == result) && conn->bits.close))
result = Curl_disconnect(conn);
else
infof(data, "Connection (#%d) left alive\n", conn->connectindex);
return result;
}
CURLcode Curl_do(struct connectdata *conn)
{
CURLcode result=CURLE_OK;
if(conn->curl_do)
result = conn->curl_do(conn);
return result;
}