gpcontrib/gpcloud/lib/ini.cpp - cloudberry - Git at Google

 /**
  * Copyright (c) 2015 rxi
  *
  * This library is free software; you can redistribute it and/or modify it
  * under the terms of the MIT license. See LICENSE for details.
  */

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 #include <curl/curl.h>

 #include "ini.h"

 struct ini_t {
   char *data;
   char *end;
 };

 /* Case insensitive string compare */
 int strcmpci(const char *a, const char *b) {
   for (;;) {
     int d = tolower(*a) - tolower(*b);
     if (d != 0 || !*a) {
       return d;
     }
     a++, b++;
   }
 }

 /* Returns the next string in the split data */
 static char* next(ini_t *ini, char *p) {
   p += strlen(p);
   while (p < ini->end && *p == '\0') {
     p++;
   }
   return p;
 }

 static void trim_back(ini_t *ini, char *p) {
   while (p >= ini->data && (*p == ' ' || *p == '\t' || *p == '\r')) {
     *p-- = '\0';
   }
 }

 static char* discard_line(ini_t *ini, char *p) {
   while (p < ini->end && *p != '\n') {
     *p++ = '\0';
   }
   return p;
 }

 static char *unescape_quoted_value(ini_t *ini, char *p) {
   /* Use `q` as write-head and `p` as read-head, `p` is always ahead of `q`
    * as escape sequences are always larger than their resultant data */
   char *q = p;
   p++;
   while (p < ini->end && *p != '"' && *p != '\r' && *p != '\n') {
     if (*p == '\\') {
       /* Handle escaped char */
       p++;
       switch (*p) {
         default   : *q = *p;    break;
         case 'r'  : *q = '\r';  break;
         case 'n'  : *q = '\n';  break;
         case 't'  : *q = '\t';  break;
         case '\r' :
         case '\n' :
         case '\0' : goto end;
       }

     } else {
       /* Handle normal char */
       *q = *p;
     }
     q++, p++;
   }
 end:
   return q;
 }

 /* Splits data in place into strings containing section-headers, keys and
  * values using one or more '\0' as a delimiter. Unescapes quoted values */
 static void split_data(ini_t *ini) {
   char *value_start, *line_start;
   char *p = ini->data;

   while (p < ini->end) {
     switch (*p) {
       case '\r':
       case '\n':
       case '\t':
       case ' ':
         *p = '\0';
         /* Fall through */

       case '\0':
         p++;
         break;

       case '[':
         p += strcspn(p, "]\n");
         *p = '\0';
         break;

       case ';':
         p = discard_line(ini, p);
         break;

       default:
         line_start = p;
         p += strcspn(p, "=\n");

         /* Is line missing a '='? */
         if (*p != '=') {
           p = discard_line(ini, line_start);
           break;
         }
         trim_back(ini, p - 1);

         /* Replace '=' and whitespace after it with '\0' */
         do {
           *p++ = '\0';
         } while (*p == ' ' || *p == '\r' || *p == '\t');

         /* Is a value after '=' missing? */
         if (*p == '\n' || *p == '\0') {
           p = discard_line(ini, line_start);
           break;
         }

         if (*p == '"') {
           /* Handle quoted string value */
           value_start = p;
           p = unescape_quoted_value(ini, p);

           /* Was the string empty? */
           if (p == value_start) {
             p = discard_line(ini, line_start);
             break;
           }

           /* Discard the rest of the line after the string value */
           p = discard_line(ini, p);

         } else {
           /* Handle normal value */
           p += strcspn(p, "\n");
           trim_back(ini, p - 1);
         }
         break;
     }
   }
 }

 #define S3MAXPGPATH 1024
 const static int extssl_protocol  = CURL_SSLVERSION_TLSv1;
 static const char* extssl_cert = "gpfdists/client.crt";
 static const char* extssl_key = "gpfdists/client.key";
 static const char* extssl_ca = "gpfdists/root.crt";
 #define INICURL_EASY_SETOPT(h, opt, val) \
     do { \
         int			e; \
         if ((e = curl_easy_setopt(h, opt, val)) != CURLE_OK){  \
             curl_easy_cleanup(curl);  \
             return NULL; \
         } \
     } while(0)

 static CURL *create_curl_from_url(const char *url, const char *datadir) {
     char extssl_key_full[S3MAXPGPATH] = {0};
     char extssl_cer_full[S3MAXPGPATH] = {0};
     char extssl_cas_full[S3MAXPGPATH] = {0};
     CURL *curl = NULL;

     curl = curl_easy_init();
     INICURL_EASY_SETOPT(curl, CURLOPT_URL, url);
     // Add https support
     if (strncmp(url, "https", 5) == 0) {
         snprintf(extssl_cer_full, S3MAXPGPATH, "%s/%s", datadir, extssl_cert);
         /* set the cert for client authentication */
         INICURL_EASY_SETOPT(curl, CURLOPT_SSLCERT, extssl_cer_full);
         INICURL_EASY_SETOPT(curl, CURLOPT_SSLKEYTYPE,"PEM");
         snprintf(extssl_key_full, S3MAXPGPATH, "%s/%s", datadir, extssl_key);
         /* set the private key (file or ID in engine) */
         INICURL_EASY_SETOPT(curl, CURLOPT_SSLKEY, extssl_key_full);
         snprintf(extssl_cas_full, S3MAXPGPATH, "%s/%s", datadir, extssl_ca);
         /* set the file with the CA certificates, for validating the server */
         INICURL_EASY_SETOPT(curl, CURLOPT_CAINFO, extssl_cas_full);
         /* set cert verification */
         INICURL_EASY_SETOPT(curl, CURLOPT_SSL_VERIFYPEER, 1);
         /* set host verification */
         INICURL_EASY_SETOPT(curl, CURLOPT_SSL_VERIFYHOST, 2);
         /* set protocol */
         INICURL_EASY_SETOPT(curl, CURLOPT_SSLVERSION, extssl_protocol);
     }
     return curl;
 }
 static size_t
 get_s3_param(char *buffer, size_t size, size_t nitems, void *userp)
 {
     ini_t *ini = (ini_t *)userp;
     int nbytes = size * nitems;
     ini->data = (char*) malloc(nbytes+1);
     if (ini->data == NULL) {
         return 0;
     }
     ini->data[nbytes] = '\0';
     ini->end = ini->data  + nbytes;
     memcpy(ini->data, buffer, nbytes);

     return nbytes;
 }
 ini_t* ini_load_from_url(const char *url, const char *datadir) {
     ini_t *ini = NULL;
     CURL *curl = NULL;
     curl_slist *headers = NULL;
     CURLcode e;

     curl_global_init(CURL_GLOBAL_ALL);
     /* Init ini struct */
     ini = (ini_t*) malloc(sizeof(*ini));
     if (!ini) {
         goto fail;
     }
     memset(ini, 0, sizeof(*ini));
     /* Curl param */
     curl = create_curl_from_url(url, datadir);
     if (curl == NULL) {
         goto fail;
     }
     // Add header "S3_Param_Req"
     headers = curl_slist_append(NULL, "S3_Param_Req: true");
     if (headers == NULL) {
         goto fail;
     }
     curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, get_s3_param);
     curl_easy_setopt(curl, CURLOPT_WRITEDATA, ini);
     /* Load file content into memory, null terminate, init end var */
     e = curl_easy_perform(curl);
     if (e != CURLE_OK) {
         goto fail;
     }
     /* Prepare data */
     split_data(ini);
     /* Clean up and return */
     curl_slist_free_all(headers);
     curl_easy_cleanup(curl);
     curl_global_cleanup();
     return ini;

 fail:
     if (ini) ini_free(ini);
     curl_slist_free_all(headers);
     curl_easy_cleanup(curl);
     curl_global_cleanup();
     return NULL;
 }

 ini_t* ini_load(const char *filename) {
   ini_t *ini = NULL;
   FILE *fp = NULL;
   int n, sz;

   /* Init ini struct */
   ini = (ini_t*) malloc(sizeof(*ini));
   if (!ini) {
     goto fail;
   }
   memset(ini, 0, sizeof(*ini));

   /* Open file */
   fp = fopen(filename, "rb");
   if (!fp) {
     goto fail;
   }

   /* Get file size */
   fseek(fp, 0, SEEK_END);
   sz = ftell(fp);
   if(sz < 0) {
       goto fail;
   }
   rewind(fp);

   /* Load file content into memory, null terminate, init end var */
   ini->data = (char*) malloc(sz + 1);
   ini->data[sz] = '\0';
   ini->end = ini->data  + sz;
   n = fread(ini->data, 1, sz, fp);
   if (n != sz) {
     goto fail;
   }

   /* Prepare data */
   split_data(ini);

   /* Clean up and return */
   fclose(fp);
   return ini;

 fail:
   if (fp) fclose(fp);
   if (ini) ini_free(ini);
   return NULL;
 }

 void ini_free(ini_t *ini) {
   free(ini->data);
   free(ini);
 }

 bool ini_section_exist(ini_t *ini, const char *section) {
   char *p = ini->data;
   while (p < ini->end) {
     if (*p == '[') {
       /* Handle section */
       char* current_section = p + 1;
       if (!section || !strcmpci(section, current_section)) {
         return true;
       }
     }
     p = next(ini, p);
   }

   return false;
 }

 const char* ini_get(ini_t *ini, const char *section, const char *key) {
   const char *current_section = "";
   char *val;
   char *p = ini->data;

   if (*p == '\0') {
     p = next(ini, p);
   }

   while (p < ini->end) {
     if (*p == '[') {
       /* Handle section */
       current_section = p + 1;

     } else {
       /* Handle key */
       val = next(ini, p);
       if (!section || !strcmpci(section, current_section)) {
         if (!strcmpci(p, key)) {
           return val;
         }
       }
       p = val;
     }

     p = next(ini, p);
   }

   return NULL;
 }

 int ini_sget(
   ini_t *ini, const char *section, const char *value,
   const char *scanfmt, void *dst
 ) {
   const char *val = ini_get(ini, section, value);
   if (!val) {
     return 0;
   }
   if (scanfmt) {
     sscanf(val, scanfmt, dst);
   } else {
     *((const char**) dst) = val;
   }
   return 1;
 }
	/**
	* Copyright (c) 2015 rxi
	*
	* This library is free software; you can redistribute it and/or modify it
	* under the terms of the MIT license. See LICENSE for details.
	*/

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <ctype.h>
	#include <curl/curl.h>

	#include "ini.h"

	struct ini_t {
	char *data;
	char *end;
	};

	/* Case insensitive string compare */
	int strcmpci(const char a, const char b) {
	for (;;) {
	int d = tolower(a) - tolower(b);
	if (d != 0 \|\| !*a) {
	return d;
	}
	a++, b++;
	}
	}

	/* Returns the next string in the split data */
	static char* next(ini_t ini, char p) {
	p += strlen(p);
	while (p < ini->end && *p == '\0') {
	p++;
	}
	return p;
	}

	static void trim_back(ini_t ini, char p) {
	while (p >= ini->data && (p == ' ' \|\| p == '\t' \|\| *p == '\r')) {
	*p-- = '\0';
	}
	}

	static char* discard_line(ini_t ini, char p) {
	while (p < ini->end && *p != '\n') {
	*p++ = '\0';
	}
	return p;
	}

	static char unescape_quoted_value(ini_t ini, char *p) {
	/* Use `q` as write-head and `p` as read-head, `p` is always ahead of `q`
	* as escape sequences are always larger than their resultant data */
	char *q = p;
	p++;
	while (p < ini->end && p != '"' && p != '\r' && *p != '\n') {
	if (*p == '\\') {
	/* Handle escaped char */
	p++;
	switch (*p) {
	default : q = p; break;
	case 'r' : *q = '\r'; break;
	case 'n' : *q = '\n'; break;
	case 't' : *q = '\t'; break;
	case '\r' :
	case '\n' :
	case '\0' : goto end;
	}

	} else {
	/* Handle normal char */
	q = p;
	}
	q++, p++;
	}
	end:
	return q;
	}

	/* Splits data in place into strings containing section-headers, keys and
	* values using one or more '\0' as a delimiter. Unescapes quoted values */
	static void split_data(ini_t *ini) {
	char value_start, line_start;
	char *p = ini->data;

	while (p < ini->end) {
	switch (*p) {
	case '\r':
	case '\n':
	case '\t':
	case ' ':
	*p = '\0';
	/* Fall through */

	case '\0':
	p++;
	break;

	case '[':
	p += strcspn(p, "]\n");
	*p = '\0';
	break;

	case ';':
	p = discard_line(ini, p);
	break;

	default:
	line_start = p;
	p += strcspn(p, "=\n");

	/* Is line missing a '='? */
	if (*p != '=') {
	p = discard_line(ini, line_start);
	break;
	}
	trim_back(ini, p - 1);

	/* Replace '=' and whitespace after it with '\0' */
	do {
	*p++ = '\0';
	} while (p == ' ' \|\| p == '\r' \|\| *p == '\t');

	/* Is a value after '=' missing? */
	if (p == '\n' \|\| p == '\0') {
	p = discard_line(ini, line_start);
	break;
	}

	if (*p == '"') {
	/* Handle quoted string value */
	value_start = p;
	p = unescape_quoted_value(ini, p);

	/* Was the string empty? */
	if (p == value_start) {
	p = discard_line(ini, line_start);
	break;
	}

	/* Discard the rest of the line after the string value */
	p = discard_line(ini, p);

	} else {
	/* Handle normal value */
	p += strcspn(p, "\n");
	trim_back(ini, p - 1);
	}
	break;
	}
	}
	}

	#define S3MAXPGPATH 1024
	const static int extssl_protocol = CURL_SSLVERSION_TLSv1;
	static const char* extssl_cert = "gpfdists/client.crt";
	static const char* extssl_key = "gpfdists/client.key";
	static const char* extssl_ca = "gpfdists/root.crt";
	#define INICURL_EASY_SETOPT(h, opt, val) \
	do { \
	int e; \
	if ((e = curl_easy_setopt(h, opt, val)) != CURLE_OK){ \
	curl_easy_cleanup(curl); \
	return NULL; \
	} \
	} while(0)

	static CURL create_curl_from_url(const char url, const char *datadir) {
	char extssl_key_full[S3MAXPGPATH] = {0};
	char extssl_cer_full[S3MAXPGPATH] = {0};
	char extssl_cas_full[S3MAXPGPATH] = {0};
	CURL *curl = NULL;

	curl = curl_easy_init();
	INICURL_EASY_SETOPT(curl, CURLOPT_URL, url);
	// Add https support
	if (strncmp(url, "https", 5) == 0) {
	snprintf(extssl_cer_full, S3MAXPGPATH, "%s/%s", datadir, extssl_cert);
	/* set the cert for client authentication */
	INICURL_EASY_SETOPT(curl, CURLOPT_SSLCERT, extssl_cer_full);
	INICURL_EASY_SETOPT(curl, CURLOPT_SSLKEYTYPE,"PEM");
	snprintf(extssl_key_full, S3MAXPGPATH, "%s/%s", datadir, extssl_key);
	/* set the private key (file or ID in engine) */
	INICURL_EASY_SETOPT(curl, CURLOPT_SSLKEY, extssl_key_full);
	snprintf(extssl_cas_full, S3MAXPGPATH, "%s/%s", datadir, extssl_ca);
	/* set the file with the CA certificates, for validating the server */
	INICURL_EASY_SETOPT(curl, CURLOPT_CAINFO, extssl_cas_full);
	/* set cert verification */
	INICURL_EASY_SETOPT(curl, CURLOPT_SSL_VERIFYPEER, 1);
	/* set host verification */
	INICURL_EASY_SETOPT(curl, CURLOPT_SSL_VERIFYHOST, 2);
	/* set protocol */
	INICURL_EASY_SETOPT(curl, CURLOPT_SSLVERSION, extssl_protocol);
	}
	return curl;
	}
	static size_t
	get_s3_param(char buffer, size_t size, size_t nitems, void userp)
	{
	ini_t ini = (ini_t )userp;
	int nbytes = size * nitems;
	ini->data = (char*) malloc(nbytes+1);
	if (ini->data == NULL) {
	return 0;
	}
	ini->data[nbytes] = '\0';
	ini->end = ini->data + nbytes;
	memcpy(ini->data, buffer, nbytes);

	return nbytes;
	}
	ini_t* ini_load_from_url(const char url, const char datadir) {
	ini_t *ini = NULL;
	CURL *curl = NULL;
	curl_slist *headers = NULL;
	CURLcode e;

	curl_global_init(CURL_GLOBAL_ALL);
	/* Init ini struct */
	ini = (ini_t) malloc(sizeof(ini));
	if (!ini) {
	goto fail;
	}
	memset(ini, 0, sizeof(*ini));
	/* Curl param */
	curl = create_curl_from_url(url, datadir);
	if (curl == NULL) {
	goto fail;
	}
	// Add header "S3_Param_Req"
	headers = curl_slist_append(NULL, "S3_Param_Req: true");
	if (headers == NULL) {
	goto fail;
	}
	curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, get_s3_param);
	curl_easy_setopt(curl, CURLOPT_WRITEDATA, ini);
	/* Load file content into memory, null terminate, init end var */
	e = curl_easy_perform(curl);
	if (e != CURLE_OK) {
	goto fail;
	}
	/* Prepare data */
	split_data(ini);
	/* Clean up and return */
	curl_slist_free_all(headers);
	curl_easy_cleanup(curl);
	curl_global_cleanup();
	return ini;

	fail:
	if (ini) ini_free(ini);
	curl_slist_free_all(headers);
	curl_easy_cleanup(curl);
	curl_global_cleanup();
	return NULL;
	}

	ini_t* ini_load(const char *filename) {
	ini_t *ini = NULL;
	FILE *fp = NULL;
	int n, sz;

	/* Init ini struct */
	ini = (ini_t) malloc(sizeof(ini));
	if (!ini) {
	goto fail;
	}
	memset(ini, 0, sizeof(*ini));

	/* Open file */
	fp = fopen(filename, "rb");
	if (!fp) {
	goto fail;
	}

	/* Get file size */
	fseek(fp, 0, SEEK_END);
	sz = ftell(fp);
	if(sz < 0) {
	goto fail;
	}
	rewind(fp);

	/* Load file content into memory, null terminate, init end var */
	ini->data = (char*) malloc(sz + 1);
	ini->data[sz] = '\0';
	ini->end = ini->data + sz;
	n = fread(ini->data, 1, sz, fp);
	if (n != sz) {
	goto fail;
	}

	/* Prepare data */
	split_data(ini);

	/* Clean up and return */
	fclose(fp);
	return ini;

	fail:
	if (fp) fclose(fp);
	if (ini) ini_free(ini);
	return NULL;
	}

	void ini_free(ini_t *ini) {
	free(ini->data);
	free(ini);
	}

	bool ini_section_exist(ini_t ini, const char section) {
	char *p = ini->data;
	while (p < ini->end) {
	if (*p == '[') {
	/* Handle section */
	char* current_section = p + 1;
	if (!section \|\| !strcmpci(section, current_section)) {
	return true;
	}
	}
	p = next(ini, p);
	}

	return false;
	}

	const char* ini_get(ini_t ini, const char section, const char *key) {
	const char *current_section = "";
	char *val;
	char *p = ini->data;

	if (*p == '\0') {
	p = next(ini, p);
	}

	while (p < ini->end) {
	if (*p == '[') {
	/* Handle section */
	current_section = p + 1;

	} else {
	/* Handle key */
	val = next(ini, p);
	if (!section \|\| !strcmpci(section, current_section)) {
	if (!strcmpci(p, key)) {
	return val;
	}
	}
	p = val;
	}

	p = next(ini, p);
	}

	return NULL;
	}

	int ini_sget(
	ini_t ini, const char section, const char *value,
	const char scanfmt, void dst
	) {
	const char *val = ini_get(ini, section, value);
	if (!val) {
	return 0;
	}
	if (scanfmt) {
	sscanf(val, scanfmt, dst);
	} else {
	((const char*) dst) = val;
	}
	return 1;
	}