Beispiel #1
0
janus_turnrest_response *janus_turnrest_request(void) {
    janus_mutex_lock(&api_mutex);
    if(api_server == NULL) {
        janus_mutex_unlock(&api_mutex);
        return NULL;
    }
    /* Prepare the request URI */
    char query_string[512];
    g_snprintf(query_string, 512, "service=turn");
    if(api_key != NULL) {
        char buffer[256];
        g_snprintf(buffer, 256, "&api=%s", api_key);
        g_strlcat(query_string, buffer, 512);
    }
    char request_uri[1024];
    g_snprintf(request_uri, 1024, "%s?%s", api_server, query_string);
    JANUS_LOG(LOG_VERB, "Sending request: %s\n", request_uri);
    janus_mutex_unlock(&api_mutex);
    /* Prepare the libcurl context */
    CURLcode res;
    CURL *curl = curl_easy_init();
    if(curl == NULL) {
        JANUS_LOG(LOG_ERR, "libcurl error\n");
        return NULL;
    }
    curl_easy_setopt(curl, CURLOPT_URL, request_uri);
    curl_easy_setopt(curl, CURLOPT_POST, 1);
    /* FIXME Some servers don't like a POST with no data */
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, query_string);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L);	/* FIXME Max 10 seconds */
    /* For getting data, we use an helper struct and the libcurl callback */
    janus_turnrest_buffer data;
    data.buffer = malloc(1);
    data.size = 0;
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, janus_turnrest_callback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&data);
    curl_easy_setopt(curl, CURLOPT_USERAGENT, "Janus/1.0");
    /* Send the request */
    res = curl_easy_perform(curl);
    if(res != CURLE_OK) {
        JANUS_LOG(LOG_ERR, "Couldn't send the request: %s\n", curl_easy_strerror(res));
        free(data.buffer);
        curl_easy_cleanup(curl);
        return NULL;
    }
    /* Cleanup the libcurl context */
    curl_easy_cleanup(curl);
    /* Process the response */
    JANUS_LOG(LOG_VERB, "Got %zu bytes from the TURN REST API server\n", data.size);
    JANUS_LOG(LOG_VERB, "%s\n", data.buffer);
    json_error_t error;
    json_t *root = json_loads(data.buffer, 0, &error);
    if(!root) {
        JANUS_LOG(LOG_ERR, "Couldn't parse response: error on line %d: %s", error.line, error.text);
        free(data.buffer);
        return NULL;
    }
    free(data.buffer);
    json_t *username = json_object_get(root, "username");
    if(!username) {
        JANUS_LOG(LOG_ERR, "Invalid response: missing username\n");
        return NULL;
    }
    if(!json_is_string(username)) {
        JANUS_LOG(LOG_ERR, "Invalid response: username should be a string\n");
        return NULL;
    }
    json_t *password = json_object_get(root, "password");
    if(!password) {
        JANUS_LOG(LOG_ERR, "Invalid response: missing password\n");
        return NULL;
    }
    if(!json_is_string(password)) {
        JANUS_LOG(LOG_ERR, "Invalid response: password should be a string\n");
        return NULL;
    }
    json_t *ttl = json_object_get(root, "ttl");
    if(ttl && (!json_is_integer(ttl) || json_integer_value(ttl) < 0)) {
        JANUS_LOG(LOG_ERR, "Invalid response: ttl should be a positive integer\n");
        return NULL;
    }
    json_t *uris = json_object_get(root, "uris");
    if(!uris) {
        JANUS_LOG(LOG_ERR, "Invalid response: missing uris\n");
        return NULL;
    }
    if(!json_is_array(uris) || json_array_size(uris) == 0) {
        JANUS_LOG(LOG_ERR, "Invalid response: uris should be a non-empty array\n");
        return NULL;
    }
    /* Turn the response into a janus_turnrest_response object we can use */
    janus_turnrest_response *response = calloc(1, sizeof(janus_turnrest_response));
    response->username = g_strdup(json_string_value(username));
    response->password = g_strdup(json_string_value(password));
    response->ttl = ttl ? json_integer_value(ttl) : 0;
    response->servers = NULL;
    size_t i = 0;
    for(i=0; i<json_array_size(uris); i++) {
        json_t *uri = json_array_get(uris, i);
        if(uri == NULL || !json_is_string(uri)) {
            JANUS_LOG(LOG_WARN, "Skipping invalid TURN URI (not a string)...\n");
            continue;
        }
        const char *turn_uri = json_string_value(uri);
        if(strstr(turn_uri, "turn:") != turn_uri && strstr(turn_uri, "turns:") != turn_uri) {
            JANUS_LOG(LOG_WARN, "Skipping invalid TURN URI '%s' (not a TURN URI)...\n", turn_uri);
            continue;
        }
        janus_turnrest_instance *instance = calloc(1, sizeof(janus_turnrest_instance));
        instance->transport = NICE_RELAY_TYPE_TURN_UDP;
        if(strstr(turn_uri, "turns:") == turn_uri)
            instance->transport = NICE_RELAY_TYPE_TURN_TLS;
        else if(strstr(turn_uri, "transport=tcp") == turn_uri)
            instance->transport = NICE_RELAY_TYPE_TURN_TCP;
        gchar **parts = NULL;
        if(strstr(turn_uri, "?") != NULL) {
            parts = g_strsplit(turn_uri, "?", -1);
            turn_uri = parts[0];
        }
        gchar **uri_parts = g_strsplit(turn_uri, ":", -1);
        /* Resolve the TURN URI address */
        struct hostent *he = gethostbyname(uri_parts[1]);
        if(he == NULL) {
            JANUS_LOG(LOG_WARN, "Skipping invalid TURN URI '%s' (could not resolve the address)...\n", uri_parts[1]);
            g_strfreev(uri_parts);
            continue;
        }
        struct in_addr **addr_list = (struct in_addr **)he->h_addr_list;
        if(addr_list[0] == NULL) {
            JANUS_LOG(LOG_WARN, "Skipping invalid TURN URI '%s' (could not resolve the address)...\n", uri_parts[1]);
            g_strfreev(uri_parts);
            continue;
        }
        instance->server = g_strdup(inet_ntoa(*addr_list[0]));
        if(uri_parts[2] == NULL) {
            /* No port? USe 3478 by default */
            instance->port = 3478;
        } else {
            instance->port = atoi(uri_parts[2]);
        }
        g_strfreev(uri_parts);
        g_strfreev(parts);
        /* Add the server to the list */
        response->servers = g_list_append(response->servers, instance);
    }
    if(response->servers == NULL) {
        JANUS_LOG(LOG_ERR, "Couldn't find any valid TURN URI in the response...\n");
        janus_turnrest_response_destroy(response);
        return NULL;
    }
    /* Done */
    return response;
}
Beispiel #2
0
CURLcode check(char *response, size_t length, const char *username, const char* password, const char* proxy, int stype) {

	CURL *curl = curl_easy_init();
	if(!curl) {
		fdo_log(GENLOG, "cURL Init Error: (?!)");
		return CURLE_FAILED_INIT; //?!?!?!?!
	}

	struct memstruct CurlStruct;

	CurlStruct.memory = malloc(1);
	*CurlStruct.memory = 0;
	CurlStruct.size = 0;

	//Prepare custom headers.
	char *userenc = curl_easy_escape(curl, username, 0);
	if(!userenc) {
		free(CurlStruct.memory);
		return CURLE_FAILED_INIT;
	}
	char *passenc = curl_easy_escape(curl, password, 0);
	if(!passenc) {
		free(CurlStruct.memory);
		curl_free(passenc); passenc = NULL;
		return CURLE_FAILED_INIT;
	}
	size_t plen = snprintf(NULL, 0, "rem=on&username=%s&password=%s&submit=Log+In&mod=www&ssl=1&dest=account_settings.ws", userenc, passenc);
	plen += 1;
	char *post = malloc(plen);
	if(!post) {
		free(CurlStruct.memory);
		curl_free(userenc); userenc = NULL;
		curl_free(passenc); passenc = NULL;
		return CURLE_FAILED_INIT;
	}
	snprintf(post, plen, "rem=on&username=%s&password=%s&submit=Log+In&mod=www&ssl=1&dest=account_settings.ws", userenc, passenc);

	curl_free(userenc); userenc = NULL;
	curl_free(passenc); passenc = NULL;

	curl_easy_setopt(curl, CURLOPT_URL, "https://secure.runescape.com/m=weblogin/login.ws"); //This may change in the future.
	curl_easy_setopt(curl, CURLOPT_USERAGENT, "Mozilla/5.0 (Windows NT 6.3; rv:36.0) Gecko/20100101 Firefox/36.0"); //Possibly change this in the future. They block useragents when they're old(Probably my fault)
	curl_easy_setopt(curl, CURLOPT_REFERER, "https://secure.runescape.com/m=weblogin/loginform.ws?mod=www&ssl=1&reauth=1&dest=account_settings.ws"); //Likewise, may be needed to change.
	curl_easy_setopt(curl, CURLOPT_AUTOREFERER, 1); //When followlocation takes place.
	curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
	curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1);
	curl_easy_setopt(curl, CURLOPT_HEADER, 0);
	curl_easy_setopt(curl, CURLOPT_ENCODING, "identity");
	curl_easy_setopt(curl, CURLOPT_POST, 1);
	curl_easy_setopt(curl, CURLOPT_POSTFIELDS, post);
	curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);
	curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
	curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
	curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 10L);
	curl_easy_setopt(curl, CURLOPT_TIMEOUT, 20L);
	curl_easy_setopt(curl, CURLOPT_PROXYTYPE, stype);
	curl_easy_setopt(curl, CURLOPT_PROXY, proxy);

	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, StoreCurl);
	curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&CurlStruct);

	CURLcode res = curl_easy_perform(curl);

	if(res != CURLE_OK) {
		fdo_log(DBGLOG, "cURL Error: %s, Proxy: %s.(type: %d)", curl_easy_strerror(res), proxy, stype);
	} else {
		if(CurlStruct.memory != NULL) {
			strncpy(response, CurlStruct.memory, length);
			response[length-1] = '\0';
		} else {
			response = NULL;
		}
	}

	curl_easy_cleanup(curl);
	free(CurlStruct.memory); CurlStruct.memory = NULL;
	free(post); post = NULL;

	return res;
}
Beispiel #3
0
char* curl_post_form(const char *url,\
	                 const char *postdata,\
	                 const char *proxy,\
	                 const char *cookie,\
	                 int flag_cookie)


{
   long timeout = 10800;
	long connect_timeout = 15;
	long low_speed_limit = 1024;
	long low_speed_time = 60;

	struct mem_node *mem_head = NULL;
	long response_code;
   CURL *curl = curl_easy_init();
   curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1); // for thread safe
   curl_easy_setopt(curl,CURLOPT_URL,url); //url地址  
   curl_easy_setopt(curl,CURLOPT_POSTFIELDS,postdata); //post参数  
   curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, connect_timeout);
	curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);
	curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, low_speed_limit);
	curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, low_speed_time);
   curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,&curl_read); //对返回的数据进行操作的函数地址  
   curl_easy_setopt(curl,CURLOPT_WRITEDATA,&mem_head); //这是write_data的第四个参数值  
   curl_easy_setopt(curl,CURLOPT_POST,1); //设置非0表示本次操作为post   
   curl_easy_setopt(curl,CURLOPT_FOLLOWLOCATION,1); //设置为非0,响应头信息location  
   if(flag_cookie)
   {
    curl_easy_setopt(curl,CURLOPT_COOKIEFILE,"./cookie.txt");
     curl_easy_setopt(curl,CURLOPT_COOKIEJAR,"./cookie.txt");
 }
  // curl_easy_setopt(easy_handle, CURLOPT_PROXY,proxy);
   CURLcode rc = curl_easy_perform(curl); 
  	curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
	curl_easy_cleanup(curl);
	if (rc!=CURLE_OK) {
		return NULL;
	}else if (response_code!=200 && response_code!=206){
		struct mem_node *p = mem_head;
		while(p){
			struct mem_node *q = p;
			p = p->next;
			free(q->buffer);
			free(q);
		}
		return NULL;
	}else{
		struct mem_node *p = mem_head;
		size_t size = 0;
		while(p){
			size += p->size;
			p = p->next;
		}
		char *content = (char*)malloc(size+1);
		p = mem_head;
		size = 0;
		while(p){
			memcpy(content+size, p->buffer, p->size);
			size += p->size;
			struct mem_node *q = p;
			p = p->next;
			free(q->buffer);
			free(q);
		}
		content[size] = 0;
		return content;
	}
  
}
Beispiel #4
0
bool stratum_connect(struct stratum_ctx *sctx, const char *url)
{
	CURL *curl;
	int rc;

	pthread_mutex_lock(&sctx->sock_lock);
	if (sctx->curl)
		curl_easy_cleanup(sctx->curl);
	sctx->curl = curl_easy_init();
	if (!sctx->curl) {
		applog(LOG_ERR, "CURL initialization failed");
		pthread_mutex_unlock(&sctx->sock_lock);
		return false;
	}
	curl = sctx->curl;
	if (!sctx->sockbuf) {
		sctx->sockbuf = (char*)calloc(RBUFSIZE, 1);
		sctx->sockbuf_size = RBUFSIZE;
	}
	sctx->sockbuf[0] = '\0';
	pthread_mutex_unlock(&sctx->sock_lock);

	if (url != sctx->url) {
		free(sctx->url);
		sctx->url = strdup(url);
	}
	free(sctx->curl_url);
	sctx->curl_url = (char*)malloc(strlen(url));
	sprintf(sctx->curl_url, "http%s", strstr(url, "://"));

	if (opt_protocol)
		curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
	curl_easy_setopt(curl, CURLOPT_URL, sctx->curl_url);
	curl_easy_setopt(curl, CURLOPT_FRESH_CONNECT, 1);
	curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 30);
	curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, sctx->curl_err_str);
	curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
	curl_easy_setopt(curl, CURLOPT_TCP_NODELAY, 1);
	if (opt_proxy && opt_proxy_type != CURLPROXY_HTTP) {
		curl_easy_setopt(curl, CURLOPT_PROXY, opt_proxy);
		curl_easy_setopt(curl, CURLOPT_PROXYTYPE, opt_proxy_type);
	} else if (getenv("http_proxy")) {
		if (getenv("all_proxy"))
			curl_easy_setopt(curl, CURLOPT_PROXY, getenv("all_proxy"));
		else if (getenv("ALL_PROXY"))
			curl_easy_setopt(curl, CURLOPT_PROXY, getenv("ALL_PROXY"));
		else
			curl_easy_setopt(curl, CURLOPT_PROXY, "");
	}
#if LIBCURL_VERSION_NUM >= 0x070f06
	curl_easy_setopt(curl, CURLOPT_SOCKOPTFUNCTION, sockopt_keepalive_cb);
#endif
#if LIBCURL_VERSION_NUM >= 0x071101
	curl_easy_setopt(curl, CURLOPT_OPENSOCKETFUNCTION, opensocket_grab_cb);
	curl_easy_setopt(curl, CURLOPT_OPENSOCKETDATA, &sctx->sock);
