logupload/client/upload.c - vendor/google/platform - Git at Google

 #include <stdlib.h>
 #include <stdio.h>
 #include <math.h>
 #include <string.h>
 #include <unistd.h>
 #include <curl/curl.h>

 #include "upload.h"
 #include "kvextract.h"
 #include "utils.h"

 #define DEVICE_KEY_PATH "/tmp/ssl/private/device.key"
 #define DEVICE_CERT_PATH "/tmp/ssl/certs/device.pem"

 #define FORM_DATA_SPLITTER_PREFIX "foo-splitter-"

 #define CURL_CLEANUP_AND_RETURN \
   if (curl_handle) curl_easy_cleanup(curl_handle); \
   curl_global_cleanup(); \
   return -1

 // Helper macro for setting a curl option and on error logging an error and
 // returning -1. Thanks @drheld
 #define SET_CURL_OPT(curl, option, param) \
   do { \
     CURLcode res = curl_easy_setopt(curl, option, param); \
     if (res != CURLE_OK) { \
       fprintf(stderr, "failed to set curl option %s: %s (%d)\n", \
              #option, curl_easy_strerror(res), res);    \
       if (curl_headers) curl_slist_free_all(curl_headers); \
     } \
   } while (0)

 // If we ever change this to C++ pull in the arraysize macro instead.
 #define ARRAYSIZE(x) (sizeof(x)/sizeof(x[0]))

 struct getdatamem {
   char memory[4096]; // it'll be storing a URL, so this is big enough
   size_t used_size;
 };

 struct postdatamem {
   char content_type[128];
   char *blob;
   char data_prefix[128];
   char data_postfix[64];
   long prefix_offset;
   long prefix_length;
   long postfix_offset;
   long postfix_length;
   long blob_offset;
   long blob_length;
 };

 static size_t my_write_callback(void *contents, size_t size, size_t nmemb,
     void* userp) {
   size_t realsize = size * nmemb;
   struct getdatamem* memp = (struct getdatamem*) userp;
   if (realsize + memp->used_size > sizeof(memp->memory)) {
     fprintf(stderr, "curl sent back more data than fits in our buffer "
         " outsize=%zd usedsize=%zd\n", sizeof(memp->memory), realsize +
         memp->used_size);
     return 0;
   }
   memcpy(&(memp->memory[memp->used_size]), contents, realsize);
   memp->used_size += realsize;
   memp->memory[memp->used_size] = '\0';

   return realsize;
 }

 static size_t my_read_callback(char* buffer, size_t size, size_t nitems,
     void *instream) {
   size_t realsize = size * nitems;
   size_t xfer_size;
   struct postdatamem *postdata = (struct postdatamem*) instream;
   if (postdata->prefix_offset < postdata->prefix_length) {
     xfer_size = postdata->prefix_length - postdata->prefix_offset;
     if (xfer_size > realsize)
       xfer_size = realsize;
     memcpy(buffer, &(postdata->data_prefix[postdata->prefix_offset]),
         xfer_size);
     postdata->prefix_offset += xfer_size;
     realsize -= xfer_size;
     buffer = buffer + xfer_size;
   }
   if (realsize > 0 && postdata->blob_offset < postdata->blob_length) {
     xfer_size = postdata->blob_length - postdata->blob_offset;
     if (xfer_size > realsize)
       xfer_size = realsize;
     memcpy(buffer, &(postdata->blob[postdata->blob_offset]), xfer_size);
     postdata->blob_offset += xfer_size;
     realsize -= xfer_size;
     buffer = buffer + xfer_size;
   }
   if (realsize > 0 && postdata->postfix_offset < postdata->postfix_length) {
     xfer_size = postdata->postfix_length - postdata->postfix_offset;
     if (xfer_size > realsize)
       xfer_size = realsize;
     memcpy(buffer, &(postdata->data_postfix[postdata->postfix_offset]),
         xfer_size);
     postdata->postfix_offset += xfer_size;
     realsize -= xfer_size;
   }
   return (size * nitems) - realsize;
 }

 static int do_request_via_ipv(CURL *curl_handle, const char *server_url,
     struct getdatamem *getdata, struct postdatamem *postdata,
     int ipv, long *http_code) {
   struct curl_slist* curl_headers = NULL;
   struct curl_slist* new_headers = NULL;
   curl_easy_reset(curl_handle);
   SET_CURL_OPT(curl_handle, CURLOPT_URL, server_url);
   SET_CURL_OPT(curl_handle, CURLOPT_USERAGENT, "upload-logs");
   SET_CURL_OPT(curl_handle, CURLOPT_IPRESOLVE, ipv);
   SET_CURL_OPT(curl_handle, CURLOPT_FOLLOWLOCATION, 0L);
   SET_CURL_OPT(curl_handle, CURLOPT_SSL_VERIFYPEER, 1L);
   SET_CURL_OPT(curl_handle, CURLOPT_SSL_VERIFYHOST, 2L);
   SET_CURL_OPT(curl_handle, CURLOPT_TIMEOUT, 60L);
   if (path_exists(DEVICE_KEY_PATH))
     SET_CURL_OPT(curl_handle, CURLOPT_SSLKEY, DEVICE_KEY_PATH);
   if (path_exists(DEVICE_CERT_PATH))
     SET_CURL_OPT(curl_handle, CURLOPT_SSLCERT, DEVICE_CERT_PATH);

   // Log upload server doesn't like Expect: 100-continue
   // so remove that.
   new_headers = curl_slist_append(curl_headers, "Expect:");
   if (!new_headers) {
     fprintf(stderr, "failed setting up curl headers\n");
     return -1;
   } else
     curl_headers = new_headers;

   if (getdata) {
     SET_CURL_OPT(curl_handle, CURLOPT_HTTPGET, 1L);
     SET_CURL_OPT(curl_handle, CURLOPT_WRITEFUNCTION, my_write_callback);
     SET_CURL_OPT(curl_handle, CURLOPT_WRITEDATA, (void *)getdata);
   } else {
     SET_CURL_OPT(curl_handle, CURLOPT_POST, 1L);
     SET_CURL_OPT(curl_handle, CURLOPT_READFUNCTION, my_read_callback);
     SET_CURL_OPT(curl_handle, CURLOPT_READDATA, (void *)postdata);
     SET_CURL_OPT(curl_handle, CURLOPT_POSTFIELDSIZE,
         postdata->prefix_length + postdata->blob_length +
         postdata->postfix_length);
     new_headers = curl_slist_append(curl_headers, postdata->content_type);
     if (!new_headers) {
       fprintf(stderr, "failed setting up curl headers\n");
       curl_slist_free_all(curl_headers);
       return -1;
     } else
       curl_headers = new_headers;
     // If this is a retry we need to reset these values.
     postdata->prefix_offset = 0;
     postdata->blob_offset = 0;
     postdata->postfix_offset = 0;
   }
   SET_CURL_OPT(curl_handle, CURLOPT_HTTPHEADER, curl_headers);
   CURLcode curl_res = curl_easy_perform(curl_handle);
   curl_slist_free_all(curl_headers);
   curl_headers = NULL;
   *http_code = 500;
   curl_easy_getinfo(curl_handle, CURLINFO_RESPONSE_CODE, http_code);
   if (curl_res != CURLE_OK) {
     *http_code = 599;
     fprintf(stderr, "request failed: %s (%d)\n", curl_easy_strerror(curl_res),
         curl_res);
     return -1;
   } else {
     if (*http_code == 200) {
       if (getdata) {
         // Success for the GET case.
         return 0;
       } else {
         // This should not happen for POST, so it's failure.
         fprintf(stderr, "received a 200 response for a POST request\n");
         return -1;
       }
     } else if (*http_code == 302 && postdata) {
       // 302 is success for the post case.
       return 0;
     } else {
       // Failure due to some other HTTP error.
       return -1;
     }
   }
 }

 int upload_file(const char *server_url, const char* target_name, char* data,
     ssize_t len, struct kvpair* kvpairs_save) {
   char url[2048];
   CURL *curl_handle = NULL;
   int timeval;
   struct getdatamem getdata;
   int i, rv = -1;
   int resolvers[2] = { CURL_IPRESOLVE_V6, CURL_IPRESOLVE_V4 };
   const char *resolvers_str[2] = { "IPv6", "IPv4" };

   memset(url, 0, sizeof(url));
   memset(&getdata, 0, sizeof(getdata));
   struct postdatamem postdata;
   memset(&postdata, 0, sizeof(postdata));
   // Strip any leading slashes from the target name
   while (target_name[0] == '/') {
     target_name++;
   }

   // Setup curl
   if (curl_global_init(CURL_GLOBAL_ALL)) {
     fprintf(stderr, "failed with curl_global_init\n");
     return -1;
   }

   for (i=0; i < (int)ARRAYSIZE(resolvers); ++i) {
     long http_code;
     struct kvpair* kvpairs = kvpairs_save;

     curl_handle = curl_easy_init();
     if (!curl_handle) {
       curl_global_cleanup();
       fprintf(stderr, "failed initializing curl\n");
       return -1;
     }

     // Construct the full URL
     snprintf(url, sizeof(url), "%s/upload/%s%s", server_url, target_name,
              (kvpairs != NULL) ? "?" : "");
     while (kvpairs != NULL) {
       // Now add the URL parameters
       size_t lim;
       char *url_end;

       char* encoded_key = curl_easy_escape(curl_handle, kvpairs->key, 0);
       if (!encoded_key) {
         fprintf(stderr, "failure in curl_easy_escape\n");
         CURL_CLEANUP_AND_RETURN;
       }

       char *encoded_value = curl_easy_escape(curl_handle, kvpairs->value, 0);
       if (!encoded_value) {
         fprintf(stderr, "failure in curl_easy_escape\n");
         CURL_CLEANUP_AND_RETURN;
       }

       url_end = url + strlen(url);
       lim = sizeof(url) - strlen(url);
       snprintf(url_end, lim, "%s=%s%s", encoded_key, encoded_value,
                (kvpairs->next_pair != NULL) ? "&" : "");

       curl_free(encoded_key);
       curl_free(encoded_value);
       kvpairs = kvpairs->next_pair;
     }

     http_code = 0;
     rv = do_request_via_ipv(curl_handle, url, &getdata, NULL, resolvers[i],
         &http_code);
     if (rv) {
       fprintf(stderr, "Curl failed in GET %s\n", resolvers_str[i]);
       curl_easy_cleanup(curl_handle);
       curl_handle = NULL;
       continue;
     }

     timeval = (int) time(NULL);
     snprintf(postdata.content_type, sizeof(postdata.content_type),
              "Content-Type: multipart/form-data; boundary=%s-%d",
              FORM_DATA_SPLITTER_PREFIX, timeval);
     snprintf(postdata.data_prefix, sizeof(postdata.data_prefix),
              "--%s-%d\r\n"
              "Content-Disposition: form-data; name=\"file\"; "
              "filename=\"%s\"\r\n\r\n",
              FORM_DATA_SPLITTER_PREFIX, timeval, target_name);
     postdata.prefix_length = strlen(postdata.data_prefix);
     snprintf(postdata.data_postfix, sizeof(postdata.data_postfix),
              "\r\n--%s-%d--\r\n\r\n", FORM_DATA_SPLITTER_PREFIX, timeval);
     postdata.postfix_length = strlen(postdata.data_postfix);
     postdata.blob = data;
     postdata.blob_length = len;

     http_code = 0;
     rv = do_request_via_ipv(curl_handle, getdata.memory, NULL, &postdata,
         resolvers[i], &http_code);
     if (rv) {
       curl_easy_cleanup(curl_handle);
       fprintf(stderr, "curl failed with %s http error: %ld\n",
               resolvers_str[i], http_code);
       curl_handle = NULL;
       continue;
     }

     // If we get here, that means the GET and POST both succeeded.
     break;
   }

   if (curl_handle)
     curl_easy_cleanup(curl_handle);
   curl_global_cleanup();
   return rv;
 }
	#include <stdlib.h>
	#include <stdio.h>
	#include <math.h>
	#include <string.h>
	#include <unistd.h>
	#include <curl/curl.h>

	#include "upload.h"
	#include "kvextract.h"
	#include "utils.h"

	#define DEVICE_KEY_PATH "/tmp/ssl/private/device.key"
	#define DEVICE_CERT_PATH "/tmp/ssl/certs/device.pem"

	#define FORM_DATA_SPLITTER_PREFIX "foo-splitter-"

	#define CURL_CLEANUP_AND_RETURN \
	if (curl_handle) curl_easy_cleanup(curl_handle); \
	curl_global_cleanup(); \
	return -1

	// Helper macro for setting a curl option and on error logging an error and
	// returning -1. Thanks @drheld
	#define SET_CURL_OPT(curl, option, param) \
	do { \
	CURLcode res = curl_easy_setopt(curl, option, param); \
	if (res != CURLE_OK) { \
	fprintf(stderr, "failed to set curl option %s: %s (%d)\n", \
	#option, curl_easy_strerror(res), res); \
	if (curl_headers) curl_slist_free_all(curl_headers); \
	} \
	} while (0)

	// If we ever change this to C++ pull in the arraysize macro instead.
	#define ARRAYSIZE(x) (sizeof(x)/sizeof(x[0]))

	struct getdatamem {
	char memory[4096]; // it'll be storing a URL, so this is big enough
	size_t used_size;
	};

	struct postdatamem {
	char content_type[128];
	char *blob;
	char data_prefix[128];
	char data_postfix[64];
	long prefix_offset;
	long prefix_length;
	long postfix_offset;
	long postfix_length;
	long blob_offset;
	long blob_length;
	};

	static size_t my_write_callback(void *contents, size_t size, size_t nmemb,
	void* userp) {
	size_t realsize = size * nmemb;
	struct getdatamem* memp = (struct getdatamem*) userp;
	if (realsize + memp->used_size > sizeof(memp->memory)) {
	fprintf(stderr, "curl sent back more data than fits in our buffer "
	" outsize=%zd usedsize=%zd\n", sizeof(memp->memory), realsize +
	memp->used_size);
	return 0;
	}
	memcpy(&(memp->memory[memp->used_size]), contents, realsize);
	memp->used_size += realsize;
	memp->memory[memp->used_size] = '\0';

	return realsize;
	}

	static size_t my_read_callback(char* buffer, size_t size, size_t nitems,
	void *instream) {
	size_t realsize = size * nitems;
	size_t xfer_size;
	struct postdatamem postdata = (struct postdatamem) instream;
	if (postdata->prefix_offset < postdata->prefix_length) {
	xfer_size = postdata->prefix_length - postdata->prefix_offset;
	if (xfer_size > realsize)
	xfer_size = realsize;
	memcpy(buffer, &(postdata->data_prefix[postdata->prefix_offset]),
	xfer_size);
	postdata->prefix_offset += xfer_size;
	realsize -= xfer_size;
	buffer = buffer + xfer_size;
	}
	if (realsize > 0 && postdata->blob_offset < postdata->blob_length) {
	xfer_size = postdata->blob_length - postdata->blob_offset;
	if (xfer_size > realsize)
	xfer_size = realsize;
	memcpy(buffer, &(postdata->blob[postdata->blob_offset]), xfer_size);
	postdata->blob_offset += xfer_size;
	realsize -= xfer_size;
	buffer = buffer + xfer_size;
	}
	if (realsize > 0 && postdata->postfix_offset < postdata->postfix_length) {
	xfer_size = postdata->postfix_length - postdata->postfix_offset;
	if (xfer_size > realsize)
	xfer_size = realsize;
	memcpy(buffer, &(postdata->data_postfix[postdata->postfix_offset]),
	xfer_size);
	postdata->postfix_offset += xfer_size;
	realsize -= xfer_size;
	}
	return (size * nitems) - realsize;
	}

	static int do_request_via_ipv(CURL curl_handle, const char server_url,
	struct getdatamem getdata, struct postdatamem postdata,
	int ipv, long *http_code) {
	struct curl_slist* curl_headers = NULL;
	struct curl_slist* new_headers = NULL;
	curl_easy_reset(curl_handle);
	SET_CURL_OPT(curl_handle, CURLOPT_URL, server_url);
	SET_CURL_OPT(curl_handle, CURLOPT_USERAGENT, "upload-logs");
	SET_CURL_OPT(curl_handle, CURLOPT_IPRESOLVE, ipv);
	SET_CURL_OPT(curl_handle, CURLOPT_FOLLOWLOCATION, 0L);
	SET_CURL_OPT(curl_handle, CURLOPT_SSL_VERIFYPEER, 1L);
	SET_CURL_OPT(curl_handle, CURLOPT_SSL_VERIFYHOST, 2L);
	SET_CURL_OPT(curl_handle, CURLOPT_TIMEOUT, 60L);
	if (path_exists(DEVICE_KEY_PATH))
	SET_CURL_OPT(curl_handle, CURLOPT_SSLKEY, DEVICE_KEY_PATH);
	if (path_exists(DEVICE_CERT_PATH))
	SET_CURL_OPT(curl_handle, CURLOPT_SSLCERT, DEVICE_CERT_PATH);

	// Log upload server doesn't like Expect: 100-continue
	// so remove that.
	new_headers = curl_slist_append(curl_headers, "Expect:");
	if (!new_headers) {
	fprintf(stderr, "failed setting up curl headers\n");
	return -1;
	} else
	curl_headers = new_headers;

	if (getdata) {
	SET_CURL_OPT(curl_handle, CURLOPT_HTTPGET, 1L);
	SET_CURL_OPT(curl_handle, CURLOPT_WRITEFUNCTION, my_write_callback);
	SET_CURL_OPT(curl_handle, CURLOPT_WRITEDATA, (void *)getdata);
	} else {
	SET_CURL_OPT(curl_handle, CURLOPT_POST, 1L);
	SET_CURL_OPT(curl_handle, CURLOPT_READFUNCTION, my_read_callback);
	SET_CURL_OPT(curl_handle, CURLOPT_READDATA, (void *)postdata);
	SET_CURL_OPT(curl_handle, CURLOPT_POSTFIELDSIZE,
	postdata->prefix_length + postdata->blob_length +
	postdata->postfix_length);
	new_headers = curl_slist_append(curl_headers, postdata->content_type);
	if (!new_headers) {
	fprintf(stderr, "failed setting up curl headers\n");
	curl_slist_free_all(curl_headers);
	return -1;
	} else
	curl_headers = new_headers;
	// If this is a retry we need to reset these values.
	postdata->prefix_offset = 0;
	postdata->blob_offset = 0;
	postdata->postfix_offset = 0;
	}
	SET_CURL_OPT(curl_handle, CURLOPT_HTTPHEADER, curl_headers);
	CURLcode curl_res = curl_easy_perform(curl_handle);
	curl_slist_free_all(curl_headers);
	curl_headers = NULL;
	*http_code = 500;
	curl_easy_getinfo(curl_handle, CURLINFO_RESPONSE_CODE, http_code);
	if (curl_res != CURLE_OK) {
	*http_code = 599;
	fprintf(stderr, "request failed: %s (%d)\n", curl_easy_strerror(curl_res),
	curl_res);
	return -1;
	} else {
	if (*http_code == 200) {
	if (getdata) {
	// Success for the GET case.
	return 0;
	} else {
	// This should not happen for POST, so it's failure.
	fprintf(stderr, "received a 200 response for a POST request\n");
	return -1;
	}
	} else if (*http_code == 302 && postdata) {
	// 302 is success for the post case.
	return 0;
	} else {
	// Failure due to some other HTTP error.
	return -1;
	}
	}
	}

	int upload_file(const char server_url, const char target_name, char* data,
	ssize_t len, struct kvpair* kvpairs_save) {
	char url[2048];
	CURL *curl_handle = NULL;
	int timeval;
	struct getdatamem getdata;
	int i, rv = -1;
	int resolvers[2] = { CURL_IPRESOLVE_V6, CURL_IPRESOLVE_V4 };
	const char *resolvers_str[2] = { "IPv6", "IPv4" };

	memset(url, 0, sizeof(url));
	memset(&getdata, 0, sizeof(getdata));
	struct postdatamem postdata;
	memset(&postdata, 0, sizeof(postdata));
	// Strip any leading slashes from the target name
	while (target_name[0] == '/') {
	target_name++;
	}

	// Setup curl
	if (curl_global_init(CURL_GLOBAL_ALL)) {
	fprintf(stderr, "failed with curl_global_init\n");
	return -1;
	}

	for (i=0; i < (int)ARRAYSIZE(resolvers); ++i) {
	long http_code;
	struct kvpair* kvpairs = kvpairs_save;

	curl_handle = curl_easy_init();
	if (!curl_handle) {
	curl_global_cleanup();
	fprintf(stderr, "failed initializing curl\n");
	return -1;
	}

	// Construct the full URL
	snprintf(url, sizeof(url), "%s/upload/%s%s", server_url, target_name,
	(kvpairs != NULL) ? "?" : "");
	while (kvpairs != NULL) {
	// Now add the URL parameters
	size_t lim;
	char *url_end;

	char* encoded_key = curl_easy_escape(curl_handle, kvpairs->key, 0);
	if (!encoded_key) {
	fprintf(stderr, "failure in curl_easy_escape\n");
	CURL_CLEANUP_AND_RETURN;
	}

	char *encoded_value = curl_easy_escape(curl_handle, kvpairs->value, 0);
	if (!encoded_value) {
	fprintf(stderr, "failure in curl_easy_escape\n");
	CURL_CLEANUP_AND_RETURN;
	}

	url_end = url + strlen(url);
	lim = sizeof(url) - strlen(url);
	snprintf(url_end, lim, "%s=%s%s", encoded_key, encoded_value,
	(kvpairs->next_pair != NULL) ? "&" : "");

	curl_free(encoded_key);
	curl_free(encoded_value);
	kvpairs = kvpairs->next_pair;
	}

	http_code = 0;
	rv = do_request_via_ipv(curl_handle, url, &getdata, NULL, resolvers[i],
	&http_code);
	if (rv) {
	fprintf(stderr, "Curl failed in GET %s\n", resolvers_str[i]);
	curl_easy_cleanup(curl_handle);
	curl_handle = NULL;
	continue;
	}

	timeval = (int) time(NULL);
	snprintf(postdata.content_type, sizeof(postdata.content_type),
	"Content-Type: multipart/form-data; boundary=%s-%d",
	FORM_DATA_SPLITTER_PREFIX, timeval);
	snprintf(postdata.data_prefix, sizeof(postdata.data_prefix),
	"--%s-%d\r\n"
	"Content-Disposition: form-data; name=\"file\"; "
	"filename=\"%s\"\r\n\r\n",
	FORM_DATA_SPLITTER_PREFIX, timeval, target_name);
	postdata.prefix_length = strlen(postdata.data_prefix);
	snprintf(postdata.data_postfix, sizeof(postdata.data_postfix),
	"\r\n--%s-%d--\r\n\r\n", FORM_DATA_SPLITTER_PREFIX, timeval);
	postdata.postfix_length = strlen(postdata.data_postfix);
	postdata.blob = data;
	postdata.blob_length = len;

	http_code = 0;
	rv = do_request_via_ipv(curl_handle, getdata.memory, NULL, &postdata,
	resolvers[i], &http_code);
	if (rv) {
	curl_easy_cleanup(curl_handle);
	fprintf(stderr, "curl failed with %s http error: %ld\n",
	resolvers_str[i], http_code);
	curl_handle = NULL;
	continue;
	}

	// If we get here, that means the GET and POST both succeeded.
	break;
	}

	if (curl_handle)
	curl_easy_cleanup(curl_handle);
	curl_global_cleanup();
	return rv;
	}