readr

utils.c (6507B)

---

 #include <stdio.h>
 #include <strings.h>
 #include <errno.h>
 #include <stdarg.h>
 #include <locale.h>
 
 #include "utils.h"
 #include "config.h"
 
 void
 validate_config(void)
 {
 	if (strlen(FEEDS) < 3 || strlen(FEEDS) > 1024) panic("invalid FEEDS path");
 	if (strlen(DB_PATH) < 3 || strlen(DB_PATH) > 1024) panic("invalid DB_PATH path");
 
 	if (MAX_POST_PER_FEED < 1 || MAX_POST_PER_FEED > 256) panic("invalid MAX_POST_PER_FEED (1~256)");
 	if (POSTS_CAP < 16 || POSTS_CAP > 512) panic("invalid POSTS_CAP (16~512)");
 	if (FEEDS_CAP < 16 || FEEDS_CAP > 512) panic("invalid FEEDS_CAP (16~512)");
 	if (TITLE_CAP < 16 || TITLE_CAP > 512) panic("invalid TITLE_CAP (16~512)");
 	if (DOMAIN_CAP < 16 || DOMAIN_CAP > 512) panic("invalid DOMAIN_CAP (16~512)");
 	if (URL_CAP < 2048 || URL_CAP > 8192) panic("invalid URL_CAP (2048~8192)");
 }
 
 void
 switch_locale(void)
 {
 	// for unicode blocks/lines, curvy quotes etc.
 	if (!setlocale(LC_ALL, "C.UTF-8")) panic("could not switch to UTF-8!");
 }
 
 void
 panic(const char* fmt, ...)
 {
 	va_list args;
 	int saved_errno;
 	saved_errno = errno;
 	va_start(args, fmt);
 	fprintf(stderr, "Error: ");
 	vfprintf(stderr, fmt, args);
 	fprintf(stderr, "\n");
 	va_end(args);
 	if (fmt[0] && fmt[strlen(fmt) - 1] == ':') fprintf(stderr, " %s", strerror(saved_errno));
 	fputc('\n', stderr);
 	exit(1);
 }
 
 #if defined(_WIN32)
 
 // to be tested on windows, and then have a shower
 
 const char*
 get_home_dir(void)
 {
 	const char* p = getenv("USERPROFILE");
 	if (p && *p) return p;
 	const char* drv = getenv("HOMEDRIVE");
 	const char* pth = getenv("HOMEPATH");
 	if (drv && pth) {
 		size_t n = strlen(drv) + strlen(pth) + 1;
 		char* buf = (char*)ecalloc(n, sizeof(char));
 		snprintf(buf, n, "%s%s", drv, pth);
 		return buf; /* caller frees if not an env ptr */
 	}
 	return NULL;
 }
 #else
 
 // macos/linux
 
 #include <pwd.h>
 #include <unistd.h>
 
 const char*
 get_home_dir(void)
 {
 	const char* p = getenv("HOME");
 	if (p && *p) return p;
 	return NULL;
 }
 
 #endif
 
 const char*
 expand_tilde(const char* path)
 {
 	if (!path) return NULL;
 	const char* home = get_home_dir();
 	if (!home) home = ""; /* degrade to empty if unknown */
 
 	/* Worst case: every char is '~' → expand to home each time */
 	size_t hlen = strlen(home);
 	size_t out_cap = 1; /* for '\0' */
 	for (const char* s = path; *s; ++s)
 		out_cap += (*s == '~') ? hlen : 1;
 
 	char* out = (char*)ecalloc(out_cap, sizeof(char));
 
 	char* w = out;
 	for (const char* s = path; *s; ++s) {
 		if (*s == '~') {
 			memcpy(w, home, hlen);
 			w += hlen;
 		} else {
 			*w++ = *s;
 		}
 	}
 	*w = '\0';
 
 #if defined(_WIN32)
 	/* If get_home_dir() allocated (HOMEDRIVE+HOMEPATH path), free it. */
 	const char* up = getenv("USERPROFILE");
 	if (!(up && *up)) { free((void*)home); }
 #endif
 	return out;
 }
 
 char*
 read_file(const char* file_path)
 {
 	FILE* fp = fopen(file_path, "rb");
 	if (fp == NULL) { return NULL; }
 
 	if (fseek(fp, 0, SEEK_END) != 0) {
 		fclose(fp);
 		printf("Failed to find the end of the file\n");
 		return NULL;
 	}
 
 	long file_size = ftell(fp);
 
 	if (file_size < 0) {
 		fclose(fp);
 		printf("Failed to determine the file size\n");
 		return NULL;
 	}
 
 	rewind(fp);
 
 	// check for overflow before casting
 	if ((unsigned long)file_size >= SIZE_MAX) {
 		fclose(fp);
 		printf("File too large to fit in memory\n");
 		return NULL;
 	}
 
 	char* contents = (char*)ecalloc(1, (size_t)file_size + 1);
 
 	size_t bytes_read = fread(contents, 1, (size_t)file_size, fp);
 	if (bytes_read != (size_t)file_size) {
 		free(contents);
 		fclose(fp);
 		printf("Failed to read the file in its entirety\n");
 		return NULL;
 	}
 
 	contents[file_size] = '\0';
 
 	fclose(fp);
 	return contents;
 }
 
 char*
 host_from_url(const char* url)
 {
 	const char *p = url, *start, *end;
 
 	// skip scheme
 	const char* scheme = strstr(p, "://");
 	if (scheme)
 		p = scheme + 3;
 	else if (p[0] == '/' && p[1] == '/')
 		p += 2;
 
 	// IPv6 literal in brackets
 	if (*p == '[') {
 		start = p + 1;
 		end = strchr(start, ']');
 		if (!end) return NULL;
 		return strndup(start, (size_t)(end - start));
 	}
 
 	start = p;
 
 	// stop at / ? # : (drop path, query, fragment, and port)
 	end = strpbrk(start, "/?:#:");
 	if (!end) end = start + strlen(start);
 
 	// optional: strip leading "www."
 	if (end - start >= 4 && strncasecmp(start, "www.", 4) == 0) start += 4;
 
 	return strndup(start, (size_t)(end - start));
 }
 
 void
 remove_all_chars(char* str, char c)
 {
 	char *pr = str, *pw = str;
 	while (*pr) {
 		*pw = *pr++;
 		pw += (*pw != c);
 	}
 	*pw = '\0';
 }
 
 void
 remove_all_tags(char* str)
 {
 	char *pr = str, *pw = str;
 	int in_tag = 0;
 
 	while (*pr) {
 		if (*pr == '<') {
 			in_tag = 1;
 			pr++;
 			continue;
 		} else if (*pr == '>') {
 			in_tag = 0;
 			pr++;
 			continue;
 		}
 		if (!in_tag) { *pw++ = *pr; }
 		pr++;
 	}
 	*pw = '\0';
 }
 
 //
 // open_url
 //
 
 #define _POSIX_C_SOURCE 200809L
 
 #ifdef _WIN32
 #include <windows.h>
 int
 open_url(const char* url)
 {
 	HINSTANCE r = ShellExecuteA(NULL, "open", url, NULL, NULL, SW_SHOWNORMAL);
 	return ((uintptr_t)r > 32) ? 0 : -1; // ShellExecute error if <= 32
 }
 #else
 static void
 shell_quote(const char* in, char* out, size_t outsz)
 {
 	// wrap in single quotes and escape embedded single quotes: ' -> '\''
 	size_t n = 0;
 	if (n + 1 < outsz) out[n++] = '\'';
 	for (; *in && n + 4 < outsz; ++in) {
 		if (*in == '\'') {
 			memcpy(out + n, "'\\''", 4);
 			n += 4;
 		} else
 			out[n++] = *in;
 	}
 	if (n + 2 <= outsz) {
 		out[n++] = '\'';
 		out[n] = '\0';
 	} else if (outsz)
 		out[outsz - 1] = '\0';
 }
 
 int
 open_url(const char* url)
 {
 	char q[4096];
 	char cmd[4600];
 	shell_quote(url, q, sizeof q);
 #ifdef __APPLE__
 	snprintf(cmd, sizeof cmd, "open %s >/dev/null 2>&1 &", q);
 #else
 	snprintf(cmd, sizeof cmd, "xdg-open %s >/dev/null 2>&1 &", q);
 #endif
 	return system(cmd); // 0 on success from the shell
 }
 #endif
 
 //
 // nonascii_replace
 //
 
 void
 nonascii_replace(char* s, char to)
 {
 	unsigned char *r = (unsigned char*)s, *w = (unsigned char*)s;
 	while (*r) {
 		if (*r < 0x80) { // ASCII byte
 			*w++ = *r++;
 		} else { // non-ASCII: skip UTF-8 seq, write one space
 			size_t need = 1;
 			if ((*r & 0xE0) == 0xC0)
 				need = 2;
 			else if ((*r & 0xF0) == 0xE0)
 				need = 3;
 			else if ((*r & 0xF8) == 0xF0)
 				need = 4;
 
 			size_t i = 1;
 			if (need > 1) {
 				for (; i < need && r[i]; ++i)
 					if ((r[i] & 0xC0) != 0x80) break;
 			}
 			r += (i == need) ? need : 1; // tolerate invalid UTF-8
 
 			if (w == (unsigned char*)s || w[-1] != ' ') *w++ = (unsigned char)to;
 		}
 	}
 	*w = '\0';
 }
 
 void*
 ecalloc(size_t c, size_t s)
 {
 	void* p;
 	if (!(p = calloc(c, s))) { panic("calloc:"); }
 	return p;
 }