C++ curl_multi_init函数代码示例

void DL_InitDownload() {
	if ( dl_initialized ) {
		return;
	}

	/* Make sure curl has initialized, so the cleanup doesn't get confused */
	curl_global_init( CURL_GLOBAL_ALL );

	dl_multi = curl_multi_init();

	Com_Printf( "Client download subsystem initialized\n" );
	dl_initialized = 1;
}

static int child_init(int rank)
{
	if (rank <= PROC_MAIN)
		return 0;

	multi_handle = curl_multi_init();
	if (!multi_handle) {
		LM_ERR("failed to init CURLM handle\n");
		return -1;
	}

	return 0;
}

void wswcurl_init( void )
{
	wswcurl_mempool = Mem_AllocPool( NULL, "Curl" );

	curldummy = curl_easy_init();
	curlmulti = curl_multi_init();

	http_requests_mutex = QMutex_Create();

	// HTTP proxy settings
	http_proxy = Cvar_Get( "http_proxy", "", CVAR_ARCHIVE );
	http_proxyuserpwd = Cvar_Get( "http_proxyuserpwd", "", CVAR_ARCHIVE );
}

kn_CURLM_t kn_CURLM_init(engine_t e){
	pthread_once(&g_curl_key_once,curl_once_routine);
	CURLM *c = curl_multi_init();
	if(!c) return NULL;
	kn_CURLM_t cm = calloc(1,sizeof(*cm));
	cm->c_handle = c;
	cm->e = e;
	kn_dlist_init(&cm->curls);
	curl_multi_setopt(c, CURLMOPT_SOCKETFUNCTION, handle_socket);
    	//curl_multi_setopt(c, CURLMOPT_TIMERDATA, cm);	
	//curl_multi_setopt(c, CURLMOPT_TIMERFUNCTION, start_timeout);	
	return cm;
}

Context::Context( boost::asio::io_service& io_service, bool verify_ssl_peer )
: timer_( io_service )
, strand_( io_service )
, io_service_( io_service )
, still_running_( 0 )
, verify_ssl_peer_( verify_ssl_peer )
{
    multi_ = curl_multi_init();

    curl_multi_setopt(multi_, CURLMOPT_SOCKETFUNCTION, sock_cb);
    curl_multi_setopt(multi_, CURLMOPT_SOCKETDATA, this);
    curl_multi_setopt(multi_, CURLMOPT_TIMERFUNCTION, multi_timer_cb);
    curl_multi_setopt(multi_, CURLMOPT_TIMERDATA, this);
}

int IO::init() {
  assert (m_initialised == false);

  curl_global_init(CURL_GLOBAL_ALL);

  m_mhandle = curl_multi_init();
#ifdef HAVE_CURL_MULTI_PIPELINING
  curl_multi_setopt(m_mhandle, CURLMOPT_PIPELINING, 1);
#endif

  m_initialised = true;

  return 0;
}

URL_FILE *url_fopen(const char *url, const char *operation)
{
    /* this code could check for URLs or types in the 'url' and
       basically use the real fopen() for standard files */

    URL_FILE *file;
    (void)operation;

    file = malloc(sizeof(URL_FILE));
    if(!file)
        return NULL;

    memset(file, 0, sizeof(URL_FILE));

    if((file->handle.file=fopen(url, operation)))
        file->type = CFTYPE_FILE; /* marked as URL */

    else {
        file->type = CFTYPE_CURL; /* marked as URL */
        file->handle.curl = curl_easy_init();

        curl_easy_setopt(file->handle.curl, CURLOPT_URL, url);
        curl_easy_setopt(file->handle.curl, CURLOPT_WRITEDATA, file);
        curl_easy_setopt(file->handle.curl, CURLOPT_VERBOSE, 0L);
        curl_easy_setopt(file->handle.curl, CURLOPT_WRITEFUNCTION, write_callback);

        if(!multi_handle)
            multi_handle = curl_multi_init();

        curl_multi_add_handle(multi_handle, file->handle.curl);

        /* lets start the fetch */
        curl_multi_perform(multi_handle, &file->still_running);

        if((file->buffer_pos == 0) && (!file->still_running)) {
            /* if still_running is 0 now, we should return NULL */

            /* make sure the easy handle is not in the multi handle anymore */
            curl_multi_remove_handle(multi_handle, file->handle.curl);

            /* cleanup */
            curl_easy_cleanup(file->handle.curl);

            free(file);

            file = NULL;
        }
    }
    return file;
}

