#include "setup.h"
#include <stdlib.h>
#include <string.h>
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <curl/curl.h>
#include "urldata.h"
#include "transfer.h"
#include "url.h"
#include "connect.h"
#include "progress.h"
#include "memory.h"
#include "easyif.h"
#include "multiif.h"
#include "sendf.h"
#include "memdebug.h"
struct Curl_message {
struct CURLMsg extmsg;
struct Curl_message *next;
};
typedef enum {
CURLM_STATE_INIT,
CURLM_STATE_CONNECT,
CURLM_STATE_WAITRESOLVE,
CURLM_STATE_WAITCONNECT,
CURLM_STATE_PROTOCONNECT,
CURLM_STATE_DO,
CURLM_STATE_DOING,
CURLM_STATE_DO_MORE,
CURLM_STATE_PERFORM,
CURLM_STATE_DONE,
CURLM_STATE_COMPLETED,
CURLM_STATE_LAST
} CURLMstate;
struct Curl_one_easy {
struct Curl_one_easy *next;
struct Curl_one_easy *prev;
struct SessionHandle *easy_handle;
struct connectdata *easy_conn;
CURLMstate state;
CURLcode result;
struct Curl_message *msg;
int msg_num;
};
#define CURL_MULTI_HANDLE 0x000bab1e
#define GOOD_MULTI_HANDLE(x) ((x)&&(((struct Curl_multi *)x)->type == CURL_MULTI_HANDLE))
#define GOOD_EASY_HANDLE(x) (x)
struct Curl_multi {
long type;
struct Curl_one_easy easy;
int num_easy;
int num_msgs;
struct curl_hash *hostcache;
};
static void multistate(struct Curl_one_easy *easy, CURLMstate state)
{
#ifdef CURLDEBUG
const char *statename[]={
"INIT",
"CONNECT",
"WAITRESOLVE",
"WAITCONNECT",
"PROTOCONNECT",
"DO",
"DOING",
"DO_MORE",
"PERFORM",
"DONE",
"COMPLETED",
};
CURLMstate oldstate = easy->state;
#endif
easy->state = state;
#ifdef CURLDEBUG
infof(easy->easy_handle,
"STATE: %s => %s handle %p: \n",
statename[oldstate], statename[easy->state], (char *)easy);
#endif
}
CURLM *curl_multi_init(void)
{
struct Curl_multi *multi;
multi = (void *)malloc(sizeof(struct Curl_multi));
if(multi) {
memset(multi, 0, sizeof(struct Curl_multi));
multi->type = CURL_MULTI_HANDLE;
}
else
return NULL;
multi->hostcache = Curl_mk_dnscache();
if(!multi->hostcache) {
free(multi);
multi = NULL;
}
return (CURLM *) multi;
}
CURLMcode curl_multi_add_handle(CURLM *multi_handle,
CURL *easy_handle)
{
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
struct Curl_one_easy *easy;
if(!GOOD_MULTI_HANDLE(multi))
return CURLM_BAD_HANDLE;
if(!GOOD_EASY_HANDLE(easy_handle))
return CURLM_BAD_EASY_HANDLE;
easy = (struct Curl_one_easy *)malloc(sizeof(struct Curl_one_easy));
if(!easy)
return CURLM_OUT_OF_MEMORY;
memset(easy, 0, sizeof(struct Curl_one_easy));
easy->easy_handle = easy_handle;
multistate(easy, CURLM_STATE_INIT);
easy->easy_handle->hostcache = multi->hostcache;
easy->next = multi->easy.next;
easy->prev = &multi->easy;
multi->easy.next = easy;
if(easy->next)
easy->next->prev = easy;
Curl_easy_addmulti(easy_handle, multi_handle);
multi->num_easy++;
return CURLM_OK;
}
CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
CURL *curl_handle)
{
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
struct Curl_one_easy *easy;
if(!GOOD_MULTI_HANDLE(multi))
return CURLM_BAD_HANDLE;
if(!GOOD_EASY_HANDLE(curl_handle))
return CURLM_BAD_EASY_HANDLE;
easy = multi->easy.next;
while(easy) {
if(easy->easy_handle == (struct SessionHandle *)curl_handle)
break;
easy=easy->next;
}
if(easy) {
easy->easy_handle->hostcache = NULL;
Curl_easy_addmulti(easy->easy_handle, NULL);
if(easy->prev)
easy->prev->next = easy->next;
if(easy->next)
easy->next->prev = easy->prev;
if (easy->msg)
free(easy->msg);
free(easy);
multi->num_easy--;
return CURLM_OK;
}
else
return CURLM_BAD_EASY_HANDLE;
}
CURLMcode curl_multi_fdset(CURLM *multi_handle,
fd_set *read_fd_set, fd_set *write_fd_set,
fd_set *exc_fd_set, int *max_fd)
{
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
struct Curl_one_easy *easy;
int this_max_fd=-1;
if(!GOOD_MULTI_HANDLE(multi))
return CURLM_BAD_HANDLE;
*max_fd = -1;
easy=multi->easy.next;
while(easy) {
switch(easy->state) {
default:
break;
case CURLM_STATE_WAITRESOLVE:
Curl_resolv_fdset(easy->easy_conn, read_fd_set, write_fd_set,
&this_max_fd);
if(this_max_fd > *max_fd)
*max_fd = this_max_fd;
break;
case CURLM_STATE_PROTOCONNECT:
Curl_protocol_fdset(easy->easy_conn, read_fd_set, write_fd_set,
&this_max_fd);
if(this_max_fd > *max_fd)
*max_fd = this_max_fd;
break;
case CURLM_STATE_DOING:
Curl_doing_fdset(easy->easy_conn, read_fd_set, write_fd_set,
&this_max_fd);
if(this_max_fd > *max_fd)
*max_fd = this_max_fd;
break;
case CURLM_STATE_WAITCONNECT:
case CURLM_STATE_DO_MORE:
{
struct connectdata *conn = easy->easy_conn;
curl_socket_t sockfd;
if(CURLM_STATE_WAITCONNECT == easy->state) {
sockfd = conn->sock[FIRSTSOCKET];
FD_SET(sockfd, write_fd_set);
}
else {
sockfd = conn->sock[SECONDARYSOCKET];
FD_SET(sockfd, write_fd_set);
}
if((int)sockfd > *max_fd)
*max_fd = (int)sockfd;
}
break;
case CURLM_STATE_PERFORM:
Curl_single_fdset(easy->easy_conn,
read_fd_set, write_fd_set,
exc_fd_set, &this_max_fd);
if(this_max_fd > *max_fd)
*max_fd = this_max_fd;
break;
}
easy = easy->next;
}
return CURLM_OK;
}
CURLMcode curl_multi_perform(CURLM *multi_handle, int *running_handles)
{
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
struct Curl_one_easy *easy;
bool done;
CURLMcode result=CURLM_OK;
struct Curl_message *msg = NULL;
bool connected;
bool async;
bool protocol_connect;
bool dophase_done;
*running_handles = 0;
if(!GOOD_MULTI_HANDLE(multi))
return CURLM_BAD_HANDLE;
easy=multi->easy.next;
while(easy) {
do {
if (CURLM_STATE_WAITCONNECT <= easy->state &&
easy->state <= CURLM_STATE_DO &&
easy->easy_handle->change.url_changed) {
char *gotourl;
Curl_posttransfer(easy->easy_handle);
easy->result = Curl_done(&easy->easy_conn, CURLE_OK);
if(CURLE_OK == easy->result) {
gotourl = strdup(easy->easy_handle->change.url);
if(gotourl) {
easy->easy_handle->change.url_changed = FALSE;
easy->result = Curl_follow(easy->easy_handle, gotourl, FALSE);
if(CURLE_OK == easy->result)
multistate(easy, CURLM_STATE_CONNECT);
else
free(gotourl);
}
else {
easy->result = CURLE_OUT_OF_MEMORY;
multistate(easy, CURLM_STATE_COMPLETED);
break;
}
}
}
easy->easy_handle->change.url_changed = FALSE;
switch(easy->state) {
case CURLM_STATE_INIT:
easy->result=Curl_pretransfer(easy->easy_handle);
if(CURLE_OK == easy->result) {
multistate(easy, CURLM_STATE_CONNECT);
result = CURLM_CALL_MULTI_PERFORM;
easy->easy_handle->state.used_interface = Curl_if_multi;
}
break;
case CURLM_STATE_CONNECT:
Curl_pgrsTime(easy->easy_handle, TIMER_STARTSINGLE);
easy->result = Curl_connect(easy->easy_handle, &easy->easy_conn,
&async, &protocol_connect);
if(CURLE_OK == easy->result) {
if(async)
multistate(easy, CURLM_STATE_WAITRESOLVE);
else {
result = CURLM_CALL_MULTI_PERFORM;
if(protocol_connect)
multistate(easy, CURLM_STATE_DO);
else
multistate(easy, CURLM_STATE_WAITCONNECT);
}
}
break;
case CURLM_STATE_WAITRESOLVE:
{
struct Curl_dns_entry *dns = NULL;
easy->result = Curl_is_resolved(easy->easy_conn, &dns);
if(dns) {
easy->result = Curl_async_resolved(easy->easy_conn,
&protocol_connect);
if(CURLE_OK != easy->result)
easy->easy_conn = NULL;
else {
multistate(easy, CURLM_STATE_WAITCONNECT);
}
}
if(CURLE_OK != easy->result) {
Curl_disconnect(easy->easy_conn);
easy->easy_conn = NULL;
break;
}
}
break;
case CURLM_STATE_WAITCONNECT:
easy->result = Curl_is_connected(easy->easy_conn, FIRSTSOCKET,
&connected);
if(connected)
easy->result = Curl_protocol_connect(easy->easy_conn,
&protocol_connect);
if(CURLE_OK != easy->result) {
Curl_disconnect(easy->easy_conn);
easy->easy_conn = NULL;
break;
}
if(connected) {
if(!protocol_connect) {
multistate(easy, CURLM_STATE_PROTOCONNECT);
fprintf(stderr, "WAITCONNECT => PROTOCONNECT\n");
}
else {
multistate(easy, CURLM_STATE_DO);
result = CURLM_CALL_MULTI_PERFORM;
}
}
break;
case CURLM_STATE_PROTOCONNECT:
easy->result = Curl_protocol_connecting(easy->easy_conn,
&protocol_connect);
if(protocol_connect) {
multistate(easy, CURLM_STATE_DO);
result = CURLM_CALL_MULTI_PERFORM;
}
else if(easy->result) {
Curl_posttransfer(easy->easy_handle);
Curl_done(&easy->easy_conn, easy->result);
Curl_disconnect(easy->easy_conn);
easy->easy_conn = NULL;
}
break;
case CURLM_STATE_DO:
easy->result = Curl_do(&easy->easy_conn, &dophase_done);
if(CURLE_OK == easy->result) {
if(!dophase_done) {
multistate(easy, CURLM_STATE_DOING);
result = CURLM_OK;
}
else if(easy->easy_conn->bits.do_more) {
multistate(easy, CURLM_STATE_DO_MORE);
result = CURLM_OK;
}
else {
easy->result = Curl_readwrite_init(easy->easy_conn);
if(CURLE_OK == easy->result) {
multistate(easy, CURLM_STATE_PERFORM);
result = CURLM_CALL_MULTI_PERFORM;
}
}
}
else {
Curl_posttransfer(easy->easy_handle);
Curl_done(&easy->easy_conn, easy->result);
Curl_disconnect(easy->easy_conn);
easy->easy_conn = NULL;
}
break;
case CURLM_STATE_DOING:
easy->result = Curl_protocol_doing(easy->easy_conn, &dophase_done);
if(CURLE_OK == easy->result) {
if(dophase_done) {
if(easy->easy_conn->bits.do_more) {
multistate(easy, CURLM_STATE_DO_MORE);
result = CURLM_OK;
}
else {
easy->result = Curl_readwrite_init(easy->easy_conn);
if(CURLE_OK == easy->result) {
multistate(easy, CURLM_STATE_PERFORM);
result = CURLM_CALL_MULTI_PERFORM;
}
}
}
}
else {
Curl_posttransfer(easy->easy_handle);
Curl_done(&easy->easy_conn, easy->result);
Curl_disconnect(easy->easy_conn);
easy->easy_conn = NULL;
}
break;
case CURLM_STATE_DO_MORE:
easy->result = Curl_is_connected(easy->easy_conn, SECONDARYSOCKET,
&connected);
if(connected) {
easy->result = Curl_do_more(easy->easy_conn);
if(CURLE_OK == easy->result)
easy->result = Curl_readwrite_init(easy->easy_conn);
if(CURLE_OK == easy->result) {
multistate(easy, CURLM_STATE_PERFORM);
result = CURLM_CALL_MULTI_PERFORM;
}
}
break;
case CURLM_STATE_PERFORM:
easy->result = Curl_readwrite(easy->easy_conn, &done);
if(easy->result) {
easy->easy_conn->bits.close = TRUE;
if(CURL_SOCKET_BAD != easy->easy_conn->sock[SECONDARYSOCKET]) {
sclose(easy->easy_conn->sock[SECONDARYSOCKET]);
easy->easy_conn->sock[SECONDARYSOCKET]=-1;
}
Curl_posttransfer(easy->easy_handle);
Curl_done(&easy->easy_conn, easy->result);
}
else if(TRUE == done) {
char *newurl;
bool retry = Curl_retry_request(easy->easy_conn, &newurl);
Curl_posttransfer(easy->easy_handle);
if(easy->easy_conn->newurl || retry) {
if(!retry) {
newurl = easy->easy_conn->newurl;
easy->easy_conn->newurl = NULL;
}
easy->result = Curl_done(&easy->easy_conn, CURLE_OK);
if(easy->result == CURLE_OK)
easy->result = Curl_follow(easy->easy_handle, newurl, retry);
if(CURLE_OK == easy->result) {
multistate(easy, CURLM_STATE_CONNECT);
result = CURLM_CALL_MULTI_PERFORM;
}
else
free(newurl);
}
else {
multistate(easy, CURLM_STATE_DONE);
result = CURLM_CALL_MULTI_PERFORM;
}
}
break;
case CURLM_STATE_DONE:
easy->result = Curl_done(&easy->easy_conn, CURLE_OK);
multistate(easy, CURLM_STATE_COMPLETED);
break;
case CURLM_STATE_COMPLETED:
break;
default:
return CURLM_INTERNAL_ERROR;
}
if(CURLM_STATE_COMPLETED != easy->state) {
if(CURLE_OK != easy->result) {
multistate(easy, CURLM_STATE_COMPLETED);
}
else
(*running_handles)++;
}
} while (easy->easy_handle->change.url_changed);
if ((CURLM_STATE_COMPLETED == easy->state) && !easy->msg) {
easy->easy_handle->hostcache = NULL;
msg = (struct Curl_message *)malloc(sizeof(struct Curl_message));
if(!msg)
return CURLM_OUT_OF_MEMORY;
msg->extmsg.msg = CURLMSG_DONE;
msg->extmsg.easy_handle = easy->easy_handle;
msg->extmsg.data.result = easy->result;
msg->next=NULL;
easy->msg = msg;
easy->msg_num = 1;
multi->num_msgs++;
}
easy = easy->next;
}
return result;
}
void Curl_multi_rmeasy(void *multi_handle, CURL *easy_handle)
{
curl_multi_remove_handle(multi_handle, easy_handle);
}
CURLMcode curl_multi_cleanup(CURLM *multi_handle)
{
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
struct Curl_one_easy *easy;
struct Curl_one_easy *nexteasy;
if(GOOD_MULTI_HANDLE(multi)) {
multi->type = 0;
Curl_hash_destroy(multi->hostcache);
easy = multi->easy.next;
while(easy) {
nexteasy=easy->next;
easy->easy_handle->hostcache = NULL;
Curl_easy_addmulti(easy->easy_handle, NULL);
if (easy->msg)
free(easy->msg);
free(easy);
easy = nexteasy;
}
free(multi);
return CURLM_OK;
}
else
return CURLM_BAD_HANDLE;
}
CURLMsg *curl_multi_info_read(CURLM *multi_handle, int *msgs_in_queue)
{
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
*msgs_in_queue = 0;
if(GOOD_MULTI_HANDLE(multi)) {
struct Curl_one_easy *easy;
if(!multi->num_msgs)
return NULL;
easy=multi->easy.next;
while(easy) {
if(easy->msg_num) {
easy->msg_num--;
break;
}
easy = easy->next;
}
if(!easy)
return NULL;
multi->num_msgs--;
*msgs_in_queue = multi->num_msgs;
return &easy->msg->extmsg;
}
else
return NULL;
}