void prefs_common_read_config(void)
{
FILE *fp;
gchar *path;
gchar buf[PREFSBUFSIZE];
path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
prefs_read_config(param, "Common", path, NULL);
g_free(path);
prefs_common.online_mode = TRUE;
path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMAND_HISTORY,
NULL);
if ((fp = g_fopen(path, "rb")) == NULL) {
if (ENOENT != errno) FILE_OP_ERROR(path, "fopen");
g_free(path);
return;
}
g_free(path);
while (fgets(buf, sizeof(buf), fp) != NULL) {
g_strstrip(buf);
if (buf[0] == '\0') continue;
prefs_common.mime_open_cmd_history =
add_history(prefs_common.mime_open_cmd_history, buf);
}
fclose(fp);
prefs_common.mime_open_cmd_history =
g_list_reverse(prefs_common.mime_open_cmd_history);
}
gchar *partial_get_filename(const gchar *server, const gchar *login,
const gchar *muidl)
{
gchar *path;
gchar *result = NULL;
FILE *fp;
gchar buf[POPBUFSIZE];
gchar uidl[POPBUFSIZE];
time_t recv_time;
time_t now;
gchar *sanitized_uid = g_strdup(login);
subst_for_filename(sanitized_uid);
path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
"uidl", G_DIR_SEPARATOR_S,
server, "-", sanitized_uid, NULL);
if ((fp = g_fopen(path, "rb")) == NULL) {
if (ENOENT != errno) FILE_OP_ERROR(path, "fopen");
g_free(path);
path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
"uidl-", server,
"-", sanitized_uid, NULL);
if ((fp = g_fopen(path, "rb")) == NULL) {
if (ENOENT != errno) FILE_OP_ERROR(path, "fopen");
g_free(sanitized_uid);
g_free(path);
return result;
}
}
g_free(sanitized_uid);
g_free(path);
now = time(NULL);
while (fgets(buf, sizeof(buf), fp) != NULL) {
gchar tmp[POPBUFSIZE];
strretchomp(buf);
recv_time = RECV_TIME_NONE;
if (sscanf(buf, "%s\t%ld\t%s", uidl, (long int *) &recv_time,
tmp) < 2) {
if (sscanf(buf, "%s", uidl) != 1)
continue;
else {
recv_time = now;
}
}
if (!strcmp(muidl, uidl)) {
result = g_strdup(tmp);
break;
}
}
fclose(fp);
return result;
}
static gchar *_old_rssyl_item_get_path(Folder *folder, FolderItem *item)
{
gchar *result, *tmp;
if (folder_item_parent(item) == NULL)
return g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, RSSYL_DIR, NULL);
tmp = rssyl_strreplace(item->name, "/", "\\");
result = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, RSSYL_DIR,
G_DIR_SEPARATOR_S, tmp, NULL);
g_free(tmp);
return result;
}
void address_keeper_prefs_init(void)
{
static gchar *path[3];
gchar *rcpath;
gchar *tmp;
path[0] = _("Plugins");
path[1] = _("Address Keeper");
path[2] = NULL;
prefs_set_default(param);
rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
prefs_read_config(param, PREFS_BLOCK_NAME, rcpath, NULL);
g_free(rcpath);
tmp = g_malloc(strlen(addkeeperprefs.block_matching_addrs) + 1);
pref_get_unescaped_pref(tmp, addkeeperprefs.block_matching_addrs);
g_free(addkeeperprefs.block_matching_addrs);
addkeeperprefs.block_matching_addrs = tmp;
addkeeperprefs_page.page.path = path;
addkeeperprefs_page.page.create_widget = addkeeper_prefs_create_widget_func;
addkeeperprefs_page.page.destroy_widget = addkeeper_prefs_destroy_widget_func;
addkeeperprefs_page.page.save_page = addkeeper_prefs_save_func;
addkeeperprefs_page.page.weight = 40.0;
prefs_gtk_register_page((PrefsPage *) &addkeeperprefs_page);
}
gint plugin_init(gchar **error)
{
gchar *rcpath;
if (!check_plugin_version(MAKE_NUMERIC_VERSION(2,9,2,72),
VERSION_NUMERIC, _("Fetchinfo"), error))
return -1;
mail_receive_hook_id = hooks_register_hook(MAIL_RECEIVE_HOOKLIST, mail_receive_hook, NULL);
if (mail_receive_hook_id == (guint)-1) {
/* i18n: Possible error message during plugin load */
*error = g_strdup(_("Failed to register mail receive hook"));
return -1;
}
prefs_set_default(param);
rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
prefs_read_config(param, "Fetchinfo", rcpath, NULL);
g_free(rcpath);
fetchinfo_gtk_init();
debug_print("Fetchinfo plugin loaded\n");
return 0;
}
void fetchinfo_save_config(void)
{
PrefFile *pfile;
gchar *rcpath;
debug_print("Saving Fetchinfo Page\n");
rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
pfile = prefs_write_open(rcpath);
g_free(rcpath);
if (!pfile || (prefs_set_block_label(pfile, "Fetchinfo") < 0))
return;
if (prefs_write_param(param, pfile->fp) < 0) {
/* i18n: Possible error message during plugin load */
g_warning("failed to write Fetchinfo configuration to file");
prefs_file_close_revert(pfile);
return;
}
if (fprintf(pfile->fp, "\n") < 0) {
FILE_OP_ERROR(rcpath, "fprintf");
prefs_file_close_revert(pfile);
} else
prefs_file_close(pfile);
}
gchar *libravatar_cache_init(const char *dirs[], gint start, gint end)
{
gchar *subdir, *rootdir;
int i;
rootdir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
LIBRAVATAR_CACHE_DIR, G_DIR_SEPARATOR_S,
NULL);
if (!is_dir_exist(rootdir)) {
if (make_dir(rootdir) < 0) {
g_warning("cannot create root directory '%s'", rootdir);
g_free(rootdir);
return NULL;
}
}
for (i = start; i <= end; ++i) {
subdir = g_strconcat(rootdir, dirs[i], NULL);
if (!is_dir_exist(subdir)) {
if (make_dir(subdir) < 0) {
g_warning("cannot create directory '%s'", subdir);
g_free(subdir);
g_free(rootdir);
return NULL;
}
}
g_free(subdir);
}
return rootdir;
}
void set_log_file(LogInstance instance, const gchar *filename)
{
gchar *fullname = NULL;
if (log_fp[instance])
return;
if (!g_path_is_absolute(filename)) {
fullname = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
filename, NULL);
} else {
fullname = g_strdup(filename);
}
/* backup old logfile if existing */
if (is_file_exist(fullname)) {
gchar *backupname;
backupname = g_strconcat(fullname, ".bak", NULL);
claws_unlink(backupname);
if (g_rename(fullname, backupname) < 0)
FILE_OP_ERROR(fullname, "rename");
g_free(backupname);
}
log_fp[instance] = g_fopen(fullname, "wb");
if (!log_fp[instance]) {
FILE_OP_ERROR(fullname, "fopen");
log_filename[instance] = NULL;
g_free(fullname);
return;
}
log_filename[instance] = g_strdup(fullname);
log_size[instance] = 0;
g_free(fullname);
}
void prefs_account_write_config_all(GList *account_list)
{
GList *cur;
gchar *rcpath;
PrefFile *pfile;
rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, ACCOUNT_RC, NULL);
if ((pfile = prefs_file_open(rcpath)) == NULL) {
g_free(rcpath);
return;
}
g_free(rcpath);
for (cur = account_list; cur != NULL; cur = cur->next) {
tmp_ac_prefs = *(PrefsAccount *)cur->data;
if (fprintf(pfile->fp, "[Account: %d]\n",
tmp_ac_prefs.account_id) <= 0 ||
prefs_file_write_param(pfile, param) < 0) {
g_warning(_("failed to write configuration to file\n"));
prefs_file_close_revert(pfile);
return;
}
if (cur->next) {
if (fputc('\n', pfile->fp) == EOF) {
FILE_OP_ERROR(rcpath, "fputc");
prefs_file_close_revert(pfile);
return;
}
}
}
if (prefs_file_close(pfile) < 0)
g_warning(_("failed to write configuration to file\n"));
}
void prefs_account_read_config(PrefsAccount *ac_prefs, const gchar *label)
{
const gchar *p = label;
gchar *rcpath;
gint id;
g_return_if_fail(ac_prefs != NULL);
g_return_if_fail(label != NULL);
memset(&tmp_ac_prefs, 0, sizeof(PrefsAccount));
rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, ACCOUNT_RC, NULL);
prefs_read_config(param, label, rcpath, NULL);
g_free(rcpath);
*ac_prefs = tmp_ac_prefs;
while (*p && !g_ascii_isdigit(*p)) p++;
id = atoi(p);
if (id < 0) g_warning("wrong account id: %d\n", id);
ac_prefs->account_id = id;
if (ac_prefs->protocol == A_APOP) {
debug_print("converting protocol A_APOP to new prefs.\n");
ac_prefs->protocol = A_POP3;
ac_prefs->use_apop_auth = TRUE;
}
custom_header_read_config(ac_prefs);
}
static void cm_gdata_save_config(void)
{
PrefFile *pfile;
gchar *rcpath;
debug_print("Saving GData plugin configuration...\n");
rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
pfile = prefs_write_open(rcpath);
g_free(rcpath);
if (!pfile || (prefs_set_block_label(pfile, "GDataPlugin") < 0))
return;
if (prefs_write_param(cm_gdata_param, pfile->fp) < 0) {
debug_print("failed!\n");
g_warning("GData Plugin: Failed to write plugin configuration to file");
prefs_file_close_revert(pfile);
return;
}
if (fprintf(pfile->fp, "\n") < 0) {
FILE_OP_ERROR(rcpath, "fprintf");
prefs_file_close_revert(pfile);
}
else
prefs_file_close(pfile);
debug_print("done.\n");
}
GList *editor_get_desktop_files(void)
{
gchar *path;
gchar *xdg_data_dirs;
gchar *all_dirs;
gchar **split_dirs;
gint i;
GList *list = NULL;
xdg_data_dirs = getenv("XDG_DATA_DIRS");
if (xdg_data_dirs && xdg_data_dirs[0])
xdg_data_dirs = path_to_utf8(xdg_data_dirs);
else
xdg_data_dirs = g_strdup("/usr/share");
all_dirs = g_strconcat(get_rc_dir(), ":", GQ_APP_DIR, ":", xdg_data_home_get(), ":", xdg_data_dirs, NULL);
g_free(xdg_data_dirs);
split_dirs = g_strsplit(all_dirs, ":", 0);
g_free(all_dirs);
for (i = 0; split_dirs[i]; i++);
for (--i; i >= 0; i--)
{
path = g_build_filename(split_dirs[i], "applications", NULL);
list = editor_add_desktop_dir(list, path);
g_free(path);
}
g_strfreev(split_dirs);
return list;
}
static void save_rssyl_prefs(PrefsPage *page)
{
RSSylPrefsPage *prefs_page = (RSSylPrefsPage *)page;
PrefFile *pref_file;
gchar *rc_file_path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
COMMON_RC, NULL);
rssyl_prefs.refresh = gtk_spin_button_get_value_as_int(
GTK_SPIN_BUTTON(prefs_page->refresh));
rssyl_prefs.expired = gtk_spin_button_get_value_as_int(
GTK_SPIN_BUTTON(prefs_page->expired));
rssyl_prefs.refresh_on_startup = gtk_toggle_button_get_active(
GTK_TOGGLE_BUTTON(prefs_page->refresh_on_startup));
g_free(rssyl_prefs.cookies_path);
rssyl_prefs.cookies_path = g_strdup(gtk_entry_get_text(
GTK_ENTRY(prefs_page->cookies_path)));
pref_file = prefs_write_open(rc_file_path);
g_free(rc_file_path);
if( !pref_file || prefs_set_block_label(pref_file, PREFS_BLOCK_NAME) < 0 )
return;
if( prefs_write_param(param, pref_file->fp) < 0 ) {
g_warning("Failed to write RSSyl plugin configuration\n");
prefs_file_close_revert(pref_file);
return;
}
if (fprintf(pref_file->fp, "\n") < 0) {
FILE_OP_ERROR(rc_file_path, "fprintf");
prefs_file_close_revert(pref_file);
} else
prefs_file_close(pref_file);
}
gint plugin_init(gchar **error)
{
gchar *rcpath;
hook_id = HOOK_NONE;
if (!check_plugin_version(MAKE_NUMERIC_VERSION(2,9,2,72),
VERSION_NUMERIC, PLUGIN_NAME, error))
return -1;
prefs_set_default(param);
rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL);
prefs_read_config(param, "Bogofilter", rcpath, NULL);
g_free(rcpath);
bogofilter_gtk_init();
debug_print("Bogofilter plugin loaded\n");
#ifdef USE_PTHREAD
bogofilter_start_thread();
#endif
if (config.process_emails) {
bogofilter_register_hook();
}
procmsg_register_spam_learner(bogofilter_learn);
procmsg_spam_set_folder(config.save_folder, bogofilter_get_spam_folder);
return 0;
}
static void read_config(void)
{
gchar *path;
gboolean initial = FALSE;
debug_print("autoenc: read_config\n");
path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, "autoencrc", NULL);
if (!is_file_exist(path)) {
initial = TRUE;
prefs_set_default(param);
} else {
prefs_read_config(param, "AutoEncrypt", path, NULL);
}
if (!config.autoenc_template_subject) {
config.autoenc_template_subject =
g_strdup(_("Password of encrypted file"));
}
if (!config.autoenc_template_body) {
config.autoenc_template_body =
g_strdup(_("Subject: %s\\n"
"Date: %d\\n"
"The password of the encrypted file attached in the above mail is as follows:\\n"
"\\n"
"File name: %z\\n"
"Password: %p"));
}
if (initial) {
write_config();
}
g_free(path);
}
/*!
*\brief create debugger script file in sylpheed directory.
* all the other options (creating temp files) looked too
* convoluted.
*/
static void crash_create_debugger_file(void)
{
gchar *filespec = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, DEBUGGERRC, NULL);
str_write_to_file(DEBUG_SCRIPT, filespec);
g_free(filespec);
}
static void browse_python_scripts_dir(GtkAction *action, gpointer data)
{
gchar *uri;
GdkAppLaunchContext *launch_context;
GError *error = NULL;
MainWindow *mainwin;
mainwin = mainwindow_get_mainwindow();
if(!mainwin) {
debug_print("Browse Python scripts: Problems getting the mainwindow\n");
return;
}
launch_context = gdk_app_launch_context_new();
gdk_app_launch_context_set_screen(launch_context, gtk_widget_get_screen(mainwin->window));
uri = g_strconcat("file://", get_rc_dir(), G_DIR_SEPARATOR_S, PYTHON_SCRIPTS_BASE_DIR, G_DIR_SEPARATOR_S, NULL);
g_app_info_launch_default_for_uri(uri, G_APP_LAUNCH_CONTEXT(launch_context), &error);
if(error) {
debug_print("Could not open scripts dir browser: '%s'\n", error->message);
g_error_free(error);
}
g_object_unref(launch_context);
g_free(uri);
}
void prefs_common_write_config(void)
{
GList *cur;
FILE *fp;
gchar *path;
prefs_write_config(param, "Common", COMMON_RC);
path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMAND_HISTORY,
NULL);
if ((fp = g_fopen(path, "wb")) == NULL) {
FILE_OP_ERROR(path, "fopen");
g_free(path);
return;
}
for (cur = prefs_common.mime_open_cmd_history;
cur != NULL; cur = cur->next) {
fputs((gchar *)cur->data, fp);
fputc('\n', fp);
}
fclose(fp);
g_free(path);
}
/* Stolen from folder.c. Return value should NOT be freed. */
static gchar *foldercheck_get_array_path(void)
{
static gchar *filename = NULL;
if(!filename)
filename = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
FOLDERCHECK_ARRAY, NULL);
return filename;
}
void save_options(ConfOptions *options)
{
gchar *rc_path;
sync_options_with_current_state(options);
rc_path = g_build_filename(get_rc_dir(), RC_FILE_NAME, NULL);
save_config_to_file(rc_path, options);
g_free(rc_path);
}
static void python_compose_script_callback(GtkAction *action, gpointer data)
{
char *filename;
ComposeActionData *dat = (ComposeActionData*)data;
filename = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, PYTHON_SCRIPTS_BASE_DIR, G_DIR_SEPARATOR_S, PYTHON_SCRIPTS_COMPOSE_DIR, G_DIR_SEPARATOR_S, dat->name, NULL);
run_script_file(filename, dat->compose);
g_free(filename);
}
static const gchar *get_autoenc_tmp_dir(void)
{
static gchar *path = NULL;
if (!path) {
path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, "autoenctmp", NULL);
}
return path;
}
static void compose_toolbar_callback(gpointer parent, const gchar *item_name, gpointer data)
{
gchar *filename;
filename = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
PYTHON_SCRIPTS_BASE_DIR, G_DIR_SEPARATOR_S,
PYTHON_SCRIPTS_COMPOSE_DIR, G_DIR_SEPARATOR_S,
item_name, NULL);
run_script_file(filename, (Compose*)parent);
g_free(filename);
}
static void python_mainwin_script_callback(GtkAction *action, gpointer data)
{
char *filename;
filename = extract_filename(data);
if(!filename)
return;
filename = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, PYTHON_SCRIPTS_BASE_DIR, G_DIR_SEPARATOR_S, PYTHON_SCRIPTS_MAIN_DIR, G_DIR_SEPARATOR_S, filename, NULL);
run_script_file(filename, NULL);
g_free(filename);
}
static void migrate_scripts_out_of_base_dir(void)
{
char *base_dir;
GDir *dir;
const char *filename;
gchar *dest_dir;
base_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, PYTHON_SCRIPTS_BASE_DIR, NULL);
dir = g_dir_open(base_dir, 0, NULL);
g_free(base_dir);
if(!dir)
return;
dest_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
PYTHON_SCRIPTS_BASE_DIR, G_DIR_SEPARATOR_S,
PYTHON_SCRIPTS_MAIN_DIR, NULL);
if(!g_file_test(dest_dir, G_FILE_TEST_IS_DIR)) {
if(g_mkdir(dest_dir, 0777) != 0) {
g_free(dest_dir);
g_dir_close(dir);
return;
}
}
while((filename = g_dir_read_name(dir)) != NULL) {
gchar *filepath;
filepath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, PYTHON_SCRIPTS_BASE_DIR, G_DIR_SEPARATOR_S, filename, NULL);
if(g_file_test(filepath, G_FILE_TEST_IS_REGULAR)) {
gchar *dest_file;
dest_file = g_strconcat(dest_dir, G_DIR_SEPARATOR_S, filename, NULL);
if(move_file(filepath, dest_file, FALSE) == 0)
debug_print("Python plugin: Moved file '%s' to %s subdir\n", filename, PYTHON_SCRIPTS_MAIN_DIR);
else
debug_print("Python plugin: Warning: Could not move file '%s' to %s subdir\n", filename, PYTHON_SCRIPTS_MAIN_DIR);
g_free(dest_file);
}
g_free(filepath);
}
g_dir_close(dir);
g_free(dest_dir);
}
static char* make_sure_script_directory_exists(const gchar *subdir)
{
char *dir;
char *retval = NULL;
dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, PYTHON_SCRIPTS_BASE_DIR, G_DIR_SEPARATOR_S, subdir, NULL);
if(!g_file_test(dir, G_FILE_TEST_IS_DIR)) {
if(g_mkdir(dir, 0777) != 0)
retval = g_strdup_printf("Could not create directory '%s': %s", dir, g_strerror(errno));
}
g_free(dir);
return retval;
}
gint procmsg_save_to_outbox(FolderItem *outbox, const gchar *file,
gboolean is_queued)
{
gint num;
MsgInfo *msginfo, *tmp_msginfo;
MsgFlags flag = {0, 0};
debug_print("saving sent message...\n");
if (!outbox)
outbox = folder_get_default_outbox();
g_return_val_if_fail(outbox != NULL, -1);
/* remove queueing headers */
if (is_queued) {
gchar tmp[MAXPATHLEN + 1];
g_snprintf(tmp, sizeof(tmp), "%s%ctmpmsg.out.%08x",
get_rc_dir(), G_DIR_SEPARATOR, (guint) rand());
if (procmsg_remove_special_headers(file, tmp) !=0)
return -1;
folder_item_scan(outbox);
if ((num = folder_item_add_msg(outbox, tmp, &flag, TRUE)) < 0) {
g_warning("can't save message\n");
unlink(tmp);
return -1;
}
} else {
folder_item_scan(outbox);
if ((num = folder_item_add_msg
(outbox, file, &flag, FALSE)) < 0) {
g_warning("can't save message\n");
return -1;
}
return -1;
}
msginfo = folder_item_get_msginfo(outbox, num); /* refcnt++ */
tmp_msginfo = procmsg_msginfo_get_full_info(msginfo); /* refcnt++ */
if (msginfo != NULL) {
procmsg_msginfo_unset_flags(msginfo, ~0, 0);
procmsg_msginfo_free(msginfo); /* refcnt-- */
/* tmp_msginfo == msginfo */
if (tmp_msginfo && (msginfo->dispositionnotificationto ||
msginfo->returnreceiptto)) {
procmsg_msginfo_set_flags(msginfo, MSG_RETRCPT_SENT, 0);
procmsg_msginfo_free(msginfo); /* refcnt-- */
}
}
return 0;
}
static void run_auto_script_file_if_it_exists(const gchar *autofilename, Compose *compose)
{
gchar *auto_filepath;
/* execute auto/autofilename, if it exists */
auto_filepath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
PYTHON_SCRIPTS_BASE_DIR, G_DIR_SEPARATOR_S,
PYTHON_SCRIPTS_AUTO_DIR, G_DIR_SEPARATOR_S, autofilename, NULL);
if(file_exist(auto_filepath, FALSE))
run_script_file(auto_filepath, compose);
g_free(auto_filepath);
}
/**
* \brief Call a lua function to get a single value.
*/
gchar *lua_callvalue(FileData *fd, const gchar *file, const gchar *function)
{
gint result;
gchar *data = NULL;
gchar *dir;
gchar *path;
FileData **image_data;
gchar *tmp;
GError *error = NULL;
/* Collection Table (Dummy at the moment) */
lua_newtable(L);
lua_setglobal(L, "Collection");
/* Current Image */
image_data = (FileData **)lua_newuserdata(L, sizeof(FileData *));
luaL_getmetatable(L, "Image");
lua_setmetatable(L, -2);
lua_setglobal(L, "Image");
*image_data = fd;
if (file[0] == '\0')
{
result = luaL_dostring(L, function);
}
else
{
dir = g_build_filename(get_rc_dir(), "lua", NULL);
path = g_build_filename(dir, file, NULL);
result = luaL_dofile(L, path);
g_free(path);
g_free(dir);
}
if (result)
{
data = g_strdup_printf("Error running lua script: %s", lua_tostring(L, -1));
return data;
}
data = g_strdup(lua_tostring(L, -1));
tmp = g_locale_to_utf8(data, strlen(data), NULL, NULL, &error);
if (error)
{
log_printf("Error converting lua output from locale to UTF-8: %s\n", error->message);
g_error_free(error);
}
else
{
g_free(data);
data = g_strdup(tmp);
} // if (error) { ... } else
return data;
}
static void missing_cache_done()
{
gchar *cache_file;
if (libravatarmisses != NULL) {
cache_file = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
LIBRAVATAR_CACHE_DIR, G_DIR_SEPARATOR_S,
LIBRAVATAR_MISSING_FILE, NULL);
missing_save_to_file(libravatarmisses, cache_file);
g_free(cache_file);
g_hash_table_destroy(libravatarmisses);
}
}