void LLXMLRPCTransaction::Impl::init(XMLRPC_REQUEST request, bool useGzip)
{
	mCurl = curl_easy_init();

	if (gSavedSettings.getBOOL("BrowserProxyEnabled"))
	{
		mProxyAddress = gSavedSettings.getString("BrowserProxyAddress");
		S32 port = gSavedSettings.getS32 ( "BrowserProxyPort" );

		// tell curl about the settings
		curl_easy_setopt(mCurl, CURLOPT_PROXY, mProxyAddress.c_str());
		curl_easy_setopt(mCurl, CURLOPT_PROXYPORT, (long)port);
		curl_easy_setopt(mCurl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
	};

//	curl_easy_setopt(mCurl, CURLOPT_VERBOSE, 1); // usefull for debugging
	curl_easy_setopt(mCurl, CURLOPT_NOSIGNAL, 1);
	curl_easy_setopt(mCurl, CURLOPT_WRITEFUNCTION, &curlDownloadCallback);
	curl_easy_setopt(mCurl, CURLOPT_WRITEDATA, this);
	curl_easy_setopt(mCurl, CURLOPT_ERRORBUFFER, &mCurlErrorBuffer);
	curl_easy_setopt(mCurl, CURLOPT_CAINFO, gDirUtilp->getCAFile().c_str());
	curl_easy_setopt(mCurl, CURLOPT_SSL_VERIFYPEER, gVerifySSLCert);
	curl_easy_setopt(mCurl, CURLOPT_SSL_VERIFYHOST, gVerifySSLCert? 2 : 0);

	/* Setting the DNS cache timeout to -1 disables it completely.
	   This might help with bug #503 */
	curl_easy_setopt(mCurl, CURLOPT_DNS_CACHE_TIMEOUT, -1);

    mHeaders = curl_slist_append(mHeaders, "Content-Type: text/xml");
	curl_easy_setopt(mCurl, CURLOPT_URL, mURI.c_str());
	curl_easy_setopt(mCurl, CURLOPT_HTTPHEADER, mHeaders);
	if (useGzip)
	{
		curl_easy_setopt(mCurl, CURLOPT_ENCODING, "");
	}
	
	mRequestText = XMLRPC_REQUEST_ToXML(request, &mRequestTextSize);
	if (mRequestText)
	{
		curl_easy_setopt(mCurl, CURLOPT_POSTFIELDS, mRequestText);
		curl_easy_setopt(mCurl, CURLOPT_POSTFIELDSIZE, mRequestTextSize);
	}
	else
	{
		setStatus(StatusOtherError);
	}
	
	mCurlMulti = curl_multi_init();
	curl_multi_add_handle(mCurlMulti, mCurl);
}

int test(char *URL)
{
  CURLM *cm = NULL;
  struct curl_slist *headers = NULL;
  char buffer[246]; /* naively fixed-size */
  int res;

  if(test_argc < 4)
    return 99;

  sprintf(buffer, "Host: %s", HOST);

  /* now add a custom Host: header */
  headers = curl_slist_append(headers, buffer);
  if(!headers) {
    fprintf(stderr, "curl_slist_append() failed\n");
    return TEST_ERR_MAJOR_BAD;
  }

  if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
    fprintf(stderr, "curl_global_init() failed\n");
    curl_slist_free_all(headers);
    return TEST_ERR_MAJOR_BAD;
  }

  if ((cm = curl_multi_init()) == NULL) {
    fprintf(stderr, "curl_multi_init() failed\n");
    curl_slist_free_all(headers);
    curl_global_cleanup();
    return TEST_ERR_MAJOR_BAD;
  }

  res = loop(cm, URL, PROXYUSERPWD, headers);
  if(res)
    goto test_cleanup;

  fprintf(stderr, "lib540: now we do the request again\n");
  res = loop(cm, URL, PROXYUSERPWD, headers);

test_cleanup:

  curl_multi_cleanup(cm);

  curl_global_cleanup();

  curl_slist_free_all(headers);

  return res;
}

