lib/multi.c - third_party/curl - Git at Google

 /*****************************************************************************
  *                                  _   _ ____  _
  *  Project                     ___| | | |  _ \| |
  *                             / __| | | | |_) | |
  *                            | (__| |_| |  _ <| |___
  *                             \___|\___/|_| \_\_____|
  *
  * Copyright (C) 1998 - 2002, Daniel Stenberg, <daniel@haxx.se>, et al.
  *
  * In order to be useful for every potential user, curl and libcurl are
  * dual-licensed under the MPL and the MIT/X-derivate licenses.
  *
  * 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
  * furnished to do so, under the terms of the MPL or the MIT/X-derivate
  * licenses. You may pick one of these licenses.
  *
  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  * KIND, either express or implied.
  *
  * $Id$
  *****************************************************************************/

 #include "setup.h"
 #include <stdlib.h>
 #include <string.h>
 #include <curl/curl.h>

 #include "urldata.h"
 #include "transfer.h"
 #include "url.h"

 struct Curl_message {
   /* the 'CURLMsg' is the part that is visible to the external user */
   struct CURLMsg extmsg;
   struct Curl_message *next;
 };

 typedef enum {
   CURLM_STATE_INIT,
   CURLM_STATE_CONNECT,
   CURLM_STATE_DO,
   CURLM_STATE_PERFORM,
   CURLM_STATE_DONE,
   CURLM_STATE_COMPLETED,

   CURLM_STATE_LAST /* not a true state, never use this */
 } CURLMstate;

 struct Curl_one_easy {
   /* first, two fields for the linked list of these */
   struct Curl_one_easy *next;
   struct Curl_one_easy *prev;

   struct SessionHandle *easy_handle; /* the easy handle for this unit */
   struct connectdata *easy_conn;     /* the "unit's" connection */

   CURLMstate state;  /* the handle's state */
   CURLcode result;   /* previous result */
 };


 #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)

 /* This is the struct known as CURLM on the outside */
 struct Curl_multi {
   /* First a simple identifier to easier detect if a user mix up
      this multi handle with an easy handle. Set this to CURL_MULTI_HANDLE. */
   long type;

   /* We have a linked list with easy handles */
   struct Curl_one_easy easy;
   /* This is the amount of entries in the linked list above. */
   int num_easy;

   /* this is a linked list of posted messages */
   struct Curl_message *msgs;
   /* amount of messages in the queue */
   int num_msgs;
   /* Hostname cache */
   curl_hash *hostcache;
 };


 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;
   }

   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;

   /* First, make some basic checks that the CURLM handle is a good handle */
   if(!GOOD_MULTI_HANDLE(multi))
     return CURLM_BAD_HANDLE;

   /* Verify that we got a somewhat good easy handle too */
   if(!GOOD_EASY_HANDLE(easy_handle))
     return CURLM_BAD_EASY_HANDLE;

   /* Now, time to add an easy handle to the multi stack */
   easy = (struct Curl_one_easy *)malloc(sizeof(struct Curl_one_easy));
   if(!easy)
     return CURLM_OUT_OF_MEMORY;

   /* clean it all first (just to be sure) */
   memset(easy, 0, sizeof(struct Curl_one_easy));

   /* set the easy handle */
   easy->easy_handle = easy_handle;
   easy->state = CURLM_STATE_INIT;

   /* We add this new entry first in the list. We make our 'next' point to the
      previous next and our 'prev' point back to the 'first' struct */
   easy->next = multi->easy.next;
   easy->prev = &multi->easy;

   /* make 'easy' the first node in the chain */
   multi->easy.next = easy;

   /* if there was a next node, make sure its 'prev' pointer links back to
      the new node */
   if(easy->next)
     easy->next->prev = easy;

   /* increase the node-counter */
   multi->num_easy++;

   return CURLM_CALL_MULTI_PERFORM;
 }

 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;

   /* First, make some basic checks that the CURLM handle is a good handle */
   if(!GOOD_MULTI_HANDLE(multi))
     return CURLM_BAD_HANDLE;

   /* Verify that we got a somewhat good easy handle too */
   if(!GOOD_EASY_HANDLE(curl_handle))
     return CURLM_BAD_EASY_HANDLE;

   /* scan through the list and remove the 'curl_handle' */
   easy = multi->easy.next;
   while(easy) {
     if(easy->easy_handle == curl_handle)
       break;
     easy=easy->next;
   }
   if(easy) {
     /* If the 'state' is not INIT or COMPLETED, we might need to do something
        nice to put the easy_handle in a good known state when this returns. */

     /* make the previous node point to our next */
     if(easy->prev)
       easy->prev->next = easy->next;
     /* make our next point to our previous node */
     if(easy->next)
       easy->next->prev = easy->prev;

     /* NOTE NOTE NOTE
        We do not touch the easy handle here! */
     free(easy);

     multi->num_easy--; /* one less to care about now */

     return CURLM_OK;
   }
   else
     return CURLM_BAD_EASY_HANDLE; /* twasn't found */
 }

 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)
 {
   /* Scan through all the easy handles to get the file descriptors set.
      Some easy handles may not have connected to the remote host yet,
      and then we must make sure that is done. */
   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; /* so far none! */

   easy=multi->easy.next;
   while(easy) {
     switch(easy->state) {
     default:
       break;
     case CURLM_STATE_PERFORM:
       /* This should have a set of file descriptors for us to set.  */
       /* after the transfer is done, go DONE */

       Curl_single_fdset(easy->easy_conn,
                         read_fd_set, write_fd_set,
                         exc_fd_set, &this_max_fd);

       /* remember the maximum file descriptor */
       if(this_max_fd > *max_fd)
         *max_fd = this_max_fd;

       break;
     }
     easy = easy->next; /* check next handle */
   }

   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;

   *running_handles = 0; /* bump this once for every living handle */

   if(!GOOD_MULTI_HANDLE(multi))
     return CURLM_BAD_HANDLE;

   easy=multi->easy.next;
   while(easy) {
     switch(easy->state) {
     case CURLM_STATE_INIT:
       /* init this transfer. */
       easy->result=Curl_pretransfer(easy->easy_handle);
       if(CURLE_OK == easy->result) {
         /* after init, go CONNECT */
         easy->state = CURLM_STATE_CONNECT;
         result = CURLM_CALL_MULTI_PERFORM;
       }
       break;
     case CURLM_STATE_CONNECT:
       if (Curl_global_host_cache_use(easy->easy_handle)) {
         easy->easy_handle->hostcache = Curl_global_host_cache_get();
       }
       else {
         if (multi->hostcache == NULL) {
           multi->hostcache = curl_hash_alloc(7, Curl_freeaddrinfo);
         }

         easy->easy_handle->hostcache = multi->hostcache;
       }

       /* Connect. We get a connection identifier filled in. */
       easy->result = Curl_connect(easy->easy_handle, &easy->easy_conn);

       /* after connect, go DO */
       if(CURLE_OK == easy->result) {
         easy->state = CURLM_STATE_DO;
         result = CURLM_CALL_MULTI_PERFORM;
       }
       break;
     case CURLM_STATE_DO:
       /* Do the fetch or put request */
       easy->result = Curl_do(&easy->easy_conn);
       /* after do, go PERFORM */
       if(CURLE_OK == easy->result) {
         if(CURLE_OK == Curl_readwrite_init(easy->easy_conn)) {
           easy->state = CURLM_STATE_PERFORM;
           result = CURLM_CALL_MULTI_PERFORM;
         }
       }
       break;
     case CURLM_STATE_PERFORM:
       /* read/write data if it is ready to do so */
       easy->result = Curl_readwrite(easy->easy_conn, &done);
       /* hm, when we follow redirects, we may need to go back to the CONNECT
          state */
       /* after the transfer is done, go DONE */
       if(TRUE == done) {
         /* call this even if the readwrite function returned error */
         easy->result = Curl_posttransfer(easy->easy_handle);
         easy->state = CURLM_STATE_DONE;
         result = CURLM_CALL_MULTI_PERFORM;
       }
       break;
     case CURLM_STATE_DONE:
       /* post-transfer command */
       easy->result = Curl_done(easy->easy_conn);
       /* after we have DONE what we're supposed to do, go COMPLETED */
       if(CURLE_OK == easy->result)
         easy->state = CURLM_STATE_COMPLETED;
       break;
     case CURLM_STATE_COMPLETED:
       /* this is a completed transfer, it is likely to still be connected */

       /* This node should be delinked from the list now and we should post
          an information message that we are complete. */
       break;
     default:
       return CURLM_INTERNAL_ERROR;
     }

     if((CURLM_STATE_COMPLETED != easy->state) &&
        (CURLE_OK != easy->result)) {
       /*
        * If an error was returned, and we aren't in completed now,
        * then we go to completed and consider this transfer aborted.
        */
       easy->state = CURLM_STATE_COMPLETED;
     }
     else if(CURLM_STATE_COMPLETED != easy->state)
       /* this one still lives! */
       (*running_handles)++;

     easy = easy->next; /* operate on next handle */
   }
   return result;
 }

 CURLMcode curl_multi_cleanup(CURLM *multi_handle)
 {
   struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
   if(GOOD_MULTI_HANDLE(multi)) {
     multi->type = 0; /* not good anymore */
     curl_hash_destroy(multi->hostcache);
     /* remove all easy handles */

     free(multi);

     return CURLM_OK;
   }
   else
     return CURLM_BAD_HANDLE;
 }

 CURLMsg *curl_multi_info_read(CURLM *multi_handle, int *msgs_in_queue);

 /*
  * local variables:
  * eval: (load-file "../curl-mode.el")
  * end:
  * vim600: fdm=marker
  * vim: et sw=2 ts=2 sts=2 tw=78
  */
	/*****************************************************************************
	* _ _ ____ _
	* Project ___\| \| \| \| _ \\| \|
	* / __\| \| \| \| \|_) \| \|
	* \| (__\| \|_\| \| _ <\| \|___
	* \___\|\___/\|_\| \_\_____\|
	*
	* Copyright (C) 1998 - 2002, Daniel Stenberg, <daniel@haxx.se>, et al.
	*
	* In order to be useful for every potential user, curl and libcurl are
	* dual-licensed under the MPL and the MIT/X-derivate licenses.
	*
	* 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
	* furnished to do so, under the terms of the MPL or the MIT/X-derivate
	* licenses. You may pick one of these licenses.
	*
	* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
	* KIND, either express or implied.
	*
	* $Id$
	*****************************************************************************/

	#include "setup.h"
	#include <stdlib.h>
	#include <string.h>
	#include <curl/curl.h>

	#include "urldata.h"
	#include "transfer.h"
	#include "url.h"

	struct Curl_message {
	/* the 'CURLMsg' is the part that is visible to the external user */
	struct CURLMsg extmsg;
	struct Curl_message *next;
	};

	typedef enum {
	CURLM_STATE_INIT,
	CURLM_STATE_CONNECT,
	CURLM_STATE_DO,
	CURLM_STATE_PERFORM,
	CURLM_STATE_DONE,
	CURLM_STATE_COMPLETED,

	CURLM_STATE_LAST /* not a true state, never use this */
	} CURLMstate;

	struct Curl_one_easy {
	/* first, two fields for the linked list of these */
	struct Curl_one_easy *next;
	struct Curl_one_easy *prev;

	struct SessionHandle easy_handle; / the easy handle for this unit */
	struct connectdata easy_conn; / the "unit's" connection */

	CURLMstate state; /* the handle's state */
	CURLcode result; /* previous result */
	};


	#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)

	/* This is the struct known as CURLM on the outside */
	struct Curl_multi {
	/* First a simple identifier to easier detect if a user mix up
	this multi handle with an easy handle. Set this to CURL_MULTI_HANDLE. */
	long type;

	/* We have a linked list with easy handles */
	struct Curl_one_easy easy;
	/* This is the amount of entries in the linked list above. */
	int num_easy;

	/* this is a linked list of posted messages */
	struct Curl_message *msgs;
	/* amount of messages in the queue */
	int num_msgs;
	/* Hostname cache */
	curl_hash *hostcache;
	};


	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;
	}

	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;

	/* First, make some basic checks that the CURLM handle is a good handle */
	if(!GOOD_MULTI_HANDLE(multi))
	return CURLM_BAD_HANDLE;

	/* Verify that we got a somewhat good easy handle too */
	if(!GOOD_EASY_HANDLE(easy_handle))
	return CURLM_BAD_EASY_HANDLE;

	/* Now, time to add an easy handle to the multi stack */
	easy = (struct Curl_one_easy *)malloc(sizeof(struct Curl_one_easy));
	if(!easy)
	return CURLM_OUT_OF_MEMORY;

	/* clean it all first (just to be sure) */
	memset(easy, 0, sizeof(struct Curl_one_easy));

	/* set the easy handle */
	easy->easy_handle = easy_handle;
	easy->state = CURLM_STATE_INIT;

	/* We add this new entry first in the list. We make our 'next' point to the
	previous next and our 'prev' point back to the 'first' struct */
	easy->next = multi->easy.next;
	easy->prev = &multi->easy;

	/* make 'easy' the first node in the chain */
	multi->easy.next = easy;

	/* if there was a next node, make sure its 'prev' pointer links back to
	the new node */
	if(easy->next)
	easy->next->prev = easy;

	/* increase the node-counter */
	multi->num_easy++;

	return CURLM_CALL_MULTI_PERFORM;
	}

	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;

	/* First, make some basic checks that the CURLM handle is a good handle */
	if(!GOOD_MULTI_HANDLE(multi))
	return CURLM_BAD_HANDLE;

	/* Verify that we got a somewhat good easy handle too */
	if(!GOOD_EASY_HANDLE(curl_handle))
	return CURLM_BAD_EASY_HANDLE;

	/* scan through the list and remove the 'curl_handle' */
	easy = multi->easy.next;
	while(easy) {
	if(easy->easy_handle == curl_handle)
	break;
	easy=easy->next;
	}
	if(easy) {
	/* If the 'state' is not INIT or COMPLETED, we might need to do something
	nice to put the easy_handle in a good known state when this returns. */

	/* make the previous node point to our next */
	if(easy->prev)
	easy->prev->next = easy->next;
	/* make our next point to our previous node */
	if(easy->next)
	easy->next->prev = easy->prev;

	/* NOTE NOTE NOTE
	We do not touch the easy handle here! */
	free(easy);

	multi->num_easy--; /* one less to care about now */

	return CURLM_OK;
	}
	else
	return CURLM_BAD_EASY_HANDLE; /* twasn't found */
	}

	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)
	{
	/* Scan through all the easy handles to get the file descriptors set.
	Some easy handles may not have connected to the remote host yet,
	and then we must make sure that is done. */
	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; / so far none! */

	easy=multi->easy.next;
	while(easy) {
	switch(easy->state) {
	default:
	break;
	case CURLM_STATE_PERFORM:
	/* This should have a set of file descriptors for us to set. */
	/* after the transfer is done, go DONE */

	Curl_single_fdset(easy->easy_conn,
	read_fd_set, write_fd_set,
	exc_fd_set, &this_max_fd);

	/* remember the maximum file descriptor */
	if(this_max_fd > *max_fd)
	*max_fd = this_max_fd;

	break;
	}
	easy = easy->next; /* check next handle */
	}

	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;

	running_handles = 0; / bump this once for every living handle */

	if(!GOOD_MULTI_HANDLE(multi))
	return CURLM_BAD_HANDLE;

	easy=multi->easy.next;
	while(easy) {
	switch(easy->state) {
	case CURLM_STATE_INIT:
	/* init this transfer. */
	easy->result=Curl_pretransfer(easy->easy_handle);
	if(CURLE_OK == easy->result) {
	/* after init, go CONNECT */
	easy->state = CURLM_STATE_CONNECT;
	result = CURLM_CALL_MULTI_PERFORM;
	}
	break;
	case CURLM_STATE_CONNECT:
	if (Curl_global_host_cache_use(easy->easy_handle)) {
	easy->easy_handle->hostcache = Curl_global_host_cache_get();
	}
	else {
	if (multi->hostcache == NULL) {
	multi->hostcache = curl_hash_alloc(7, Curl_freeaddrinfo);
	}

	easy->easy_handle->hostcache = multi->hostcache;
	}

	/* Connect. We get a connection identifier filled in. */
	easy->result = Curl_connect(easy->easy_handle, &easy->easy_conn);

	/* after connect, go DO */
	if(CURLE_OK == easy->result) {
	easy->state = CURLM_STATE_DO;
	result = CURLM_CALL_MULTI_PERFORM;
	}
	break;
	case CURLM_STATE_DO:
	/* Do the fetch or put request */
	easy->result = Curl_do(&easy->easy_conn);
	/* after do, go PERFORM */
	if(CURLE_OK == easy->result) {
	if(CURLE_OK == Curl_readwrite_init(easy->easy_conn)) {
	easy->state = CURLM_STATE_PERFORM;
	result = CURLM_CALL_MULTI_PERFORM;
	}
	}
	break;
	case CURLM_STATE_PERFORM:
	/* read/write data if it is ready to do so */
	easy->result = Curl_readwrite(easy->easy_conn, &done);
	/* hm, when we follow redirects, we may need to go back to the CONNECT
	state */
	/* after the transfer is done, go DONE */
	if(TRUE == done) {
	/* call this even if the readwrite function returned error */
	easy->result = Curl_posttransfer(easy->easy_handle);
	easy->state = CURLM_STATE_DONE;
	result = CURLM_CALL_MULTI_PERFORM;
	}
	break;
	case CURLM_STATE_DONE:
	/* post-transfer command */
	easy->result = Curl_done(easy->easy_conn);
	/* after we have DONE what we're supposed to do, go COMPLETED */
	if(CURLE_OK == easy->result)
	easy->state = CURLM_STATE_COMPLETED;
	break;
	case CURLM_STATE_COMPLETED:
	/* this is a completed transfer, it is likely to still be connected */

	/* This node should be delinked from the list now and we should post
	an information message that we are complete. */
	break;
	default:
	return CURLM_INTERNAL_ERROR;
	}

	if((CURLM_STATE_COMPLETED != easy->state) &&
	(CURLE_OK != easy->result)) {
	/*
	* If an error was returned, and we aren't in completed now,
	* then we go to completed and consider this transfer aborted.
	*/
	easy->state = CURLM_STATE_COMPLETED;
	}
	else if(CURLM_STATE_COMPLETED != easy->state)
	/* this one still lives! */
	(*running_handles)++;

	easy = easy->next; /* operate on next handle */
	}
	return result;
	}

	CURLMcode curl_multi_cleanup(CURLM *multi_handle)
	{
	struct Curl_multi multi=(struct Curl_multi )multi_handle;
	if(GOOD_MULTI_HANDLE(multi)) {
	multi->type = 0; /* not good anymore */
	curl_hash_destroy(multi->hostcache);
	/* remove all easy handles */

	free(multi);

	return CURLM_OK;
	}
	else
	return CURLM_BAD_HANDLE;
	}

	CURLMsg curl_multi_info_read(CURLM multi_handle, int *msgs_in_queue);

	/*
	* local variables:
	* eval: (load-file "../curl-mode.el")
	* end:
	* vim600: fdm=marker
	* vim: et sw=2 ts=2 sts=2 tw=78
	*/