/* Expand a variable reference and append to filename. */
static int expand_file_var(const clamz_config *cfg, const clamz_track *tr,
char **filename, char *var, const char *format)
{
char *p, *value;
if ((p = strchr(var, ':'))) {
if (p[1] == '-') {
/* ${VAR:-ALT} -- substitute VAR if defined, otherwise ALT */
*p = 0;
if (!(value = get_file_var(cfg, tr, var, 0)))
return 1;
if (value[0]) {
if (concatenate_var(filename, value)) {
free(value);
return 1;
}
free(value);
return 0;
}
else {
free(value);
return expand_file_name(cfg, tr, filename, p + 2);
}
}
else if (p[1] == '+') {
/* ${VAR:+ALT} -- substitute ALT if VAR is defined */
*p = 0;
if (!(value = get_file_var(cfg, tr, var, 0)))
return 1;
if (value[0]) {
if (expand_file_name(cfg, tr, filename, p + 2)) {
free(value);
return 1;
}
}
free(value);
return 0;
}
else {
print_error("Invalid expression '${%s}' in '%s'", var, format);
return 1;
}
}
else {
if (!(value = get_file_var(cfg, tr, var, 1)))
return 1;
if (concatenate_var(filename, value)) {
free(value);
return 1;
}
free(value);
return 0;
}
}
struct service service_init (char* service_name) {
struct service s;
char* prefix = expand_file_name (RTPREFIX);
s.name = service_name;
s.confpath = malloc (PATH_MAX);
s.binpath = malloc (PATH_MAX);
s.sockpath = malloc (PATH_MAX);
if (strcmp (s.name, "broker") == 0) {
sprintf (s.confpath, "%s/share/clove/clove.conf", prefix);
s.binpath = NULL;
sprintf (s.sockpath, "%s/broker", expand_file_name (RUNPATH));
} else {
sprintf (s.confpath, "%s/share/clove/clove-%s.conf", prefix, s.name);
sprintf (s.binpath, "%s/share/clove/clove-%s", prefix, s.name);
sprintf (s.sockpath, "%s/clove-%s", expand_file_name (RUNPATH), s.name);
}
s.confpath_last_mtime = 0;
s.pid = -1;
s.sock = -1;
return s;
}
static int
read_default_file (char* buffer, size_t buffer_size)
{
int fid;
buffer = expand_file_name (buffer, buffer_size);
if (!buffer)
{
log_err ("read_default_file: filename too long. %s", buffer);
return (-1);
}
fid = file_loaded (buffer);
if (fid == -1)
{ /* Not correct file */
printf ("Error reading %s\n", buffer);
return (-1);
}
if (FILE_NOT_READ != fid)
{ /* already read */
return (-1);
}
if ((fid = get_new_fid ()) == -1)
{ /* no more file */
printf ("Error reading %s\n", buffer);
return (-1);
}
files[fid].localf = LOCAL;
strcpy (files[fid].name, buffer);
printf ("Reading %s\t Fid = %d\n", buffer, fid);
if (read_file (&files[fid]) == -1)
{
printf ("Error reading %s\n", buffer);
files[fid].ref_count = -1; /* fail */
return (-1);
}
files[fid].ref_count = 1;
return (fid);
}
int
folder_menu(char *path, int mode)
{
FILE *folder;
register article_header *ah;
news_header_buffer dgbuf;
char buffer[256];
int more, length, re, menu_cmd, was_raw;
memory_marker mem_marker;
group_header fake_group;
int cc_save;
char folder_name[FILENAME], folder_file[FILENAME];
int orig_layout;
char *orig_hdr_lines;
orig_layout = fmt_linenum;
orig_hdr_lines = header_lines;
strcpy(folder_name, path);
fake_group.group_name = folder_name;
fake_group.kill_list = NULL;
if (!expand_file_name(folder_file, folder_name, 1))
return ME_NO_REDRAW;
fake_group.archive_file = path = folder_file;
fake_group.next_group = fake_group.prev_group = NULL;
fake_group.group_flag = G_FOLDER | G_FAKED;
fake_group.master_flag = 0;
fake_group.save_file = NULL;
current_group = NULL;
init_group(&fake_group);
folder = open_file(path, OPEN_READ);
if (folder == NULL) {
msg("%s not found", path);
return ME_NO_REDRAW;
}
switch (get_folder_type(folder)) {
case 0:
msg("Reading: %-.65s", path);
break;
case 1:
case 2:
msg("Reading %s folder: %-.50s",
current_folder_type == 1 ? "mail" : "mmdf", path);
break;
default:
msg("Folder is empty");
fclose(folder);
return ME_NO_REDRAW;
}
rewind(folder);
was_raw = no_raw();
s_keyboard = 0;
current_group = &fake_group;
mark_memory(&mem_marker);
ah = alloc_art();
more = 1;
while (more && (more = get_digest_article(folder, dgbuf)) >= 0) {
if (s_keyboard)
break;
ah->a_number = 0;
ah->flag = A_FOLDER;
ah->attr = 0;
ah->lines = digest.dg_lines;
ah->hpos = digest.dg_hpos;
ah->fpos = digest.dg_fpos;
ah->lpos = digest.dg_lpos;
if (digest.dg_from) {
length = pack_name(buffer, digest.dg_from, Name_Length);
ah->sender = alloc_str(length);
strcpy(ah->sender, buffer);
ah->name_length = length;
if (mode == 1)
fold_string(ah->sender);
} else {
ah->sender = "";
ah->name_length = 0;
}
if (digest.dg_subj) {
length = pack_subject(buffer, digest.dg_subj, &re, 255);
ah->replies = re;
ah->subject = alloc_str(length);
strcpy(ah->subject, buffer);
ah->subj_length = length;
if (mode == 1 && length > 1)
fold_string(ah->subject + 1);
} else {
ah->replies = 0;
ah->subject = "";
ah->subj_length = 0;
}
ah->t_stamp = digest.dg_date ? pack_date(digest.dg_date) : 0;
add_article(ah);
ah = alloc_art();
}
fclose(folder);
if (s_keyboard) {
menu_cmd = ME_NO_REDRAW;
} else if (n_articles == 0) {
msg("Not a folder (no article header)");
menu_cmd = ME_NO_REDRAW;
} else {
if (n_articles > 1) {
clrdisp();
prompt_line = 2;
if (mode == 0 && !dont_sort_folders)
sort_articles(-1);
else if (mode == 1) {
article_number n;
for (n = 0; n < n_articles; n++) {
ah = articles[n];
if (n == 0)
ah->flag |= A_ROOT_ART;
else if (strcmp(ah->sender, articles[n - 1]->sender) == 0)
articles[n - 1]->flag |= A_NEXT_SAME;
else
ah->flag |= A_ROOT_ART;
}
bypass_consolidation = consolidated_manual ? 2 : 1;
} else
no_sort_articles();
} else
no_sort_articles();
cc_save = cancel_count;
cancel_count = 0;
if (mode == 1) {
fmt_linenum = -1;
header_lines = "*";
}
reenter_menu:
ignore_fancy_select = 1;
menu_cmd = menu(folder_header);
ignore_fancy_select = 0;
if (mode == 0 && cancel_count) {
register article_number cur;
cancel_count = 0;
for (cur = 0; cur < n_articles; cur++) {
if (articles[cur]->attr == A_CANCEL)
cancel_count++;
}
}
if (mode == 0 && cancel_count) {
clrdisp();
tprintf("\rFolder: %s\n\rFile: %s\n\n\r", folder_name, folder_file);
if (cancel_count == n_articles)
tprintf("Cancel all articles and remove folder? ");
else
tprintf("Remove %d article%s from folder? ",
cancel_count, plural((long) cancel_count));
fl;
switch (yes(1)) {
case 1:
tprintf("\n\n");
if (cancel_count == n_articles) {
if (unlink(group_path_name) < 0 &&
nn_truncate(group_path_name, (off_t) 0) < 0) {
tprintf("\rCould not unlink %s\n\r", group_path_name);
any_key(0);
}
} else
rewrite_folder();
break;
case 0:
break;
default:
goto reenter_menu;
}
}
cancel_count = cc_save;
}
release_memory(&mem_marker);
if (fmt_linenum == -1) {
fmt_linenum = orig_layout;
header_lines = orig_hdr_lines;
}
if (was_raw)
nn_raw();
return menu_cmd;
}
int
file_completion(char *path, int index)
{
static int dir_in_use = 0;
static char *head, *tail = NULL;
static int tail_offset;
char nbuf[FILENAME], buffer[FILENAME];
char *dir, *base;
if (path) {
if (dir_in_use) {
close_directory();
dir_in_use = 0;
}
if (index < 0)
return 0;
head = path;
tail = path + index;
}
if (!dir_in_use) {
path = head;
*tail = NUL;
if (*path == '|')
return -1; /* no completion for pipes */
if (*path == '+' || *path == '~') {
if (!expand_file_name(nbuf, path, 0x11))
return 0; /* no completions */
} else
strcpy(nbuf, path);
if ((base = strrchr(nbuf, '/'))) {
if (base == nbuf) {
dir = "/";
base++;
} else {
*base++ = NUL;
dir = nbuf;
}
} else {
base = nbuf;
dir = ".";
}
tail_offset = strlen(base);
dir_in_use = list_directory(dir, base);
return dir_in_use;
}
if (index)
return compl_help_directory();
if (!next_directory(buffer, 1))
return 0;
strcpy(tail, buffer + tail_offset);
return 1;
}
/**
* \brief Get the full path to a file. Find a random file if the parameter is a
* file pattern.
* \param p (in) The relative path/pattern. (out) The full path.
* \param w The workspace used.
*
* \a p is unchanged if no data path is found to make it a full path.
*/
bool bf::path_configuration::expand_file_name
( std::string& p, const std::string& w ) const
{
return expand_file_name(p, std::numeric_limits<std::size_t>::max(), w);
} // path_configuration::expand_file_name()
int
set_variable(char *variable, int on, char *val_string)
{
int value;
register struct variable_defs *var;
if (strncmp(variable, "no", 2) == 0) {
on = !on;
variable += 2;
if (variable[0] == '-')
variable++;
}
if ((var = lookup_variable(variable)) == NULL)
return 0;
if (!in_init && (var->var_flags & (V_INIT | V_SAFE))) {
if (var->var_flags & V_INIT) {
msg("'%s' can only be set in the init file", variable);
return 0;
}
if (shell_restrictions) {
msg("Restricted operation - cannot change");
return 0;
}
}
if (var->var_flags & V_LOCKED) {
msg("Variable '%s' is locked", variable);
return 0;
}
if (!on || val_string == NULL)
value = 0;
else
value = atoi(val_string);
var->var_flags |= V_MODIFIED;
switch (VAR_TYPE) {
case V_STRING:
if (on)
adjust(val_string);
switch (VAR_OP) {
case 0:
STR_VAR = (on && val_string) ? copy_str(val_string) : (char *) NULL;
break;
case 1:
strcpy(CBUF_VAR, (on && val_string) ? val_string : "");
break;
case 2:
if (on) {
char exp_buf[FILENAME];
if (val_string) {
if (expand_file_name(exp_buf, val_string, 1))
STR_VAR = home_relative(exp_buf);
}
} else
STR_VAR = (char *) NULL;
break;
case 3:
case 4:
if (!on || val_string == NULL) {
msg("Cannot unset string `%s'", variable);
break;
}
if (VAR_OP == 4) {
char exp_buf[FILENAME];
if (expand_file_name(exp_buf, val_string, 1)) {
STR_VAR = copy_str(exp_buf);
break;
}
}
STR_VAR = copy_str(val_string);
break;
case 5:
STR_VAR = (on && val_string) ? copy_str(val_string) : "";
break;
}
break;
case V_BOOLEAN:
adjust(val_string);
if (val_string && *val_string != NUL) {
if (val_string[0] == 'o')
on = val_string[1] == 'n'; /* on */
else
on = val_string[0] == 't'; /* true */
}
switch (VAR_OP) {
case 0:
BOOL_VAR = on;
break;
case 1:
BOOL_VAR = on;
return 1;
case 2:
if (BOOL_VAR) { /* don't change if already ok */
if (!on)
break;
} else if (on)
break;
BOOL_VAR = !on;
if (!in_init) {
sort_articles(BOOL_VAR ? 0 : -1);
return 1;
}
break;
case 4:
BOOL_VAR = !on;
break;
}
break;
case V_INTEGER:
switch (VAR_OP) {
case 0:
case 1:
INT_VAR = value;
break;
case 2:
case 3:
if (!on)
value = -1;
INT_VAR = value;
break;
}
return (VAR_OP & 1);
case V_KEY:
switch (VAR_OP) {
case 0:
if (val_string) {
if (*val_string)
adjust(val_string + 1); /* #N is valid */
KEY_VAR = parse_key(val_string);
}
break;
}
break;
case V_SPECIAL:
switch (VAR_OP) {
case 1:
if (val_string) {
adjust(val_string);
news_record = home_relative(val_string);
mail_record = news_record;
var->var_flags &= ~V_MODIFIED;
lookup_variable("mail-record")->var_flags |= V_MODIFIED;
lookup_variable("news-record")->var_flags |= V_MODIFIED;
}
break;
case 2:
also_read_articles = on;
article_limit = (on && value > 0) ? value : -1;
break;
case 3:
{
struct chset *csp;
struct variable_defs *dbvar;
dbvar = lookup_variable("data-bits");
if (on && val_string) {
if ((csp = getchset(val_string)) == NULL)
msg("Illegal value for `%s' variable", variable);
else {
curchset = csp;
data_bits = csp->cs_width ? csp->cs_width : 7;
dbvar->var_flags &= ~V_MODIFIED;
}
} else
msg("Cannot unset special `%s' variable", variable);
}
break;
}
break;
case V_CODES:
{
char codes[80], code[16], *sp, *cp, *vs;
if (val_string == NULL)
on = 0;
if (on) {
adjust(val_string);
if (val_string[0] == NUL)
on = 0;
}
if (on) {
sp = codes;
vs = val_string;
while (*vs) {
while (*vs && (!isascii(*vs) || isspace(*vs)))
vs++;
if (*vs == NUL)
break;
cp = code;
while (*vs && isascii(*vs) && !isspace(*vs))
*cp++ = *vs++;
*cp = NUL;
*sp++ = parse_key(code);
}
*sp = NUL;
if (codes[0] == NUL)
on = 0;
}
freeobj(code_strings[VAR_OP]);
code_strings[VAR_OP] = on ? copy_str(val_string) : NULL;
STR_VAR = on ? copy_str(codes) : (char *) NULL;
break;
}
}
return 0;
}
/* Tag( external_unlink )
*/
int external_unlink (char *path)
{
return DeleteFile (expand_file_name (path));
}
/* Tag( external_link )
*/
int external_link (char *oldpath, char *newpath)
{
return CreateHardLink (expand_file_name (newpath),
expand_file_name (oldpath), NULL);
}
/* Tag( external_stat )
*/
int external_stat (char *path, struct stat *buf)
{
return stat (expand_file_name (path), buf);
}