jsr_curlm_t *
jsr_curlm_new(void)
{
    jsr_curlm_t *jsr_curlm = (jsr_curlm_t *)malloc(sizeof(jsr_curlm_t));
    if (!jsr_curlm)
        return NULL;

    jsr_curlm->multi_handle = curl_multi_init();
    jsr_curlm->list = jsr_list_new();
    jsr_curlm->running_handles = 1;
    jsr_curlm->timeout = 1;

    return jsr_curlm;

}

/**
 * Setup http_client plugin
 *
 * @param plugin the plugin handle
 * @return GNUNET_OK on success, GNUNET_SYSERR on error
 */
static int
client_start (struct HTTP_Client_Plugin *plugin)
{
  curl_global_init (CURL_GLOBAL_ALL);
  plugin->curl_multi_handle = curl_multi_init ();

  if (NULL == plugin->curl_multi_handle)
  {
    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, plugin->name,
                     _("Could not initialize curl multi handle, failed to start %s plugin!\n"),
                     plugin->name);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

	void RequestManager::Initialise(ByteString Proxy)
	{
		curl_global_init(CURL_GLOBAL_DEFAULT);
		multi = curl_multi_init();
		if (multi)
		{
			curl_multi_setopt(multi, CURLMOPT_MAX_HOST_CONNECTIONS, curl_max_host_connections);
		}

		proxy = Proxy;

		user_agent = ByteString::Build("PowderToy/", SAVE_VERSION, ".", MINOR_VERSION, " (", IDENT_PLATFORM, "; ", IDENT_BUILD, "; M", MOD_ID, ") TPTPP/", SAVE_VERSION, ".", MINOR_VERSION, ".", BUILD_NUM, IDENT_RELTYPE, ".", SNAPSHOT_ID);

		worker_thread = std::thread([this]() { Worker(); });
	}

MULTI_CONTEXT* __stdcall vbcurl_multi_init()
{
    MULTI_CONTEXT* pmc = NULL;
    CURLM* pm = curl_multi_init();
    if (!pm)
        return NULL;
    pmc = (MULTI_CONTEXT*)malloc(sizeof(MULTI_CONTEXT));
    pmc->_magic = MULTI_MAGIC;
    pmc->_multi = pm;
    FD_ZERO(&pmc->_readSet);
    FD_ZERO(&pmc->_writeSet);
    FD_ZERO(&pmc->_excSet);
    pmc->_maxFD = 0;
    return pmc;
}

/**
 * Initialises the Ecore_Con_Url library.
 * @return Number of times the library has been initialised without being
 *          shut down.
 * @ingroup Ecore_Con_Url_Group
 */
EAPI int
ecore_con_url_init(void)
{
#ifdef HAVE_CURL
   init_count++;

   if (init_count > 1) return init_count;

   if (!ECORE_CON_EVENT_URL_DATA)
     {
	ECORE_CON_EVENT_URL_DATA = ecore_event_type_new();
	ECORE_CON_EVENT_URL_COMPLETE = ecore_event_type_new();
	ECORE_CON_EVENT_URL_PROGRESS = ecore_event_type_new();
     }

   if (!curlm)
     {
	long ms;

	FD_ZERO(&_current_fd_set);
	if (curl_global_init(CURL_GLOBAL_NOTHING))
	  {
	     while (_url_con_list)
	       ecore_con_url_destroy(eina_list_data_get(_url_con_list));
	     return 0;
	  }

	curlm = curl_multi_init();
	if (!curlm)
	  {
	     while (_url_con_list)
	       ecore_con_url_destroy(eina_list_data_get(_url_con_list));

	     init_count--;
	     return 0;
	  }

	curl_multi_timeout(curlm, &ms);
	if (ms <= 0) ms = 1000;

	_curl_timeout = ecore_timer_add((double) ms / 1000, _ecore_con_url_idler_handler, (void *) 0xACE);
	ecore_timer_freeze(_curl_timeout);
     }
   return 1;
#else
   return 0;
#endif
}

zeb_curl_client_t *
zeb_curl_client_new ()
{
#if defined (HAVE_LIBCURL)
    zeb_curl_client_t *self = (zeb_curl_client_t *) zmalloc (sizeof (zeb_curl_client_t));
    assert (self);

    //  Initialize properties
    curl_global_init(CURL_GLOBAL_ALL);
    self->multi_handle = curl_multi_init ();

    return self;
#else
    return NULL;
#endif
}