#endif
	curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 1);

	rc = curl_easy_perform(curl);
	if (rc) {
		applog(LOG_ERR, "Stratum connection failed: %s", sctx->curl_err_str);
		curl_easy_cleanup(curl);
		sctx->curl = NULL;
		return false;
	}

#if LIBCURL_VERSION_NUM < 0x071101
	/* CURLINFO_LASTSOCKET is broken on Win64; only use it as a last resort */
	curl_easy_getinfo(curl, CURLINFO_LASTSOCKET, (long *)&sctx->sock);
#endif

	return true;
}
Beispiel #5
0
/* 
 * Performs http_query and saves possible result (first body line of reply)
 * to pvar.
 */
int http_query(struct sip_msg* _m, char* _url, char* _dst, char* _post)
{
    CURL *curl;
    CURLcode res;  
    str value, post_value;
    char *url, *at, *post;
    char* stream;
    long stat;
    pv_spec_t *dst;
    pv_value_t val;
    double download_size;

    if (fixup_get_svalue(_m, (gparam_p)_url, &value) != 0) {
	LM_ERR("cannot get page value\n");
	return -1;
    }

    curl = curl_easy_init();
    if (curl == NULL) {
	LM_ERR("failed to initialize curl\n");
	return -1;
    }

    url = pkg_malloc(value.len + 1);
    if (url == NULL) {
	curl_easy_cleanup(curl);
	LM_ERR("cannot allocate pkg memory for url\n");
	return -1;
    }
    memcpy(url, value.s, value.len);
    *(url + value.len) = (char)0;
    curl_easy_setopt(curl, CURLOPT_URL, url);

    if (_post) {
        /* Now specify we want to POST data */ 
	curl_easy_setopt(curl, CURLOPT_POST, 1L);

    	if (fixup_get_svalue(_m, (gparam_p)_post, &post_value) != 0) {
		LM_ERR("cannot get post value\n");
		pkg_free(url);
		return -1;
    	}
        post = pkg_malloc(post_value.len + 1);
        if (post == NULL) {
		curl_easy_cleanup(curl);
		pkg_free(url);
        	LM_ERR("cannot allocate pkg memory for post\n");
        	return -1;
	}
	memcpy(post, post_value.s, post_value.len);
	*(post + post_value.len) = (char)0;
 	curl_easy_setopt(curl, CURLOPT_POSTFIELDS, post);
    }
       

    curl_easy_setopt(curl, CURLOPT_NOSIGNAL, (long)1);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, (long)http_query_timeout);

    stream = NULL;
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_function);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &stream);

    res = curl_easy_perform(curl);  
    pkg_free(url);
    if (_post) {
	pkg_free(post);
    }
    curl_easy_cleanup(curl);

    if (res != CURLE_OK) {
	LM_ERR("failed to perform curl\n");
	return -1;
    }

    curl_easy_getinfo(curl, CURLINFO_HTTP_CODE, &stat);
    if ((stat >= 200) && (stat < 400)) {
	curl_easy_getinfo(curl, CURLINFO_SIZE_DOWNLOAD, &download_size);
	LM_DBG("http_query download size: %u\n", (unsigned int)download_size);
	/* search for line feed */
	at = memchr(stream, (char)10, download_size);
	if (at == NULL) {
	    /* not found: use whole stream */
	    at = stream + (unsigned int)download_size;
	}
	val.rs.s = stream;
	val.rs.len = at - stream;
	LM_DBG("http)query result: %.*s\n", val.rs.len, val.rs.s);
	val.flags = PV_VAL_STR;
	dst = (pv_spec_t *)_dst;
	dst->setf(_m, &dst->pvp, (int)EQ_T, &val);
    }
	
    return stat;
}
Beispiel #6
0
int main(void)
{
  CURL *curl;
  CURLM *mcurl;
  int still_running = 1;
  struct timeval mp_start;
  struct curl_slist *recipients = NULL;
  struct upload_status upload_ctx;

  upload_ctx.lines_read = 0;

  curl_global_init(CURL_GLOBAL_DEFAULT);

  curl = curl_easy_init();
  if(!curl)
    return 1;

  mcurl = curl_multi_init();
  if(!mcurl)
    return 2;

  /* This is the URL for your mailserver */
  curl_easy_setopt(curl, CURLOPT_URL, "smtp://mail.example.com");

  /* Note that this option isn't strictly required, omitting it will result in
   * libcurl sending the MAIL FROM command with empty sender data. All
   * autoresponses should have an empty reverse-path, and should be directed
   * to the address in the reverse-path which triggered them. Otherwise, they
   * could cause an endless loop. See RFC 5321 Section 4.5.5 for more details.
   */
  curl_easy_setopt(curl, CURLOPT_MAIL_FROM, FROM);

  /* Add two recipients, in this particular case they correspond to the
   * To: and Cc: addressees in the header, but they could be any kind of
   * recipient. */
  recipients = curl_slist_append(recipients, TO);
  recipients = curl_slist_append(recipients, CC);
  curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, recipients);

  /* We're using a callback function to specify the payload (the headers and
   * body of the message). You could just use the CURLOPT_READDATA option to
   * specify a FILE pointer to read from. */
  curl_easy_setopt(curl, CURLOPT_READFUNCTION, payload_source);
  curl_easy_setopt(curl, CURLOPT_READDATA, &upload_ctx);
  curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);

  /* Tell the multi stack about our easy handle */
  curl_multi_add_handle(mcurl, curl);

  /* Record the start time which we can use later */
  mp_start = tvnow();

  /* We start some action by calling perform right away */
  curl_multi_perform(mcurl, &still_running);

  while(still_running) {
    struct timeval timeout;
    fd_set fdread;
    fd_set fdwrite;
    fd_set fdexcep;
    int maxfd = -1;
    int rc;

    long curl_timeo = -1;

    /* Initialise the file descriptors */
    FD_ZERO(&fdread);
    FD_ZERO(&fdwrite);
    FD_ZERO(&fdexcep);

    /* Set a suitable timeout to play around with */
    timeout.tv_sec = 1;
    timeout.tv_usec = 0;

    curl_multi_timeout(mcurl, &curl_timeo);
    if(curl_timeo >= 0) {
      timeout.tv_sec = curl_timeo / 1000;
      if(timeout.tv_sec > 1)
        timeout.tv_sec = 1;
      else
        timeout.tv_usec = (curl_timeo % 1000) * 1000;
    }

    /* Get file descriptors from the transfers */
    curl_multi_fdset(mcurl, &fdread, &fdwrite, &fdexcep, &maxfd);

    /* In a real-world program you OF COURSE check the return code of the
       function calls.  On success, the value of maxfd is guaranteed to be
       greater or equal than -1.  We call select(maxfd + 1, ...), specially in
       case of (maxfd == -1), we call select(0, ...), which is basically equal
       to sleep. */
    rc = select(maxfd+1, &fdread, &fdwrite, &fdexcep, &timeout);

    if(tvdiff(tvnow(), mp_start) > MULTI_PERFORM_HANG_TIMEOUT) {
      fprintf(stderr,
              "ABORTING: Since it seems that we would have run forever.\n");
      break;
    }

    switch(rc) {
    case -1:  /* select error */
      break;
    case 0:   /* timeout */
    default:  /* action */
      curl_multi_perform(mcurl, &still_running);
      break;
    }
  }

  /* Free the list of recipients */
  curl_slist_free_all(recipients);

  /* Always cleanup */
  curl_multi_remove_handle(mcurl, curl);
  curl_multi_cleanup(mcurl);
  curl_easy_cleanup(curl);
  curl_global_cleanup();

  return 0;
}
Beispiel #7
0
int test(char *URL)
{
  int res = 0;
  CURL *curl[NUM_HANDLES];
  int running;
  char done=FALSE;
  CURLM *m;
  int i, j;
  struct timeval ml_start;
  struct timeval mp_start;
  char ml_timedout = FALSE;
  char mp_timedout = FALSE;
  char target_url[256];

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

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

  /* get NUM_HANDLES easy handles */
  for(i=0; i < NUM_HANDLES; i++) {
    curl[i] = curl_easy_init();
    if(!curl[i]) {
      fprintf(stderr, "curl_easy_init() failed "
              "on handle #%d\n", i);
      for (j=i-1; j >= 0; j--) {
        curl_multi_remove_handle(m, curl[j]);
        curl_easy_cleanup(curl[j]);
      }
      curl_multi_cleanup(m);
      curl_global_cleanup();
      return TEST_ERR_MAJOR_BAD + i;
    }
    sprintf(target_url, "%s%04i", URL, i + 1);
    target_url[sizeof(target_url) - 1] = '\0';
    curl_easy_setopt(curl[i], CURLOPT_URL, target_url);

    /* go verbose */
    curl_easy_setopt(curl[i], CURLOPT_VERBOSE, 1L);

    /* include headers */
    curl_easy_setopt(curl[i], CURLOPT_HEADER, 1L);

    /* add handle to multi */
    if ((res = (int)curl_multi_add_handle(m, curl[i])) != CURLM_OK) {
      fprintf(stderr, "curl_multi_add_handle() failed, "
              "on handle #%d with code %d\n", i, res);
      curl_easy_cleanup(curl[i]);
      for (j=i-1; j >= 0; j--) {
        curl_multi_remove_handle(m, curl[j]);
        curl_easy_cleanup(curl[j]);
      }
      curl_multi_cleanup(m);
      curl_global_cleanup();
      return TEST_ERR_MAJOR_BAD + i;
    }
  }

  curl_multi_setopt(m, CURLMOPT_PIPELINING, 1L);

  ml_timedout = FALSE;
  ml_start = tutil_tvnow();

  fprintf(stderr, "Start at URL 0\n");

  while (!done) {
    fd_set rd, wr, exc;
    int max_fd;
    struct timeval interval;

    interval.tv_sec = 1;
    interval.tv_usec = 0;

    if (tutil_tvdiff(tutil_tvnow(), ml_start) > 
        MAIN_LOOP_HANG_TIMEOUT) {
      ml_timedout = TRUE;
      break;
    }
    mp_timedout = FALSE;
    mp_start = tutil_tvnow();

    while (res == CURLM_CALL_MULTI_PERFORM) {
      res = (int)curl_multi_perform(m, &running);
      if (tutil_tvdiff(tutil_tvnow(), mp_start) > 
          MULTI_PERFORM_HANG_TIMEOUT) {
        mp_timedout = TRUE;
        break;
      }
      if (running <= 0) {
        done = TRUE; /* bail out */
        break;
      }
    }
    if (mp_timedout || done)
      break;

    if (res != CURLM_OK) {
      fprintf(stderr, "not okay???\n");
      break;
    }

    FD_ZERO(&rd);
    FD_ZERO(&wr);
    FD_ZERO(&exc);
    max_fd = 0;

    if (curl_multi_fdset(m, &rd, &wr, &exc, &max_fd) != CURLM_OK) {
      fprintf(stderr, "unexpected failured of fdset.\n");
      res = 189;
      break;
    }

    if (select_test(max_fd+1, &rd, &wr, &exc, &interval) == -1) {
      fprintf(stderr, "bad select??\n");
      res = 195;
      break;
    }

    res = CURLM_CALL_MULTI_PERFORM;
  }

  if (ml_timedout || mp_timedout) {
    if (ml_timedout) fprintf(stderr, "ml_timedout\n");
    if (mp_timedout) fprintf(stderr, "mp_timedout\n");
    fprintf(stderr, "ABORTING TEST, since it seems "
            "that it would have run forever.\n");
    res = TEST_ERR_RUNS_FOREVER;
  }

  /* cleanup NUM_HANDLES easy handles */
  for(i=0; i < NUM_HANDLES; i++) {
    curl_multi_remove_handle(m, curl[i]);
    curl_easy_cleanup(curl[i]);
  }

  curl_multi_cleanup(m);
  curl_global_cleanup();

  return res;
}
Beispiel #8
0
// ------------------------------------------------------------------
// Funcion que realiza un post al WS
// ------------------------------------------------------------------
int PostToWS(const char *url, const char *postData, char result[2048])
{
	char tmp[1024];
	char tmpb[1024];
	int exitStatus = 0;
	CURL* curl;
	CURLcode res;	
	struct WritePOST wtext;
	struct ReadPOST rtext;
   init_struct(&rtext);	
	
	/* Headers */ 
	struct curl_slist *headers = NULL;
	headers = curl_slist_append(headers, "Accept: application/json");
	headers = curl_slist_append(headers, "Content-Type: application/json");
	headers = curl_slist_append(headers, "charsets: utf-8");
	// Parameters for call 
	wtext.ptr = postData;
	wtext.sizeleft = strlen(postData);
	/* Initialise libcurl */
	curl_global_init(CURL_GLOBAL_ALL);	
	/* Get a curl handle */
	curl = curl_easy_init(); 
	if(curl) 
	{
		//printf("%s", url);
		/* First set the URL that is about to receive our POST. */ 
		curl_easy_setopt(curl, CURLOPT_URL, url);
		curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
		/* Now specify we want to POST data */ 
		curl_easy_setopt(curl, CURLOPT_POST, 1L);
		/* we want to use our own read function */ 
		curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
		/* pointer to pass to our read function */ 
		curl_easy_setopt(curl, CURLOPT_READDATA, &wtext);
		/* get verbose debug output please */ 
		//curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
		/* Set the expected POST size. If you want to POST large amounts of data,
			consider CURLOPT_POSTFIELDSIZE_LARGE */ 
		curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (curl_off_t)wtext.sizeleft);
		/* we want to use our own write function */ 
		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
		/* pointer to pass to our write function */ 
		curl_easy_setopt(curl, CURLOPT_WRITEDATA, &rtext);
		/* Perform the request, res will get the return code */ 
		res = curl_easy_perform(curl);
		if(res) 
		{
			sprintf(tmp, "ERROR: %s", curl_easy_strerror(res));
			printf("%s\n", tmp);
			exitStatus = 0;
		}
		else
		{
			if(rtext.ptr != NULL)
			{
				if(strlen(rtext.ptr) > 0)
				{		
					sprintf(result, "%s", rtext.ptr);
					// Imprimir resultados del WS
					printf("\nA: %s\n", result);
				}
				else
				{
					printf("\nA: if(strlen(rtext.ptr) > 0) es falso");
				}
				free(rtext.ptr);				
			}
			exitStatus = 1;
		}
		/* always cleanup */ 
		curl_easy_cleanup(curl);
	}
	else 
	{
		exitStatus = 0;
	}
	/* Return the exit status */
	return exitStatus;
}
Beispiel #9
0
void email::send() {
	if( ! activated ) {
		printf( "Send mail attempted: %s", content.c_str() );
		exit(0);
	} else {
		// Check maximum sent count
		if( sent_count > 3 ) {
			dump( "Too much email sent. Exiting for safety...\n" );
			exit(0);
		} else {
			dump( "Sending an email...\n" );
			dump( "%s\n" , subject.c_str());
			dump( "Content: %s\n", content.c_str() );
		}
		
		// Correct return code
		for( uint n=0; n<content.size(); n++ ) {
			if( content[n] == '\n' && content[n+1] == 0 ) content[n] = 0;
		}
		// Set message
		payload_text[2] = subject.c_str();
		payload_text[4] = content.c_str();
	}
#if ENABLE_LCURL
	CURL *curl;
	CURLcode res;
	struct curl_slist *recipients = NULL;
	struct upload_status upload_ctx;
	upload_ctx.lines_read = 0;
	
	curl = curl_easy_init();
	if (curl) {
		/* This is the URL for your mailserver. Note the use of port 587 here,
		 * instead of the normal SMTP port (25). Port 587 is commonly used for
		 * secure mail submission (see RFC4403), but you should use whatever
		 * matches your server configuration. */
		curl_easy_setopt(curl, CURLOPT_URL, "smtp://smtp.yoursever.com:587");
		
		/* In this example, we'll start with a plain text connection, and upgrade
		 * to Transport Layer Security (TLS) using the STARTTLS command. Be careful
		 * of using CURLUSESSL_TRY here, because if TLS upgrade fails, the transfer
		 * will continue anyway - see the security discussion in the libcurl
		 * tutorial for more details. */
		curl_easy_setopt(curl, CURLOPT_USE_SSL, (long)CURLUSESSL_ALL);
		
		/* If your server doesn't have a valid certificate, then you can disable
		 * part of the Transport Layer Security protection by setting the
		 * CURLOPT_SSL_VERIFYPEER and CURLOPT_SSL_VERIFYHOST options to 0 (false).
		 *   curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
		 *   curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
		 * That is, in general, a bad idea. It is still better than sending your
		 * authentication details in plain text though.
		 * Instead, you should get the issuer certificate (or the host certificate
		 * if the certificate is self-signed) and add it to the set of certificates
		 * that are known to libcurl using CURLOPT_CAINFO and/or CURLOPT_CAPATH. See
		 * docs/SSLCERTS for more information.
		 */
		// curl_easy_setopt(curl, CURLOPT_CAINFO, "/path/to/certificate.pem");
		
		/* A common reason for requiring transport security is to protect
		 * authentication details (user names and passwords) from being "snooped"
		 * on the network. Here is how the user name and password are provided: */
		curl_easy_setopt(curl, CURLOPT_USERNAME, "*****@*****.**");
		curl_easy_setopt(curl, CURLOPT_PASSWORD, "yourpassword");
		
		/* value for envelope reverse-path */
		curl_easy_setopt(curl, CURLOPT_MAIL_FROM, FROM);
		/* Add two recipients, in this particular case they correspond to the
		 * To: and Cc: addressees in the header, but they could be any kind of
		 * recipient. */
		recipients = curl_slist_append(recipients, TO);
		curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, recipients);
		
		/* In this case, we're using a callback function to specify the data. You
		 * could just use the CURLOPT_READDATA option to specify a FILE pointer to
		 * read from.
		 */
		curl_easy_setopt(curl, CURLOPT_READFUNCTION, payload_source);
		curl_easy_setopt(curl, CURLOPT_READDATA, &upload_ctx);
		
		/* Since the traffic will be encrypted, it is very useful to turn on debug
		 * information within libcurl to see what is happening during the transfer.
		 */
		// curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
		curl_easy_setopt(curl, CURLOPT_VERBOSE, 0);
		
		/* send the message (including headers) */
		res = curl_easy_perform(curl);
		/* Check for errors */
		if(res != CURLE_OK) {
			fprintf(stderr, "curl_easy_perform() failed: %s\n",
					curl_easy_strerror(res));
			exit(0);
		}
		/* free the list of recipients and clean up */
		curl_slist_free_all(recipients);
		curl_easy_cleanup(curl);
		
		// Clear message body
		content.clear();
		
		// Record sent count
		sent_count ++;
	}
