fyb/calcurse-edge
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
calcurse-edge/src/io.c
Lukas Fleischer 50be1a1772 Mark some more variables/parameters constant 
Fixes a couple of warnings seen with GCC 4.7.

Signed-off-by: Lukas Fleischer <calcurse@cryptocrack.de>
2012-04-05 22:18:51 +02:00

1474 lines
37 KiB
C
Raw Blame History

/*
* Calcurse - text-based organizer
*
* Copyright (c) 2004-2012 calcurse Development Team <misc@calcurse.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above
* copyright notice, this list of conditions and the
* following disclaimer.
*
* - Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the
* following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Send your feedback or comments to : misc@calcurse.org
* Calcurse home page : http://calcurse.org
*
*/
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <signal.h>
#include <time.h>
#include <math.h>
#include <unistd.h>
#include <errno.h>
#include "calcurse.h"
#include "sha1.h"
typedef enum {
PROGRESS_BAR_SAVE,
PROGRESS_BAR_LOAD,
PROGRESS_BAR_EXPORT
} progress_bar_t;
enum {
PROGRESS_BAR_CONF,
PROGRESS_BAR_TODO,
PROGRESS_BAR_APTS,
PROGRESS_BAR_KEYS
};
enum {
PROGRESS_BAR_EXPORT_EVENTS,
PROGRESS_BAR_EXPORT_APOINTS,
PROGRESS_BAR_EXPORT_TODO
};
struct ht_keybindings_s {
char *label;
enum key key;
HTABLE_ENTRY (ht_keybindings_s);
};
static void load_keys_ht_getkey (struct ht_keybindings_s *, char **, int *);
static int load_keys_ht_compare (struct ht_keybindings_s *,
struct ht_keybindings_s *);
#define HSIZE 256
HTABLE_HEAD (ht_keybindings, HSIZE, ht_keybindings_s);
HTABLE_GENERATE (ht_keybindings, ht_keybindings_s, load_keys_ht_getkey,
load_keys_ht_compare)
/* Draw a progress bar while saving, loading or exporting data. */
static void
progress_bar (progress_bar_t type, int progress)
{
#define NBFILES 4
#define NBEXPORTED 3
#define LABELENGTH 15
int i, step, steps;
const char *mesg_sav = _("Saving...");
const char *mesg_load = _("Loading...");
const char *mesg_export = _("Exporting...");
const char *error_msg = _("Internal error while displaying progress bar");
char *barchar = "|";
char *file[NBFILES] = {
"[ conf ]",
"[ todo ]",
"[ apts ]",
"[ keys ]"
};
char *data[NBEXPORTED] = {
"[ events ]",
"[appointments]",
"[ todo ]"
};
int ipos = LABELENGTH + 2;
int epos[NBFILES];
/* progress bar length init. */
ipos = LABELENGTH + 2;
steps = (type == PROGRESS_BAR_EXPORT) ? NBEXPORTED : NBFILES;
step = floor (col / (steps + 1));
for (i = 0; i < steps - 1; i++)
epos[i] = (i + 2) * step;
epos[steps - 1] = col - 2;
switch (type)
{
case PROGRESS_BAR_SAVE:
EXIT_IF (progress < 0 || progress > PROGRESS_BAR_KEYS, "%s", error_msg);
status_mesg (mesg_sav, file[progress]);
break;
case PROGRESS_BAR_LOAD:
EXIT_IF (progress < 0 || progress > PROGRESS_BAR_KEYS, "%s", error_msg);
status_mesg (mesg_load, file[progress]);
break;
case PROGRESS_BAR_EXPORT:
EXIT_IF (progress < 0
|| progress > PROGRESS_BAR_EXPORT_TODO, "%s", error_msg);
status_mesg (mesg_export, data[progress]);
break;
}
/* Draw the progress bar. */
mvwprintw (win[STA].p, 1, ipos, barchar);
mvwprintw (win[STA].p, 1, epos[steps - 1], barchar);
custom_apply_attr (win[STA].p, ATTR_HIGHEST);
for (i = ipos + 1; i < epos[progress]; i++)
mvwaddch (win[STA].p, 1, i, ' ' | A_REVERSE);
custom_remove_attr (win[STA].p, ATTR_HIGHEST);
wmove (win[STA].p, 0, 0);
wins_wrefresh (win[STA].p);
#undef NBFILES
#undef NBEXPORTED
#undef LABELENGTH
}
/* Ask user for a file name to export data to. */
static FILE *
get_export_stream (enum export_type type)
{
FILE *stream;
int cancel;
char *home, *stream_name;
const char *question = _("Choose the file used to export calcurse data:");
const char *wrong_name =
_("The file cannot be accessed, please enter another file name.");
const char *press_enter = _("Press [ENTER] to continue.");
const char *file_ext[IO_EXPORT_NBTYPES] = {"ical", "txt"};
stream = NULL;
stream_name = (char *) mem_malloc (BUFSIZ);
if ((home = getenv ("HOME")) != NULL)
snprintf (stream_name, BUFSIZ, "%s/calcurse.%s", home, file_ext[type]);
else
snprintf (stream_name, BUFSIZ, "%s/calcurse.%s", get_tempdir (),
file_ext[type]);
while (stream == NULL)
{
status_mesg (question, "");
cancel = updatestring (win[STA].p, &stream_name, 0, 1);
if (cancel)
{
mem_free (stream_name);
return NULL;
}
stream = fopen (stream_name, "w");
if (stream == NULL)
{
status_mesg (wrong_name, press_enter);
wgetch (win[STA].p);
}
}
mem_free (stream_name);
return stream;
}
/* Append a line to a file. */
unsigned
io_fprintln (const char *fname, const char *fmt, ...)
{
FILE *fp;
va_list ap;
char buf[BUFSIZ];
int ret;
fp = fopen (fname, "a");
RETVAL_IF (!fp, 0, _("Failed to open \"%s\", - %s\n"),
fname, strerror (errno));
va_start (ap, fmt);
ret = vsnprintf (buf, sizeof buf, fmt, ap);
RETVAL_IF (ret < 0, 0, _("Failed to build message\n"));
va_end (ap);
ret = fprintf (fp, "%s", buf);
RETVAL_IF (ret < 0, 0, _("Failed to print message \"%s\"\n"), buf);
ret = fclose (fp);
RETVAL_IF (ret != 0, 0, _("Failed to close \"%s\" - %s\n"),
fname, strerror (errno));
return 1;
}
/*
* Initialization of data paths. The cfile argument is the variable
* which contains the calendar file. If none is given, then the default
* one (~/.calcurse/apts) is taken. If the one given does not exist, it
* is created.
* The datadir argument can be use to specify an alternative data root dir.
*/
void
io_init (char *cfile, char *datadir)
{
FILE *data_file;
char *home;
char apts_file[BUFSIZ] = "";
int ch;
if (datadir != NULL)
{
home = datadir;
snprintf (path_dir, BUFSIZ, "%s", home);
snprintf (path_todo, BUFSIZ, "%s/" TODO_PATH_NAME, home);
snprintf (path_conf, BUFSIZ, "%s/" CONF_PATH_NAME, home);
snprintf (path_notes, BUFSIZ, "%s/" NOTES_DIR_NAME, home);
snprintf (path_apts, BUFSIZ, "%s/" APTS_PATH_NAME, home);
snprintf (path_keys, BUFSIZ, "%s/" KEYS_PATH_NAME, home);
snprintf (path_cpid, BUFSIZ, "%s/" CPID_PATH_NAME, home);
snprintf (path_dpid, BUFSIZ, "%s/" DPID_PATH_NAME, home);
snprintf (path_dmon_log, BUFSIZ, "%s/" DLOG_PATH_NAME, home);
}
else
{
home = getenv ("HOME");
if (home == NULL)
{
home = ".";
}
snprintf (path_dir, BUFSIZ, "%s/" DIR_NAME, home);
snprintf (path_todo, BUFSIZ, "%s/" TODO_PATH, home);
snprintf (path_conf, BUFSIZ, "%s/" CONF_PATH, home);
snprintf (path_keys, BUFSIZ, "%s/" KEYS_PATH, home);
snprintf (path_cpid, BUFSIZ, "%s/" CPID_PATH, home);
snprintf (path_dpid, BUFSIZ, "%s/" DPID_PATH, home);
snprintf (path_dmon_log, BUFSIZ, "%s/" DLOG_PATH, home);
snprintf (path_notes, BUFSIZ, "%s/" NOTES_DIR, home);
if (cfile == NULL)
{
snprintf (path_apts, BUFSIZ, "%s/" APTS_PATH, home);
}
else
{
snprintf (apts_file, BUFSIZ, "%s", cfile);
strncpy (path_apts, apts_file, BUFSIZ);
/* check if the file exists, otherwise create it */
data_file = fopen (path_apts, "r");
if (data_file == NULL)
{
printf (_("%s does not exist, create it now [y or n] ? "),
path_apts);
ch = getchar ();
switch (ch)
{
case 'N':
case 'n':
puts (_("aborting...\n"));
exit_calcurse (EXIT_FAILURE);
break;
case 'Y':
case 'y':
data_file = fopen (path_apts, "w");
if (data_file == NULL)
{
perror (path_apts);
exit_calcurse (EXIT_FAILURE);
}
else
{
printf (_("%s successfully created\n"), path_apts);
puts (_("starting interactive mode...\n"));
}
break;
default:
puts (_("aborting...\n"));
exit_calcurse (EXIT_FAILURE);
break;
}
}
file_close (data_file, __FILE_POS__);
}
}
}
void
io_extract_data (char *dst_data, const char *org, int len)
{
int i;
for (; *org == ' ' || *org == '\t'; org++);
for (i = 0; i < len - 1; i++)
{
if (*org == '\n' || *org == '\0' || *org == '#')
break;
*dst_data++ = *org++;
}
*dst_data = '\0';
}
void
display_mark (void)
{
const int DISPLAY_TIME = 1;
WINDOW *mwin;
mwin = newwin (1, 2, 1, col - 3);
custom_apply_attr (mwin, ATTR_HIGHEST);
mvwprintw (mwin, 0, 0, "**");
wins_wrefresh (mwin);
sleep (DISPLAY_TIME);
mvwprintw (mwin, 0, 0, " ");
wins_wrefresh (mwin);
delwin (mwin);
wins_doupdate ();
}
static pthread_mutex_t io_save_mutex = PTHREAD_MUTEX_INITIALIZER;
/*
* Save the apts data file, which contains the
* appointments first, and then the events.
* Recursive items are written first.
*/
unsigned
io_save_apts (void)
{
llist_item_t *i;
FILE *fp;
if (read_only)
return 1;
if ((fp = fopen (path_apts, "w")) == NULL)
return 0;
recur_save_data (fp);
if (ui_mode == UI_CURSES)
LLIST_TS_LOCK (&alist_p);
LLIST_TS_FOREACH (&alist_p, i)
{
struct apoint *apt = LLIST_TS_GET_DATA (i);
apoint_write (apt, fp);
}
if (ui_mode == UI_CURSES)
LLIST_TS_UNLOCK (&alist_p);
LLIST_FOREACH (&eventlist, i)
{
struct event *ev = LLIST_TS_GET_DATA (i);
event_write (ev, fp);
}
file_close (fp, __FILE_POS__);
return 1;
}
/* Save the todo data file. */
unsigned
io_save_todo (void)
{
llist_item_t *i;
FILE *fp;
if (read_only)
return 1;
if ((fp = fopen (path_todo, "w")) == NULL)
return 0;
LLIST_FOREACH (&todolist, i)
{
struct todo *todo = LLIST_TS_GET_DATA (i);
todo_write (todo, fp);
}
file_close (fp, __FILE_POS__);
return 1;
}
/* Save user-defined keys */
unsigned
io_save_keys (void)
{
FILE *fp;
if (read_only)
return 1;
if ((fp = fopen (path_keys, "w")) == NULL)
return 0;
keys_save_bindings (fp);
file_close (fp, __FILE_POS__);
return 1;
}
/* Save the calendar data */
void
io_save_cal (enum save_display display)
{
const char *access_pb = _("Problems accessing data file ...");
const char *save_success = _("The data files were successfully saved");
const char *enter = _("Press [ENTER] to continue");
int show_bar;
if (read_only)
return;
pthread_mutex_lock (&io_save_mutex);
show_bar = 0;
if (ui_mode == UI_CURSES && display == IO_SAVE_DISPLAY_BAR
&& conf.progress_bar)
show_bar = 1;
else if (ui_mode == UI_CURSES && display == IO_SAVE_DISPLAY_MARK)
display_mark ();
if (show_bar)
progress_bar (PROGRESS_BAR_SAVE, PROGRESS_BAR_CONF);
if (!config_save ())
ERROR_MSG ("%s", access_pb);
if (show_bar)
progress_bar (PROGRESS_BAR_SAVE, PROGRESS_BAR_TODO);
if (!io_save_todo ())
ERROR_MSG ("%s", access_pb);
if (show_bar)
progress_bar (PROGRESS_BAR_SAVE, PROGRESS_BAR_APTS);
if (!io_save_apts ())
ERROR_MSG ("%s", access_pb);
if (show_bar)
progress_bar (PROGRESS_BAR_SAVE, PROGRESS_BAR_KEYS);
if (!io_save_keys ())
ERROR_MSG ("%s", access_pb);
/* Print a message telling data were saved */
if (ui_mode == UI_CURSES && conf.system_dialogs
&& display != IO_SAVE_DISPLAY_MARK)
{
status_mesg (save_success, enter);
wgetch (win[STA].p);
}
pthread_mutex_unlock (&io_save_mutex);
}
/*
* Check what type of data is written in the appointment file,
* and then load either: a new appointment, a new event, or a new
* recursive item (which can also be either an event or an appointment).
*/
void
io_load_app (void)
{
FILE *data_file;
int c, is_appointment, is_event, is_recursive;
struct tm start, end, until, *lt;
llist_t exc;
time_t t;
int id = 0;
int freq;
char type, state = 0L;
char note[MAX_NOTESIZ + 1], *notep;
t = time (NULL);
lt = localtime (&t);
start = end = until = *lt;
data_file = fopen (path_apts, "r");
EXIT_IF (data_file == NULL, _("failed to open appointment file"));
for (;;)
{
LLIST_INIT (&exc);
is_appointment = is_event = is_recursive = 0;
c = getc (data_file);
if (c == EOF)
break;
ungetc (c, data_file);
/* Read the date first: it is common to both events
* and appointments.
*/
if (fscanf (data_file, "%d / %d / %d ",
&start.tm_mon, &start.tm_mday, &start.tm_year) != 3)
EXIT (_("syntax error in the item date"));
/* Read the next character : if it is an '@' then we have
* an appointment, else if it is an '[' we have en event.
*/
c = getc (data_file);
if (c == '@')
is_appointment = 1;
else if (c == '[')
is_event = 1;
else
EXIT (_("no event nor appointment found"));
/* Read the remaining informations. */
if (is_appointment)
{
if (fscanf (data_file, " %d : %d -> %d / %d / %d @ %d : %d ",
&start.tm_hour, &start.tm_min,
&end.tm_mon, &end.tm_mday, &end.tm_year,
&end.tm_hour, &end.tm_min) != 7)
EXIT (_("syntax error in item time or duration"));
}
else if (is_event)
{
if (fscanf (data_file, " %d ", &id) != 1 || getc (data_file) != ']')
EXIT (_("syntax error in item identifier"));
while ((c = getc (data_file)) == ' ');
ungetc (c, data_file);
}
else
{
EXIT (_("wrong format in the appointment or event"));
/* NOTREACHED */
}
/* Check if we have a recursive item. */
c = getc (data_file);
if (c == '{')
{
is_recursive = 1;
if (fscanf (data_file, " %d%c ", &freq, &type) != 2)
EXIT (_("syntax error in item repetition"));
c = getc (data_file);
if (c == '}')
{ /* endless recurrent item */
until.tm_year = 0;
while ((c = getc (data_file)) == ' ');
ungetc (c, data_file);
}
else if (c == '-' && getc (data_file) == '>')
{
if (fscanf (data_file, " %d / %d / %d ", &until.tm_mon,
&until.tm_mday, &until.tm_year) != 3)
EXIT (_("syntax error in item repetition"));
c = getc (data_file);
if (c == '!')
{
ungetc (c, data_file);
recur_exc_scan (&exc, data_file);
c = getc (data_file);
}
else if (c == '}')
{
while ((c = getc (data_file)) == ' ');
ungetc (c, data_file);
}
else
EXIT (_("syntax error in item repetition"));
}
else if (c == '!')
{ /* endless item with exceptions */
ungetc (c, data_file);
recur_exc_scan (&exc, data_file);
c = getc (data_file);
until.tm_year = 0;
}
else
{
EXIT (_("wrong format in the appointment or event"));
/* NOTREACHED */
}
}
else
ungetc (c, data_file);
/* Check if a note is attached to the item. */
c = getc (data_file);
if (c == '>')
{
note_read (note, data_file);
notep = note;
}
else
{
notep = NULL;
ungetc (c, data_file);
}
/*
* Last: read the item description and load it into its
* corresponding linked list, depending on the item type.
*/
if (is_appointment)
{
c = getc (data_file);
if (c == '!')
{
state |= APOINT_NOTIFY;
while ((c = getc (data_file)) == ' ');
ungetc (c, data_file);
}
else if (c == '|')
{
state = 0L;
while ((c = getc (data_file)) == ' ');
ungetc (c, data_file);
}
else
EXIT (_("syntax error in item repetition"));
if (is_recursive)
{
recur_apoint_scan (data_file, start, end,
type, freq, until, notep, &exc, state);
}
else
{
apoint_scan (data_file, start, end, state, notep);
}
}
else if (is_event)
{
if (is_recursive)
{
recur_event_scan (data_file, start, id, type,
freq, until, notep, &exc);
}
else
{
event_scan (data_file, start, id, notep);
}
}
else
{
EXIT (_("wrong format in the appointment or event"));
/* NOTREACHED */
}
}
file_close (data_file, __FILE_POS__);
}
/* Load the todo data */
void
io_load_todo (void)
{
FILE *data_file;
char *newline;
int nb_tod = 0;
int c, id;
char buf[BUFSIZ], e_todo[BUFSIZ], note[MAX_NOTESIZ + 1];
data_file = fopen (path_todo, "r");
EXIT_IF (data_file == NULL, _("failed to open todo file"));
for (;;)
{
c = getc (data_file);
if (c == EOF)
break;
else if (c == '[')
{ /* new style with id */
if (fscanf (data_file, " %d ", &id) != 1 || getc (data_file) != ']')
EXIT (_("syntax error in item identifier"));
while ((c = getc (data_file)) == ' ');
ungetc (c, data_file);
}
else
{
id = 9;
ungetc (c, data_file);
}
/* Now read the attached note, if any. */
c = getc (data_file);
if (c == '>')
note_read (note, data_file);
else
{
note[0] = '\0';
ungetc (c, data_file);
}
/* Then read todo description. */
if (!fgets (buf, sizeof buf, data_file))
buf[0] = '\0';
newline = strchr (buf, '\n');
if (newline)
*newline = '\0';
io_extract_data (e_todo, buf, sizeof buf);
todo_add (e_todo, id, note);
++nb_tod;
}
file_close (data_file, __FILE_POS__);
todo_set_nb (nb_tod);
}
static void
load_keys_ht_getkey (struct ht_keybindings_s *data, char **key, int *len)
{
*key = data->label;
*len = strlen (data->label);
}
static int
load_keys_ht_compare (struct ht_keybindings_s *data1,
struct ht_keybindings_s *data2)
{
const int KEYLEN = strlen (data1->label);
if (strlen (data2->label) == KEYLEN
&& !memcmp (data1->label, data2->label, KEYLEN))
return 0;
else
return 1;
}
/*
* isblank(3) is protected by the __BSD_VISIBLE macro and this fails to be
* visible in some specific cases. Thus replace it by the following is_blank()
* function.
*/
static int is_blank (int c)
{
return c == ' ' || c == '\t';
}
/*
* Load user-definable keys from file.
* A hash table is used to speed up loading process in avoiding string
* comparisons.
* A log file is also built in case some errors were found in the key
* configuration file.
*/
void
io_load_keys (char *pager)
{
struct ht_keybindings_s keys[NBKEYS];
FILE *keyfp;
char buf[BUFSIZ];
struct io_file *log;
int i, skipped, loaded, line;
const int MAX_ERRORS = 5;
keys_init ();
struct ht_keybindings ht_keys = HTABLE_INITIALIZER (&ht_keys);
for (i = 0; i < NBKEYS; i++)
{
keys[i].key = (enum key)i;
keys[i].label = keys_get_label ((enum key)i);
HTABLE_INSERT (ht_keybindings, &ht_keys, &keys[i]);
}
keyfp = fopen (path_keys, "r");
EXIT_IF (keyfp == NULL, _("failed to open key file"));
log = io_log_init ();
skipped = loaded = line = 0;
while (fgets (buf, BUFSIZ, keyfp) != NULL)
{
char key_label[BUFSIZ], *p;
struct ht_keybindings_s *ht_elm, ht_entry;
const int AWAITED = 1;
int assigned;
line++;
if (skipped > MAX_ERRORS)
{
const char *too_many =
_("\nToo many errors while reading configuration file!\n"
"Please backup your keys file, remove it from directory, "
"and launch calcurse again.\n");
io_log_print (log, line, too_many);
break;
}
for (p = buf; is_blank ((int)*p); p++)
;
if (p != buf)
memmove (buf, p, strlen (p));
if (buf[0] == '#' || buf[0] == '\n')
continue;
if (sscanf (buf, "%s", key_label) != AWAITED)
{
skipped++;
io_log_print (log, line, _("Could not read key label"));
continue;
}
ht_entry.label = key_label;
p = buf + strlen (key_label) + 1;
ht_elm = HTABLE_LOOKUP (ht_keybindings, &ht_keys, &ht_entry);
if (!ht_elm)
{
skipped++;
io_log_print (log, line, _("Key label not recognized"));
continue;
}
assigned = 0;
for (;;)
{
char key_ch[BUFSIZ], tmpbuf[BUFSIZ];
while (*p == ' ')
p++;
(void)strncpy (tmpbuf, p, BUFSIZ);
if (sscanf (tmpbuf, "%s", key_ch) == AWAITED)
{
int ch;
if ((ch = keys_str2int (key_ch)) < 0)
{
char unknown_key[BUFSIZ];
skipped++;
(void)snprintf (unknown_key, BUFSIZ,
_("Error reading key: \"%s\""), key_ch);
io_log_print (log, line, unknown_key);
}
else
{
int used;
used = keys_assign_binding (ch, ht_elm->key);
if (used)
{
char already_assigned[BUFSIZ];
skipped++;
(void)snprintf (already_assigned, BUFSIZ,
_("\"%s\" assigned multiple times!"), key_ch);
io_log_print (log, line, already_assigned);
}
else
assigned++;
}
p += strlen (key_ch) + 1;
}
else
{
if (assigned)
loaded++;
break;
}
}
}
file_close (keyfp, __FILE_POS__);
file_close (log->fd, __FILE_POS__);
if (skipped > 0)
{
const char *view_log =
_("There were some errors when loading keys file, see log file ?");
io_log_display (log, view_log, pager);
}
io_log_free (log);
EXIT_IF (skipped > MAX_ERRORS,
_("Too many errors while reading keys file, aborting..."));
if (loaded < NBKEYS)
keys_fill_missing ();
if (keys_check_missing_bindings ())
WARN_MSG (_("Some actions do not have any associated key bindings!"));
}
void
io_check_dir (char *dir, int *missing)
{
if (read_only)
return;
errno = 0;
if (mkdir (dir, 0700) != 0)
{
if (errno != EEXIST)
{
fprintf (stderr, _("FATAL ERROR: could not create %s: %s\n"), dir,
strerror (errno));
exit_calcurse (EXIT_FAILURE);
}
}
else
{
if (missing)
(*missing)++;
}
}
unsigned
io_file_exist (char *file)
{
FILE *fd;
if (!file)
return 0;
if ((fd = fopen (file, "r")) == NULL)
return 0;
fclose (fd);
return 1;
}
void
io_check_file (char *file, int *missing)
{
if (read_only)
return;
errno = 0;
if (!io_file_exist (file))
{
FILE *fd;
if (missing)
(*missing)++;
if ((fd = fopen (file, "w")) == NULL)
{
fprintf (stderr, _("FATAL ERROR: could not create %s: %s\n"), file,
strerror (errno));
exit_calcurse (EXIT_FAILURE);
}
file_close (fd, __FILE_POS__);
}
}
/*
* Checks if data files exist. If not, create them.
* The following structure has to be created:
*
* $HOME/.calcurse/
* |
* +--- notes/
* |___ conf
* |___ keys
* |___ apts
* |___ todo
*/
int
io_check_data_files (void)
{
int missing, missing_keys;
missing = missing_keys = 0;
errno = 0;
io_check_dir (path_dir, &missing);
io_check_dir (path_notes, &missing);
io_check_file (path_todo, &missing);
io_check_file (path_apts, &missing);
io_check_file (path_conf, &missing);
io_check_file (path_keys, &missing_keys);
if (missing_keys)
{
missing++;
keys_dump_defaults (path_keys);
}
return missing;
}
/* Draw the startup screen */
void
io_startup_screen (unsigned show_dialogs, int no_data_file)
{
const char *welcome_mesg =
_("Welcome to Calcurse. Missing data files were created.");
const char *data_mesg = _("Data files found. Data will be loaded now.");
const char *enter = _("Press [ENTER] to continue");
if (no_data_file != 0)
{
status_mesg (welcome_mesg, enter);
wgetch (win[STA].p);
}
else if (show_dialogs)
{
status_mesg (data_mesg, enter);
wgetch (win[STA].p);
}
}
/* Export calcurse data. */
void
io_export_data (enum export_type type)
{
FILE *stream;
const char *success = _("The data were successfully exported");
const char *enter = _("Press [ENTER] to continue");
if (type < IO_EXPORT_ICAL || type >= IO_EXPORT_NBTYPES)
EXIT (_("unknown export type"));
stream = 0;
switch (ui_mode)
{
case UI_CMDLINE:
stream = stdout;
break;
case UI_CURSES:
stream = get_export_stream (type);
break;
default:
EXIT (_("wrong export mode"));
/* NOTREACHED */
}
if (stream == NULL)
return;
if (type == IO_EXPORT_ICAL)
ical_export_data (stream);
else if (type == IO_EXPORT_PCAL)
pcal_export_data (stream);
if (conf.system_dialogs && ui_mode == UI_CURSES)
{
status_mesg (success, enter);
wgetch (win[STA].p);
}
}
/* Draws the export format selection bar */
void
io_export_bar (void)
{
int smlspc, spc;
smlspc = 2;
spc = 15;
custom_apply_attr (win[STA].p, ATTR_HIGHEST);
mvwprintw (win[STA].p, 0, 2, "Q");
mvwprintw (win[STA].p, 1, 2, "I");
mvwprintw (win[STA].p, 0, 2 + spc, "P");
custom_remove_attr (win[STA].p, ATTR_HIGHEST);
mvwprintw (win[STA].p, 0, 2 + smlspc, _("Exit"));
mvwprintw (win[STA].p, 1, 2 + smlspc, _("Ical"));
mvwprintw (win[STA].p, 0, 2 + spc + smlspc, _("Pcal"));
wnoutrefresh (win[STA].p);
wmove (win[STA].p, 0, 0);
wins_doupdate ();
}
static FILE *
get_import_stream (enum export_type type)
{
FILE *stream;
char *stream_name;
const char *ask_fname = _("Enter the file name to import data from:");
const char *wrong_file =
_("The file cannot be accessed, please enter another file name.");
const char *press_enter = _("Press [ENTER] to continue.");
int cancel;
stream = NULL;
stream_name = mem_malloc (BUFSIZ);
memset (stream_name, 0, BUFSIZ);
while (stream == NULL)
{
status_mesg (ask_fname, "");
cancel = updatestring (win[STA].p, &stream_name, 0, 1);
if (cancel)
{
mem_free (stream_name);
return NULL;
}
stream = fopen (stream_name, "r");
if (stream == NULL)
{
status_mesg (wrong_file, press_enter);
wgetch (win[STA].p);
}
}
mem_free (stream_name);
return stream;
}
/*
* Import data from a given stream (either stdin in non-interactive mode, or the
* user given file in interactive mode).
* A temporary log file is created in /tmp to store the import process report,
* and is cleared at the end.
*/
void
io_import_data (enum import_type type, char *stream_name)
{
const char *proc_report = _("Import process report: %04d lines read ");
char stats_str[4][BUFSIZ];
FILE *stream = NULL;
struct io_file *log;
struct {
unsigned events, apoints, todos, lines, skipped;
} stats;
EXIT_IF (type < 0 || type >= IO_IMPORT_NBTYPES, _("unknown import type"));
switch (ui_mode)
{
case UI_CMDLINE:
stream = fopen (stream_name, "r");
EXIT_IF (stream == NULL,
_("FATAL ERROR: the input file cannot be accessed, "
"Aborting..."));
break;
case UI_CURSES:
stream = get_import_stream (type);
break;
default:
EXIT (_("FATAL ERROR: wrong import mode"));
/* NOTREACHED */
}
if (stream == NULL)
return;
memset (&stats, 0, sizeof stats);
log = io_log_init ();
if (log == NULL)
{
if (stream != stdin)
file_close (stream, __FILE_POS__);
return;
}
if (type == IO_IMPORT_ICAL)
ical_import_data (stream, log->fd, &stats.events, &stats.apoints,
&stats.todos, &stats.lines, &stats.skipped);
if (stream != stdin)
file_close (stream, __FILE_POS__);
snprintf (stats_str[0], BUFSIZ,
ngettext ("%d app", "%d apps", stats.apoints), stats.apoints);
snprintf (stats_str[1], BUFSIZ,
ngettext ("%d event", "%d events", stats.events), stats.events);
snprintf (stats_str[2], BUFSIZ,
ngettext ("%d todo", "%d todos", stats.todos), stats.todos);
snprintf (stats_str[3], BUFSIZ, _("%d skipped"), stats.skipped);
/* Update the number of todo items. */
todo_set_nb (todo_nb () + stats.todos);
if (ui_mode == UI_CURSES && conf.system_dialogs)
{
char read[BUFSIZ], stat[BUFSIZ];
snprintf (read, BUFSIZ, proc_report, stats.lines);
snprintf (stat, BUFSIZ, "%s / %s / %s / %s (%s)", stats_str[0],
stats_str[1], stats_str[2], stats_str[3],
_("Press [ENTER] to continue"));
status_mesg (read, stat);
wgetch (win[STA].p);
}
else if (ui_mode == UI_CMDLINE)
{
printf (proc_report, stats.lines);
printf ("\n%s / %s / %s / %s\n", stats_str[0], stats_str[1],
stats_str[2], stats_str[3]);
}
/* User has the choice to look at the log file if some items could not be
imported.
*/
file_close (log->fd, __FILE_POS__);
if (stats.skipped > 0)
{
const char *view_log = _("Some items could not be imported, see log file ?");
io_log_display (log, view_log, conf.pager);
}
io_log_free (log);
}
struct io_file *
io_log_init (void)
{
char logprefix[BUFSIZ];
char *logname;
struct io_file *log;
snprintf (logprefix, BUFSIZ, "%s/calcurse_log.", get_tempdir ());
logname = new_tempfile (logprefix, TMPEXTSIZ);
RETVAL_IF (logname == NULL, 0,
_("Warning: could not create temporary log file, Aborting..."));
log = mem_malloc (sizeof (struct io_file));
RETVAL_IF (log == NULL, 0,
_("Warning: could not open temporary log file, Aborting..."));
snprintf (log->name, sizeof (log->name), "%s%s", logprefix, logname);
mem_free (logname);
log->fd = fopen (log->name, "w");
if (log->fd == NULL)
{
ERROR_MSG (_("Warning: could not open temporary log file, Aborting..."));
mem_free (log);
return 0;
}
return log;
}
void
io_log_print (struct io_file *log, int line, const char *msg)
{
if (log && log->fd)
fprintf (log->fd, "line %d: %s\n", line, msg);
}
void
io_log_display (struct io_file *log, const char *msg, char *pager)
{
char *choices = "[y/n] ";
int ans;
RETURN_IF (log == NULL, _("No log file to display!"));
if (ui_mode == UI_CMDLINE)
{
printf ("\n%s %s", msg, choices);
ans = fgetc (stdin);
if (ans == 'y')
{
char *arg[] = { pager, log->name, NULL };
int pid;
if ((pid = fork_exec (NULL, NULL, pager, arg)))
child_wait (NULL, NULL, pid);
}
}
else
{
status_mesg (msg, choices);
do
{
ans = wgetch (win[STA].p);
if (ans == 'y')
{
wins_launch_external (log->name, pager);
}
}
while (ans != 'y' && ans != 'n');
wins_erase_status_bar ();
}
}
void
io_log_free (struct io_file *log)
{
if (!log)
return;
EXIT_IF (unlink (log->name) != 0,
_("Warning: could not erase temporary log file %s, Aborting..."),
log->name);
mem_free (log);
}
static pthread_t io_t_psave;
/* Thread used to periodically save data. */
static void *
io_psave_thread (void *arg)
{
int delay;
delay = conf.periodic_save;
EXIT_IF (delay < 0, _("Invalid delay"));
for (;;)
{
sleep (delay * MININSEC);
io_save_cal (IO_SAVE_DISPLAY_MARK);
}
}
/* Launch the thread which handles periodic saves. */
void
io_start_psave_thread (void)
{
pthread_create (&io_t_psave, NULL, io_psave_thread, NULL);
}
/* Stop periodic data saves. */
void
io_stop_psave_thread (void)
{
if (io_t_psave)
{
pthread_cancel (io_t_psave);
pthread_join (io_t_psave, NULL);
}
}
/*
* This sets a lock file to prevent from having two different instances of
* calcurse running.
*
* If the lock cannot be obtained, then warn the user and exit calcurse. Else,
* create a .calcurse.pid file in the user defined directory, which will be
* removed when calcurse exits.
*
* Note: When creating the lock file, the interactive mode is not initialized
* yet.
*/
void
io_set_lock (void)
{
FILE *lock = fopen (path_cpid, "r");
int pid;
if (lock != NULL)
{
/* If there is a lock file, check whether the process exists. */
if (fscanf(lock, "%d", &pid) == 1)
{
fclose(lock);
if (kill(pid, 0) != 0 && errno == ESRCH)
lock = NULL;
}
else
fclose(lock);
}
if (lock != NULL)
{
fprintf (stderr,
_("\nWARNING: it seems that another calcurse instance is "
"already running.\n"
"If this is not the case, please remove the following "
"lock file: \n\"%s\"\n"
"and restart calcurse.\n"), path_cpid);
exit (EXIT_FAILURE);
}
else
{
if (!io_dump_pid (path_cpid))
EXIT (_("FATAL ERROR: could not create %s: %s\n"),
path_cpid, strerror (errno));
}
}
/*
* Create a new file and write the process pid inside (used to create a simple
* lock for example). Overwrite already existing files.
*/
unsigned
io_dump_pid (char *file)
{
pid_t pid;
FILE *fp;
if (!file)
return 0;
pid = getpid ();
if (!(fp = fopen (file, "w"))
|| fprintf (fp, "%ld\n", (long)pid) < 0
|| fclose (fp) != 0)
return 0;
return 1;
}
/*
* Return the pid number contained in a file previously created with
* io_dump_pid ().
* If no file was found, return 0.
*/
unsigned
io_get_pid (char *file)
{
FILE *fp;
unsigned pid;
if (!file)
return 0;
if ((fp = fopen (file, "r")) == NULL)
return 0;
if (fscanf (fp, "%u", &pid) != 1)
return 0;
fclose (fp);
return pid;
}
/*
* Check whether a file is empty.
*/
int
io_file_is_empty (char *file)
{
FILE *fp;
if (file && (fp = fopen (file, "r")))
{
if ((fgetc (fp) == '\n' && fgetc (fp) == EOF) || feof (fp))
{
fclose (fp);
return 1;
}
else
{
fclose (fp);
return 0;
}
}
return -1;
}
/*
* Copy an existing file to a new location.
*/
int
io_file_cp (const char *src, const char *dst)
{
FILE *fp_src, *fp_dst;
char *buffer[BUFSIZ];
unsigned int bytes_read;
if (!(fp_src = fopen (src, "rb")))
return 0;
if (!(fp_dst = fopen (dst, "wb")))
return 0;
while (!feof (fp_src))
{
bytes_read = fread (buffer, 1, BUFSIZ, fp_src);
if (bytes_read > 0)
{
if (fwrite (buffer, 1, bytes_read, fp_dst) != bytes_read)
return 0;
}
else
return 0;
}
fclose (fp_dst);
fclose (fp_src);
return 1;
}
Reference in New Issue View Git Blame Copy Permalink