struct connectdata *conn);
-/* does nothing, returns OK */
-CURLcode curl_init(void)
-{
- return CURLE_OK;
-}
-
-/* does nothing */
-void curl_free(void)
-{
-}
-
-CURLcode curl_close(CURL *curl)
+CURLcode Curl_close(CURL *curl)
{
struct UrlData *data=(struct UrlData *)curl;
free(data->connects);
free(data);
-
- /* global cleanup */
- curl_free();
-
return CURLE_OK;
}
}
-CURLcode curl_open(CURL **curl, char *url)
+CURLcode Curl_open(CURL **curl, char *url)
{
/* We don't yet support specifying the URL at this point */
struct UrlData *data;
data = (struct UrlData *)malloc(sizeof(struct UrlData));
if(data) {
memset(data, 0, sizeof(struct UrlData));
- data->handle = STRUCT_OPEN;
- data->interf = CURLI_NORMAL; /* normal interface by default */
/* We do some initial setup here, all those fields that can't be just 0 */
return CURLE_OUT_OF_MEMORY;
}
-CURLcode curl_setopt(CURL *curl, CURLoption option, ...)
+CURLcode Curl_setopt(CURL *curl, CURLoption option, ...)
{
struct UrlData *data = curl;
va_list param;
}
#endif
-CURLcode curl_disconnect(CURLconnect *c_connect)
+CURLcode Curl_disconnect(struct connectdata *conn)
{
- struct connectdata *conn = c_connect;
-
if(conn->curl_disconnect)
/* This is set if protocol-specific cleanups should be made */
conn->curl_disconnect(conn);
if(conn->allocptr.host)
free(conn->allocptr.host);
+ if(conn->proxyhost)
+ free(conn->proxyhost);
+
free(conn); /* free all the connection oriented data */
return CURLE_OK;
if(!check)
/* NULL pointer means not filled-in entry */
continue;
- if(strequal(needle->protostr, check->protostr) &&
- strequal(needle->name, check->name) &&
- (needle->port == check->port) ) {
- if(strequal(needle->protostr, "FTP")) {
- /* This is FTP, verify that we're using the same name and
- password as well */
- if(!strequal(needle->data->user, check->proto.ftp->user) ||
- !strequal(needle->data->passwd, check->proto.ftp->passwd)) {
- /* one of them was different */
- continue;
- }
- }
- {
+ if(!needle->bits.httpproxy) {
+ /* The requested connection does not use a HTTP proxy */
+
+ if(strequal(needle->protostr, check->protostr) &&
+ strequal(needle->name, check->name) &&
+ (needle->port == check->port) ) {
bool dead;
+ if(strequal(needle->protostr, "FTP")) {
+ /* This is FTP, verify that we're using the same name and
+ password as well */
+ if(!strequal(needle->data->user, check->proto.ftp->user) ||
+ !strequal(needle->data->passwd, check->proto.ftp->passwd)) {
+ /* one of them was different */
+ continue;
+ }
+ }
dead = SocketIsDead(check->firstsocket);
if(dead) {
infof(data, "Connection %d seems to be dead!\n", i);
- curl_disconnect(check); /* disconnect resources */
+ Curl_disconnect(check); /* disconnect resources */
data->connects[i]=NULL; /* nothing here */
continue; /* try another one now */
}
*usethis = check;
return TRUE; /* yes, we found one to use! */
}
+ else { /* The requested needle connection is using a proxy,
+ is the checked one using the same? */
+ if(check->bits.httpproxy &&
+ strequal(needle->proxyhost, check->proxyhost) &&
+ needle->port == check->port) {
+ /* This is the same proxy connection, use it! */
+ *usethis = check;
+ return TRUE;
+ }
+ }
}
return FALSE; /* no matching connecting exists */
}
if(connindex >= 0) {
/* the winner gets the honour of being disconnected */
- result = curl_disconnect(data->connects[connindex]);
+ result = Curl_disconnect(data->connects[connindex]);
/* clean the array entry */
data->connects[connindex] = NULL;
size = sizeof(add);
if(getsockname(conn->firstsocket, (struct sockaddr *) &add,
- (int *)&size)<0) {
+ (socklen_t *)&size)<0) {
failf(data, "getsockname() failed");
return CURLE_HTTP_PORT_FAILED;
}
return CURLE_OK;
}
-static CURLcode _connect(CURL *curl,
- CURLconnect **in_connect,
- bool allow_port) /* allow data->use_port ? */
+static CURLcode Connect(struct UrlData *data,
+ struct connectdata **in_connect,
+ bool allow_port) /* allow data->use_port ? */
{
char *tmp;
char *buf;
CURLcode result;
char resumerange[40]="";
- struct UrlData *data = curl;
struct connectdata *conn;
struct connectdata *conn_temp;
char endbracket;
* Check input data
*************************************************************/
- if(!data || (data->handle != STRUCT_OPEN))
- return CURLE_BAD_FUNCTION_ARGUMENT; /* TBD: make error codes */
-
if(!data->url)
return CURLE_URL_MALFORMAT;
memset(conn, 0, sizeof(struct connectdata));
/* and we setup a few fields in case we end up actually using this struct */
- conn->handle = STRUCT_CONNECT; /* this is a connection handle */
conn->data = data; /* remember our daddy */
- conn->state = CONN_INIT; /* init state */
conn->upload_bufsize = UPLOAD_BUFSIZE; /* default upload buffer size */
conn->firstsocket = -1; /* no file descriptor */
conn->secondarysocket = -1; /* no file descriptor */
conn->connectindex = -1; /* no index */
+ conn->bits.httpproxy = data->bits.httpproxy; /* proxy-or-not status */
/* Default protocol-indepent behaveiour doesn't support persistant
connections, so we set this to force-close. Protocols that support
conn->remote_port = atoi(tmp);
}
+ if(data->bits.httpproxy) {
+ /* 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. */
+
+#ifdef ENABLE_IPV6
+ failf(data, "proxy yet to be supported");
+ return CURLE_OUT_OF_MEMORY;
+#else
+ char *prox_portno;
+ char *endofprot;
+
+ /* We need to make a duplicate of the proxy so that we can modify the
+ string safely. */
+ char *proxydup=strdup(data->proxy);
+
+ /* 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);
+ }
+ else if(data->proxyport) {
+ /* None given in the proxy string, then get the default one if it is
+ given */
+ conn->port = data->proxyport;
+ }
+
+ /* now, clone the cleaned proxy host name */
+ conn->proxyhost = strdup(proxyptr);
+
+ free(proxydup); /* free the duplicate pointer and not the modified */
+#endif /* end of IPv4-section */
+ }
+
/*************************************************************
* Check the current list of connections to see if we can
* re-use an already existing one or if we have to create a
* existing one.
*/
char *path = conn->path; /* setup the current path pointer properly */
+ if(conn->proxyhost)
+ free(conn->proxyhost);
free(conn); /* we don't need this new one */
conn = conn_temp; /* use this connection from now on */
free(conn->path); /* free the previous path pointer */
conn->maxdownload = 0; /* might have been used previously! */
conn->bits.reuse = TRUE; /* yes, we're re-using here */
+ *in_connect = conn; /* return this instead! */
+
infof(data, "Re-using existing connection! (#%d)\n", conn->connectindex);
}
else {
else if(!conn->hp) {
/* This is a proxy that hasn't been resolved yet. It may be resolved
if we're reusing an existing connection. */
-#ifdef ENABLE_IPV6
- failf(data, "proxy yet to be supported");
- return CURLE_OUT_OF_MEMORY;
-#else
- char *prox_portno;
- char *endofprot;
-
- /* We need to make a duplicate of the proxy so that we can modify the
- string safely. */
- char *proxydup=strdup(data->proxy);
-
- /* 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);
- }
- else if(data->proxyport) {
- /* None given in the proxy string, then get the default one if it is
- given */
- conn->port = data->proxyport;
- }
/* resolve proxy */
- conn->hp = Curl_gethost(data, proxyptr, &conn->hostent_buf);
+ conn->hp = Curl_gethost(data, conn->proxyhost, &conn->hostent_buf);
if(!conn->hp) {
- failf(data, "Couldn't resolve proxy '%s'", proxyptr);
+ failf(data, "Couldn't resolve proxy '%s'", conn->proxyhost);
return CURLE_COULDNT_RESOLVE_PROXY;
}
-
- free(proxydup); /* free the duplicate pointer and not the modified */
-#endif
}
Curl_pgrsTime(data, TIMER_NAMELOOKUP);
return CURLE_OK;
}
-CURLcode curl_connect(CURL *curl, CURLconnect **in_connect,
+CURLcode Curl_connect(struct UrlData *data,
+ struct connectdata **in_connect,
bool allow_port)
{
CURLcode code;
struct connectdata *conn;
/* call the stuff that needs to be called */
- code = _connect(curl, in_connect, allow_port);
+ code = Connect(data, in_connect, allow_port);
if(CURLE_OK != code) {
/* We're not allowed to return failure with memory left allocated
in the connectdata struct, free those here */
conn = (struct connectdata *)*in_connect;
if(conn) {
- struct UrlData *data;
int index;
- data = conn->data;
index = conn->connectindex; /* get the index */
- curl_disconnect(conn); /* close the connection */
+ Curl_disconnect(conn); /* close the connection */
data->connects[index]=NULL; /* clear the pointer */
}
}
}
-/*
- * NAME curl_connect()
- *
- * DESCRIPTION
- *
- * Connects to the peer server and performs the initial setup. This function
- * writes a connect handle to its second argument that is a unique handle for
- * this connect. This allows multiple connects from the same handle returned
- * by curl_open().
- *
- * EXAMPLE
- *
- * CURLCode result;
- * CURL curl;
- * CURLconnect connect;
- * result = curl_connect(curl, &connect);
- */
-
-
-
-
-CURLcode curl_done(CURLconnect *c_connect)
+CURLcode Curl_done(struct connectdata *conn)
{
- struct connectdata *conn = c_connect;
struct UrlData *data;
CURLcode result;
int index;
- if(!conn || (conn->handle!= STRUCT_CONNECT)) {
- return CURLE_BAD_FUNCTION_ARGUMENT;
- }
- if(conn->state != CONN_DO) {
- /* This can only be called after a curl_do() */
- return CURLE_BAD_CALLING_ORDER;
- }
data = conn->data;
/* this calls the protocol-specific function pointer previously set */
Curl_pgrsDone(data); /* done with the operation */
- conn->state = CONN_DONE;
-
/* if bits.close is TRUE, it means that the connection should be closed
in spite of all our efforts to be nice */
if((CURLE_OK == result) && conn->bits.close) {
index = conn->connectindex; /* get the index */
- result = curl_disconnect(conn); /* close the connection */
+ result = Curl_disconnect(conn); /* close the connection */
data->connects[index]=NULL; /* clear the pointer */
}
return result;
}
-CURLcode curl_do(CURLconnect *in_conn)
+CURLcode Curl_do(struct connectdata *conn)
{
- struct connectdata *conn = in_conn;
- CURLcode result;
+ CURLcode result=CURLE_OK;
- if(!conn || (conn->handle!= STRUCT_CONNECT)) {
- return CURLE_BAD_FUNCTION_ARGUMENT;
- }
- switch(conn->state) {
- case CONN_INIT:
- case CONN_DONE:
- /* these two states are OK */
- break;
- default:
- /* anything else is bad */
- return CURLE_BAD_CALLING_ORDER;
- }
-
- if(conn->curl_do) {
+ if(conn->curl_do)
/* generic protocol-specific function pointer set in curl_connect() */
result = conn->curl_do(conn);
- if(result) {
- conn->state = CONN_ERROR;
- return result;
- }
- }
-
- conn->state = CONN_DO; /* we have entered this state */
- return CURLE_OK;
+ return result;
}
projects / platform / upstream / curl.git / commitdiff