#endif
}
Beispiel #10
0
int query_tool_set_powered(const char* tool_id, bool powered) {
  CURL* handle;
  CURLcode error_code;
  char buf[1024];
  long response = 0;
  struct curl_slist *headers = NULL;

#ifdef DEBUG_EVENT_RESPONSE
  FILE *fdebug;
  fdebug = fopen("debug.html", "w");
#endif

  handle = curl_easy_init();
  if (handle == NULL)
    return 1;

  headers = curl_slist_append(headers, "Accept: application/json");
  headers = curl_slist_append(headers, "Content-Type: application/json");

  sprintf(buf, "PUBLIC_KEY: %s", public_key);
  headers = curl_slist_append(headers, buf);

  sprintf(buf, "PRIVATE_KEY: %s", private_key);
  headers = curl_slist_append(headers, buf);

  // For new ModWSGI version.  Delete previous
  // authentication headers when Roboclub8 fully migrated
  sprintf(buf, "PUBLIC-KEY: %s", public_key);
  headers = curl_slist_append(headers, buf);

  sprintf(buf, "PRIVATE-KEY: %s", private_key);
  headers = curl_slist_append(headers, buf);

  json_object* json = json_object_new_object();
  json_object_object_add(json, "powered", json_object_new_boolean(powered));

  sprintf(buf, "%s/api/machines/%s/", server, tool_id);
  error_code = curl_easy_setopt(handle, CURLOPT_URL, buf);
  if (error_code) goto error;

  /* TODO disabling host and peer verification should theoretically be removed
   * eventually */
  error_code = curl_easy_setopt(handle, CURLOPT_SSL_VERIFYHOST, 0L);
  if (error_code) goto error;

  error_code = curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 0L);
  if (error_code) goto error;

#ifdef DEBUG_EVENT_RESPONSE
  error_code = curl_easy_setopt(handle, CURLOPT_WRITEDATA, fdebug);
#else
  error_code = curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, write_ignore);
#endif
  if (error_code) goto error;

  error_code = curl_easy_setopt(handle, CURLOPT_CUSTOMREQUEST, "PUT");
  if (error_code) goto error;

  error_code = curl_easy_setopt(handle, CURLOPT_HTTPHEADER, headers);
  if (error_code) goto error;

  error_code = curl_easy_setopt(handle, CURLOPT_POSTFIELDS, json_object_to_json_string(json));
  if (error_code) goto error;


  error_code = curl_easy_perform(handle);
  if (error_code) goto error;

  error_code = curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &response);
  if (error_code) goto error;
  if (response >= 400)
    log_print("ERROR: response %ld from %s", response, buf);
  else if (response > 200)
    log_print("WARNING: response %ld from %s", response, buf);

  curl_easy_cleanup(handle);
  curl_slist_free_all(headers);
#ifdef DEBUG_EVENT_RESPONSE
  fclose(fdebug);
#endif

  // Free json object
  json_object_put(json);

  // return error if it's not a 200-level response
  return response >= 300;

error:
  log_print("ERROR: curl: %s", curl_easy_strerror(error_code));
  curl_easy_cleanup(handle);
  curl_slist_free_all(headers);
#ifdef DEBUG_EVENT_RESPONSE
  fclose(fdebug);
#endif

  // Free json object
  json_object_put(json);

  return 1;
}
Beispiel #11
0
int query_tools(struct tool_t*** tools) {
  log_print("Requesting machines from server");
  
  CURL* handle;
  CURLcode error_code;
  char url[1024];
  long response = 0;

  handle = curl_easy_init();
  if (handle == NULL)
    return 0;

  // only retrieve machines that have Tooltron boxes on them
  sprintf(url, "%s/api/machines/?toolbox_id__isnull=False", server);

  error_code = curl_easy_setopt(handle, CURLOPT_URL, url);
  if (error_code) goto error;

  buffer_idx = 0;
  error_code = curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, write_buffer);
  if (error_code) goto error;

  error_code = curl_easy_setopt(handle, CURLOPT_WRITEDATA, NULL);
  if (error_code) goto error;

  error_code = curl_easy_perform(handle);
  if (error_code) goto error;

  error_code = curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &response);
  if (error_code) goto error;
  if (response >= 400)
    log_print("ERROR: response %ld from %s", response, url);
  else if (response > 200)
    log_print("WARNING: response %ld from %s", response, url);

  struct json_object *json_tools = json_tokener_parse((char*)buffer);

  int num_tools = json_object_array_length(json_tools);

  log_print("Read %d tools from server", num_tools);

  (*tools) = (struct tool_t**)malloc(num_tools * sizeof(struct tool_t*));

  if(!tools) {
    log_print("Out of memory mallocing tool array");
    return -1;
  }

  int i;
  for(i = 0; i < num_tools; i++) {
    json_object* json_tool = json_object_array_get_idx(json_tools, i);

    json_object* json_tool_id = json_object_object_get(json_tool, "id");
    json_object* json_tool_toolbox_id = json_object_object_get(json_tool, "toolbox_id");
    json_object* json_tool_name = json_object_object_get(json_tool, "type");

    const char* tool_id = json_object_get_string(json_tool_id);
    const char* tool_name = json_object_get_string(json_tool_name);
    int tool_toolbox_id = json_object_get_int(json_tool_toolbox_id);

    log_print("Tool ID: %s, Tool Name: %s, Toolbox ID: %d", tool_id, tool_name, tool_toolbox_id);

    struct tool_t* tool = malloc(sizeof(struct tool_t));

    if(!tool) {
      log_print("Out of memory mallocing tool");
      return -1;
    }

    tool->id = malloc(strlen(tool_id) + 1);

    if(!tool->id) {
      log_print("Out of memory mallocing tool id");
      return -1;
    }

    strcpy(tool->id, tool_id);


    tool->name = malloc(strlen(tool_name) + 1);

    if(!tool->name) {
      log_print("Out of memory mallocing tool name");
      return -1;
    }

    strcpy(tool->name, tool_name);

  
    tool->address = tool_toolbox_id;
    tool->connected = 1;
    tool->state = TS_INIT;
    tool->user = 0;
    tool->event = NULL;
    tool->powered = false;

    (*tools)[i] = tool;
  }

  curl_easy_cleanup(handle);
  return num_tools;

error:
  log_print("ERROR: curl: %s", curl_easy_strerror(error_code));
  log_print("ERROR:       when requesting machines from server");
  curl_easy_cleanup(handle);
  return -1;

}
Beispiel #12
0
/*
 * query_add_event
 *
 * Makes an HTTPS POST request to add an event to the CRM server, including
 * user, tool, start time, and stop time. Reads the password from password.txt.
 * Returns 0 if successful, or 1 if there was an error and the caller should
 * try the same event again later.
 *
 * Times are represented as strftime's "%F %T", which is like "YYYY-MM-DD
 * HH:MM:SS" with 24-hour time
 */
int query_add_event(struct event_t *event) {
  CURL* handle;
  CURLcode error_code;
  struct curl_httppost *formpost = NULL, *lastptr = NULL;
  char buf[1024];
  struct tm *timeinfo;
  long response = 0;

#ifdef DEBUG_EVENT_RESPONSE
  FILE *fdebug;
  fdebug = fopen("debug.html", "w");
#endif

  handle = curl_easy_init();
  if (handle == NULL)
    return 1;

  timeinfo = localtime(&event->tstart);
  strftime(buf, sizeof(buf), "%F %T", timeinfo);
  curl_formadd(&formpost, &lastptr,
      CURLFORM_COPYNAME, "tstart",
      CURLFORM_COPYCONTENTS, buf,
      CURLFORM_END);

  timeinfo = localtime(&event->tend);
  strftime(buf, sizeof(buf), "%F %T", timeinfo);
  curl_formadd(&formpost, &lastptr,
      CURLFORM_COPYNAME, "tend",
      CURLFORM_COPYCONTENTS, buf,
      CURLFORM_END);

  sprintf(buf, "%08x", event->user);
  curl_formadd(&formpost, &lastptr,
      CURLFORM_COPYNAME, "user_id",
      CURLFORM_COPYCONTENTS, buf,
      CURLFORM_END);

  sprintf(buf, "%d", event->tool_id);
  curl_formadd(&formpost, &lastptr,
      CURLFORM_COPYNAME, "machine_id",
      CURLFORM_COPYCONTENTS, buf,
      CURLFORM_END);

  curl_formadd(&formpost, &lastptr,
      CURLFORM_COPYNAME, "succ",
      CURLFORM_COPYCONTENTS, event->succ? "1" : "0",
      CURLFORM_END);

  sprintf(buf, "%s/crm/add_card_event/", server);
  error_code = curl_easy_setopt(handle, CURLOPT_URL, buf);
  if (error_code) goto error;

  /* TODO disabling host and peer verification should theoretically be removed
   * eventually */
  error_code = curl_easy_setopt(handle, CURLOPT_SSL_VERIFYHOST, 0L);
  if (error_code) goto error;

  error_code = curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 0L);
  if (error_code) goto error;

#ifdef DEBUG_EVENT_RESPONSE
  error_code = curl_easy_setopt(handle, CURLOPT_WRITEDATA, fdebug);
#else
  error_code = curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, write_ignore);
#endif
  if (error_code) goto error;

  error_code = curl_easy_setopt(handle, CURLOPT_HTTPPOST, formpost);
  if (error_code) goto error;

  error_code = curl_easy_perform(handle);
  if (error_code) goto error;

  error_code = curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &response);
  if (error_code) goto error;
  if (response >= 400)
    log_print("ERROR: response %ld from %s", response, buf);
  else if (response > 200)
    log_print("WARNING: response %ld from %s", response, buf);

  curl_easy_cleanup(handle);
  curl_formfree(formpost);
#ifdef DEBUG_EVENT_RESPONSE
  fclose(fdebug);
#endif
  // return error if it's not a 200-level response
  return response >= 300;

error:
  log_print("ERROR: curl: %s", curl_easy_strerror(error_code));
  curl_easy_cleanup(handle);
  curl_formfree(formpost);
#ifdef DEBUG_EVENT_RESPONSE
  fclose(fdebug);
#endif
  return 1;
}
Beispiel #13
0
/* feed_update()
 * Takes initialized feed with url set, fetches the feed from this url,
 * updates rest of Feed struct members and returns HTTP response code
 * we got from url's server. */
