cpc

cpc.c (4925B)

---

 #include <stdio.h>
 #include <pwd.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <cjson/cJSON.h>
 #include <curl/curl.h>
 
 #include "config.h"
 
 #define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
 
 typedef enum {AS_FIAT, AS_CRYPTO} Action;
 
 typedef struct
 {
 	char *response;
 	size_t size;
 } Memory;
 
 static size_t writefunc(char *data, size_t size, size_t nmemb, Memory *mem);
 static void wfile(cJSON *array);
 static void parse_json_object(const char *json_string);
 static char * replace_home(char *buf, const char *path);
 static void do_action(Action action, const double value);
 static void call_api();
 static char * cpstr(char *dest, const char *src);
 static void fatal(const char *fmt, ...);
 
 static char file[PATH_MAX];
 
 int
 main(int argc, char **argv)
 {
 	int opt, update = 0;
 	double value = 1;
 	Action action = AS_CRYPTO;
 
 	replace_home(file, PRICES_FILE);
 
 	while ((opt = getopt(argc, argv, "urv:")) != -1) {
 		switch (opt) {
 			case 'u':
 				update = 1;
 				break;
 			case 'r':
 				action = AS_FIAT;
 				break;
 			case 'v':
 				sscanf(optarg, "%lf", &value);
 				break;
 			default:
 				fatal("Unknown option: %c\n", optopt);
 				break;
 		}
 	}
 
 	for(; optind < argc; optind++)
 		printf("ignored arguments: %s\n", argv[optind]);
 
 	if (update)
 		call_api();
 
 	do_action(action, value);
 }
 
 size_t
 writefunc(char *data, size_t size, size_t nmemb, Memory *mem)
 {
 	char *ptr;
 	size_t realsize = size * nmemb;
 	
 	if ((ptr = realloc(mem->response, mem->size + realsize + 1)) == NULL)
 		fatal("Realloc failed\n");
 	
 	mem->response = ptr;
 	memcpy(&(mem->response[mem->size]), data, realsize);
 	mem->size += realsize;
 	mem->response[mem->size] = 0;
 	
 	return realsize;
 }
 
 void
 wfile(cJSON *array)
 {
 	cJSON *item = array ? array->child : 0;
 	FILE *fp;
 
 	if ((fp = fopen(file, "w+")) == NULL)
 		fatal("Opening file failed: %s\n", file);
 
 	while (item) {
 		cJSON *name = cJSON_GetObjectItem(item, "name");
 		cJSON *price = cJSON_GetObjectItem(item, "current_price");
 		fprintf(fp, "%s;%f\n", name->valuestring, price->valuedouble);
 		item=item->next;
 	}
 
 	fclose(fp);
 }
 
 void
 parse_json_object(const char *json_string)
 {
 	cJSON *json = cJSON_Parse(json_string);
 
 	if (json == NULL) {
 		const char *error_ptr = cJSON_GetErrorPtr();
 		if (error_ptr != NULL)
 			fatal("Error before: %s\n", error_ptr);
 		return;
 	}
 	wfile(json);
 	cJSON_Delete(json);
 }
 
 char *
 replace_home(char *buf, const char *path)
 {
 	char *userhome, *envv = "$HOME";
 	struct passwd userinf;
 
 	userinf = *getpwuid(getuid());
 	userhome = strdup(userinf.pw_dir);
 
 	if ((strstr(path, envv) != NULL)) {
 		cpstr(buf, userhome);
 		strcat(buf, path + strlen(envv));
 	} else
 		cpstr(buf, path);
 
 	free(userhome);
 
 	return buf;
 }
 
 void
 do_action(Action action, const double value)
 {
 	char name[50], *line_buf = NULL;
 	size_t line_buf_size = 0;
 	ssize_t line_size;
 	double price;
 	FILE *fp;
 ;
 	if ((fp = fopen(file, "r")) == NULL)
 		fatal("Error opening file '%s'\n", file);
 
 	while ((getline(&line_buf, &line_buf_size, fp)) >= 0) {
 		sscanf(line_buf, "%[^;];%lf", name, &price);
 		switch (action) {
 			case AS_FIAT:
 				printf("%f %s\n", value/price, name);
 				break;
 			case AS_CRYPTO:
 				printf("(%s) %f %s\n", name, value*price, FIAT);
 				break;
 			default:
 				break;
 		}
 	}
 
 	free(line_buf);
 
 	fclose(fp);
 }
 
 void
 call_api()
 {
 	char libversion[20], request[strlen(URL) + strlen(FIAT) + strlen(CURRENCIES) + 1];
 	struct curl_slist *headers = NULL;
 	Memory mem = {0};
 
 	CURL *curl = curl_easy_init();
 
 	if (curl) {
 		headers = curl_slist_append(headers, "Content-Type: application/json");
 		headers = curl_slist_append(headers, "charset: utf-8");
 
 		curl_version_info_data *ver = curl_version_info(CURLVERSION_NOW);
 		sprintf(libversion, "curl/%u.%u.%u",
 				(ver->version_num >> 16) & 0xff,
 				(ver->version_num >> 8) & 0xff,
 				ver->version_num & 0xff);
 		sprintf(request, URL, CURRENCIES, FIAT);
 
 		CURLcode res;
 		curl_easy_setopt(curl, CURLOPT_URL, request);
 		curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "");
 		curl_easy_setopt(curl, CURLOPT_USERAGENT, libversion);
 		curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
  		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writefunc);
 		curl_easy_setopt(curl, CURLOPT_WRITEDATA, &mem);
 		curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
 
 		res = curl_easy_perform(curl);
 
 		if (res != CURLE_OK)
 			fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
 		else {
 			parse_json_object(mem.response);
 			printf("\n=== Updated prices ===\n");
 			free(mem.response);
 		}
 		curl_slist_free_all(headers);
 	}
 
 	curl_easy_cleanup(curl);
 }
 
 char *
 cpstr(char *dest, const char *src)
 {
 	size_t cplen = strlen(src);
 	memcpy(dest, src, cplen);
 	dest[cplen] = '\0';
 	return dest;
 }
 
 void
 fatal(const char *fmt, ...)
 {
 	va_list ap;
 
 	va_start(ap, fmt);
 	vfprintf(stderr, fmt, ap);
 	va_end(ap);
 
 	exit(EXIT_FAILURE);
 }