pegasus/weechat
1
0
Fork 0
mirror of https://github.com/weechat/weechat.git synced 2026-06-29 22:36:38 +02:00
Code Activity
Files
399636f98453bdc1fca19b4dbc742993549aa6c3
weechat/src/core/wee-util.c
T
Sébastien Helleu cf6aca1619 core: add pointer in some callbacks (closes #406) 
This pointer is the first argument received by callbacks, and the
existing argument "data" is now automatically freed by WeeChat when the
object containing the callback is removed.

With this new pointer, the linked list of callbacks in scripts has been
removed. This will improve speed of scripts (using a lot of hooks),
reduce memory used by scripts and reduce time to unload scripts.

Following functions are affected in the C API:

* exec_on_files
* config_new
* config_new_section
* config_new_option
* hook_command
* hook_command_run
* hook_timer
* hook_fd
* hook_process
* hook_process_hashtable
* hook_connect
* hook_print
* hook_signal
* hook_hsignal
* hook_config
* hook_completion
* hook_modifier
* hook_info
* hook_info_hashtable
* hook_infolist
* hook_hdata
* hook_focus
* unhook_all_plugin
* buffer_new
* bar_item_new
* upgrade_new
* upgrade_read
2016-03-21 18:11:21 +01:00

768 lines
18 KiB
C
Raw Blame History

/*
* wee-util.c - some useful functions
*
* Copyright (C) 2003-2016 Sébastien Helleu <flashcode@flashtux.org>
*
* This file is part of WeeChat, the extensible chat client.
*
* WeeChat 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.
*
* WeeChat 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
* along with WeeChat. If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#ifdef HAVE_SYS_RESOURCE_H
#include <sys/resource.h>
#endif
#include <unistd.h>
#include <dirent.h>
#include <signal.h>
#include <ctype.h>
#include <time.h>
#include "weechat.h"
#include "wee-util.h"
#include "wee-config.h"
#include "wee-log.h"
#include "wee-string.h"
#include "wee-utf8.h"
#include "../gui/gui-chat.h"
#include "../gui/gui-window.h"
#ifdef HAVE_SYS_RESOURCE_H
struct t_rlimit_resource rlimit_resource[] =
{
#ifdef RLIMIT_AS
{ "as", RLIMIT_AS },
#endif
#ifdef RLIMIT_CORE
{ "core", RLIMIT_CORE },
#endif
#ifdef RLIMIT_CPU
{ "cpu", RLIMIT_CPU },
#endif
#ifdef RLIMIT_DATA
{ "data", RLIMIT_DATA },
#endif
#ifdef RLIMIT_FSIZE
{ "fsize", RLIMIT_FSIZE },
#endif
#ifdef RLIMIT_LOCKS
{ "locks", RLIMIT_LOCKS },
#endif
#ifdef RLIMIT_MEMLOCK
{ "memlock", RLIMIT_MEMLOCK },
#endif
#ifdef RLIMIT_MSGQUEUE
{ "msgqueue", RLIMIT_MSGQUEUE },
#endif
#ifdef RLIMIT_NICE
{ "nice", RLIMIT_NICE },
#endif
#ifdef RLIMIT_NOFILE
{ "nofile", RLIMIT_NOFILE },
#endif
#ifdef RLIMIT_NPROC
{ "nproc", RLIMIT_NPROC },
#endif
#ifdef RLIMIT_RSS
{ "rss", RLIMIT_RSS },
#endif
#ifdef RLIMIT_RTPRIO
{ "rtprio", RLIMIT_RTPRIO },
#endif
#ifdef RLIMIT_RTTIME
{ "rttime", RLIMIT_RTTIME },
#endif
#ifdef RLIMIT_SIGPENDING
{ "sigpending", RLIMIT_SIGPENDING },
#endif
#ifdef RLIMIT_STACK
{ "stack", RLIMIT_STACK },
#endif
{ NULL, 0 },
};
#endif /* HAVE_SYS_RESOURCE_H */
struct t_util_signal util_signals[] =
{ { "hup", SIGHUP },
{ "int", SIGINT },
{ "quit", SIGQUIT },
{ "kill", SIGKILL },
{ "term", SIGTERM },
{ "usr1", SIGUSR1 },
{ "usr2", SIGUSR2 },
{ NULL, 0 },
};
/*
* Sets resource limit.
*/
#ifdef HAVE_SYS_RESOURCE_H
void
util_setrlimit_resource (const char *resource_name, long limit)
{
int i;
struct rlimit rlim;
char str_limit[64];
if (!resource_name)
return;
if (limit == -1)
snprintf (str_limit, sizeof (str_limit), "unlimited");
else
snprintf (str_limit, sizeof (str_limit), "%ld", limit);
for (i = 0; rlimit_resource[i].name; i++)
{
if (strcmp (rlimit_resource[i].name, resource_name) == 0)
{
if (limit < -1)
{
gui_chat_printf (NULL,
_("%sError: invalid limit for resource \"%s\": "
"%s (must be >= -1)"),
gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
resource_name, str_limit);
return;
}
rlim.rlim_cur = (limit >= 0) ? (rlim_t)limit : RLIM_INFINITY;
rlim.rlim_max = rlim.rlim_cur;
if (setrlimit (rlimit_resource[i].resource, &rlim) == 0)
{
log_printf (_("Limit for resource \"%s\" has been set to %s"),
resource_name, str_limit);
if (gui_init_ok)
{
gui_chat_printf (NULL,
_("Limit for resource \"%s\" has been set "
"to %s"),
resource_name, str_limit);
}
}
else
{
gui_chat_printf (NULL,
_("%sError: unable to set resource limit "
"\"%s\" to %s: error %d %s"),
gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
resource_name, str_limit,
errno, strerror (errno));
}
return;
}
}
gui_chat_printf (NULL,
_("%sError: unknown resource limit \"%s\" (see /help "
"weechat.startup.sys_rlimit)"),
gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
resource_name);
}
#endif /* HAVE_SYS_RESOURCE_H */
/*
* Sets resource limits using value of option "weechat.startup.sys_rlimit".
*/
void
util_setrlimit ()
{
#ifdef HAVE_SYS_RESOURCE_H
char **items, *pos, *error;
int num_items, i;
long number;
items = string_split (CONFIG_STRING(config_startup_sys_rlimit), ",", 0, 0,
&num_items);
if (items)
{
for (i = 0; i < num_items; i++)
{
pos = strchr (items[i], ':');
if (pos)
{
pos[0] = '\0';
error = NULL;
number = strtol (pos + 1, &error, 10);
if (error && !error[0])
{
util_setrlimit_resource (items[i], number);
}
else
{
gui_chat_printf (NULL,
_("%sError: invalid limit for resource "
"\"%s\": %s (must be >= -1)"),
gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
items[i], pos + 1);
}
}
}
string_free_split (items);
}
#endif /* HAVE_SYS_RESOURCE_H */
}
/*
* Compares two timeval structures.
*
* Returns:
* -1: tv1 < tv2
* 0: tv1 == tv2
* 1: tv1 > tv2
*/
int
util_timeval_cmp (struct timeval *tv1, struct timeval *tv2)
{
if (!tv1 || !tv2)
return (tv1) ? 1 : ((tv2) ? -1 : 0);
if (tv1->tv_sec < tv2->tv_sec)
return -1;
if (tv1->tv_sec > tv2->tv_sec)
return 1;
if (tv1->tv_usec < tv2->tv_usec)
return -1;
if (tv1->tv_usec > tv2->tv_usec)
return 1;
return 0;
}
/*
* Calculates difference between two timeval structures.
*
* Returns difference in microseconds.
*/
long long
util_timeval_diff (struct timeval *tv1, struct timeval *tv2)
{
long long diff_sec, diff_usec;
if (!tv1 || !tv2)
return 0;
diff_sec = tv2->tv_sec - tv1->tv_sec;
diff_usec = tv2->tv_usec - tv1->tv_usec;
if (diff_usec < 0)
{
diff_usec += 1000000;
diff_sec--;
}
return (diff_sec * 1000000) + diff_usec;
}
/*
* Adds interval (in microseconds) to a timeval structure.
*/
void
util_timeval_add (struct timeval *tv, long long interval)
{
long long usec;
if (!tv)
return;
tv->tv_sec += (interval / 1000000);
usec = tv->tv_usec + (interval % 1000000);
if (usec > 1000000)
{
tv->tv_usec = usec % 1000000;
tv->tv_sec++;
}
else
tv->tv_usec = usec;
}
/*
* Converts date to a string, using format of option "weechat.look.time_format"
* (can be localized).
*/
const char *
util_get_time_string (const time_t *date)
{
struct tm *local_time;
static char text_time[128];
text_time[0] = '\0';
local_time = localtime (date);
if (local_time)
{
strftime (text_time, sizeof (text_time),
CONFIG_STRING(config_look_time_format), local_time);
}
return text_time;
}
/*
* Gets a signal number with a name; only some commonly used signal names are
* supported here (see declaration of util_signals[]).
*
* Returns the signal number, -1 if not found.
*/
int
util_signal_search (const char *name)
{
int i;
for (i = 0; util_signals[i].name; i++)
{
if (string_strcasecmp (util_signals[i].name, name) == 0)
return util_signals[i].signal;
}
/* signal not found */
return -1;
}
/*
* Catches a system signal.
*/
void
util_catch_signal (int signum, void (*handler)(int))
{
struct sigaction act;
sigemptyset (&act.sa_mask);
act.sa_flags = 0;
act.sa_handler = handler;
sigaction(signum, &act, NULL);
}
/*
* Creates a directory in WeeChat home.
*
* Returns:
* 1: OK
* 0: error
*/
int
util_mkdir_home (const char *directory, int mode)
{
char *dir_name;
int dir_length;
if (!directory)
return 0;
/* build directory, adding WeeChat home */
dir_length = strlen (weechat_home) + strlen (directory) + 2;
dir_name = malloc (dir_length);
if (!dir_name)
return 0;
snprintf (dir_name, dir_length, "%s/%s", weechat_home, directory);
if (mkdir (dir_name, mode) < 0)
{
if (errno != EEXIST)
{
free (dir_name);
return 0;
}
}
free (dir_name);
return 1;
}
/*
* Creates a directory.
*
* Returns:
* 1: OK
* 0: error
*/
int
util_mkdir (const char *directory, int mode)
{
if (!directory)
return 0;
if (mkdir (directory, mode) < 0)
{
if (errno != EEXIST)
return 0;
}
return 1;
}
/*
* Creates a directory and makes parent directories as needed.
*
* Returns:
* 1: OK
* 0: error
*/
int
util_mkdir_parents (const char *directory, int mode)
{
char *string, *ptr_string, *pos_sep;
struct stat buf;
int rc;
if (!directory)
return 0;
string = strdup (directory);
if (!string)
return 0;
ptr_string = string;
while (ptr_string[0] == DIR_SEPARATOR_CHAR)
{
ptr_string++;
}
while (ptr_string && ptr_string[0])
{
pos_sep = strchr (ptr_string, DIR_SEPARATOR_CHAR);
if (pos_sep)
pos_sep[0] = '\0';
rc = stat (string, &buf);
if ((rc < 0) || !S_ISDIR(buf.st_mode))
{
/* try to create directory */
if (!util_mkdir (string, mode))
{
free (string);
return 0;
}
}
if (pos_sep)
{
pos_sep[0] = DIR_SEPARATOR_CHAR;
ptr_string = pos_sep + 1;
}
else
ptr_string = NULL;
}
free (string);
return 1;
}
/*
* Finds files in a directory and executes a function on each file.
*/
void
util_exec_on_files (const char *directory, int hidden_files,
void (*callback)(void *data, const char *filename),
void *callback_data)
{
char complete_filename[1024];
DIR *dir;
struct dirent *entry;
struct stat statbuf;
if (!directory || !callback)
return;
dir = opendir (directory);
if (dir)
{
while ((entry = readdir (dir)))
{
if (hidden_files || (entry->d_name[0] != '.'))
{
snprintf (complete_filename, sizeof (complete_filename),
"%s/%s", directory, entry->d_name);
lstat (complete_filename, &statbuf);
if (!S_ISDIR(statbuf.st_mode))
{
(*callback) (callback_data, complete_filename);
}
}
}
closedir (dir);
}
}
/*
* Searches for the full name of a WeeChat library with name and extension
* (searches first in WeeChat user's dir, then WeeChat global lib directory).
*
* Returns name of library found, NULL if not found.
*
* Note: result must be freed after use (if not NULL).
*/
char *
util_search_full_lib_name_ext (const char *filename, const char *extension,
const char *plugins_dir)
{
char *name_with_ext, *final_name;
int length;
struct stat st;
length = strlen (filename) + strlen (extension) + 1;
name_with_ext = malloc (length);
if (!name_with_ext)
return NULL;
snprintf (name_with_ext, length,
"%s%s",
filename,
(strchr (filename, '.')) ? "" : extension);
/* try WeeChat user's dir */
length = strlen (weechat_home) + strlen (name_with_ext) +
strlen (plugins_dir) + 16;
final_name = malloc (length);
if (!final_name)
{
free (name_with_ext);
return NULL;
}
snprintf (final_name, length,
"%s%s%s%s%s",
weechat_home,
DIR_SEPARATOR,
plugins_dir,
DIR_SEPARATOR,
name_with_ext);
if ((stat (final_name, &st) == 0) && (st.st_size > 0))
{
free (name_with_ext);
return final_name;
}
free (final_name);
/* try WeeChat global lib dir */
length = strlen (WEECHAT_LIBDIR) + strlen (name_with_ext) +
strlen (plugins_dir) + 16;
final_name = malloc (length);
if (!final_name)
{
free (name_with_ext);
return NULL;
}
snprintf (final_name, length,
"%s%s%s%s%s",
WEECHAT_LIBDIR,
DIR_SEPARATOR,
plugins_dir,
DIR_SEPARATOR,
name_with_ext);
if ((stat (final_name, &st) == 0) && (st.st_size > 0))
{
free (name_with_ext);
return final_name;
}
free (final_name);
free (name_with_ext);
return NULL;
}
/*
* Searches for the full name of a WeeChat library with name.
*
* All extensions listed in option "weechat.plugin.extension" are tested.
*
* Note: result must be freed after use (if not NULL).
*/
char *
util_search_full_lib_name (const char *filename, const char *plugins_dir)
{
char *filename2, *full_name;
int i;
/* expand home in filename */
filename2 = string_expand_home (filename);
if (!filename2)
return NULL;
/* if full path, return it */
if (strchr (filename2, '/') || strchr (filename2, '\\'))
return filename2;
if (config_plugin_extensions)
{
for (i = 0; i < config_num_plugin_extensions; i++)
{
full_name = util_search_full_lib_name_ext (filename2,
config_plugin_extensions[i],
plugins_dir);
if (full_name)
{
free (filename2);
return full_name;
}
}
}
else
{
full_name = util_search_full_lib_name_ext (filename2, "", plugins_dir);
if (full_name)
{
free (filename2);
return full_name;
}
}
free (filename2);
return strdup (filename);
}
/*
* Reads content of a file.
*
* Returns an allocated buffer with the content of file, NULL if error.
*
* Note: result must be freed after use.
*/
char *
util_file_get_content (const char *filename)
{
char *buffer, *buffer2;
FILE *f;
size_t count, fp;
if (!filename)
return NULL;
buffer = NULL;
fp = 0;
f = fopen (filename, "r");
if (f)
{
while (!feof (f))
{
buffer2 = (char *) realloc (buffer, (fp + (1024 * sizeof (char))));
if (!buffer2)
{
if (buffer)
free (buffer);
return NULL;
}
buffer = buffer2;
count = fread (&buffer[fp], sizeof(char), 1024, f);
if (count <= 0)
{
free (buffer);
return NULL;
}
fp += count;
}
buffer2 = (char *) realloc (buffer, fp + sizeof (char));
if (!buffer2)
{
if (buffer)
free (buffer);
return NULL;
}
buffer = buffer2;
buffer[fp] = '\0';
fclose (f);
}
return buffer;
}
/*
* Gets version number (integer) with a version as string.
*
* Non-digit chars like "-dev" are ignored.
*
* Examples:
* "0.3.2-dev" ==> 197120 (== 0x00030200)
* "0.3.2-rc1" ==> 197120 (== 0x00030200)
* "0.3.2" ==> 197120 (== 0x00030200)
* "0.3.1.1" ==> 196865 (== 0x00030101)
* "0.3.1" ==> 196864 (== 0x00030100)
* "0.3.0" ==> 196608 (== 0x00030000)
*/
int
util_version_number (const char *version)
{
char **items, buf[64], *error;
const char *ptr_item;
int num_items, i, version_int[4], index_buf;
long number;
items = string_split (version, ".", 0, 4, &num_items);
for (i = 0; i < 4; i++)
{
version_int[i] = 0;
if (items && (i < num_items))
{
ptr_item = items[i];
index_buf = 0;
while (ptr_item && ptr_item[0] && (index_buf < (int)sizeof (buf) - 1))
{
if (ptr_item[0] == '-')
break;
if (isdigit ((unsigned char)ptr_item[0]))
{
buf[index_buf] = ptr_item[0];
index_buf++;
}
ptr_item = utf8_next_char (ptr_item);
}
buf[index_buf] = '\0';
if (buf[0])
{
error = NULL;
number = strtol (buf, &error, 10);
if (error && !error[0])
{
if (number < 0)
number = 0;
else if (number > 0xFF)
number = 0xFF;
version_int[i] = number;
}
}
}
}
if (items)
string_free_split (items);
return (version_int[0] << 24) | (version_int[1] << 16)
| (version_int[2] << 8) | version_int[3];
}
View Git Blame Copy Permalink