int newsfeed_update(struct newsfeed * feed, time_t last_update)
{
#if (defined(HAVE_LIBCURL) && defined(HAVE_EXPAT))
  CURL * eh;
  CURLcode curl_res;
  struct newsfeed_parser_context * feed_ctx;
  unsigned int res;
  unsigned int timeout_value;
  long response_code;
  
  if (feed->feed_url == NULL) {
    res = NEWSFEED_ERROR_BADURL;
    goto err;
  }
  
  /* Init curl before anything else. */
  eh = curl_easy_init();
  if (eh == NULL) {
    res = NEWSFEED_ERROR_MEMORY;
    goto err;
  }
  
  /* Curl initialized, create parser context now. */
  feed_ctx = malloc(sizeof(* feed_ctx));
  if (feed_ctx == NULL) {
    res = NEWSFEED_ERROR_MEMORY;
    goto free_eh;
  }
  
  feed_ctx->parser = XML_ParserCreate(NULL);
  if (feed_ctx->parser == NULL) {
    res = NEWSFEED_ERROR_MEMORY;
    goto free_ctx;
  }
  feed_ctx->depth = 0;
  feed_ctx->str = mmap_string_sized_new(256);
  if (feed_ctx->str == NULL) {
    res = NEWSFEED_ERROR_MEMORY;
    goto free_praser;
  }
  feed_ctx->feed = feed;
  feed_ctx->location = 0;
  feed_ctx->curitem = NULL;
  feed_ctx->error = NEWSFEED_NO_ERROR;
  
  /* Set initial expat handlers, which will take care of choosing
   * correct parser later. */
  newsfeed_parser_set_expat_handlers(feed_ctx);
  
  if (feed->feed_timeout != 0)
    timeout_value = feed->feed_timeout;
  else
    timeout_value = mailstream_network_delay.tv_sec;
  
  curl_easy_setopt(eh, CURLOPT_URL, feed->feed_url);
  curl_easy_setopt(eh, CURLOPT_NOPROGRESS, 1);
#ifdef CURLOPT_MUTE
  curl_easy_setopt(eh, CURLOPT_MUTE, 1);
#endif
  curl_easy_setopt(eh, CURLOPT_WRITEFUNCTION, newsfeed_writefunc);
  curl_easy_setopt(eh, CURLOPT_WRITEDATA, feed_ctx);
  curl_easy_setopt(eh, CURLOPT_FOLLOWLOCATION, 1);
  curl_easy_setopt(eh, CURLOPT_MAXREDIRS, 3);
  curl_easy_setopt(eh, CURLOPT_TIMEOUT, timeout_value);
  curl_easy_setopt(eh, CURLOPT_NOSIGNAL, 1);
  curl_easy_setopt(eh, CURLOPT_USERAGENT, "libEtPan!");
  
  /* Use HTTP's If-Modified-Since feature, if application provided
   * the timestamp of last update. */
  if (last_update != -1) {
    curl_easy_setopt(eh, CURLOPT_TIMECONDITION,
        CURL_TIMECOND_IFMODSINCE);
    curl_easy_setopt(eh, CURLOPT_TIMEVALUE, last_update);
  }
        
#if LIBCURL_VERSION_NUM >= 0x070a00
  curl_easy_setopt(eh, CURLOPT_SSL_VERIFYPEER, 0);
  curl_easy_setopt(eh, CURLOPT_SSL_VERIFYHOST, 0);
#endif

  curl_res = curl_easy_perform(eh);
  if (curl_res != 0) {
    res = curl_error_convert(curl_res);
    goto free_str;
  }
  
  curl_easy_getinfo(eh, CURLINFO_RESPONSE_CODE, &response_code);
  
  curl_easy_cleanup(eh);
  
  if (feed_ctx->error != NEWSFEED_NO_ERROR) {
    res = feed_ctx->error;
    goto free_str;
  }
  
  /* Cleanup, we should be done. */
  mmap_string_free(feed_ctx->str);
  XML_ParserFree(feed_ctx->parser);
  free(feed_ctx);
  
  feed->feed_response_code = (int) response_code;
  
  return NEWSFEED_NO_ERROR;;
  
 free_str:
  mmap_string_free(feed_ctx->str);
 free_praser:
  XML_ParserFree(feed_ctx->parser);
 free_ctx:
  free(feed_ctx);
 free_eh:
  curl_easy_cleanup(eh);
 err:
  return res;
#else
  return NEWSFEED_ERROR_INTERNAL;
#endif
}
Beispiel #14
0
int main(int argc, char *argv[]) {

    CURL *curl;
    CURLcode ret;
    char *url = NULL;
    char *host_header = NULL;
    char *host_name = NULL;
    char *regex = NULL;

    struct timeval tvBegin, tvEnd, tvDiff;

    /* Commandline switches */
    int verbose_level=0;
    int status_only = false;
    int measure_time = false;
    int nossl_verify = false;
    int follow_location = false;
    int fail_on_curl_error = false;
    int ssl_valid_date = false;

    struct curl_slist *headers = NULL;
    int i;
    int curl_timeout = TIMEOUT;
    char *curl_userpwd = NULL;

    ASN1_TIME * notAfter;
    time_t now;
    time_t expire;
    int time_left;

    pcre *re;
    int pcre_opts=0;
    const char *error;
    int erroffset;
    int ovector[OVECCOUNT];
    int rc;
    int opt;

    wr_error = 0;
    wr_index = 0;

    /* First step, init curl */
    curl = curl_easy_init();
    if(!curl) {
        fprintf(stderr, "couldn't init curl\n");
        exit(EXIT_FAILURE);
    }

    /* 
     * if no arguments are given
     */
    if(argc == 1) {
        fprintf(stderr, "This program needs arguments....\n\n");
        print_arguments(argc, argv);
        print_help(1);
    }

    while((opt = getopt(argc, argv, "?VfcamMlsvp:t:u:h:r:i")) != -1) {
        switch(opt) {
            case 'V':
                fprintf(stderr,"%s %s\n\n", PACKAGE, VERSION);
                exit(0);
                break;
            case 'v':
                verbose_level++;
                break;
            case 'a':
                curl_easy_setopt(curl, CURLOPT_HEADER  , true);
                break;
            case 'i':
                curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);
                curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, false);
                nossl_verify = true;
                break;
            case 's':
                status_only = true;
                break;
            case 'm':
                measure_time = true;
                break;
            case 'M':
                pcre_opts |= PCRE_MULTILINE;
                break;
            case 'l':
                follow_location = true;
                curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, true);
                break;
            case 'f':
                fail_on_curl_error = true;
                break;
            case 'p':
                curl_userpwd = optarg;
                break;
            case 'u':
                url = optarg;
                break;
            case 't':
                curl_timeout = atoi(optarg);
                break;
            case 'h':
                host_header = malloc(strlen("Host: ") + strlen(optarg) + 1);
                host_name = optarg;
                strcpy(host_header, "Host: ");
                strcat(host_header, optarg);
                headers = curl_slist_append(headers, host_header);
                curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
                break;
            case 'c':
                ssl_valid_date = true;
            case 'r':
                regex = optarg;
                break;
            case ':':
                fprintf(stderr, "%s: Error - Option `%c' needs a value\n\n", PACKAGE, optopt);
                print_arguments(argc, argv);
                print_help(1);
                break;
            case '?':
                fprintf(stderr, "%s: Error - No such option: `%c'\n", PACKAGE, optopt);
                print_arguments(argc, argv);
                print_help(1);
        }
    }

    if (verbose_level > 3){
        curl_easy_setopt(curl, CURLOPT_VERBOSE , true);
    }

    if (verbose_level > 0){
        fprintf(stderr, "%-17s %s\n", "URL", url);
        fprintf(stderr, "%-17s %s\n", "REGEX", regex);
        fprintf(stderr, "%-17s %i\n", "TIMEOUT", curl_timeout);
        fprintf(stderr, "%-17s %s\n",   "HOST HEADER", host_header);
        fprintf(stderr, "%-17s %i\n\n", "STATUS ONLY", status_only);

        fprintf(stderr, "%-17s %s -t %i -u \"%s\" -r \"%s\"", "CMD ", PACKAGE, curl_timeout, url, regex);
        if ( status_only == true ){
            fprintf(stderr, " -s");
        }
        if ( measure_time  == true ){
            fprintf(stderr, " -m");
        }
        if ( nossl_verify == true ){
            fprintf(stderr, " -i");
             }
        if ( follow_location == true ){
            fprintf(stderr, " -l");
             }
        if ( fail_on_curl_error == true ){
            fprintf(stderr, " -f");
        }
        if ( (pcre_opts & PCRE_MULTILINE) == PCRE_MULTILINE ){
            fprintf(stderr, " -M");
        }
        if (curl_userpwd != NULL){
            fprintf(stderr, " -p %s", curl_userpwd);
        }

        if ( host_name != NULL ){
            fprintf(stderr, " -h %s",host_name);
        }
        fprintf(stderr, "\n");

        fprintf(stderr, "%-17s %s[\"-t\",\"%i\",\"-u\",\"%s\",\"-r\",\"%s\"", "ZABBIX 2.0 ITEM", PACKAGE, curl_timeout, url, regex);
        if ( status_only == true ){
            fprintf(stderr, ",\"-s\"");
        }
        if ( measure_time  == true ){
            fprintf(stderr, ",\"-m\"");
        }
        if ( nossl_verify == true ){
            fprintf(stderr, ",\"-i\"");
             }
        if ( follow_location == true ){
            fprintf(stderr, ",\"-l\"");
             }
        if ( fail_on_curl_error == true ){
            fprintf(stderr, ",\"-f\"");
        }
        if ( (pcre_opts & PCRE_MULTILINE) == PCRE_MULTILINE ){
            fprintf(stderr, ",\"-M\"");
        }
        if (curl_userpwd != NULL){
            fprintf(stderr, ",\"-p\",\"%s\"", curl_userpwd);
        }

        if ( host_name != NULL ){
            fprintf(stderr, ",\"-h\",\"%s\"",host_name);
        }
       fprintf(stderr, "]\n");
    }


    if (((url == NULL) || (regex == NULL)) && (ssl_valid_date == false)){
        print_arguments(argc, argv);
        print_help(EXIT_FAILURE);
    }

    /* Tell curl the URL of the file we're going to retrieve */
    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_USERAGENT, "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.2) Gecko/20090729 Firefox/3.5.2 GTB5");

    /* Tell curl that we'll receive data to the function write_data, and
     * also provide it with a context pointer for our error return.
     */
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *) &wr_error);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, curl_timeout);

    curl_easy_setopt(curl, CURLOPT_USERPWD, curl_userpwd);

    gettimeofday(&tvBegin, NULL);
    /* Initialize certificate array*/
    for(i=0; i<MAX_CERTS;i++) {
        certificates[i] = 0;
        certificates_error[i] = X509_V_OK;
    }
    curl_easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION, sslctxfunc);
    if(ssl_valid_date == true) {
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, false);
    }

    /* Allow curl to perform the action */
    ret = curl_easy_perform(curl);
    /* Stop execution here if only status is needed */
    if ((ret != 0) || (fail_on_curl_error == true)){
        if (status_only == true){
            printf("0");
            if (verbose_level > 1){
                fprintf(stderr,"returned: '0'\n");
            }
        } else if (measure_time == true){
            printf("0.0");
            if (verbose_level > 1){
                fprintf(stderr,"returned: '0.0'\n");
            }
        }
        exit(EXIT_FAILURE);
    }

    /* Get days until certificate expires */
    if(ssl_valid_date == true) {
        if(ret!=0 || certificates[0]==0) {
            exit(EXIT_FAILURE);
        }
        notAfter = X509_get_notAfter(certificates[0]);
        now = time(NULL);
        expire = ASN1_GetTimeT(notAfter);
        time_left = (expire-now)/(60*60*24);

        printf("%d",time_left);

        if (verbose_level > 1){
            fprintf(stderr,"returned: '%d'\n",time_left);
        }

        curl_easy_cleanup(curl);
        exit(EXIT_SUCCESS);
    }

    re = pcre_compile(regex,    /* the pattern */
                      pcre_opts,        /* default options */
                      &error,   /* for error message */
                      &erroffset,   /* for error offset */
                      NULL);    /* use default character tables */


    rc = pcre_exec(re,          /* the compiled pattern */
                   NULL,        /* no extra data - we didn't study the pattern */
                   wr_buf,      /* the subject string */
                   wr_index,    /* the length of the subject */
                   0,           /* start at offset 0 in the subject */
                   0,           /* default options */
                   ovector,     /* output vector for substring information */
                   OVECCOUNT);  /* number of elements in the output vector */

    if(verbose_level > 2) {
        fprintf(stderr, "out: >>>%s<<< [%i bytes]\n", wr_buf, wr_index);
    }

    /* Evaluate the match and output status */
    if(rc < 0) {
        if (status_only == true) {
            printf("0");
            if (verbose_level > 1){
                fprintf(stderr,"returned: '0'\n");
            }
        } else if (measure_time == true) {
            printf("0.0");
            if (verbose_level > 1){
                fprintf(stderr,"returned: '0.0'\n");
            }
        } else {
            switch (rc) {
                case PCRE_ERROR_NOMATCH      : fprintf(stderr,"String did not match the pattern\n");        break;
                case PCRE_ERROR_NULL         : fprintf(stderr,"Something was null\n");                      break;
                case PCRE_ERROR_BADOPTION    : fprintf(stderr,"A bad option was passed\n");                 break;
                case PCRE_ERROR_BADMAGIC     : fprintf(stderr,"Magic number bad (compiled re corrupt?)\n"); break;
                case PCRE_ERROR_UNKNOWN_NODE : fprintf(stderr,"Something kooky in the compiled re\n");      break;
                case PCRE_ERROR_NOMEMORY     : fprintf(stderr,"Ran out of memory\n");                       break;
                default                      : fprintf(stderr,"Matching error %d\n", rc);                   break;
            }
        }
        pcre_free(re);          /* Release memory used for the compiled pattern */
        exit(EXIT_FAILURE);
    }

    if(rc == 2) {
        if (status_only == true) {
            printf("1");
            if (verbose_level > 1) {
                fprintf(stderr,"returned: '1'\n");
            }
        } else if (measure_time == true) {
            gettimeofday(&tvEnd, NULL);
            timeval_subtract(&tvDiff, &tvEnd, &tvBegin);
            printf("%ld.%06ld", tvDiff.tv_sec, tvDiff.tv_usec);
            if (verbose_level > 1){
                fprintf(stderr,"measure time returned: '%ld.%06ld'\n", tvDiff.tv_sec, tvDiff.tv_usec);
            }
        } else {
            char *substring_start = NULL;
            int substring_length = 0;
            i = 1;
            substring_start = wr_buf + ovector[2 * i];
            substring_length = ovector[2 * i + 1] - ovector[2 * i];
            printf("%.*s", substring_length, substring_start);
            fprintf(stderr,"parsing returned: '%.*s'\n", substring_length, substring_start);
        }
    }
    curl_easy_cleanup(curl);

    exit(EXIT_SUCCESS);
}
Beispiel #15
0
static int youtube_streamChange(interfaceMenu_t *pMenu, void *pArg)
{
	CURLcode ret;
	CURL *hnd;
	char proxy[32];
	char login[512];
	char *str;
	static char url[MAX_URL];
	static char url_tmp[MAX_URL];
	static char curl_data[YOUTUBE_INFO_BUFFER_SIZE];
	static char err_buff[CURL_ERROR_SIZE];
	static curlBufferInfo_t buffer;
	char *fmt_url_map;
	//int supported_formats[] = { 18, 17, 34, 5, 0 };
	int supported_formats[] = { 34, 18, 0 };
	/* 37/1920x1080/9/0/115
	   22/1280x720/9/0/115
	   35/854x480/9/0/115
	   34/640x360/9/0/115
	   5/320x240/7/0/0 */
	char *fmt_url;
	int i;
	int len_str;
	int len_url = 0;
	int videoIndex = (int)pArg;

	if( videoIndex == CHANNEL_CUSTOM )
	{
		str = strstr( appControlInfo.mediaInfo.lastFile, "watch?v=" );
		if( str == NULL )
		{
			eprintf("%s: can't file YouTube ID in %s\n", __FUNCTION__, appControlInfo.mediaInfo.lastFile);
			interface_showMessageBox(_T("ERR_PLAY_FILE"), thumbnail_error, 3000);
			return -1;
		}
		str += 8;
		str[sizeof(youtubeInfo.current_id)-1] = 0;
		if( strlen(str) != YOUTUBE_ID_LENGTH-1 )
		{
			eprintf("%s: invalid YouTube ID %s\n", __FUNCTION__, str);
			interface_showMessageBox(_T("ERR_PLAY_FILE"), thumbnail_error, 3000);
			return -1;
		}
		memcpy( youtubeInfo.current_id, str, sizeof(youtubeInfo.current_id) );
	} else if( videoIndex < 0 || videoIndex >= youtubeInfo.count )
	{
		eprintf("%s: there is no stream %d\n", __FUNCTION__, videoIndex);
		interface_showMessageBox(_T("ERR_PLAY_FILE"), thumbnail_error, 3000);
		return -1;
	} else
	{
		memcpy( youtubeInfo.current_id, youtubeInfo.videos[videoIndex].video_id, sizeof(youtubeInfo.current_id) );
	}

	buffer.data = curl_data;
	buffer.size = sizeof(curl_data);
	buffer.pos  = 0;

	curl_data[0] = 0;
	sprintf(url,"http://www.youtube.com/get_video_info?video_id=%s%s",youtubeInfo.current_id, "&eurl=&el=detailpage&ps=default&gl=US&hl=en");
	hnd = curl_easy_init();

	curl_easy_setopt(hnd, CURLOPT_WRITEFUNCTION, write_data);
	curl_easy_setopt(hnd, CURLOPT_WRITEDATA, &buffer);
	curl_easy_setopt(hnd, CURLOPT_URL, url);
	curl_easy_setopt(hnd, CURLOPT_ERRORBUFFER, err_buff);
	curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYHOST, 2);
	curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYPEER, 0);
	curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYHOST, 1);
	curl_easy_setopt(hnd, CURLOPT_CONNECTTIMEOUT, 15);
	curl_easy_setopt(hnd, CURLOPT_TIMEOUT, 15);
	getParam(BROWSER_CONFIG_FILE, "HTTPProxyServer", "", proxy);
	if( proxy[0] != 0 )
	{
		curl_easy_setopt(hnd, CURLOPT_PROXY, proxy);
		getParam(BROWSER_CONFIG_FILE, "HTTPProxyLogin", "", login);
		if( login[0] != 0 )
		{
			str = &login[strlen(login)+1];
			getParam(BROWSER_CONFIG_FILE, "HTTPProxyPasswd", "", str);
			if( *str != 0 )
			{
				str[-1] = ':';
			}
			curl_easy_setopt(hnd, CURLOPT_PROXYUSERPWD, login);
		}
	}

	ret = curl_easy_perform(hnd);

	eprintf("%s: video info for %s acquired (length %d)\n", __FUNCTION__, youtubeInfo.current_id, buffer.pos);
	eprintf("%s:  YouTube URL %s\n", __FUNCTION__, url);

	curl_easy_cleanup(hnd);

	if (ret != 0)
	{
		eprintf("Youtube: Failed to get video info from '%s': %s\n", url, err_buff);
		interface_showMessageBox(_T("ERR_PLAY_FILE"), thumbnail_error, 3000);
		return 1;
	}
