2012-10-21 15:02:20 -04:00
|
|
|
/*
|
2012-05-19 16:56:23 -04:00
|
|
|
* common.c
|
2019-11-13 06:11:05 -05:00
|
|
|
* vim: expandtab:ts=4:sts=4:sw=4
|
2012-05-19 16:56:23 -04:00
|
|
|
*
|
2019-01-22 05:31:45 -05:00
|
|
|
* Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
|
2024-01-22 10:03:48 -05:00
|
|
|
* Copyright (C) 2019 - 2024 Michael Vetter <jubalh@iodoru.org>
|
2012-10-21 15:02:20 -04:00
|
|
|
*
|
2012-05-19 16:56:23 -04:00
|
|
|
* 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/>.
|
2012-05-19 16:56:23 -04:00
|
|
|
*
|
2014-08-24 15:57:39 -04:00
|
|
|
* 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.
|
|
|
|
*
|
2012-05-19 16:56:23 -04:00
|
|
|
*/
|
2020-12-04 10:13:13 -05:00
|
|
|
|
2016-03-31 16:05:02 -04:00
|
|
|
#include "config.h"
|
2012-05-19 16:56:23 -04:00
|
|
|
|
2012-08-25 20:50:50 -04:00
|
|
|
#include <errno.h>
|
2013-08-03 07:14:30 -04:00
|
|
|
#include <sys/select.h>
|
2013-02-10 06:41:30 -05:00
|
|
|
#include <assert.h>
|
2014-06-01 17:53:30 -04:00
|
|
|
#include <stdlib.h>
|
|
|
|
#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>
|
2012-08-25 20:50:50 -04:00
|
|
|
#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>
|
2013-02-02 15:55:58 -05:00
|
|
|
#include <glib.h>
|
2018-05-07 13:41:47 -04:00
|
|
|
#include <gio/gio.h>
|
2023-08-29 07:46:07 -04:00
|
|
|
#include <glib/gstdio.h>
|
2014-06-01 17:42:10 -04:00
|
|
|
|
2016-03-31 16:05:02 -04:00
|
|
|
#ifdef HAVE_NCURSESW_NCURSES_H
|
2016-02-14 17:28:55 -05:00
|
|
|
#include <ncursesw/ncurses.h>
|
2016-03-31 16:05:02 -04:00
|
|
|
#elif HAVE_NCURSES_H
|
2016-02-14 17:28:55 -05:00
|
|
|
#include <ncurses.h>
|
2020-09-04 06:55:20 -04:00
|
|
|
#elif HAVE_CURSES_H
|
|
|
|
#include <curses.h>
|
2016-02-14 17:28:55 -05:00
|
|
|
#endif
|
|
|
|
|
2013-08-03 07:14:30 -04:00
|
|
|
#include "log.h"
|
2012-07-19 17:38:46 -04:00
|
|
|
#include "common.h"
|
2023-08-29 07:46:07 -04:00
|
|
|
#include "config/files.h"
|
2012-11-17 21:31:32 -05:00
|
|
|
|
2023-07-25 14:58:15 -04:00
|
|
|
#ifdef HAVE_GIT_VERSION
|
|
|
|
#include "gitversion.h"
|
|
|
|
#endif
|
|
|
|
|
2013-01-28 15:07:25 -05:00
|
|
|
struct curl_data_t
|
|
|
|
{
|
|
|
|
char* buffer;
|
|
|
|
size_t size;
|
|
|
|
};
|
|
|
|
|
|
|
|
static size_t _data_callback(void* ptr, size_t size, size_t nmemb, void* data);
|
2023-08-29 07:46:07 -04:00
|
|
|
static gchar* _get_file_or_linked(gchar* loc);
|
2013-01-28 15:07:25 -05:00
|
|
|
|
2023-07-13 10:46:24 -04:00
|
|
|
/**
|
|
|
|
* Frees the memory allocated for a gchar* string.
|
|
|
|
*
|
|
|
|
* @param str Pointer to the gchar* string to be freed. If NULL, no action is taken.
|
|
|
|
*/
|
2022-12-05 04:25:57 -05:00
|
|
|
void
|
|
|
|
auto_free_gchar(gchar** str)
|
|
|
|
{
|
|
|
|
if (str == NULL)
|
|
|
|
return;
|
|
|
|
g_free(*str);
|
|
|
|
}
|
|
|
|
|
2023-07-13 10:46:24 -04:00
|
|
|
/**
|
|
|
|
* Frees the memory allocated for a guchar* string.
|
|
|
|
*
|
|
|
|
* @param str Pointer to the guchar* string to be freed. If NULL, no action is taken.
|
|
|
|
*/
|
2023-07-13 11:04:59 -04:00
|
|
|
void
|
|
|
|
auto_free_guchar(guchar** ptr)
|
|
|
|
{
|
|
|
|
if (ptr == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
g_free(*ptr);
|
|
|
|
}
|
|
|
|
|
2023-07-13 10:46:24 -04:00
|
|
|
/**
|
|
|
|
* Frees the memory allocated for a gchar** string array.
|
|
|
|
*
|
|
|
|
* @param args Pointer to the gchar** string array to be freed. If NULL, no action is taken.
|
|
|
|
*/
|
2023-01-18 10:43:53 -05:00
|
|
|
void
|
|
|
|
auto_free_gcharv(gchar*** args)
|
|
|
|
{
|
|
|
|
if (args == NULL)
|
|
|
|
return;
|
|
|
|
g_strfreev(*args);
|
|
|
|
}
|
|
|
|
|
2023-07-13 10:46:24 -04:00
|
|
|
/**
|
|
|
|
* Frees the memory allocated for a char* string.
|
|
|
|
*
|
|
|
|
* @param str Pointer to the char* string to be freed. If NULL, no action is taken.
|
|
|
|
*/
|
2022-12-05 04:25:57 -05:00
|
|
|
void
|
|
|
|
auto_free_char(char** str)
|
|
|
|
{
|
|
|
|
if (str == NULL)
|
|
|
|
return;
|
|
|
|
free(*str);
|
|
|
|
}
|
|
|
|
|
2023-08-29 07:46:07 -04:00
|
|
|
static gboolean
|
|
|
|
_load_keyfile(prof_keyfile_t* keyfile)
|
|
|
|
{
|
|
|
|
GError* error = NULL;
|
|
|
|
keyfile->keyfile = g_key_file_new();
|
|
|
|
|
|
|
|
if (g_key_file_load_from_file(keyfile->keyfile, keyfile->filename, G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, &error)) {
|
|
|
|
return TRUE;
|
|
|
|
} else if (error->code != G_FILE_ERROR_NOENT) {
|
|
|
|
log_warning("[Keyfile] error loading %s: %s", keyfile->filename, error->message);
|
|
|
|
g_error_free(error);
|
|
|
|
} else {
|
|
|
|
log_warning("[Keyfile] no such file: %s", keyfile->filename);
|
|
|
|
g_error_free(error);
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
gboolean
|
|
|
|
load_data_keyfile(prof_keyfile_t* keyfile, const char* filename)
|
|
|
|
{
|
|
|
|
auto_gchar gchar* loc = files_get_data_path(filename);
|
|
|
|
return load_custom_keyfile(keyfile, _get_file_or_linked(loc));
|
|
|
|
}
|
|
|
|
|
|
|
|
gboolean
|
|
|
|
load_config_keyfile(prof_keyfile_t* keyfile, const char* filename)
|
|
|
|
{
|
|
|
|
auto_gchar gchar* loc = files_get_config_path(filename);
|
|
|
|
return load_custom_keyfile(keyfile, _get_file_or_linked(loc));
|
|
|
|
}
|
|
|
|
|
|
|
|
gboolean
|
|
|
|
load_custom_keyfile(prof_keyfile_t* keyfile, gchar* filename)
|
|
|
|
{
|
|
|
|
keyfile->filename = filename;
|
|
|
|
|
|
|
|
if (g_file_test(keyfile->filename, G_FILE_TEST_EXISTS)) {
|
|
|
|
g_chmod(keyfile->filename, S_IRUSR | S_IWUSR);
|
|
|
|
}
|
|
|
|
|
|
|
|
return _load_keyfile(keyfile);
|
|
|
|
}
|
|
|
|
|
|
|
|
gboolean
|
|
|
|
save_keyfile(prof_keyfile_t* keyfile)
|
|
|
|
{
|
|
|
|
GError* error = NULL;
|
|
|
|
if (!g_key_file_save_to_file(keyfile->keyfile, keyfile->filename, &error)) {
|
|
|
|
log_error("[Keyfile]: saving file %s failed! %s", keyfile->filename, error->message);
|
|
|
|
g_error_free(error);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
g_chmod(keyfile->filename, S_IRUSR | S_IWUSR);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
free_keyfile(prof_keyfile_t* keyfile)
|
|
|
|
{
|
|
|
|
log_debug("[Keyfile]: free %s", STR_MAYBE_NULL(keyfile->filename));
|
|
|
|
if (keyfile->keyfile)
|
|
|
|
g_key_file_free(keyfile->keyfile);
|
|
|
|
keyfile->keyfile = NULL;
|
|
|
|
g_free(keyfile->filename);
|
|
|
|
keyfile->filename = NULL;
|
|
|
|
}
|
|
|
|
|
2022-12-05 04:25:57 -05:00
|
|
|
gboolean
|
|
|
|
string_to_verbosity(const char* cmd, int* verbosity, gchar** err_msg)
|
|
|
|
{
|
|
|
|
return strtoi_range(cmd, verbosity, 0, 3, err_msg);
|
|
|
|
}
|
|
|
|
|
2013-08-03 07:14:30 -04:00
|
|
|
gboolean
|
2022-03-13 07:02:59 -04:00
|
|
|
create_dir(const char* name)
|
2012-07-19 16:30:07 -04:00
|
|
|
{
|
2022-03-13 07:02:59 -04:00
|
|
|
if (g_mkdir_with_parents(name, S_IRWXU) != 0) {
|
|
|
|
log_error("Failed to create directory at '%s' with error '%s'", name, strerror(errno));
|
|
|
|
return FALSE;
|
2013-08-03 07:14:30 -04:00
|
|
|
}
|
|
|
|
return TRUE;
|
2012-07-19 16:30:07 -04:00
|
|
|
}
|
2012-08-22 20:08:06 -04:00
|
|
|
|
2016-07-12 18:50:21 -04:00
|
|
|
gboolean
|
2018-05-07 13:41:47 -04:00
|
|
|
copy_file(const char* const sourcepath, const char* const targetpath, const gboolean overwrite_existing)
|
2016-07-12 18:50:21 -04:00
|
|
|
{
|
2018-05-07 13:41:47 -04:00
|
|
|
GFile* source = g_file_new_for_path(sourcepath);
|
|
|
|
GFile* dest = g_file_new_for_path(targetpath);
|
|
|
|
GError* error = NULL;
|
2018-08-02 01:51:13 -04:00
|
|
|
GFileCopyFlags flags = overwrite_existing ? G_FILE_COPY_OVERWRITE : G_FILE_COPY_NONE;
|
|
|
|
gboolean success = g_file_copy(source, dest, flags, NULL, NULL, NULL, &error);
|
2020-04-13 20:24:02 -04:00
|
|
|
if (error != NULL)
|
|
|
|
g_error_free(error);
|
2018-08-02 01:51:13 -04:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2023-07-13 10:46:24 -04:00
|
|
|
/**
|
|
|
|
* @brief Replaces all occurrences of a substring with a replacement in a string.
|
|
|
|
*
|
|
|
|
* @param string The input string to perform replacement on.
|
|
|
|
* @param substr The substring to be replaced.
|
|
|
|
* @param replacement The replacement string.
|
|
|
|
* @return The modified string with replacements, or NULL on failure.
|
|
|
|
*
|
|
|
|
* @note Remember to free returned value using `auto_char` or `free()` when it is no longer needed.
|
|
|
|
* @note If 'string' is NULL, the function returns NULL.
|
|
|
|
* @note If 'substr' or 'replacement' is NULL or an empty string, a duplicate of 'string' is returned.
|
|
|
|
*/
|
2015-10-25 20:52:33 -04:00
|
|
|
char*
|
2012-10-21 15:02:20 -04:00
|
|
|
str_replace(const char* string, const char* substr,
|
|
|
|
const char* replacement)
|
2012-08-22 20:08:06 -04:00
|
|
|
{
|
2023-08-29 04:37:10 -04:00
|
|
|
const char* head = NULL;
|
|
|
|
const char* tok = NULL;
|
2012-08-22 20:08:06 -04:00
|
|
|
char* newstr = NULL;
|
2023-08-29 04:37:10 -04:00
|
|
|
char* wr = NULL;
|
|
|
|
size_t num_substr = 0;
|
|
|
|
size_t len_string, len_substr, len_replacement, len_string_remains, len_newstr;
|
2012-10-21 15:02:20 -04:00
|
|
|
|
2012-08-22 20:08:06 -04:00
|
|
|
if (string == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2012-10-21 15:02:20 -04:00
|
|
|
if (substr == NULL || replacement == NULL || (strcmp(substr, "") == 0))
|
2012-08-22 20:08:06 -04:00
|
|
|
return strdup(string);
|
|
|
|
|
2023-08-29 04:37:10 -04:00
|
|
|
tok = string;
|
|
|
|
while ((tok = strstr(tok, substr))) {
|
|
|
|
num_substr++;
|
|
|
|
tok++;
|
|
|
|
}
|
2012-08-22 20:08:06 -04:00
|
|
|
|
2023-08-29 04:37:10 -04:00
|
|
|
if (num_substr == 0)
|
|
|
|
return strdup(string);
|
2012-10-21 15:02:20 -04:00
|
|
|
|
2023-08-29 04:37:10 -04:00
|
|
|
len_string = strlen(string);
|
|
|
|
len_substr = strlen(substr);
|
|
|
|
len_replacement = strlen(replacement);
|
|
|
|
len_newstr = len_string - (num_substr * len_substr) + (num_substr * len_replacement);
|
|
|
|
newstr = malloc(len_newstr + 1);
|
|
|
|
if (newstr == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
len_string_remains = len_string;
|
2012-10-21 15:02:20 -04:00
|
|
|
|
2023-08-29 04:37:10 -04:00
|
|
|
head = string;
|
|
|
|
wr = newstr;
|
2012-10-21 15:02:20 -04:00
|
|
|
|
2023-08-29 04:37:10 -04:00
|
|
|
while ((tok = strstr(head, substr))) {
|
|
|
|
size_t l = tok - head;
|
|
|
|
memcpy(wr, head, l);
|
|
|
|
wr += l;
|
|
|
|
memcpy(wr, replacement, len_replacement);
|
|
|
|
wr += len_replacement;
|
|
|
|
len_string_remains -= len_substr + l;
|
|
|
|
|
|
|
|
head = tok + len_substr;
|
2012-08-22 20:08:06 -04:00
|
|
|
}
|
2023-08-29 04:37:10 -04:00
|
|
|
memcpy(wr, head, len_string_remains);
|
|
|
|
newstr[len_newstr] = '\0';
|
2012-10-21 15:02:20 -04:00
|
|
|
|
2012-08-22 20:08:06 -04:00
|
|
|
return newstr;
|
|
|
|
}
|
|
|
|
|
2015-03-15 21:06:40 -04:00
|
|
|
gboolean
|
2022-12-05 04:25:57 -05:00
|
|
|
strtoi_range(const char* str, int* saveptr, int min, int max, gchar** err_msg)
|
2015-03-15 21:06:40 -04:00
|
|
|
{
|
|
|
|
char* ptr;
|
|
|
|
int val;
|
2022-12-05 04:25:57 -05:00
|
|
|
if (str == NULL) {
|
|
|
|
if (err_msg)
|
|
|
|
*err_msg = g_strdup_printf("'str' input pointer can not be NULL");
|
|
|
|
return FALSE;
|
|
|
|
}
|
2015-03-15 21:06:40 -04:00
|
|
|
errno = 0;
|
|
|
|
val = (int)strtol(str, &ptr, 0);
|
|
|
|
if (errno != 0 || *str == '\0' || *ptr != '\0') {
|
2022-12-05 04:25:57 -05:00
|
|
|
if (err_msg)
|
|
|
|
*err_msg = g_strdup_printf("Could not convert \"%s\" to a number.", str);
|
2015-03-15 21:06:40 -04:00
|
|
|
return FALSE;
|
|
|
|
} else if (val < min || val > max) {
|
2022-12-05 04:25:57 -05:00
|
|
|
if (err_msg)
|
|
|
|
*err_msg = g_strdup_printf("Value %s out of range. Must be in %d..%d.", str, min, max);
|
2015-03-15 21:06:40 -04:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
*saveptr = val;
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2015-01-17 16:09:40 -05:00
|
|
|
int
|
2015-10-25 20:52:33 -04:00
|
|
|
utf8_display_len(const char* const str)
|
2015-01-17 16:09:40 -05:00
|
|
|
{
|
|
|
|
if (!str) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int len = 0;
|
|
|
|
gchar* curr = g_utf8_offset_to_pointer(str, 0);
|
|
|
|
while (*curr != '\0') {
|
|
|
|
gunichar curru = g_utf8_get_char(curr);
|
|
|
|
if (g_unichar_iswide(curru)) {
|
|
|
|
len += 2;
|
|
|
|
} else {
|
|
|
|
len++;
|
|
|
|
}
|
|
|
|
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
|
|
|
{
|
2019-05-03 04:30:44 -04:00
|
|
|
char* url = "https://profanity-im.github.io/profanity_version.txt";
|
2013-01-28 15:07:25 -05:00
|
|
|
|
|
|
|
CURL* handle = curl_easy_init();
|
|
|
|
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);
|
|
|
|
curl_easy_setopt(handle, CURLOPT_WRITEDATA, (void*)&output);
|
|
|
|
|
|
|
|
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
|
|
|
|
release_is_new(char* found_version)
|
|
|
|
{
|
|
|
|
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,
|
2013-04-20 18:39:17 -04:00
|
|
|
&curr_patch);
|
|
|
|
int parse_found = sscanf(found_version, "%d.%d.%d", &found_maj, &found_min,
|
|
|
|
&found_patch);
|
|
|
|
|
|
|
|
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
|
|
|
|
&& found_patch > curr_patch) {
|
|
|
|
return TRUE;
|
|
|
|
} else {
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-28 15:07:25 -05:00
|
|
|
static size_t
|
|
|
|
_data_callback(void* ptr, size_t size, size_t nmemb, void* data)
|
|
|
|
{
|
|
|
|
size_t realsize = size * nmemb;
|
|
|
|
struct curl_data_t* mem = (struct curl_data_t*)data;
|
|
|
|
mem->buffer = realloc(mem->buffer, mem->size + realsize + 1);
|
|
|
|
|
|
|
|
if (mem->buffer) {
|
|
|
|
memcpy(&(mem->buffer[mem->size]), ptr, realsize);
|
|
|
|
mem->size += realsize;
|
|
|
|
mem->buffer[mem->size] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return realsize;
|
|
|
|
}
|
2014-10-26 16:43:05 -04:00
|
|
|
|
2023-08-29 07:46:07 -04:00
|
|
|
static gchar*
|
|
|
|
_get_file_or_linked(gchar* loc)
|
2014-10-26 16:43:05 -04:00
|
|
|
{
|
2023-08-29 07:46:07 -04:00
|
|
|
auto_gchar gchar* basedir = g_path_get_dirname(loc);
|
2023-08-29 05:50:40 -04:00
|
|
|
gchar* true_loc = g_strdup(loc);
|
2014-10-26 16:43:05 -04:00
|
|
|
|
|
|
|
// check for symlink
|
2023-08-29 05:50:40 -04:00
|
|
|
while (g_file_test(true_loc, G_FILE_TEST_IS_SYMLINK)) {
|
|
|
|
gchar* tmp = g_file_read_link(true_loc, NULL);
|
|
|
|
g_free(true_loc);
|
|
|
|
true_loc = tmp;
|
2014-10-26 16:43:05 -04:00
|
|
|
|
|
|
|
// if relative, add basedir
|
|
|
|
if (!g_str_has_prefix(true_loc, "/") && !g_str_has_prefix(true_loc, "~")) {
|
2023-08-29 05:50:40 -04:00
|
|
|
tmp = g_strdup_printf("%s/%s", basedir, true_loc);
|
2023-07-11 07:23:58 -04:00
|
|
|
g_free(true_loc);
|
2023-03-17 18:58:33 -04:00
|
|
|
true_loc = tmp;
|
2014-10-26 16:43:05 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true_loc;
|
|
|
|
}
|
2015-02-08 15:59:51 -05:00
|
|
|
|
2015-10-25 20:52:33 -04:00
|
|
|
char*
|
|
|
|
strip_arg_quotes(const char* const input)
|
2015-02-08 15:59:51 -05:00
|
|
|
{
|
|
|
|
char* unquoted = strdup(input);
|
|
|
|
|
|
|
|
// Remove starting quote if it exists
|
2015-05-04 18:26:08 -04:00
|
|
|
if (strchr(unquoted, '"')) {
|
2015-02-08 15:59:51 -05:00
|
|
|
if (strchr(unquoted, ' ') + 1 == strchr(unquoted, '"')) {
|
|
|
|
memmove(strchr(unquoted, '"'), strchr(unquoted, '"') + 1, strchr(unquoted, '\0') - strchr(unquoted, '"'));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Remove ending quote if it exists
|
2015-05-04 18:26:08 -04:00
|
|
|
if (strchr(unquoted, '"')) {
|
2015-02-08 15:59:51 -05:00
|
|
|
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
|
|
|
}
|
2015-10-09 05:50:21 -04:00
|
|
|
|
|
|
|
gboolean
|
|
|
|
is_notify_enabled(void)
|
|
|
|
{
|
|
|
|
gboolean notify_enabled = FALSE;
|
|
|
|
|
2016-03-31 16:05:02 -04:00
|
|
|
#ifdef HAVE_OSXNOTIFY
|
2015-10-09 05:50:21 -04:00
|
|
|
notify_enabled = TRUE;
|
|
|
|
#endif
|
2016-03-31 16:05:02 -04:00
|
|
|
#ifdef HAVE_LIBNOTIFY
|
2015-10-09 05:50:21 -04:00
|
|
|
notify_enabled = TRUE;
|
|
|
|
#endif
|
2016-03-31 16:05:02 -04:00
|
|
|
#ifdef PLATFORM_CYGWIN
|
2015-10-09 05:50:21 -04:00
|
|
|
notify_enabled = TRUE;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return notify_enabled;
|
|
|
|
}
|
2016-04-03 17:30:24 -04:00
|
|
|
|
2016-04-06 20:01:27 -04:00
|
|
|
GSList*
|
|
|
|
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) {
|
2016-04-06 20:01:27 -04:00
|
|
|
return *result;
|
2016-04-03 17:30:24 -04:00
|
|
|
}
|
|
|
|
|
2023-03-10 08:52:54 -05:00
|
|
|
do {
|
|
|
|
gchar* haystack_curr = g_utf8_offset_to_pointer(haystack, offset);
|
|
|
|
if (g_str_has_prefix(haystack_curr, needle)) {
|
|
|
|
if (whole_word) {
|
|
|
|
gunichar before = 0;
|
|
|
|
gchar* haystack_before_ch = g_utf8_find_prev_char(haystack, haystack_curr);
|
|
|
|
if (haystack_before_ch) {
|
|
|
|
before = g_utf8_get_char(haystack_before_ch);
|
|
|
|
}
|
|
|
|
|
|
|
|
gunichar after = 0;
|
|
|
|
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 {
|
2016-04-06 20:01:27 -04:00
|
|
|
*result = g_slist_append(*result, GINT_TO_POINTER(offset));
|
|
|
|
}
|
2016-04-03 17:30:24 -04:00
|
|
|
}
|
2016-04-06 20:01:27 -04:00
|
|
|
|
2023-03-10 08:52:54 -05:00
|
|
|
offset++;
|
|
|
|
} while (g_strcmp0(g_utf8_offset_to_pointer(haystack, offset), "\0") != 0);
|
2016-04-06 20:01:27 -04:00
|
|
|
|
|
|
|
return *result;
|
2016-04-03 17:30:24 -04:00
|
|
|
}
|
|
|
|
|
2017-02-05 16:09:03 -05:00
|
|
|
int
|
|
|
|
is_regular_file(const char* path)
|
|
|
|
{
|
|
|
|
struct stat st;
|
2019-10-04 17:29:10 -04:00
|
|
|
int ret = stat(path, &st);
|
|
|
|
if (ret != 0) {
|
|
|
|
perror(NULL);
|
|
|
|
return 0;
|
|
|
|
}
|
2017-02-05 16:09:03 -05:00
|
|
|
return S_ISREG(st.st_mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
is_dir(const char* path)
|
|
|
|
{
|
|
|
|
struct stat st;
|
2019-10-04 17:29:10 -04:00
|
|
|
int ret = stat(path, &st);
|
|
|
|
if (ret != 0) {
|
|
|
|
perror(NULL);
|
|
|
|
return 0;
|
|
|
|
}
|
2017-02-05 16:09:03 -05:00
|
|
|
return S_ISDIR(st.st_mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
get_file_paths_recursive(const char* path, GSList** contents)
|
|
|
|
{
|
|
|
|
if (!is_dir(path)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
GDir* directory = g_dir_open(path, 0, NULL);
|
|
|
|
const gchar* entry = g_dir_read_name(directory);
|
2023-03-17 18:58:33 -04:00
|
|
|
gchar* full;
|
2017-02-05 16:09:03 -05:00
|
|
|
while (entry) {
|
2023-03-17 18:58:33 -04:00
|
|
|
if (g_str_has_suffix(path, "/")) {
|
|
|
|
full = g_strdup_printf("%s%s", path, entry);
|
|
|
|
} else {
|
|
|
|
full = g_strdup_printf("%s/%s", path, entry);
|
2017-02-05 16:09:03 -05:00
|
|
|
}
|
|
|
|
|
2023-03-17 18:58:33 -04:00
|
|
|
if (is_dir(full)) {
|
|
|
|
get_file_paths_recursive(full, contents);
|
|
|
|
} else if (is_regular_file(full)) {
|
|
|
|
*contents = g_slist_append(*contents, full);
|
2017-02-05 16:09:03 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
entry = g_dir_read_name(directory);
|
|
|
|
}
|
|
|
|
}
|
2019-10-16 04:39:35 -04:00
|
|
|
|
|
|
|
char*
|
|
|
|
get_random_string(int length)
|
|
|
|
{
|
|
|
|
GRand* prng;
|
|
|
|
char* rand;
|
|
|
|
char alphabet[] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
2021-04-17 16:37:21 -04:00
|
|
|
int endrange = sizeof(alphabet) - 1;
|
2019-10-16 04:39:35 -04:00
|
|
|
|
|
|
|
rand = calloc(length + 1, sizeof(char));
|
|
|
|
|
|
|
|
prng = g_rand_new();
|
|
|
|
|
2020-11-09 05:03:54 -05:00
|
|
|
for (int i = 0; i < length; i++) {
|
2021-04-17 16:37:21 -04:00
|
|
|
rand[i] = alphabet[g_rand_int_range(prng, 0, endrange)];
|
2019-10-16 04:39:35 -04:00
|
|
|
}
|
|
|
|
g_rand_free(prng);
|
|
|
|
|
|
|
|
return rand;
|
|
|
|
}
|
2020-02-20 04:03:36 -05:00
|
|
|
|
|
|
|
GSList*
|
|
|
|
get_mentions(gboolean whole_word, gboolean case_sensitive, const char* const message, const char* const nick)
|
|
|
|
{
|
|
|
|
GSList* mentions = NULL;
|
2023-04-18 20:44:19 -04:00
|
|
|
auto_gchar gchar* message_search = case_sensitive ? g_strdup(message) : g_utf8_strdown(message, -1);
|
|
|
|
auto_gchar gchar* mynick_search = case_sensitive ? g_strdup(nick) : g_utf8_strdown(nick, -1);
|
2020-02-20 04:03:36 -05:00
|
|
|
|
|
|
|
mentions = prof_occurrences(mynick_search, message_search, 0, whole_word, &mentions);
|
|
|
|
|
|
|
|
return mentions;
|
|
|
|
}
|
2020-05-20 04:36:02 -04:00
|
|
|
|
2020-05-24 10:38:56 -04:00
|
|
|
gboolean
|
2022-09-26 07:29:14 -04:00
|
|
|
call_external(gchar** argv)
|
2020-05-20 04:36:02 -04:00
|
|
|
{
|
2022-09-26 07:29:14 -04:00
|
|
|
GError* spawn_error;
|
2022-08-24 16:50:24 -04:00
|
|
|
gboolean is_successful;
|
2020-12-11 09:51:01 -05:00
|
|
|
|
2022-09-26 07:29:14 -04:00
|
|
|
GSpawnFlags flags = G_SPAWN_SEARCH_PATH | G_SPAWN_STDOUT_TO_DEV_NULL | G_SPAWN_STDERR_TO_DEV_NULL;
|
|
|
|
|
|
|
|
is_successful = g_spawn_async(NULL, // Inherit the parent PWD
|
|
|
|
argv,
|
|
|
|
NULL, // Inherit the parent environment
|
|
|
|
flags,
|
|
|
|
NULL, NULL, NULL,
|
|
|
|
&spawn_error);
|
2022-08-24 16:50:24 -04:00
|
|
|
if (!is_successful) {
|
2023-04-18 20:44:19 -04:00
|
|
|
auto_gchar gchar* cmd = g_strjoinv(" ", argv);
|
2022-09-26 07:29:14 -04:00
|
|
|
log_error("Spawning '%s' failed with error '%s'", cmd, spawn_error ? spawn_error->message : "Unknown, spawn_error is NULL");
|
2022-08-24 16:50:24 -04:00
|
|
|
|
|
|
|
g_error_free(spawn_error);
|
|
|
|
}
|
2020-05-20 04:36:02 -04:00
|
|
|
|
2022-08-24 16:50:24 -04:00
|
|
|
return is_successful;
|
2020-05-20 04:36:02 -04:00
|
|
|
}
|
2020-12-03 10:43:07 -05:00
|
|
|
|
2023-07-13 10:46:24 -04:00
|
|
|
/**
|
|
|
|
* @brief Formats an argument vector for calling an external command with placeholders.
|
|
|
|
*
|
|
|
|
* This function constructs an argument vector (argv) based on the provided template string, replacing placeholders ("%u" and "%p") with the provided URL and filename, respectively.
|
|
|
|
*
|
|
|
|
* @param template The template string with placeholders.
|
|
|
|
* @param url The URL to replace "%u" (or NULL to skip).
|
|
|
|
* @param filename The filename to replace "%p" (or NULL to skip).
|
|
|
|
* @return The constructed argument vector (argv) as a null-terminated array of strings.
|
|
|
|
*
|
|
|
|
* @note Remember to free the returned argument vector using `auto_gcharv` or `g_strfreev()`.
|
|
|
|
*/
|
2020-12-03 10:43:07 -05: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;
|
|
|
|
}
|
2020-12-04 10:13:13 -05:00
|
|
|
|
2023-11-14 08:55:29 -05:00
|
|
|
static gchar*
|
2020-12-04 10:13:13 -05:00
|
|
|
_unique_filename(const char* filename)
|
|
|
|
{
|
|
|
|
gchar* unique = g_strdup(filename);
|
|
|
|
|
|
|
|
unsigned int i = 0;
|
|
|
|
while (g_file_test(unique, G_FILE_TEST_EXISTS)) {
|
2021-03-30 11:38:13 -04:00
|
|
|
g_free(unique);
|
2020-12-04 10:13:13 -05:00
|
|
|
|
|
|
|
if (i > 1000) { // Give up after 1000 attempts.
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2021-03-30 11:38:13 -04:00
|
|
|
unique = g_strdup_printf("%s.%u", filename, i);
|
|
|
|
if (!unique) {
|
2020-12-04 10:13:13 -05:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return unique;
|
|
|
|
}
|
|
|
|
|
2023-11-14 08:55:29 -05:00
|
|
|
static bool
|
2020-12-06 11:02:09 -05:00
|
|
|
_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));
|
|
|
|
}
|
|
|
|
|
2023-07-13 10:46:24 -04:00
|
|
|
/**
|
|
|
|
* @brief Extracts the basename from a given URL.
|
|
|
|
*
|
|
|
|
* @param url The URL to extract the basename from.
|
|
|
|
* @return The extracted basename or a default name ("index") if the basename has a directory suffix.
|
|
|
|
*
|
|
|
|
* @note The returned string must be freed by the caller using `auto_free` or `free()`.
|
|
|
|
*/
|
2020-12-06 11:02:09 -05:00
|
|
|
char*
|
2023-04-19 08:19:47 -04:00
|
|
|
basename_from_url(const char* url)
|
2020-12-04 10:13:13 -05:00
|
|
|
{
|
2020-12-06 11:02:09 -05:00
|
|
|
const char* default_name = "index";
|
2020-12-04 10:13:13 -05:00
|
|
|
|
2020-12-06 11:02:09 -05:00
|
|
|
GFile* file = g_file_new_for_commandline_arg(url);
|
2023-07-13 11:04:59 -04:00
|
|
|
auto_gchar gchar* basename = g_file_get_basename(file);
|
|
|
|
g_object_unref(file);
|
2020-12-04 10:13:13 -05:00
|
|
|
|
2020-12-06 11:02:09 -05:00
|
|
|
if (_has_directory_suffix(basename)) {
|
2023-07-13 11:04:59 -04:00
|
|
|
return strdup(default_name);
|
2020-12-04 10:13:13 -05:00
|
|
|
}
|
|
|
|
|
2023-07-13 11:04:59 -04:00
|
|
|
return strdup(basename);
|
2020-12-04 10:13:13 -05:00
|
|
|
}
|
|
|
|
|
2023-07-13 10:46:24 -04:00
|
|
|
/**
|
|
|
|
* Expands the provided path by resolving special characters like '~' and 'file://'.
|
|
|
|
*
|
|
|
|
* @param path The path to expand.
|
|
|
|
* @return The expanded path.
|
|
|
|
*
|
|
|
|
* @note Remember to free the returned value using `auto_gchar` or `g_free()`.
|
|
|
|
*/
|
2020-12-09 02:25:37 -05:00
|
|
|
gchar*
|
2020-12-09 13:24:15 -05:00
|
|
|
get_expanded_path(const char* path)
|
2020-12-09 02:25:37 -05:00
|
|
|
{
|
2021-03-09 14:45:29 -05:00
|
|
|
if (g_str_has_prefix(path, "file://")) {
|
|
|
|
path += strlen("file://");
|
|
|
|
}
|
2020-12-09 02:25:37 -05:00
|
|
|
if (strlen(path) >= 2 && path[0] == '~' && path[1] == '/') {
|
2023-03-17 18:58:33 -04:00
|
|
|
return g_strdup_printf("%s/%s", getenv("HOME"), path + 2);
|
2020-12-09 02:25:37 -05:00
|
|
|
} else {
|
2023-03-17 18:58:33 -04:00
|
|
|
return g_strdup_printf("%s", path);
|
2020-12-09 02:25:37 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-07-13 10:46:24 -04:00
|
|
|
/**
|
|
|
|
* Generates a unique filename based on the provided URL and path.
|
|
|
|
*
|
|
|
|
* @param url The URL to derive the basename from.
|
|
|
|
* @param path The path to prepend to the generated filename. If NULL, the current directory is used.
|
|
|
|
* @return A unique filename combining the path and derived basename from the URL.
|
|
|
|
*
|
|
|
|
* @note Remember to free the returned value using `auto_gchar` or `g_free()`.
|
|
|
|
*/
|
2020-12-04 10:13:13 -05:00
|
|
|
gchar*
|
|
|
|
unique_filename_from_url(const char* url, const char* path)
|
|
|
|
{
|
2023-04-18 20:44:19 -04:00
|
|
|
auto_gchar gchar* realpath = NULL;
|
2020-12-09 02:25:37 -05:00
|
|
|
|
2020-12-06 11:02:09 -05:00
|
|
|
// Default to './' as path when none has been provided.
|
|
|
|
if (path == NULL) {
|
2020-12-09 13:24:15 -05:00
|
|
|
realpath = g_strdup("./");
|
2020-12-09 02:25:37 -05:00
|
|
|
} else {
|
|
|
|
realpath = get_expanded_path(path);
|
2020-12-04 10:13:13 -05:00
|
|
|
}
|
|
|
|
|
2020-12-06 11:02:09 -05:00
|
|
|
// Resolves paths such as './../.' for path.
|
2020-12-09 02:25:37 -05:00
|
|
|
GFile* target = g_file_new_for_commandline_arg(realpath);
|
2023-04-18 20:44:19 -04:00
|
|
|
auto_gchar gchar* filename = NULL;
|
2020-12-04 10:13:13 -05:00
|
|
|
|
2020-12-09 02:25:37 -05:00
|
|
|
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.
|
2023-07-13 11:04:59 -04:00
|
|
|
auto_char char* basename = basename_from_url(url);
|
2020-12-06 11:02:09 -05:00
|
|
|
filename = g_build_filename(g_file_peek_path(target), basename, NULL);
|
|
|
|
} else {
|
|
|
|
// Just use the target as filename.
|
|
|
|
filename = g_build_filename(g_file_peek_path(target), NULL);
|
2020-12-04 10:13:13 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
gchar* unique_filename = _unique_filename(filename);
|
2020-12-06 11:02:09 -05:00
|
|
|
if (unique_filename == NULL) {
|
2020-12-04 10:13:13 -05:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2020-12-06 11:02:09 -05:00
|
|
|
g_object_unref(target);
|
|
|
|
|
2020-12-04 10:13:13 -05:00
|
|
|
return unique_filename;
|
|
|
|
}
|
2022-12-27 17:17:33 -05:00
|
|
|
|
2023-07-25 14:58:15 -04:00
|
|
|
/* build profanity version string.
|
|
|
|
* example: 0.13.1dev.master.69d8c1f9
|
|
|
|
*/
|
|
|
|
gchar*
|
|
|
|
prof_get_version(void)
|
|
|
|
{
|
|
|
|
if (strcmp(PACKAGE_STATUS, "development") == 0) {
|
|
|
|
#ifdef HAVE_GIT_VERSION
|
|
|
|
return g_strdup_printf("%sdev.%s.%s", PACKAGE_VERSION, PROF_GIT_BRANCH, PROF_GIT_REVISION);
|
|
|
|
#else
|
|
|
|
return g_strdup_printf("%sdev", PACKAGE_VERSION);
|
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
return g_strdup_printf("%s", PACKAGE_VERSION);
|
|
|
|
}
|
|
|
|
}
|