1
0
mirror of https://github.com/profanity-im/profanity.git synced 2024-12-04 14:46:46 -05:00
profanity/src/common.c

635 lines
16 KiB
C
Raw Normal View History

/*
* common.c
2019-11-13 06:11:05 -05:00
* vim: expandtab:ts=4:sts=4:sw=4
*
2019-01-22 05:31:45 -05:00
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
2021-01-08 10:36:30 -05:00
* Copyright (C) 2019 - 2021 Michael Vetter <jubalh@iodoru.org>
*
* This file is part of Profanity.
*
* Profanity is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Profanity is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
2016-07-23 20:14:49 -04:00
* along with Profanity. If not, see <https://www.gnu.org/licenses/>.
*
* In addition, as a special exception, the copyright holders give permission to
* link the code of portions of this program with the OpenSSL library under
* certain conditions as described in each individual source file, and
* distribute linked combinations including the two.
*
* You must obey the GNU General Public License in all respects for all of the
* code used other than OpenSSL. If you modify file(s) with this exception, you
* may extend this exception to your version of the file(s), but you are not
* obligated to do so. If you do not wish to do so, delete this exception
* statement from your version. If you delete this exception statement from all
* source files in the program, then also delete it here.
*
*/
2016-03-31 16:05:02 -04:00
#include "config.h"
#include <errno.h>
#include <sys/select.h>
#include <assert.h>
#include <stdlib.h>
2014-06-01 17:53:30 -04:00
#include <stdint.h>
2016-07-12 18:50:21 -04:00
#include <stdio.h>
2012-08-22 20:08:06 -04:00
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
2012-07-19 16:30:07 -04:00
2013-01-28 15:07:25 -05:00
#include <curl/curl.h>
#include <curl/easy.h>
#include <glib.h>
#include <gio/gio.h>
2016-03-31 16:05:02 -04:00
#ifdef HAVE_NCURSESW_NCURSES_H
#include <ncursesw/ncurses.h>
2016-03-31 16:05:02 -04:00
#elif HAVE_NCURSES_H
#include <ncurses.h>
#elif HAVE_CURSES_H
#include <curses.h>
#endif
#include "log.h"
#include "common.h"
2013-01-28 15:07:25 -05:00
struct curl_data_t
{
2020-07-07 08:18:57 -04:00
char* buffer;
2013-01-28 15:07:25 -05:00
size_t size;
};
2020-07-07 08:18:57 -04:00
static size_t _data_callback(void* ptr, size_t size, size_t nmemb, void* data);
2013-01-28 15:07:25 -05:00
gboolean
2020-07-07 08:18:57 -04:00
create_dir(char* name)
2012-07-19 16:30:07 -04:00
{
struct stat sb;
if (stat(name, &sb) != 0) {
if (errno != ENOENT || mkdir(name, S_IRWXU) != 0) {
return FALSE;
}
} else {
if ((sb.st_mode & S_IFDIR) != S_IFDIR) {
log_debug("create_dir: %s exists and is not a directory!", name);
return FALSE;
}
}
return TRUE;
2012-07-19 16:30:07 -04:00
}
2012-08-22 20:08:06 -04:00
gboolean
2020-07-07 08:18:57 -04:00
mkdir_recursive(const char* dir)
{
gboolean result = TRUE;
for (int i = 1; i <= strlen(dir); i++) {
if (dir[i] == '/' || dir[i] == '\0') {
2020-07-07 08:18:57 -04:00
gchar* next_dir = g_strndup(dir, i);
result = create_dir(next_dir);
g_free(next_dir);
if (!result) {
break;
}
}
}
return result;
}
2016-07-12 18:50:21 -04:00
gboolean
2020-07-07 08:18:57 -04:00
copy_file(const char* const sourcepath, const char* const targetpath, const gboolean overwrite_existing)
2016-07-12 18:50:21 -04:00
{
2020-07-07 08:18:57 -04:00
GFile* source = g_file_new_for_path(sourcepath);
GFile* dest = g_file_new_for_path(targetpath);
GError* error = NULL;
GFileCopyFlags flags = overwrite_existing ? G_FILE_COPY_OVERWRITE : G_FILE_COPY_NONE;
2020-07-07 08:18:57 -04:00
gboolean success = g_file_copy(source, dest, flags, NULL, NULL, NULL, &error);
if (error != NULL)
g_error_free(error);
g_object_unref(source);
g_object_unref(dest);
2018-05-07 13:41:47 -04:00
return success;
2016-07-12 18:50:21 -04:00
}
2015-10-25 20:52:33 -04:00
char*
2020-07-07 08:18:57 -04:00
str_replace(const char* string, const char* substr,
const char* replacement)
2012-08-22 20:08:06 -04:00
{
2020-07-07 08:18:57 -04:00
char* tok = NULL;
char* newstr = NULL;
char* head = NULL;
2012-08-22 20:08:06 -04:00
if (string == NULL)
return NULL;
2020-07-07 08:18:57 -04:00
if (substr == NULL || replacement == NULL || (strcmp(substr, "") == 0))
return strdup(string);
2012-08-22 20:08:06 -04:00
2020-07-07 08:18:57 -04:00
newstr = strdup(string);
2012-08-22 20:08:06 -04:00
head = newstr;
2020-07-07 08:18:57 -04:00
while ((tok = strstr(head, substr))) {
char* oldstr = newstr;
newstr = malloc(strlen(oldstr) - strlen(substr) + strlen(replacement) + 1);
2020-07-07 08:18:57 -04:00
if (newstr == NULL) {
free(oldstr);
2012-08-22 20:08:06 -04:00
return NULL;
}
2020-07-07 08:18:57 -04:00
memcpy(newstr, oldstr, tok - oldstr);
memcpy(newstr + (tok - oldstr), replacement, strlen(replacement));
memcpy(newstr + (tok - oldstr) + strlen(replacement),
tok + strlen(substr),
strlen(oldstr) - strlen(substr) - (tok - oldstr));
memset(newstr + strlen(oldstr) - strlen(substr) + strlen(replacement), 0, 1);
2020-07-07 08:18:57 -04:00
head = newstr + (tok - oldstr) + strlen(replacement);
free(oldstr);
2012-08-22 20:08:06 -04:00
}
2012-08-22 20:08:06 -04:00
return newstr;
}
2015-03-15 21:06:40 -04:00
gboolean
2020-07-07 08:18:57 -04:00
strtoi_range(char* str, int* saveptr, int min, int max, char** err_msg)
2015-03-15 21:06:40 -04:00
{
2020-07-07 08:18:57 -04:00
char* ptr;
2015-03-15 21:06:40 -04:00
int val;
errno = 0;
val = (int)strtol(str, &ptr, 0);
if (errno != 0 || *str == '\0' || *ptr != '\0') {
2020-07-07 08:18:57 -04:00
GString* err_str = g_string_new("");
2015-03-15 21:06:40 -04:00
g_string_printf(err_str, "Could not convert \"%s\" to a number.", str);
*err_msg = err_str->str;
g_string_free(err_str, FALSE);
return FALSE;
} else if (val < min || val > max) {
2020-07-07 08:18:57 -04:00
GString* err_str = g_string_new("");
2015-03-15 21:06:40 -04:00
g_string_printf(err_str, "Value %s out of range. Must be in %d..%d.", str, min, max);
*err_msg = err_str->str;
g_string_free(err_str, FALSE);
return FALSE;
}
*saveptr = val;
return TRUE;
}
2015-01-17 16:09:40 -05:00
int
2020-07-07 08:18:57 -04:00
utf8_display_len(const char* const str)
2015-01-17 16:09:40 -05:00
{
if (!str) {
return 0;
}
int len = 0;
2020-07-07 08:18:57 -04:00
gchar* curr = g_utf8_offset_to_pointer(str, 0);
2015-01-17 16:09:40 -05:00
while (*curr != '\0') {
gunichar curru = g_utf8_get_char(curr);
if (g_unichar_iswide(curru)) {
len += 2;
} else {
2020-07-07 08:18:57 -04:00
len++;
2015-01-17 16:09:40 -05:00
}
curr = g_utf8_next_char(curr);
}
return len;
}
2015-10-25 20:52:33 -04:00
char*
release_get_latest(void)
2013-01-28 15:07:25 -05:00
{
2020-07-07 08:18:57 -04:00
char* url = "https://profanity-im.github.io/profanity_version.txt";
2013-01-28 15:07:25 -05:00
2020-07-07 08:18:57 -04:00
CURL* handle = curl_easy_init();
2013-01-28 15:07:25 -05:00
struct curl_data_t output;
output.buffer = NULL;
output.size = 0;
curl_easy_setopt(handle, CURLOPT_URL, url);
curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, _data_callback);
curl_easy_setopt(handle, CURLOPT_TIMEOUT, 2);
2020-07-07 08:18:57 -04:00
curl_easy_setopt(handle, CURLOPT_WRITEDATA, (void*)&output);
2013-01-28 15:07:25 -05:00
curl_easy_perform(handle);
curl_easy_cleanup(handle);
2015-05-04 18:26:08 -04:00
if (output.buffer) {
2013-01-28 15:07:25 -05:00
output.buffer[output.size++] = '\0';
return output.buffer;
} else {
return NULL;
}
}
2013-04-20 18:39:17 -04:00
gboolean
2020-07-07 08:18:57 -04:00
release_is_new(char* found_version)
2013-04-20 18:39:17 -04:00
{
int curr_maj, curr_min, curr_patch, found_maj, found_min, found_patch;
2016-03-31 16:05:02 -04:00
int parse_curr = sscanf(PACKAGE_VERSION, "%d.%d.%d", &curr_maj, &curr_min,
2020-07-07 08:18:57 -04:00
&curr_patch);
2013-04-20 18:39:17 -04:00
int parse_found = sscanf(found_version, "%d.%d.%d", &found_maj, &found_min,
2020-07-07 08:18:57 -04:00
&found_patch);
2013-04-20 18:39:17 -04:00
if (parse_found == 3 && parse_curr == 3) {
if (found_maj > curr_maj) {
return TRUE;
} else if (found_maj == curr_maj && found_min > curr_min) {
return TRUE;
} else if (found_maj == curr_maj && found_min == curr_min
2020-07-07 08:18:57 -04:00
&& found_patch > curr_patch) {
2013-04-20 18:39:17 -04:00
return TRUE;
} else {
return FALSE;
}
} else {
return FALSE;
}
}
2013-01-28 15:07:25 -05:00
static size_t
2020-07-07 08:18:57 -04:00
_data_callback(void* ptr, size_t size, size_t nmemb, void* data)
2013-01-28 15:07:25 -05:00
{
size_t realsize = size * nmemb;
2020-07-07 08:18:57 -04:00
struct curl_data_t* mem = (struct curl_data_t*)data;
2013-01-28 15:07:25 -05:00
mem->buffer = realloc(mem->buffer, mem->size + realsize + 1);
2020-07-07 08:18:57 -04:00
if (mem->buffer) {
memcpy(&(mem->buffer[mem->size]), ptr, realsize);
2013-01-28 15:07:25 -05:00
mem->size += realsize;
2020-07-07 08:18:57 -04:00
mem->buffer[mem->size] = 0;
2013-01-28 15:07:25 -05:00
}
return realsize;
}
char*
2020-07-07 08:18:57 -04:00
get_file_or_linked(char* loc, char* basedir)
{
2020-07-07 08:18:57 -04:00
char* true_loc = NULL;
// check for symlink
if (g_file_test(loc, G_FILE_TEST_IS_SYMLINK)) {
true_loc = g_file_read_link(loc, NULL);
// if relative, add basedir
if (!g_str_has_prefix(true_loc, "/") && !g_str_has_prefix(true_loc, "~")) {
2020-07-07 08:18:57 -04:00
GString* base_str = g_string_new(basedir);
g_string_append(base_str, "/");
g_string_append(base_str, true_loc);
free(true_loc);
true_loc = base_str->str;
g_string_free(base_str, FALSE);
}
2020-07-07 08:18:57 -04:00
// use given location
} else {
true_loc = strdup(loc);
}
return true_loc;
}
2015-10-25 20:52:33 -04:00
char*
2020-07-07 08:18:57 -04:00
strip_arg_quotes(const char* const input)
{
2020-07-07 08:18:57 -04:00
char* unquoted = strdup(input);
// Remove starting quote if it exists
2020-07-07 08:18:57 -04:00
if (strchr(unquoted, '"')) {
if (strchr(unquoted, ' ') + 1 == strchr(unquoted, '"')) {
memmove(strchr(unquoted, '"'), strchr(unquoted, '"') + 1, strchr(unquoted, '\0') - strchr(unquoted, '"'));
}
}
// Remove ending quote if it exists
2020-07-07 08:18:57 -04:00
if (strchr(unquoted, '"')) {
if (strchr(unquoted, '\0') - 1 == strchr(unquoted, '"')) {
memmove(strchr(unquoted, '"'), strchr(unquoted, '"') + 1, strchr(unquoted, '\0') - strchr(unquoted, '"'));
}
}
return unquoted;
2015-02-08 16:03:26 -05:00
}
gboolean
is_notify_enabled(void)
{
gboolean notify_enabled = FALSE;
2016-03-31 16:05:02 -04:00
#ifdef HAVE_OSXNOTIFY
notify_enabled = TRUE;
#endif
2016-03-31 16:05:02 -04:00
#ifdef HAVE_LIBNOTIFY
notify_enabled = TRUE;
#endif
2016-03-31 16:05:02 -04:00
#ifdef PLATFORM_CYGWIN
notify_enabled = TRUE;
#endif
return notify_enabled;
}
2016-04-03 17:30:24 -04:00
GSList*
2020-07-07 08:18:57 -04:00
prof_occurrences(const char* const needle, const char* const haystack, int offset, gboolean whole_word, GSList** result)
2016-04-03 17:30:24 -04:00
{
if (needle == NULL || haystack == NULL) {
return *result;
2016-04-03 17:30:24 -04:00
}
2020-07-07 08:18:57 -04:00
gchar* haystack_curr = g_utf8_offset_to_pointer(haystack, offset);
if (g_str_has_prefix(haystack_curr, needle)) {
if (whole_word) {
2017-04-29 15:33:28 -04:00
gunichar before = 0;
2020-07-07 08:18:57 -04:00
gchar* haystack_before_ch = g_utf8_find_prev_char(haystack, haystack_curr);
if (haystack_before_ch) {
before = g_utf8_get_char(haystack_before_ch);
}
2017-04-29 15:33:28 -04:00
gunichar after = 0;
2020-07-07 08:18:57 -04:00
gchar* haystack_after_ch = haystack_curr + strlen(needle);
if (haystack_after_ch[0] != '\0') {
after = g_utf8_get_char(haystack_after_ch);
}
if (!g_unichar_isalnum(before) && !g_unichar_isalnum(after)) {
*result = g_slist_append(*result, GINT_TO_POINTER(offset));
}
} else {
*result = g_slist_append(*result, GINT_TO_POINTER(offset));
2016-04-03 17:30:24 -04:00
}
}
offset++;
if (g_strcmp0(g_utf8_offset_to_pointer(haystack, offset), "\0") != 0) {
*result = prof_occurrences(needle, haystack, offset, whole_word, result);
}
return *result;
2016-04-03 17:30:24 -04:00
}
int
2020-07-07 08:18:57 -04:00
is_regular_file(const char* path)
{
struct stat st;
int ret = stat(path, &st);
if (ret != 0) {
perror(NULL);
return 0;
}
return S_ISREG(st.st_mode);
}
int
2020-07-07 08:18:57 -04:00
is_dir(const char* path)
{
struct stat st;
int ret = stat(path, &st);
if (ret != 0) {
perror(NULL);
return 0;
}
return S_ISDIR(st.st_mode);
}
void
2020-07-07 08:18:57 -04:00
get_file_paths_recursive(const char* path, GSList** contents)
{
if (!is_dir(path)) {
return;
}
GDir* directory = g_dir_open(path, 0, NULL);
2020-07-07 08:18:57 -04:00
const gchar* entry = g_dir_read_name(directory);
while (entry) {
2020-07-07 08:18:57 -04:00
GString* full = g_string_new(path);
if (!g_str_has_suffix(full->str, "/")) {
g_string_append(full, "/");
}
g_string_append(full, entry);
if (is_dir(full->str)) {
get_file_paths_recursive(full->str, contents);
} else if (is_regular_file(full->str)) {
*contents = g_slist_append(*contents, full->str);
}
g_string_free(full, FALSE);
entry = g_dir_read_name(directory);
}
}
char*
get_random_string(int length)
{
2020-07-07 08:18:57 -04:00
GRand* prng;
char* rand;
char alphabet[] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
int endrange = sizeof(alphabet) - 1;
2020-07-07 08:18:57 -04:00
rand = calloc(length + 1, sizeof(char));
prng = g_rand_new();
for (int i = 0; i < length; i++) {
rand[i] = alphabet[g_rand_int_range(prng, 0, endrange)];
}
g_rand_free(prng);
return rand;
}
GSList*
2020-07-07 08:18:57 -04:00
get_mentions(gboolean whole_word, gboolean case_sensitive, const char* const message, const char* const nick)
{
2020-07-07 08:18:57 -04:00
GSList* mentions = NULL;
gchar* message_search = case_sensitive ? g_strdup(message) : g_utf8_strdown(message, -1);
gchar* mynick_search = case_sensitive ? g_strdup(nick) : g_utf8_strdown(nick, -1);
mentions = prof_occurrences(mynick_search, message_search, 0, whole_word, &mentions);
g_free(message_search);
g_free(mynick_search);
return mentions;
}
2020-05-20 04:36:02 -04:00
gboolean
2020-12-11 09:51:01 -05:00
call_external(gchar** argv, gchar** std_out, gchar** std_err)
2020-05-20 04:36:02 -04:00
{
GSpawnFlags flags = G_SPAWN_SEARCH_PATH;
2020-12-11 09:51:01 -05:00
if (std_out == NULL)
flags |= G_SPAWN_STDOUT_TO_DEV_NULL;
2020-12-11 09:51:01 -05:00
if (std_err == NULL)
flags |= G_SPAWN_STDERR_TO_DEV_NULL;
2020-12-11 09:51:01 -05:00
gint exit_status;
gboolean spawn_result;
GError* spawn_error;
spawn_result = g_spawn_sync(NULL, // Inherit the parent PWD.
argv,
NULL, // Inherit the parent environment.
flags,
NULL, NULL, // No func. before exec() in child.
std_out, std_err,
&exit_status, &spawn_error);
if (!spawn_result
|| !g_spawn_check_exit_status(exit_status, &spawn_error)) {
gchar* cmd = g_strjoinv(" ", argv);
log_error("Spawning '%s' failed with '%s'.", cmd, spawn_error->message);
g_free(cmd);
2020-12-11 09:51:01 -05:00
g_error_free(spawn_error);
}
2020-05-20 04:36:02 -04:00
2020-12-11 09:51:01 -05:00
return spawn_result;
2020-05-20 04:36:02 -04:00
}
gchar**
format_call_external_argv(const char* template, const char* url, const char* filename)
{
gchar** argv = g_strsplit(template, " ", 0);
guint num_args = 0;
while (argv[num_args]) {
if (0 == g_strcmp0(argv[num_args], "%u") && url != NULL) {
g_free(argv[num_args]);
argv[num_args] = g_strdup(url);
} else if (0 == g_strcmp0(argv[num_args], "%p") && filename != NULL) {
g_free(argv[num_args]);
argv[num_args] = strdup(filename);
}
num_args++;
}
return argv;
}
gchar*
_unique_filename(const char* filename)
{
gchar* unique = g_strdup(filename);
unsigned int i = 0;
while (g_file_test(unique, G_FILE_TEST_EXISTS)) {
g_free(unique);
if (i > 1000) { // Give up after 1000 attempts.
return NULL;
}
unique = g_strdup_printf("%s.%u", filename, i);
if (!unique) {
return NULL;
}
i++;
}
return unique;
}
2020-12-06 11:02:09 -05:00
bool
_has_directory_suffix(const char* path)
{
return (g_str_has_suffix(path, ".")
|| g_str_has_suffix(path, "..")
|| g_str_has_suffix(path, G_DIR_SEPARATOR_S));
}
char*
_basename_from_url(const char* url)
{
2020-12-06 11:02:09 -05:00
const char* default_name = "index";
2020-12-06 11:02:09 -05:00
GFile* file = g_file_new_for_commandline_arg(url);
char* basename = g_file_get_basename(file);
2020-12-06 11:02:09 -05:00
if (_has_directory_suffix(basename)) {
g_free(basename);
basename = strdup(default_name);
}
2020-12-06 11:02:09 -05:00
g_object_unref(file);
return basename;
}
gchar*
get_expanded_path(const char* path)
{
GString* exp_path = g_string_new("");
gchar* result;
if (g_str_has_prefix(path, "file://")) {
path += strlen("file://");
}
if (strlen(path) >= 2 && path[0] == '~' && path[1] == '/') {
g_string_printf(exp_path, "%s/%s", getenv("HOME"), path + 2);
} else {
g_string_printf(exp_path, "%s", path);
}
result = exp_path->str;
g_string_free(exp_path, FALSE);
return result;
}
gchar*
unique_filename_from_url(const char* url, const char* path)
{
gchar* realpath;
2020-12-06 11:02:09 -05:00
// Default to './' as path when none has been provided.
if (path == NULL) {
realpath = g_strdup("./");
} else {
realpath = get_expanded_path(path);
}
2020-12-06 11:02:09 -05:00
// Resolves paths such as './../.' for path.
GFile* target = g_file_new_for_commandline_arg(realpath);
2020-12-06 11:02:09 -05:00
gchar* filename = NULL;
if (_has_directory_suffix(realpath) || g_file_test(realpath, G_FILE_TEST_IS_DIR)) {
2020-12-06 11:02:09 -05:00
// The target should be used as a directory. Assume that the basename
// should be derived from the URL.
char* basename = _basename_from_url(url);
filename = g_build_filename(g_file_peek_path(target), basename, NULL);
g_free(basename);
} else {
// Just use the target as filename.
filename = g_build_filename(g_file_peek_path(target), NULL);
}
gchar* unique_filename = _unique_filename(filename);
2020-12-06 11:02:09 -05:00
if (unique_filename == NULL) {
g_free(filename);
g_free(realpath);
return NULL;
}
2020-12-06 11:02:09 -05:00
g_object_unref(target);
g_free(filename);
g_free(realpath);
2020-12-06 11:02:09 -05:00
return unique_filename;
}