/*
	fmt_url_map = strstr(curl_data, "fmt_list=");
	if( fmt_url_map )
	{
		fmt_url_map += sizeof("fmt_list=")-1;
		for( str = fmt_url_map; *str && *str != '&'; str++ );
		if( *str != '&' )
			str = NULL;
		else
			*str = 0;

		if( utf8_urltomb(fmt_url_map, strlen(fmt_url_map)+1, url, sizeof(url)-1 ) > 0 )
		{
			eprintf("%s: fmt_list='%s'\n", __FUNCTION__, url);
		}
	}
*/
	//fmt_url_map = strstr(curl_data, "fmt_url_map=");
    fmt_url_map = strstr(curl_data, "url_encoded_fmt_stream_map=");
	if( fmt_url_map )
	{
		//fmt_url_map += sizeof("fmt_url_map=")-1;
		fmt_url_map += sizeof("url_encoded_fmt_stream_map=")-1;
		for( str = fmt_url_map; *str && *str != '&'; str++ );
		if( *str != '&' )
			str = NULL;
		else
			*str = 0;

		for( i = 0; supported_formats[i] != 0; i++ )
		{
			//sprintf(proxy, "%d%%7C", supported_formats[i]);
			sprintf(proxy, "itag%%3D%d", supported_formats[i]); // find format tag field
			if( (fmt_url = strstr( fmt_url_map, proxy )) != NULL )
			{
				fmt_url += strlen(proxy) + 9;// skip "%2Curl%3D"
				str = strstr( fmt_url, "%26quality" ); // find end url
				if( str )
					*str = 0;
				eprintf("%s:  URL %s\n", __FUNCTION__, fmt_url);
				if( utf8_urltomb(fmt_url, strlen(fmt_url)+1, url_tmp, sizeof(url_tmp)-1 ) < 0 )
				{
					eprintf("%s: Failed to decode '%s'\n", __FUNCTION__, fmt_url);
				} else
				{
					if( utf8_urltomb(url_tmp, strlen(url_tmp)+1, url, sizeof(url)-1 ) < 0 )
					{
						eprintf("%s: Failed to decode '%s'\n", __FUNCTION__, url_tmp);
					} else {
						eprintf("%s: selected format %d\n", __FUNCTION__, supported_formats[i]);
						break;
					}
				}
			}
		}
		if( supported_formats[i] == 0 )
		{
			interface_showMessageBox(_T("ERR_STREAM_NOT_SUPPORTED"), thumbnail_warning, 0);
			return 1;
		}
	}

	eprintf("Youtube: Playing '%s'\n", url);

	char *descr     = NULL;
	char *thumbnail = NULL;
	if( videoIndex != CHANNEL_CUSTOM )
	{
		youtubeInfo.index = videoIndex;
		if( interface_getMenuEntryInfo( (interfaceMenu_t*)&YoutubeMenu, videoIndex+1, login, sizeof(login) ) == 0 )
			descr = login;
		thumbnail = youtubeInfo.videos[videoIndex].thumbnail[0] ? youtubeInfo.videos[videoIndex].thumbnail : NULL;
		appControlInfo.playbackInfo.channel = videoIndex+1;
		appControlInfo.playbackInfo.playlistMode = playlistModeYoutube;
	} else
	{
		youtubeInfo.index = 0;
		descr     = appControlInfo.playbackInfo.description;
		thumbnail = appControlInfo.playbackInfo.thumbnail;
	}
	appControlInfo.playbackInfo.streamSource = streamSourceYoutube;
	media_playURL(screenMain, url, descr, thumbnail != NULL ? thumbnail : resource_thumbnails[thumbnail_youtube] );

	return 0;
}
Beispiel #16
0
int main(int argc, char *argv[])
{
  CURL    *curl;
  conf_t  conf[1];
  int     OptionIndex;
  struct  tm *lt;
  struct  tm *gmt;
  time_t  tt;
  time_t  tt_local;
  time_t  tt_gmt;
  double  tzonediffFloat;
  int     tzonediffWord;
  char    timeBuf[61];
  char    tzoneBuf[16];
  int     RetValue;

  OptionIndex     = 0;
  ShowAllHeader   = 0;    /* Do not show HTTP Header */
  AutoSyncTime    = 0;    /* Do not synchronise computer clock */
  RetValue        = 0;    /* Successful Exit */
  conf_init(conf);

  if (argc > 1) {
    while (OptionIndex < argc) {
      if (strncmp(argv[OptionIndex], "--server=", 9) == 0)
        snprintf(conf->timeserver, MAX_STRING, "%s", &argv[OptionIndex][9]);

      if (strcmp(argv[OptionIndex], "--showall") == 0)
        ShowAllHeader = 1;

      if (strcmp(argv[OptionIndex], "--synctime") == 0)
        AutoSyncTime = 1;

      if (strncmp(argv[OptionIndex], "--proxy-user="******"%s", &argv[OptionIndex][13]);

      if (strncmp(argv[OptionIndex], "--proxy=", 8) == 0)
        snprintf(conf->http_proxy, MAX_STRING, "%s", &argv[OptionIndex][8]);

      if ((strcmp(argv[OptionIndex], "--help") == 0) ||
          (strcmp(argv[OptionIndex], "/?") == 0)) {
        showUsage();
        return 0;
      }
      OptionIndex++;
    }
  }

  if (*conf->timeserver == 0)     /* Use default server for time information */
    snprintf(conf->timeserver, MAX_STRING, "%s", DefaultTimeServer[0]);

  /* Init CURL before usage */
  curl_global_init(CURL_GLOBAL_ALL);
  curl = curl_easy_init();
  if (curl) {
    SyncTime_CURL_Init(curl, conf->http_proxy, conf->proxy_user);

    /* Calculating time diff between GMT and localtime */
    tt       = time(0);
    lt       = localtime(&tt);
    tt_local = mktime(lt);
    gmt      = gmtime(&tt);
    tt_gmt   = mktime(gmt);
    tzonediffFloat = difftime(tt_local, tt_gmt);
    tzonediffWord  = (int)(tzonediffFloat/3600.0);

    if ((double)(tzonediffWord * 3600) == tzonediffFloat)
      snprintf(tzoneBuf, 15, "%+03d'00'", tzonediffWord);
    else
      snprintf(tzoneBuf, 15, "%+03d'30'", tzonediffWord);

    /* Get current system time and local time */
    GetSystemTime(&SYSTime);
    GetLocalTime(&LOCALTime);
    snprintf(timeBuf, 60, "%s, %02d %s %04d %02d:%02d:%02d.%03d, ",
             DayStr[LOCALTime.wDayOfWeek], LOCALTime.wDay,
             MthStr[LOCALTime.wMonth-1], LOCALTime.wYear,
             LOCALTime.wHour, LOCALTime.wMinute, LOCALTime.wSecond,
             LOCALTime.wMilliseconds);

    fprintf(stderr, "Fetch: %s\n\n", conf->timeserver);
    fprintf(stderr, "Before HTTP. Date: %s%s\n\n", timeBuf, tzoneBuf);

    /* HTTP HEAD command to the Webserver */
    SyncTime_CURL_Fetch(curl, conf->timeserver, "index.htm",
                        HTTP_COMMAND_HEAD);

    GetLocalTime(&LOCALTime);
    snprintf(timeBuf, 60, "%s, %02d %s %04d %02d:%02d:%02d.%03d, ",
             DayStr[LOCALTime.wDayOfWeek], LOCALTime.wDay,
             MthStr[LOCALTime.wMonth-1], LOCALTime.wYear,
             LOCALTime.wHour, LOCALTime.wMinute, LOCALTime.wSecond,
             LOCALTime.wMilliseconds);
    fprintf(stderr, "\nAfter  HTTP. Date: %s%s\n", timeBuf, tzoneBuf);

    if (AutoSyncTime == 3) {
      /* Synchronising computer clock */
      if (!SetSystemTime(&SYSTime)) {  /* Set system time */
        fprintf(stderr, "ERROR: Unable to set system time.\n");
        RetValue = 1;
      }
      else {
        /* Successfully re-adjusted computer clock */
        GetLocalTime(&LOCALTime);
        snprintf(timeBuf, 60, "%s, %02d %s %04d %02d:%02d:%02d.%03d, ",
                 DayStr[LOCALTime.wDayOfWeek], LOCALTime.wDay,
                 MthStr[LOCALTime.wMonth-1], LOCALTime.wYear,
                 LOCALTime.wHour, LOCALTime.wMinute, LOCALTime.wSecond,
                 LOCALTime.wMilliseconds);
        fprintf(stderr, "\nNew System's Date: %s%s\n", timeBuf, tzoneBuf);
      }
    }

    /* Cleanup before exit */
    conf_init(conf);
    curl_easy_cleanup(curl);
  }
  return RetValue;
}
Beispiel #17
0
/* exported function documented in content/fetchers/curl.h */
nserror fetch_curl_register(void)
{
	CURLcode code;
	curl_version_info_data *data;
	int i;
	lwc_string *scheme;
	const struct fetcher_operation_table fetcher_ops = {
		.initialise = fetch_curl_initialise,
		.acceptable = fetch_curl_can_fetch,
		.setup = fetch_curl_setup,
		.start = fetch_curl_start,
		.abort = fetch_curl_abort,
		.free = fetch_curl_free,
		.poll = fetch_curl_poll,
		.finalise = fetch_curl_finalise
	};

	LOG("curl_version %s", curl_version());

	code = curl_global_init(CURL_GLOBAL_ALL);
	if (code != CURLE_OK) {
		LOG("curl_global_init failed.");
		return NSERROR_INIT_FAILED;
	}

	fetch_curl_multi = curl_multi_init();
	if (!fetch_curl_multi) {
		LOG("curl_multi_init failed.");
		return NSERROR_INIT_FAILED;
	}

#if LIBCURL_VERSION_NUM >= 0x071e00
	/* built against 7.30.0 or later: configure caching */
	{
		CURLMcode mcode;
		int maxconnects = nsoption_int(max_fetchers) +
				nsoption_int(max_cached_fetch_handles);

#undef SETOPT
#define SETOPT(option, value) \
	mcode = curl_multi_setopt(fetch_curl_multi, option, value);	\
	if (mcode != CURLM_OK)						\
		goto curl_multi_setopt_failed;

		SETOPT(CURLMOPT_MAXCONNECTS, maxconnects);
		SETOPT(CURLMOPT_MAX_TOTAL_CONNECTIONS, maxconnects);
		SETOPT(CURLMOPT_MAX_HOST_CONNECTIONS, nsoption_int(max_fetchers_per_host));
	}
#endif

	/* Create a curl easy handle with the options that are common to all
	   fetches.
	*/
	fetch_blank_curl = curl_easy_init();
	if (!fetch_blank_curl) {
		LOG("curl_easy_init failed");
		return NSERROR_INIT_FAILED;
	}

#undef SETOPT
#define SETOPT(option, value) \
	code = curl_easy_setopt(fetch_blank_curl, option, value);	\
	if (code != CURLE_OK)						\
		goto curl_easy_setopt_failed;

	if (verbose_log) {
	    SETOPT(CURLOPT_VERBOSE, 1);
	} else {
	    SETOPT(CURLOPT_VERBOSE, 0);
	}
	SETOPT(CURLOPT_ERRORBUFFER, fetch_error_buffer);
	if (nsoption_bool(suppress_curl_debug)) {
		SETOPT(CURLOPT_DEBUGFUNCTION, fetch_curl_ignore_debug);
	}
	SETOPT(CURLOPT_WRITEFUNCTION, fetch_curl_data);
	SETOPT(CURLOPT_HEADERFUNCTION, fetch_curl_header);
	SETOPT(CURLOPT_PROGRESSFUNCTION, fetch_curl_progress);
	SETOPT(CURLOPT_NOPROGRESS, 0);
	SETOPT(CURLOPT_USERAGENT, user_agent_string());
	SETOPT(CURLOPT_ENCODING, "gzip");
	SETOPT(CURLOPT_LOW_SPEED_LIMIT, 1L);
	SETOPT(CURLOPT_LOW_SPEED_TIME, 180L);
	SETOPT(CURLOPT_NOSIGNAL, 1L);
	SETOPT(CURLOPT_CONNECTTIMEOUT, nsoption_uint(curl_fetch_timeout));

	if (nsoption_charp(ca_bundle) &&
	    strcmp(nsoption_charp(ca_bundle), "")) {
		LOG("ca_bundle: '%s'", nsoption_charp(ca_bundle));
		SETOPT(CURLOPT_CAINFO, nsoption_charp(ca_bundle));
	}
	if (nsoption_charp(ca_path) && strcmp(nsoption_charp(ca_path), "")) {
		LOG("ca_path: '%s'", nsoption_charp(ca_path));
		SETOPT(CURLOPT_CAPATH, nsoption_charp(ca_path));
	}

	/* Detect whether the SSL CTX function API works */
	curl_with_openssl = true;
	code = curl_easy_setopt(fetch_blank_curl,
			CURLOPT_SSL_CTX_FUNCTION, NULL);
	if (code != CURLE_OK) {
		curl_with_openssl = false;
	}

	LOG("cURL %slinked against openssl", curl_with_openssl ? "" : "not ");

	/* cURL initialised okay, register the fetchers */

	data = curl_version_info(CURLVERSION_NOW);

	for (i = 0; data->protocols[i]; i++) {
		if (strcmp(data->protocols[i], "http") == 0) {
			scheme = lwc_string_ref(corestring_lwc_http);

		} else if (strcmp(data->protocols[i], "https") == 0) {
			scheme = lwc_string_ref(corestring_lwc_https);

		} else {
			/* Ignore non-http(s) protocols */
			continue;
		}

		if (fetcher_add(scheme, &fetcher_ops) != NSERROR_OK) {
			LOG("Unable to register cURL fetcher for %s", data->protocols[i]);
		}
	}

	return NSERROR_OK;

curl_easy_setopt_failed:
	LOG("curl_easy_setopt failed.");
	return NSERROR_INIT_FAILED;

#if LIBCURL_VERSION_NUM >= 0x071e00
curl_multi_setopt_failed:
	LOG("curl_multi_setopt failed.");
	return NSERROR_INIT_FAILED;
#endif
}
Beispiel #18
0
CurlHolder* Session::Impl::newHolder() {
    CurlHolder* holder = new CurlHolder();
    holder->handle = curl_easy_init();
    return holder;
}
Beispiel #19
0
static gpointer
download_thread(gpointer data)
{
	CURL *curl = NULL;
	CURLcode res;
	FILE *fp = NULL;

	Task *task = (Task *)data;

	curl = curl_easy_init();

	if(curl == NULL)
	{
		gdk_threads_enter();
		g_signal_emit(task->downloader, signals[DOWNLOAD_FAILED], 0, task->url, _("curl_easy_init failed"));
		gdk_threads_leave();
		goto _exit;
	}

	fp = fopen(task->file, "w");
	if (fp == NULL)
	{
		gchar *message;

		message = g_strdup_printf(_("Unable to write file: %s"), task->file);
		gdk_threads_enter();
		g_signal_emit(task->downloader, signals[DOWNLOAD_FAILED], 0, task->url, message);
		gdk_threads_leave();

		g_free(message);
		goto _exit;
	}

	curl_easy_setopt(curl, CURLOPT_URL, task->url);
	curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, my_write_func);
	curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
	curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, (curl_progress_callback)my_progress_func);
	curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, task);

	res = curl_easy_perform(curl);

	if (res == CURLE_OK)
	{
		gdk_threads_enter();
		g_signal_emit(task->downloader, signals[DOWNLOAD_FINISH], 0, task->url, task->file);
		gdk_threads_leave();
	}
	else
	{
		gchar *message;
		message = g_strdup_printf(_("curl_easy_perform failed: %s"), curl_easy_strerror(res));
		gdk_threads_enter();
		g_signal_emit(task->downloader, signals[DOWNLOAD_FAILED], 0, task->url, message);
		gdk_threads_leave();

		g_free(message);
	}

_exit:
	if (fp)
		fclose(fp);

	if (curl)
		curl_easy_cleanup(curl);

	g_mutex_lock(task->downloader->priv->mutex);
	task->downloader->priv->tasks = g_slist_remove(task->downloader->priv->tasks, task);
	g_mutex_unlock(task->downloader->priv->mutex);

	g_free(task->url);
	g_free(task->file);
	g_free(task);

	return NULL;
}
Beispiel #20
0
/* Initialize db->curl */
static int cx_init_curl (cx_t *db) /* {{{ */
{
  db->curl = curl_easy_init ();
  if (db->curl == NULL)
  {
    ERROR ("curl_xml plugin: curl_easy_init failed.");
    return (-1);
  }

  curl_easy_setopt (db->curl, CURLOPT_NOSIGNAL, 1L);
  curl_easy_setopt (db->curl, CURLOPT_WRITEFUNCTION, cx_curl_callback);
  curl_easy_setopt (db->curl, CURLOPT_WRITEDATA, db);
  curl_easy_setopt (db->curl, CURLOPT_USERAGENT, COLLECTD_USERAGENT);
  curl_easy_setopt (db->curl, CURLOPT_ERRORBUFFER, db->curl_errbuf);
  curl_easy_setopt (db->curl, CURLOPT_URL, db->url);
  curl_easy_setopt (db->curl, CURLOPT_FOLLOWLOCATION, 1L);
  curl_easy_setopt (db->curl, CURLOPT_MAXREDIRS, 50L);

  if (db->user != NULL)
  {
#ifdef HAVE_CURLOPT_USERNAME
    curl_easy_setopt (db->curl, CURLOPT_USERNAME, db->user);
    curl_easy_setopt (db->curl, CURLOPT_PASSWORD,
        (db->pass == NULL) ? "" : db->pass);
#else
    size_t credentials_size;

    credentials_size = strlen (db->user) + 2;
    if (db->pass != NULL)
      credentials_size += strlen (db->pass);

    db->credentials = malloc (credentials_size);
    if (db->credentials == NULL)
    {
      ERROR ("curl_xml plugin: malloc failed.");
      return (-1);
    }

    ssnprintf (db->credentials, credentials_size, "%s:%s",
               db->user, (db->pass == NULL) ? "" : db->pass);
    curl_easy_setopt (db->curl, CURLOPT_USERPWD, db->credentials);
#endif

    if (db->digest)
      curl_easy_setopt (db->curl, CURLOPT_HTTPAUTH, CURLAUTH_DIGEST);
  }

  curl_easy_setopt (db->curl, CURLOPT_SSL_VERIFYPEER, db->verify_peer ? 1L : 0L);
  curl_easy_setopt (db->curl, CURLOPT_SSL_VERIFYHOST,
                    db->verify_host ? 2L : 0L);
  if (db->cacert != NULL)
    curl_easy_setopt (db->curl, CURLOPT_CAINFO, db->cacert);
  if (db->headers != NULL)
    curl_easy_setopt (db->curl, CURLOPT_HTTPHEADER, db->headers);
  if (db->post_body != NULL)
    curl_easy_setopt (db->curl, CURLOPT_POSTFIELDS, db->post_body);

#ifdef HAVE_CURLOPT_TIMEOUT_MS
  if (db->timeout >= 0)
    curl_easy_setopt (db->curl, CURLOPT_TIMEOUT_MS, (long) db->timeout);
  else
    curl_easy_setopt (db->curl, CURLOPT_TIMEOUT_MS, (long) CDTIME_T_TO_MS(plugin_get_interval()));
#endif

  return (0);
} /* }}} int cx_init_curl */
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR lpszCmdLine, int nCmdShow)
{
	bool isSilentMode = false;
	FILE *pFile = NULL;

	bool launchSettingsDlg = false;
	bool isVerbose = false;
	string version = "";

	if (lpszCmdLine && lpszCmdLine[0])
	{
		launchSettingsDlg = isInList(FLAG_OPTIONS, lpszCmdLine);
		isVerbose = isInList(FLAG_VERBOSE, lpszCmdLine);
		version = getParamVal('v', lpszCmdLine);
	}
	hInst = hInstance;
	try {
		GupParameters gupParams("gup.xml");
		GupExtraOptions extraOptions("gupOptions.xml");
		GupNativeLang nativeLang("nativeLang.xml");

		if (launchSettingsDlg)
		{
			if (extraOptions.hasProxySettings())
			{
				proxySrv = extraOptions.getProxyServer();
				proxyPort = extraOptions.getPort();
			}
			if (::DialogBox(hInst, MAKEINTRESOURCE(IDD_PROXY_DLG), NULL, reinterpret_cast<DLGPROC>(proxyDlgProc)))
				extraOptions.writeProxyInfo("gupOptions.xml", proxySrv.c_str(), proxyPort);

			return 0;
		}

		msgBoxTitle = gupParams.getMessageBoxTitle();
		abortOrNot = nativeLang.getMessageString("MSGID_ABORTORNOT");

		std::string updateInfo;
		char errorBuffer[CURL_ERROR_SIZE];

		// Get your software's current version.
		// If you pass the version number as the argument
		// then the version set in the gup.xml will be overrided
		if (lpszCmdLine && lpszCmdLine[0])
			gupParams.setCurrentVersion(lpszCmdLine);

		// override silent mode if "-isVerbose" is passed as argument
		if (isVerbose)
			gupParams.setSilentMode(false);

		isSilentMode = gupParams.isSilentMode();

		// Check on the web the availibility of update
		// Get the update package's location
		CURL *curl;
		CURLcode res;

		curl = curl_easy_init();
		if(curl) 
		{
			std::string urlComplete = gupParams.getInfoLocation() + "?version=";
			if (version != "")
				urlComplete += version;
			else
				urlComplete += gupParams.getCurrentVersion();

			curl_easy_setopt(curl, CURLOPT_URL, urlComplete.c_str());
            curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, TRUE);

			curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, getUpdateInfo);
			curl_easy_setopt(curl, CURLOPT_WRITEDATA, &updateInfo);
			curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errorBuffer);

			if (extraOptions.hasProxySettings())
			{
				curl_easy_setopt(curl, CURLOPT_PROXY, extraOptions.getProxyServer().c_str());
				curl_easy_setopt(curl, CURLOPT_PROXYPORT, extraOptions.getPort());
			}

			res = curl_easy_perform(curl);

			curl_easy_cleanup(curl);
		}

		if (res != 0)
		{
			if (!isSilentMode)
				::MessageBoxA(NULL, errorBuffer, "curl error", MB_OK);
			return -1;
		}

		GupDownloadInfo gupDlInfo(updateInfo.c_str());

		if (!gupDlInfo.doesNeed2BeUpdated())
		{
			if (!isSilentMode)
			{
				string noUpdate = nativeLang.getMessageString("MSGID_NOUPDATE");
				if (noUpdate == "")
					noUpdate = MSGID_NOUPDATE;
				::MessageBoxA(NULL, noUpdate.c_str(), gupParams.getMessageBoxTitle().c_str(), MB_OK);
			}
			return 0;
		}

		string updateAvailable = nativeLang.getMessageString("MSGID_UPDATEAVAILABLE");
		if (updateAvailable == "")
			updateAvailable = MSGID_UPDATEAVAILABLE;
		
		int thirdButtonCmd = gupParams.get3rdButtonCmd();
		int buttonStyle = thirdButtonCmd?MB_YESNOCANCEL:MB_YESNO;
		int dlAnswer = ::MessageBoxA(NULL, updateAvailable.c_str(), gupParams.getMessageBoxTitle().c_str(), buttonStyle);

		if (dlAnswer == IDNO)
		{
			return 0;
		}
		
		if (dlAnswer == IDCANCEL)
		{
			if (gupParams.getClassName() != "")
			{
				HWND h = ::FindWindowExA(NULL, NULL, gupParams.getClassName().c_str(), NULL);

				if (h)
				{
					::SendMessage(h, thirdButtonCmd, gupParams.get3rdButtonWparam(), gupParams.get3rdButtonLparam());
				}
			}
			return 0;
		}
		
		::CreateThread(NULL, 0, launchProgressBar, NULL, 0, NULL);
		
		std::string dlDest = std::getenv("TEMP");
		dlDest += "\\";
		dlDest += ::PathFindFileNameA(gupDlInfo.getDownloadLocation().c_str());

        char *ext = ::PathFindExtensionA(gupDlInfo.getDownloadLocation().c_str());
        if (strcmp(ext, ".exe") != 0)
            dlDest += ".exe";

		pFile = fopen(dlDest.c_str(), "wb");

		//  Download the install package from indicated location
		curl = curl_easy_init();
		if(curl) 
		{
			curl_easy_setopt(curl, CURLOPT_URL, gupDlInfo.getDownloadLocation().c_str());
            curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, TRUE);

			curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, getDownloadData);
			curl_easy_setopt(curl, CURLOPT_WRITEDATA, pFile);

			curl_easy_setopt(curl, CURLOPT_NOPROGRESS, FALSE);
			curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, setProgress);
			curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, hProgressBar);
			
			curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errorBuffer);
			
			if (extraOptions.hasProxySettings())
			{
				curl_easy_setopt(curl, CURLOPT_PROXY, extraOptions.getProxyServer().c_str());
				curl_easy_setopt(curl, CURLOPT_PROXYPORT, extraOptions.getPort());
			}
			res = curl_easy_perform(curl);

			curl_easy_cleanup(curl);
		}

		if (res != 0)
		{
			if (!isSilentMode)
				::MessageBoxA(NULL, errorBuffer, "curl error", MB_OK);
			if (doAbort)
			{
				string dlStopped = nativeLang.getMessageString("MSGID_DOWNLOADSTOPPED");
				if (dlStopped == "")
					dlStopped = MSGID_DOWNLOADSTOPPED;
				::MessageBoxA(NULL, dlStopped.c_str(), gupParams.getMessageBoxTitle().c_str(), MB_OK);
			}
			return -1;
		}

		fflush(pFile);
		fclose(pFile);
		pFile = NULL;

		if (gupParams.getClassName() != "")
		{
			HWND h = ::FindWindowExA(NULL, NULL, gupParams.getClassName().c_str(), NULL);

			if (h)
			{
				string msg = gupParams.getClassName();
				string closeApp = nativeLang.getMessageString("MSGID_CLOSEAPP");
				if (closeApp == "")
					closeApp = MSGID_CLOSEAPP;
				msg += closeApp;

				int installAnswer = ::MessageBoxA(NULL, msg.c_str(), gupParams.getMessageBoxTitle().c_str(), MB_YESNO);

				if (installAnswer == IDNO)
				{
					return 0;
				}
			}
			// kill all process of binary needs to be updated.
			while (h)
			{
				::SendMessage(h, WM_CLOSE, 0, 0);
				h = ::FindWindowExA(NULL, NULL, gupParams.getClassName().c_str(), NULL);
			}
		}

		// execute the installer
		HINSTANCE result = ::ShellExecuteA(NULL, "open", dlDest.c_str(), "", ".", SW_SHOW);
        
        if ((unsigned long)result <= 32) // There's a problem (Don't ask me why, ask Microsoft)
        {
            return -1;
        }   
		return 0;

	} catch (exception ex) {
		if (!isSilentMode)
			::MessageBoxA(NULL, ex.what(), "Xml Exception", MB_OK);

		if (pFile != NULL)
			fclose(pFile);

		return -1;
	}
	catch (...)
	{
		if (!isSilentMode)
			::MessageBoxA(NULL, "Unknown", "Unknown Exception", MB_OK);

		if (pFile != NULL)
			fclose(pFile);

		return -1;
	}
}
struct account_info get_user_info(struct gss_account account, char *source)
{
	char url[100];
	sprintf(url, "%s://%s/api/users/show.xml%s", account.protocol, account.server, source);
	FILE *xml = fopen("temp/file.xml", "wb");
	CURL *curl = curl_easy_init();
        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_USERPWD, account.user);
        curl_easy_setopt(curl, CURLOPT_PASSWORD, account.password);
        curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, save_xml);
	curl_easy_setopt(curl, CURLOPT_WRITEDATA, xml);
        curl_easy_perform(curl);
        curl_easy_cleanup(curl);
	fclose(xml);
	xml = fopen("temp/file.xml", "r");
	fseek(xml, 0L, SEEK_END);
	int filesize = ftell(xml);
	rewind(xml);
	char *xml_data = (char *)malloc(filesize);
	fread(xml_data, filesize, filesize, xml);
	fclose(xml);
	char *error = (char *)malloc(512);
	char *output = (char *)malloc(512);
	int xml_data_size = strlen(xml_data);
	struct account_info info;
	if (parseXml(xml_data, xml_data_size, "<error>", 7, error, 512) > 0) {
		printf("Error: %s\n", error);
		info.screen_name[0] = '\0';
	}
	else {
		if (parseXml(xml_data, xml_data_size, "<name>", 6, output, 512) > 0) {
			strcpy(info.name, output);
		}
		else {
			info.name[0] = '?';
			info.name[1] = '\0';
		}
		if (parseXml(xml_data, xml_data_size, "<screen_name>", 13, output, 512) > 0) {
			strcpy(info.screen_name, output);
		}
		else {
			info.screen_name[0] = '?';
			info.screen_name[1] = '\0';
		}
		if (parseXml(xml_data, xml_data_size, "<location>", 10, output, 512) > 0) {
			strcpy(info.location, output);
		}
		else {
			info.location[0] = '?';
			info.location[1] = '\0';
		}
		if (parseXml(xml_data, xml_data_size, "<description>", 13, output, 512) > 0) {
			strcpy(info.description, output);
		}
		else {
			info.description[0] = '?';
			info.description[1] = '\0';
		}
		if (parseXml(xml_data, xml_data_size, "<url>", 5, output, 512) > 0) {
			strcpy(info.url, output);
		}
		else {
			info.url[0] = '?';
			info.url[1] = '\0';
		}
		if (parseXml(xml_data, xml_data_size, "<followers_count>", 17, output, 512) > 0) {
			info.followers = atoi(output);
		}
		else {
			info.followers = -1;
		}
		if (parseXml(xml_data, xml_data_size, "<friends_count>", 15, output, 512) > 0) {
			info.friends = atoi(output);
		}
		else {
			info.friends = -1;
		}
		if (parseXml(xml_data, xml_data_size, "<statuses_count>", 16, output, 512) > 0) {
			info.statuses = atoi(output);
		}
		else {
			info.statuses = -1;
		}
	}
	free(output);
	free(error);
	free(xml_data);
	return info;
}
Beispiel #23
0
int test(char *URL)
{
  CURL *c;
  CURLM *m;
  int res = 0;
  int running;
  char done = FALSE;
  struct timeval ml_start;
  struct timeval mp_start;
  char ml_timedout = FALSE;
  char mp_timedout = FALSE;

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

  if ((c = curl_easy_init()) == NULL) {
    fprintf(stderr, "curl_easy_init() failed\n");
    curl_global_cleanup();
    return TEST_ERR_MAJOR_BAD;
  }

  curl_easy_setopt(c, CURLOPT_PROXY, libtest_arg2); /* set in first.c */
  curl_easy_setopt(c, CURLOPT_URL, URL);
  curl_easy_setopt(c, CURLOPT_USERPWD, "test:ing");
  curl_easy_setopt(c, CURLOPT_PROXYUSERPWD, "test:ing");
  curl_easy_setopt(c, CURLOPT_HTTPPROXYTUNNEL, 1L);
  curl_easy_setopt(c, CURLOPT_HEADER, 1L);

  if ((m = curl_multi_init()) == NULL) {
    fprintf(stderr, "curl_multi_init() failed\n");
    curl_easy_cleanup(c);
    curl_global_cleanup();
    return TEST_ERR_MAJOR_BAD;
  }

  if ((res = (int)curl_multi_add_handle(m, c)) != CURLM_OK) {
    fprintf(stderr, "curl_multi_add_handle() failed, "
            "with code %d\n", res);
    curl_multi_cleanup(m);
    curl_easy_cleanup(c);
    curl_global_cleanup();
    return TEST_ERR_MAJOR_BAD;
  }

  ml_timedout = FALSE;
  ml_start = tutil_tvnow();

  while(!done) {
    fd_set rd, wr, exc;
    int max_fd;
    struct timeval interval;

    interval.tv_sec = 1;
    interval.tv_usec = 0;

    if (tutil_tvdiff(tutil_tvnow(), ml_start) >
        MAIN_LOOP_HANG_TIMEOUT) {
      ml_timedout = TRUE;
      break;
    }
    mp_timedout = FALSE;
    mp_start = tutil_tvnow();

    while (res == CURLM_CALL_MULTI_PERFORM) {
      res = (int)curl_multi_perform(m, &running);
      if (tutil_tvdiff(tutil_tvnow(), mp_start) >
          MULTI_PERFORM_HANG_TIMEOUT) {
        mp_timedout = TRUE;
        break;
      }
      if (running <= 0) {
        done = TRUE;
        break;
      }
    }
    if (mp_timedout || done)
      break;

    if (res != CURLM_OK) {
      fprintf(stderr, "not okay???\n");
      break;
    }

    FD_ZERO(&rd);
    FD_ZERO(&wr);
    FD_ZERO(&exc);
    max_fd = 0;

    if (curl_multi_fdset(m, &rd, &wr, &exc, &max_fd) != CURLM_OK) {
      fprintf(stderr, "unexpected failured of fdset.\n");
      res = 89;
      break;
    }

    if (select_test(max_fd+1, &rd, &wr, &exc, &interval) == -1) {
      fprintf(stderr, "bad select??\n");
      res = 95;
      break;
    }

    res = CURLM_CALL_MULTI_PERFORM;
  }

  if (ml_timedout || mp_timedout) {
    if (ml_timedout) fprintf(stderr, "ml_timedout\n");
    if (mp_timedout) fprintf(stderr, "mp_timedout\n");
    fprintf(stderr, "ABORTING TEST, since it seems "
            "that it would have run forever.\n");
    res = TEST_ERR_RUNS_FOREVER;
  }

  curl_multi_remove_handle(m, c);
  curl_easy_cleanup(c);
  curl_multi_cleanup(m);
  curl_global_cleanup();

  return res;
}
Beispiel #24
0
    CURLLoader(URLRequest &r)
    {
        mState = urlInit;
        if (!sCurlM)
            sCurlM = curl_multi_init();
        mBytesTotal = -1;
        mBytesLoaded = 0;
        mHttpCode = 0;
        sLoaders++;
        mHandle = curl_easy_init();
        if (!sCurlMap)
            sCurlMap = new CurlMap;

        mBufferRemaining = 0;
        mPutBuffer = 0;
        mBufferPos = 0;
        headerlist = NULL;

        curl_easy_setopt(mHandle, CURLOPT_URL, r.url);

        /* send all data to this function  */
        curl_easy_setopt(mHandle, CURLOPT_WRITEFUNCTION, staticOnData);
        curl_easy_setopt(mHandle, CURLOPT_WRITEDATA, (void *)this);
        curl_easy_setopt(mHandle, CURLOPT_NOPROGRESS, 0);
        curl_easy_setopt(mHandle, CURLOPT_FOLLOWLOCATION, 1);
        if (r.authType!=0)
        {
            curl_easy_setopt(mHandle, CURLOPT_HTTPAUTH, r.authType);
            if (r.credentials && r.credentials[0])
                curl_easy_setopt(mHandle, CURLOPT_USERPWD, r.credentials);
        }
        curl_easy_setopt(mHandle, CURLOPT_PROGRESSFUNCTION, staticOnProgress);
        curl_easy_setopt(mHandle, CURLOPT_PROGRESSDATA, (void *)this);
        curl_easy_setopt(mHandle, CURLOPT_ERRORBUFFER, mErrorBuf );
        if (r.debug)
            curl_easy_setopt(mHandle, CURLOPT_VERBOSE, 1);
        curl_easy_setopt( mHandle, CURLOPT_COOKIEFILE, "" );
        if (r.cookies && r.cookies[0])
            curl_easy_setopt( mHandle, CURLOPT_COOKIE, r.cookies );
        if (sCACertFile.empty())
            curl_easy_setopt(mHandle, CURLOPT_SSL_VERIFYPEER, false);
        else
            curl_easy_setopt(mHandle, CURLOPT_CAINFO, sCACertFile.c_str());

        if (r.method)
        {
            if (!strcmp(r.method,"POST"))
            {
                curl_easy_setopt(mHandle, CURLOPT_POST, true);

                if (r.postData.Ok())
                {
                    curl_easy_setopt(mHandle, CURLOPT_POSTFIELDSIZE, r.postData.Size());
                    curl_easy_setopt(mHandle, CURLOPT_COPYPOSTFIELDS, r.postData.Bytes());
                }
            }
            else if (!strcmp(r.method,"PUT"))
            {
                // The file to PUT must be set with CURLOPT_INFILE and CURLOPT_INFILESIZE.
                curl_easy_setopt(mHandle, CURLOPT_PUT, true);

                curl_easy_setopt(mHandle, CURLOPT_UPLOAD, 1);
                if (r.postData.Ok())
                    SetPutBuffer(r.postData.Bytes(),r.postData.Size());
            }
            else if (!strcmp(r.method,"GET"))
            {
                // GET is the default, so this is not necessary but here for completeness.
                curl_easy_setopt(mHandle, CURLOPT_HTTPGET, true);
            }
            else if (!strcmp(r.method,"DELETE"))
            {
                curl_easy_setopt(mHandle, CURLOPT_CUSTOMREQUEST, r.method);
            }
            else
            {
                // unsupported method !!
            }
        }

        if (r.contentType)
        {
            std::vector<char> buffer;
            buffer.resize(512);
            snprintf(&buffer[0], buffer.size(), "Content-Type: %s", r.contentType);
            headerlist = curl_slist_append(headerlist, &buffer[0]);
        }
        headerlist = curl_slist_append(headerlist, "Expect:");

        int n = r.headers.size();
        if (n >= 0) {
            for(int i = 0; i < n; i++)
            {
                URLRequestHeader h = r.headers[i];
                std::vector<char> buffer;
                buffer.resize(512);
                snprintf(&buffer[0], buffer.size(), "%s: %s", h.name, h.value);
                headerlist = curl_slist_append(headerlist, &buffer[0]);
            }
        }

        curl_easy_setopt(mHandle, CURLOPT_HTTPHEADER, headerlist);

        mErrorBuf[0] = '\0';

        /* some servers don't like requests that are made without a user-agent
          field, so we provide one */
        curl_easy_setopt(mHandle, CURLOPT_USERAGENT, "libcurl-agent/1.0");

        mState = urlLoading;

        if (sCurlMap->size()<MAX_ACTIVE)
        {
            StartProcessing();
        }
        else
        {
            if (sCurlList==0)
                sCurlList = new CurlList;
            sCurlList->push_back(this);
        }
    }
Beispiel #25
0
static int wh_callback_init (wh_callback_t *cb) /* {{{ */
{
        struct curl_slist *headers;

        if (cb->curl != NULL)
                return (0);

        cb->curl = curl_easy_init ();
        if (cb->curl == NULL)
        {
                ERROR ("curl plugin: curl_easy_init failed.");
                return (-1);
        }

        curl_easy_setopt (cb->curl, CURLOPT_NOSIGNAL, 1L);
        curl_easy_setopt (cb->curl, CURLOPT_USERAGENT, COLLECTD_USERAGENT);

        headers = NULL;
        headers = curl_slist_append (headers, "Accept:  */*");
        if (cb->format == WH_FORMAT_JSON)
                headers = curl_slist_append (headers, "Content-Type: application/json");
        else
                headers = curl_slist_append (headers, "Content-Type: text/plain");
        headers = curl_slist_append (headers, "Expect:");
        curl_easy_setopt (cb->curl, CURLOPT_HTTPHEADER, headers);

        curl_easy_setopt (cb->curl, CURLOPT_ERRORBUFFER, cb->curl_errbuf);
        curl_easy_setopt (cb->curl, CURLOPT_URL, cb->location);

        if (cb->user != NULL)
        {
                size_t credentials_size;

                credentials_size = strlen (cb->user) + 2;
                if (cb->pass != NULL)
                        credentials_size += strlen (cb->pass);

                cb->credentials = (char *) malloc (credentials_size);
                if (cb->credentials == NULL)
                {
                        ERROR ("curl plugin: malloc failed.");
                        return (-1);
                }

                ssnprintf (cb->credentials, credentials_size, "%s:%s",
                                cb->user, (cb->pass == NULL) ? "" : cb->pass);
                curl_easy_setopt (cb->curl, CURLOPT_USERPWD, cb->credentials);
                curl_easy_setopt (cb->curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
        }

        curl_easy_setopt (cb->curl, CURLOPT_SSL_VERIFYPEER, (long) cb->verify_peer);
        curl_easy_setopt (cb->curl, CURLOPT_SSL_VERIFYHOST,
                        cb->verify_host ? 2L : 0L);
        curl_easy_setopt (cb->curl, CURLOPT_SSLVERSION, cb->sslversion);
        if (cb->cacert != NULL)
                curl_easy_setopt (cb->curl, CURLOPT_CAINFO, cb->cacert);
        if (cb->capath != NULL)
                curl_easy_setopt (cb->curl, CURLOPT_CAPATH, cb->capath);

        if (cb->clientkey != NULL && cb->clientcert != NULL)
        {
            curl_easy_setopt (cb->curl, CURLOPT_SSLKEY, cb->clientkey);
            curl_easy_setopt (cb->curl, CURLOPT_SSLCERT, cb->clientcert);

            if (cb->clientkeypass != NULL)
                curl_easy_setopt (cb->curl, CURLOPT_SSLKEYPASSWD, cb->clientkeypass);
        }

        wh_reset_buffer (cb);

        return (0);
} /* }}} int wh_callback_init */
Beispiel #26
0
std::string VKBase::parseHTML()
{
    std::string cookiestring = "";
    _curl = curl_easy_init();
    CURLcode result;
    std::string buffer = "";	// for response
    std::string url = "";	// for url

    char errorBuffer[CURL_ERROR_SIZE];
    if(!_curl)
    {
        printf("%s\n", "ERROR: curl_easy_init()");
        exit(0);
    }

    std::string scopes = "";
    std::vector<std::string> vscopes = getScopes();
    std::for_each(vscopes.begin(), vscopes.end(), [&scopes](std::string scope){
        scopes += scope+"&";
    });

    url = "https://oauth.vk.com/authorize?client_id=";
    url += getClientId();
    url += "&scope="+scopes+"redirect_uri=http://api.vkontakte.ru/blank.html&display=mobile&v=5.24&response_type=token&revoke=1";

    curl_easy_setopt(_curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(_curl, CURLOPT_FOLLOWLOCATION, 1L);
    curl_easy_setopt(_curl, CURLOPT_NOSIGNAL, 1);
    curl_easy_setopt(_curl, CURLOPT_HEADER, 1);
    curl_easy_setopt(_curl, CURLOPT_SSL_VERIFYPEER, 0L);
    curl_easy_setopt(_curl, CURLOPT_SSL_VERIFYHOST, 0L);
    curl_easy_setopt(_curl, CURLOPT_COOKIEFILE, cookiestring.c_str());
    curl_easy_setopt(_curl, CURLOPT_PORT, 443);
    curl_easy_setopt(_curl, CURLOPT_WRITEFUNCTION, &VKBase::writer);
    curl_easy_setopt(_curl, CURLOPT_WRITEDATA, &buffer);
    curl_easy_setopt(_curl, CURLOPT_ERRORBUFFER, errorBuffer);

    result = curl_easy_perform(_curl);
    curlCheckError(_curl, result, errorBuffer);


    buffer.clear();
    Authorization();

    // grant access
    url  = "https://login.vk.com/?act=grant_access&client_id="+getClientId();
    url += "&settings=8&redirect_uri=http%3A%2F%2Fapi.vkontakte.ru%2Fblank.html&response_type=token&direct_hash=85bc6b0b250f6f44d1&token_type=0&v=5.24";
    url += "&state=&display=mobile";
    url += "&ip_h="+_ip_h;
    url += "&hash="+_hash;
    url += "&https=1";

    curl_easy_setopt(_curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(_curl, CURLOPT_WRITEDATA, &buffer);
    result = curl_easy_perform(_curl);
    curlCheckError(_curl, result, errorBuffer);

    url = "https://api.vk.com/method/"+getMethod()+"?&access_token="+parseAccessTokenFromHeaders(buffer);
    buffer.clear();

    curl_easy_setopt(_curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(_curl, CURLOPT_HEADER, 0);
    result = curl_easy_perform(_curl);
    curlCheckError(_curl, result, errorBuffer);

    Json::Value root;
    Json::Reader reader;

    bool bjsonparse = reader.parse(buffer, root);
    if(bjsonparse && root["error"].get("error_code", 0).asInt())
    {
        err.b = true;
        err.msg = root["error"].get("error_msg", "false").asString();
    }else{
        err.b = false;
        err.msg = "";
    }

    return buffer;
}
Beispiel #27
0
int curl_http_file(const char * localpath, const char * remotepath, const char * referer,const char *cookie)
{
	long timeout = 10800;
	long connect_timeout = 30;
	long low_speed_limit = 1024;
	long low_speed_time = 60;

	FILE *fp;
	if (!(fp=fopen(localpath, "wb"))){
		perror(localpath);
		return 0;
	}
	long response_code;
	CURL *curl = curl_easy_init();
	curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1); //for thread safe
	curl_easy_setopt(curl, CURLOPT_URL, remotepath);
	if(referer) curl_easy_setopt(curl, CURLOPT_REFERER, referer);
	if(cookie)  curl_easy_setopt(curl, CURLOPT_COOKIE, cookie);
	curl_easy_setopt(curl, CURLOPT_USERAGENT, "icache");
	curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, connect_timeout);
	curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);
	curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, low_speed_limit);
	curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, low_speed_time);
	curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
	curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 10L);
	curl_easy_setopt(curl, CURLOPT_FILETIME, 1);
	//curl_easy_setopt(curl, CURLOPT_ENCODING, "gzip, deflate");
	curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
	CURLcode rc = curl_easy_perform(curl);
	curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
	double len = 0;
	long filesize = 0;
	time_t last_modified = 0;
	curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &len);
	filesize = len;
	curl_easy_getinfo(curl, CURLINFO_FILETIME, &last_modified);
	curl_easy_cleanup(curl);
	fclose(fp);

	int success = 1;
	if (rc!=CURLE_OK || response_code!=200) {
		success = 0;
	}else {
		if (filesize!=-1) {
			long localsize = 0;
			struct stat fileinfo;
			if (stat(localpath, &fileinfo) == 0) localsize =  fileinfo.st_size;
			if (filesize!=localsize) success = 0;
		}
	}

	if (success) {
		if (last_modified!=-1){
			struct utimbuf amtime;
			amtime.actime = amtime.modtime = last_modified;
			utime(localpath, &amtime);
		}
		return 1;
	}else{
		unlink(localpath);
		return 0;
	}
}
Beispiel #28
0
int youtube_getVideoList(const char *url, youtubeEntryHandler pCallback, int page)
{
	CURLcode ret;
	CURL *hnd;
	char proxy[32];
	char login[512];
	char *str;
	xmlConfigHandle_t list;
	xmlConfigHandle_t item;
	TiXmlNode *entry;
	TiXmlNode *child;
	TiXmlElement *elem;
	const char *video_name, *video_type, *video_url, *thumbnail;
	static char curl_data[YOUTUBE_LIST_BUFFER_SIZE];
	static char err_buff[CURL_ERROR_SIZE];
	static curlBufferInfo_t buffer;
	buffer.data = curl_data;
	buffer.size = sizeof(curl_data);
	buffer.pos  = 0;

	if( url == 0 || pCallback == 0 )
		return -2;

	curl_data[0] = 0;

	hnd = curl_easy_init();

	curl_easy_setopt(hnd, CURLOPT_WRITEFUNCTION, write_data);
	curl_easy_setopt(hnd, CURLOPT_WRITEDATA, &buffer);
	curl_easy_setopt(hnd, CURLOPT_URL, url);
	curl_easy_setopt(hnd, CURLOPT_ERRORBUFFER, err_buff);
	curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYHOST, 2);
	curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYPEER, 0);
	curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYHOST, 1);
	curl_easy_setopt(hnd, CURLOPT_CONNECTTIMEOUT, 15);
	curl_easy_setopt(hnd, CURLOPT_TIMEOUT, 15);
	getParam(BROWSER_CONFIG_FILE, "HTTPProxyServer", "", proxy);
	if( proxy[0] != 0 )
	{
		curl_easy_setopt(hnd, CURLOPT_PROXY, proxy);
		getParam(BROWSER_CONFIG_FILE, "HTTPProxyLogin", "", login);
		if( login[0] != 0 )
		{
			str = &login[strlen(login)+1];
			getParam(BROWSER_CONFIG_FILE, "HTTPProxyPasswd", "", str);
			if( *str != 0 )
			{
				str[-1] = ':';
			}
			curl_easy_setopt(hnd, CURLOPT_PROXYUSERPWD, login);
		}
	}

	if (page == 1)
	{
		interface_showLoading();
		interface_displayMenu(1);
	}

	ret = curl_easy_perform(hnd);

	dprintf("%s: page %d of '%s' acquired (length %d)\n", __FUNCTION__, page, youtubeInfo.search[0] ? youtubeInfo.search : "standard feeds", buffer.pos);

	curl_easy_cleanup(hnd);

	if (ret != 0)
	{
		eprintf("Youtube: Failed to get video list from '%s': %s\n", url, err_buff);
		if (page == 1) interface_hideLoading();
		return -1;
	}
	list = xmlConfigParse( curl_data );
	if (list == NULL
		|| (item = xmlConfigGetElement(list, "feed", 0)) == NULL)
	{
		if (list)
		{
			eprintf("Youtube: parse error %s\n", ((TiXmlDocument*)list)->ErrorDesc());
			xmlConfigClose(list);
		}
		if (page == 1)interface_hideLoading();
		eprintf("Youtube: Failed to parse video list %d\n", page);
		return -1;
	}
	for ( entry = ((TiXmlNode *)item)->FirstChild(); entry != 0; entry = entry->NextSibling() )
	{
		if (entry->Type() == TiXmlNode::TINYXML_ELEMENT && strcasecmp(entry->Value(), "entry") == 0)
		{
			item = xmlConfigGetElement(entry, "media:group", 0);
			if( item != NULL )
			{
				video_name = (char *)xmlConfigGetText(item, "media:title");
				video_url = NULL;
				thumbnail = NULL;
				for ( child = ((TiXmlNode *)item)->FirstChild();
					child != 0 && (video_url == NULL || thumbnail == NULL);
					child = child->NextSibling() )
				{
					if (child->Type() == TiXmlNode::TINYXML_ELEMENT )
					{
						if(strcasecmp(child->Value(), "media:content") == 0)
						{
							elem = (TiXmlElement *)child;
							video_type = elem->Attribute("type");
							if( strcmp( video_type, "application/x-shockwave-flash" ) == 0)
							{
								video_url = elem->Attribute("url");
							}
						} else if(thumbnail== 0 && strcasecmp(child->Value(), "media:thumbnail") == 0)
						{
							elem = (TiXmlElement *)child;
							thumbnail = elem->Attribute("url");
						}
					}
				}
				if( video_url != NULL )
				{
					//dprintf("%s: Adding Youtube video '%s' url='%s' thumb='%s'\n", __FUNCTION__,video_name,video_url,thumbnail);
					pCallback(video_url,video_name,thumbnail);
				}
			}
		}
	}
	xmlConfigClose(list);
	if (page == 1) interface_hideLoading();
	return ret;
}
Beispiel #29
0
char* curl_http_content(const char *uri ,int flag_cookie)
{
	long timeout = 10800;
	long connect_timeout = 15;
	long low_speed_limit = 1024;
	long low_speed_time = 60;

	struct mem_node *mem_head = NULL;
	long response_code;
	CURL *curl = curl_easy_init();
	curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1); // for thread safe
	curl_easy_setopt(curl, CURLOPT_URL, uri);
	curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, connect_timeout);
	curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);
	curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, low_speed_limit);
	curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, low_speed_time);
	curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
	curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 10L);
	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &curl_read);
	curl_easy_setopt(curl, CURLOPT_WRITEDATA, &mem_head);
	if(flag_cookie)
	{
	 curl_easy_setopt(curl,CURLOPT_COOKIEFILE,"./cookie.txt");
    curl_easy_setopt(curl,CURLOPT_COOKIEJAR,"./cookie.txt");
    }
	CURLcode rc = curl_easy_perform(curl);
	curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
	curl_easy_cleanup(curl);

	if (rc!=CURLE_OK) {
		return NULL;
	}else if (response_code!=200 && response_code!=206){
		struct mem_node *p = mem_head;
		while(p){
			struct mem_node *q = p;
			p = p->next;
			free(q->buffer);
			free(q);
		}
		return NULL;
	}else{
		struct mem_node *p = mem_head;
		size_t size = 0;
		while(p){
			size += p->size;
			p = p->next;
		}
		char *content = (char*)malloc(size+1);
		p = mem_head;
		size = 0;
		while(p){
			memcpy(content+size, p->buffer, p->size);
			size += p->size;
			struct mem_node *q = p;
			p = p->next;
			free(q->buffer);
			free(q);
		}
		content[size] = 0;
		return content;
	}
}
  void* pull_one_url(void *arg_cbget)
  {
    if (!arg_cbget)
      return NULL;

    cbget *arg = static_cast<cbget*>(arg_cbget);

    CURL *curl = NULL;

    if (!arg->_handler)
      {
        curl = curl_easy_init();
        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
        curl_easy_setopt(curl, CURLOPT_MAXREDIRS,5);
        curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0); // do not check on SSL certificate.
      }
    else curl = arg->_handler;

    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, arg->_connect_timeout_sec);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, arg->_transfer_timeout_sec);
    curl_easy_setopt(curl, CURLOPT_URL, arg->_url);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, arg);

    if (!arg->_cookies.empty())
      curl_easy_setopt(curl, CURLOPT_COOKIE, arg->_cookies.c_str());

    if (!arg->_proxy_addr.empty())
      {
        std::string proxy_str = arg->_proxy_addr + ":" + miscutil::to_string(arg->_proxy_port);
        curl_easy_setopt(curl, CURLOPT_PROXY, proxy_str.c_str());
      }

    if (arg->_http_method == "POST") // POST request.
      {
        if (arg->_content)
          {
            curl_easy_setopt(curl, CURLOPT_POST, 1);
            curl_easy_setopt(curl, CURLOPT_POSTFIELDS, (void*)arg->_content->c_str());
            if (arg->_content_size >= 0)
              curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, arg->_content_size);
            /*std::cerr << "curl_mget POST size: " << arg->_content_size << std::endl
              << "content: " << *arg->_content << std::endl;*/
          }
        else curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
      }
    else if (arg->_http_method == "PUT" || arg->_http_method == "DELETE")
      {
        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, arg->_http_method.c_str());
      }

    struct curl_slist *slist=NULL;

    // useful headers.
    if (arg->_headers)
      {
        std::list<const char*>::const_iterator sit = arg->_headers->begin();
        while (sit!=arg->_headers->end())
          {
            slist = curl_slist_append(slist,(*sit));
            ++sit;
          }
        if (arg->_content)
          {
            slist = curl_slist_append(slist,strdup(arg->_content_type.c_str()));
            slist = curl_slist_append(slist,strdup("Expect:"));
          }
      }
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);

    char errorbuffer[CURL_ERROR_SIZE];
    curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &errorbuffer);

    try
      {
        int status = curl_easy_perform(curl);
        if (status != 0)  // an error occurred.
          {
            arg->_status = status;
            errlog::log_error(LOG_LEVEL_ERROR, "curl error on url %s: %s",arg->_url,errorbuffer);

            if (arg->_output)
              {
                delete arg->_output;
                arg->_output = NULL;
              }
          }
      }
    catch (std::exception &e)
      {
        arg->_status = -1;
        errlog::log_error(LOG_LEVEL_ERROR, "Error %s in fetching remote data with curl.", e.what());
        if (arg->_output)
          {
            delete arg->_output;
            arg->_output = NULL;
          }
      }
    catch (...)
      {
        arg->_status = -2;
        if (arg->_output)
          {
            delete arg->_output;
            arg->_output = NULL;
          }
      }

    if (!arg->_handler)
      curl_easy_cleanup(curl);

    if (slist)
      curl_slist_free_all(slist);

    return NULL;
  }