imapfilter/imapfilter/file.c

#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <regex.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <time.h>

#include "config.h"
#include "imapfilter.h"
#include "data.h"


extern char logfile[PATH_MAX];
extern unsigned int options;
extern unsigned int flags;
extern unsigned int interval;
extern long timeout;
extern char *home;

#ifdef ENCRYPTED_PASSWORDS
char *passphr;                  /* Master password to access the passwords
                                   file. */
#endif


/*
 * Find the path to configuration file, open it and call parse_config().
 */
int read_config(char *cfg)
{
    int r;
    FILE *fd;
    char *c = NULL;

    if (!cfg) {
        cfg = c = (char *)xmalloc(PATH_MAX * sizeof(char));
        snprintf(cfg, PATH_MAX, "%s/%s", home, ".imapfilterrc");
    }
#ifdef DEBUG
    printf("debug: configuration file: '%s'\n", cfg);
#endif
#ifdef CHECK_PERMISSIONS
    check_file_perms(cfg, S_IRUSR | S_IWUSR);
#endif
    fd = fopen(cfg, "r");

    if (!fd)
        fatal(ERROR_FILE_OPEN, "imapfilter: opening config file %s; %s\n",
              cfg, strerror(errno));

    if (c)
        xfree(c);

    if ((r = parse_config(fd)))
        fatal(ERROR_CONFIG_PARSE,
              "imapfilter: parse error in config file at row %d\n", r);

    fclose(fd);

#ifdef DEBUG
    printf("debug: options: %0#10x\n", options);
#endif

    return 0;
}


/*
 * Parse configuration file.
 */
int parse_config(FILE * fd)
{
    int i, r = 0;
    unsigned int row = 0;
    char line[LINE_MAX];
    regex_t creg[13];
    regmatch_t match[11];
    const char *reg[13] = {
        "^([[:blank:]]*\n|#.*\n)$",

        "^[[:blank:]]*ACCOUNT[[:blank:]]+([[:alnum:]_-]+)[[:blank:]]+"
        "(([[:graph:]]+):([[:graph:]]*)|([[:graph:]]+))@([[:alnum:].-]+)"
        "(:[[:digit:]]+)?[[:blank:]]*([[:blank:]]SSL|[[:blank:]]SSL2|"
        "[[:blank:]]SSL3|[[:blank:]]TLS1)?[[:blank:]]*\n$",

        "^[[:blank:]]*FOLDER[[:blank:]]+([[:alnum:]_-]+)[[:blank:]]+"
        "([[:print:]]+)[[:blank:]]*\n$",

        "^[[:blank:]]*FILTER[[:blank:]]+([[:alnum:]_-]+)[[:blank:]]*"
        "([[:blank:]]OR|[[:blank:]]AND)?[[:blank:]]*\n$",

        "^[[:blank:]]*ACTION[[:blank:]]+(DELETE|"
        "COPY[[:blank:]]+(\"[[:print:]]*\"|[[:graph:]]+)|"
        "MOVE[[:blank:]]+(\"[[:print:]]*\"|[[:graph:]]+)|"
        "RCOPY[[:blank:]]+([[:alnum:]_-]+)[[:blank:]]+"
        "(\"[[:print:]]*\"|[[:graph:]]+)|"
        "RMOVE[[:blank:]]+([[:alnum:]_-]+)[[:blank:]]+"
        "(\"[[:print:]]*\"|[[:graph:]]+)|"
        "FLAG[[:blank:]]+(REPLACE|ADD|REMOVE)[[:blank:]]+"
        "([[:alpha:],]+)|"
        "LIST)[[:blank:]]*([[:graph:]]*)[[:blank:]]*\n$",

        "^[[:blank:]]*(MASK[[:blank:]])?[[:blank:]]*(OR[[:blank:]]|"
        "AND[[:blank:]])?[[:blank:]]*(NOT[[:blank:]])?[[:blank:]]*"
        "(ANSWERED|DELETED|DRAFT|FLAGGED|NEW|OLD|RECENT|SEEN|UNANSWERED|"
        "UNDELETED|UNDRAFT|UNFLAGGED|UNSEEN)[[:blank:]]*\n$",

        "^[[:blank:]]*(MASK[[:blank:]])?[[:blank:]]*(OR[[:blank:]]|"
        "AND[[:blank:]])?[[:blank:]]*(NOT[[:blank:]])?[[:blank:]]*"
        "(BCC|BODY|CC|FROM|SUBJECT|TEXT|TO)[[:blank:]]+(\"[[:print:]]*\"|"
        "[[:graph:]]+)[[:blank:]]*\n$",

        "^[[:blank:]]*(MASK[[:blank:]])?[[:blank:]]*(OR[[:blank:]]|"
        "AND[[:blank:]])?[[:blank:]]*(NOT[[:blank:]])?[[:blank:]]*"
        "(HEADER)[[:blank:]]+(\"[[:print:]]*\"|[[:graph:]]+)[[:blank:]]+"
        "(\"[[:print:]]*\"|[[:graph:]]+)[[:blank:]]*\n$",

        "^[[:blank:]]*(MASK[[:blank:]])?[[:blank:]]*(OR[[:blank:]]|"
        "AND[[:blank:]])?[[:blank:]]*(NOT[[:blank:]])?[[:blank:]]*"
        "(LARGER|SMALLER|OLDER|NEWER)[[:blank:]]+([[:digit:]]+)"
        "[[:blank:]]*\n$",

        "^[[:blank:]]*JOB[[:blank:]]+([[:alnum:],_-]+)[[:blank:]]+"
        "([[:alnum:],_-]+)[[:blank:]]*\n$",

        "^[[:blank:]]*(SET[[:blank:]])?[[:blank:]]*(LOGFILE)"
        "[[:blank:]]*=[[:blank:]]*([[:print:]]+)\n$",

        "^[[:blank:]]*(SET[[:blank:]])?[[:blank:]]*(EXPUNGE|HEADERS|NAMESPACE|"
        "SUBSCRIBE)[[:blank:]]*=[[:blank:]]*(YES|NO)[[:blank:]]*\n$",

        "^[[:blank:]]*(SET[[:blank:]])?[[:blank:]]*(DAEMON|TIMEOUT)"
        "[[:blank:]]*=[[:blank:]]*([[:digit:]]+)\n$"
    };

    for (i = 0; i < 13; i++)
        regcomp(&creg[i], reg[i], REG_EXTENDED | REG_ICASE);

    while (fgets(line, LINE_MAX - 1, fd)) {
        row++;
        if (!regexec(&creg[0], line, 0, match, 0))
            continue;
        else if (!regexec(&creg[1], line, 9, match, 0))
            set_account(line, match);
        else if (!regexec(&creg[2], line, 3, match, 0))
            r = set_mboxgrp(line, match);
        else if (!regexec(&creg[3], line, 3, match, 0))
            r = set_filter(line, match);
        else if (!regexec(&creg[4], line, 11, match, 0))
            r = set_action(line, match);
        else if (!regexec(&creg[5], line, 5, match, 0))
            r = set_mask(line, match, MASK_MATCH_1);
        else if (!regexec(&creg[6], line, 6, match, 0))
            r = set_mask(line, match, MASK_MATCH_2);
        else if (!regexec(&creg[7], line, 7, match, 0))
            r = set_mask(line, match, MASK_MATCH_3);
        else if (!regexec(&creg[8], line, 6, match, 0))
            r = set_mask(line, match, MASK_MATCH_4);
        else if (!regexec(&creg[9], line, 3, match, 0))
            r = set_job(line, match);
        else if (!regexec(&creg[10], line, 4, match, 0) ||
                 !regexec(&creg[11], line, 4, match, 0) ||
                 !regexec(&creg[12], line, 4, match, 0))
            set_options(line, match);
        else
            return row;

        if (r == ERROR_CONFIG_PARSE)
            return row;
    }

    for (i = 0; i < 13; i++)
        regfree(&creg[i]);

    destroy_data();

    return 0;
}


/*
 * Set other options found in config file.
 */
void set_options(char *line, regmatch_t * match)
{
    if (!strncasecmp(line + match[2].rm_so, "logfile", 7)) {
        if (!*logfile)
            strncat(logfile, line + match[3].rm_so,
                    min((match[3].rm_eo - match[3].rm_so), PATH_MAX - 1));
    } else if (!strncasecmp(line + match[2].rm_so, "expunge", 7)) {
        if (!strncasecmp(line + match[3].rm_so, "yes", 3))
            options |= OPTION_EXPUNGE;
        else
            options &= ~(OPTION_EXPUNGE);
    } else if (!strncasecmp(line + match[2].rm_so, "header", 6)) {
        if (!strncasecmp(line + match[3].rm_so, "yes", 3))
            options |= OPTION_HEADERS;
        else
            options &= ~(OPTION_HEADERS);
    } else if (!strncasecmp(line + match[2].rm_so, "namespace", 9)) {
        if (!strncasecmp(line + match[3].rm_so, "yes", 3))
            options |= OPTION_NAMESPACE;
        else
            options &= ~(OPTION_NAMESPACE);
    } else if (!strncasecmp(line + match[2].rm_so, "subscribe", 9)) {
        if (!strncasecmp(line + match[2].rm_so, "yes", 3))
            options |= OPTION_SUBSCRIBE;
        else
            options &= ~(OPTION_SUBSCRIBE);
    } else if (!strncasecmp(line + match[2].rm_so, "timeout", 7)) {
        errno = 0;
        timeout = strtol(line + match[3].rm_so, NULL, 10);
        if (errno)
            timeout = 0;
    } else if (!strncasecmp(line + match[2].rm_so, "daemon", 6) &&
               !(options & OPTION_DAEMON_MODE)) {
        options |= OPTION_DAEMON_MODE;
        errno = 0;
        interval = strtoul(line + match[3].rm_so, NULL, 10);
        if (errno)
            interval = 0;
    }
}


#ifdef ENCRYPTED_PASSWORDS
/*
 * Open password file and call parse_passwords().
 */
int read_passwords(void)
{
    FILE *fd;
    char pwfile[PATH_MAX];

    if (!(flags & FLAG_BLANK_PASSWORD))
        return ERROR_CONFIG_PARSE;

    passphr = (char *)smalloc(PASSPHRASE_LEN);
    *passphr = 0;

    snprintf(pwfile, PATH_MAX, "%s/%s", home, ".imapfilter/passwords");
#ifdef DEBUG
    printf("debug: passwords file: '%s'\n", pwfile);
#endif

    if (!exists_file(pwfile))
        return ERROR_FILE_OPEN;

#ifdef CHECK_PERMISSIONS
    check_file_perms(pwfile, S_IRUSR | S_IWUSR);
#endif

    fd = fopen(pwfile, "r");

    if (!fd)
        fatal(ERROR_FILE_OPEN, "imapfilter: opening passwords file %s; %s\n",
              pwfile, strerror(errno));

    parse_passwords(fd);

    fclose(fd);

    return 0;
}


/*
 *  Parse unencrypted password file.
 */
int parse_passwords(FILE * fd)
{
    int t = 3;
    char *pe = NULL;
    char user[USERNAME_LEN], serv[SERVER_LEN];
    unsigned char *buf;
    char *c, *cp, *line;
    regex_t creg;
    regmatch_t match[4];
    const char *reg = "([[:alnum:].-]+) ([[:graph:]]+) ([[:graph:]]+)";
    int r;

    do {
        fseek(fd, 0L, SEEK_SET);
        printf("Enter master passphrase: ");
        get_password(passphr, PASSPHRASE_LEN);
    } while ((r = decrypt_passwords(&buf, fd)) && --t);

    if (!t)
        return ERROR_PASSPHRASE;

    c = cp = sstrdup(buf);

    regcomp(&creg, reg, REG_EXTENDED | REG_ICASE);

    while ((line = strsep(&c, "\n")) &&
           !regexec(&creg, line, 4, match, 0)) {
        user[0] = serv[0] = 0;

        strncat(serv, line + match[1].rm_so,
                min(match[1].rm_eo - match[1].rm_so, SERVER_LEN - 1));
        strncat(user, line + match[2].rm_so,
                min(match[2].rm_eo - match[2].rm_so, USERNAME_LEN - 1));

        if ((pe = (char *)find_password(user, serv)))
            strncat(pe, line + match[3].rm_so,
                    min(match[3].rm_eo - match[3].rm_so, PASSWORD_LEN - 1));
    }

    regfree(&creg);
    sfree(cp);
    sfree(buf);

    return 0;
}


/*
 * Store encrypted passwords to file.
 */
int store_passwords(account_t * accts[])
{
    char pwfile[PATH_MAX];
    FILE *fd;

    snprintf(pwfile, PATH_MAX, "%s/%s", home, ".imapfilter/passwords");

    create_file(pwfile, S_IRUSR | S_IWUSR);

    fd = fopen(pwfile, "w");

    if (!fd)
        fatal(ERROR_FILE_OPEN, "imapfilter: opening passwords file %s; %s\n",
              pwfile, strerror(errno));

    encrypt_passwords(fd, accts);

    fclose(fd);

    return 0;
}

#endif


/*
 * Create $HOME/.imapfilter directory.
 */
int create_homedir(void)
{
    char *hdn = ".imapfilter";

    if (home)
        if (chdir(home))
            error("imapfilter: could not change directory; %s\n",
                  strerror(errno));

    if (!exists_dir(hdn))
        if (mkdir(hdn, S_IRUSR | S_IWUSR | S_IXUSR))
            error("imapfilter: could not create directory %s; %s\n", hdn,
                  strerror(errno));

    return 0;
}


/*
 * Check if a file exists.
 */
int exists_file(char *fname)
{
    struct stat fs;

    if (access(fname, F_OK))
        return 0;

    stat(fname, &fs);
    if (!S_ISREG(fs.st_mode)) {
        error("imapfilter: file %s not a regular file\n", fname);
        return ERROR_FILE_OPEN;
    }
    return 1;
}


/*
 * Check if a directory exists.
 */
int exists_dir(char *dname)
{
    struct stat ds;

    if (access(dname, F_OK))
        return 0;

    stat(dname, &ds);
    if (!S_ISDIR(ds.st_mode)) {
        error("imapfilter: file %s not a directory\n", dname);
        return ERROR_FILE_OPEN;
    }
    return 1;
}


/*
 * Create a file with the specified permissions.
 */
int create_file(char *fname, mode_t mode)
{
    int fd = 0;

    if (!exists_file(fname)) {
        fd = open(fname, O_CREAT | O_WRONLY | O_TRUNC, mode);
        if (fd == -1) {
            error("imapfilter: could not create file %s; %s\n", fname,
                  strerror(errno));
            return ERROR_FILE_OPEN;
        }
        close(fd);
    }
    return 0;
}


#ifdef CHECK_PERMISSIONS
/*
 * Check the permissions of a file.
 */
int check_file_perms(char *fname, mode_t mode)
{
    struct stat fs;

    if (stat(fname, &fs)) {
        error("imapfilter: getting file %s status; %s\n", fname,
              strerror(errno));
        return ERROR_TRIVIAL;
    }
    if (!S_ISREG(fs.st_mode)) {
        error("imapfilter: file %s not a regular file\n", fname);
        return ERROR_TRIVIAL;
    }
    if ((fs.st_mode & 00777) != mode) {
        error("imapfilter: warning: improper file %s permissions\n"
              "imapfilter: warning: file's mode should be %o not %o\n",
              fname, mode, fs.st_mode & 00777);
        return ERROR_TRIVIAL;
    }
    return 0;
}


/*
 * Check the permissions of a directory.
 */
int check_dir_perms(char *dname, mode_t mode)
{
    struct stat ds;

    if (stat(dname, &ds)) {
        error("imapfilter: getting file %s status; %s\n", dname,
              strerror(errno));
        return ERROR_TRIVIAL;
    }
    if (!S_ISDIR(ds.st_mode)) {
        error("imapfilter: file %s not a directory\n", dname);
        return ERROR_TRIVIAL;
    }
    if ((ds.st_mode & 00777) != mode) {
        error("imapfilter: warning: improper dir %s permissions\n"
              "imapfilter: warning: file's mode should be %o not %o\n",
              dname, mode, ds.st_mode & 00777);
        return ERROR_TRIVIAL;
    }
    return 0;
}

#endif
1	lefcha	1.1	#include <stdio.h>
2	lefcha	1.28	#include <unistd.h>
3	lefcha	1.1	#include <errno.h>
4	lefcha	1.5	#include <sys/types.h>
5	lefcha	1.1	#include <regex.h>
6			#include <string.h>
7			#include <stdlib.h>
8			#include <limits.h>
9	lefcha	1.10	#include <sys/stat.h>
10	lefcha	1.28	#include <fcntl.h>
11	lefcha	1.29	#include <time.h>
12	lefcha	1.1
13			#include "config.h"
14			#include "imapfilter.h"
15	lefcha	1.13	#include "data.h"
16	lefcha	1.1
17
18	lefcha	1.6	extern char logfile[PATH_MAX];
19	lefcha	1.11	extern unsigned int options;
20	lefcha	1.34	extern unsigned int flags;
21			extern unsigned int interval;
22	lefcha	1.28	extern long timeout;
23	lefcha	1.29	extern char *home;
24
25			#ifdef ENCRYPTED_PASSWORDS
26	lefcha	1.38	char passphr; / Master password to access the passwords
27			file. */
28	lefcha	1.28	#endif
29	lefcha	1.27
30	lefcha	1.1
31			/*
32	lefcha	1.13	* Find the path to configuration file, open it and call parse_config().
33	lefcha	1.1	*/
34			int read_config(char *cfg)
35			{
36			int r;
37	lefcha	1.29	FILE *fd;
38	lefcha	1.23	char *c = NULL;
39	lefcha	1.24
40	lefcha	1.1	if (!cfg) {
41	lefcha	1.38	cfg = c = (char )xmalloc(PATH_MAX sizeof(char));
42	lefcha	1.1	snprintf(cfg, PATH_MAX, "%s/%s", home, ".imapfilterrc");
43			}
44			#ifdef DEBUG
45	lefcha	1.11	printf("debug: configuration file: '%s'\n", cfg);
46	lefcha	1.1	#endif
47	lefcha	1.13	#ifdef CHECK_PERMISSIONS
48	lefcha	1.28	check_file_perms(cfg, S_IRUSR \| S_IWUSR);
49	lefcha	1.12	#endif
50	lefcha	1.29	fd = fopen(cfg, "r");
51	lefcha	1.1
52	lefcha	1.29	if (!fd)
53	lefcha	1.17	fatal(ERROR_FILE_OPEN, "imapfilter: opening config file %s; %s\n",
54	lefcha	1.11	cfg, strerror(errno));
55	lefcha	1.1
56	lefcha	1.23	if (c)
57	lefcha	1.29	xfree(c);
58	lefcha	1.23
59	lefcha	1.29	if ((r = parse_config(fd)))
60	lefcha	1.17	fatal(ERROR_CONFIG_PARSE,
61			"imapfilter: parse error in config file at row %d\n", r);
62	lefcha	1.1
63	lefcha	1.29	fclose(fd);
64	lefcha	1.1
65	lefcha	1.11	#ifdef DEBUG
66			printf("debug: options: %0#10x\n", options);
67			#endif
68
69	lefcha	1.17	return 0;
70	lefcha	1.1	}
71
72	lefcha	1.6
73	lefcha	1.10	/*
74	lefcha	1.13	* Parse configuration file.
75	lefcha	1.1	*/
76	lefcha	1.29	int parse_config(FILE * fd)
77	lefcha	1.1	{
78	lefcha	1.17	int i, r = 0;
79	lefcha	1.1	unsigned int row = 0;
80			char line[LINE_MAX];
81	lefcha	1.27	regex_t creg[13];
82	lefcha	1.39	regmatch_t match[11];
83	lefcha	1.27	const char *reg[13] = {
84	lefcha	1.15	"^([[:blank:]]\n\|#.\n)$",
85	lefcha	1.36
86			"^[[:blank:]]*ACCOUNT[[:blank:]]+([[:alnum:]_-]+)[[:blank:]]+"
87			"(([[:graph:]]+):([[:graph:]]*)\|([[:graph:]]+))@([[:alnum:].-]+)"
88			"(:[[:digit:]]+)?[[:blank:]]*([[:blank:]]SSL\|[[:blank:]]SSL2\|"
89			"[[:blank:]]SSL3\|[[:blank:]]TLS1)?[[:blank:]]*\n$",
90
91			"^[[:blank:]]*FOLDER[[:blank:]]+([[:alnum:]_-]+)[[:blank:]]+"
92			"([[:print:]]+)[[:blank:]]*\n$",
93
94			"^[[:blank:]]FILTER[[:blank:]]+([[:alnum:]_-]+)[[:blank:]]"
95			"([[:blank:]]OR\|[[:blank:]]AND)?[[:blank:]]*\n$",
96
97			"^[[:blank:]]*ACTION[[:blank:]]+(DELETE\|"
98			"COPY[[:blank:]]+(\"[[:print:]]*\"\|[[:graph:]]+)\|"
99			"MOVE[[:blank:]]+(\"[[:print:]]*\"\|[[:graph:]]+)\|"
100			"RCOPY[[:blank:]]+([[:alnum:]_-]+)[[:blank:]]+"
101			"(\"[[:print:]]*\"\|[[:graph:]]+)\|"
102			"RMOVE[[:blank:]]+([[:alnum:]_-]+)[[:blank:]]+"
103			"(\"[[:print:]]*\"\|[[:graph:]]+)\|"
104	lefcha	1.39	"FLAG[[:blank:]]+(REPLACE\|ADD\|REMOVE)[[:blank:]]+"
105			"([[:alpha:],]+)\|"
106	lefcha	1.36	"LIST)[[:blank:]]([[:graph:]])[[:blank:]]*\n$",
107
108			"^[[:blank:]](MASK[[:blank:]])?[[:blank:]](OR[[:blank:]]\|"
109			"AND[[:blank:]])?[[:blank:]](NOT[[:blank:]])?[[:blank:]]"
110			"(ANSWERED\|DELETED\|DRAFT\|FLAGGED\|NEW\|OLD\|RECENT\|SEEN\|UNANSWERED\|"
111			"UNDELETED\|UNDRAFT\|UNFLAGGED\|UNSEEN)[[:blank:]]*\n$",
112
113			"^[[:blank:]](MASK[[:blank:]])?[[:blank:]](OR[[:blank:]]\|"
114			"AND[[:blank:]])?[[:blank:]](NOT[[:blank:]])?[[:blank:]]"
115			"(BCC\|BODY\|CC\|FROM\|SUBJECT\|TEXT\|TO)[[:blank:]]+(\"[[:print:]]*\"\|"
116			"[[:graph:]]+)[[:blank:]]*\n$",
117
118			"^[[:blank:]](MASK[[:blank:]])?[[:blank:]](OR[[:blank:]]\|"
119			"AND[[:blank:]])?[[:blank:]](NOT[[:blank:]])?[[:blank:]]"
120			"(HEADER)[[:blank:]]+(\"[[:print:]]*\"\|[[:graph:]]+)[[:blank:]]+"
121			"(\"[[:print:]]\"\|[[:graph:]]+)[[:blank:]]\n$",
122
123			"^[[:blank:]](MASK[[:blank:]])?[[:blank:]](OR[[:blank:]]\|"
124			"AND[[:blank:]])?[[:blank:]](NOT[[:blank:]])?[[:blank:]]"
125			"(LARGER\|SMALLER\|OLDER\|NEWER)[[:blank:]]+([[:digit:]]+)"
126			"[[:blank:]]*\n$",
127
128			"^[[:blank:]]*JOB[[:blank:]]+([[:alnum:],_-]+)[[:blank:]]+"
129			"([[:alnum:],_-]+)[[:blank:]]*\n$",
130
131			"^[[:blank:]](SET[[:blank:]])?[[:blank:]](LOGFILE)"
132			"[[:blank:]]=[[:blank:]]([[:print:]]+)\n$",
133
134	lefcha	1.40	"^[[:blank:]](SET[[:blank:]])?[[:blank:]](EXPUNGE\|HEADERS\|NAMESPACE\|"
135			"SUBSCRIBE)[[:blank:]]=[[:blank:]](YES\|NO)[[:blank:]]*\n$",
136	lefcha	1.36
137			"^[[:blank:]](SET[[:blank:]])?[[:blank:]](DAEMON\|TIMEOUT)"
138			"[[:blank:]]=[[:blank:]]([[:digit:]]+)\n$"
139	lefcha	1.1	};
140
141	lefcha	1.27	for (i = 0; i < 13; i++)
142	lefcha	1.14	regcomp(&creg[i], reg[i], REG_EXTENDED \| REG_ICASE);
143	lefcha	1.1
144	lefcha	1.29	while (fgets(line, LINE_MAX - 1, fd)) {
145	lefcha	1.1	row++;
146	lefcha	1.15	if (!regexec(&creg[0], line, 0, match, 0))
147			continue;
148	lefcha	1.36	else if (!regexec(&creg[1], line, 9, match, 0))
149	lefcha	1.13	set_account(line, match);
150	lefcha	1.15	else if (!regexec(&creg[2], line, 3, match, 0))
151	lefcha	1.17	r = set_mboxgrp(line, match);
152	lefcha	1.15	else if (!regexec(&creg[3], line, 3, match, 0))
153	lefcha	1.17	r = set_filter(line, match);
154	lefcha	1.39	else if (!regexec(&creg[4], line, 11, match, 0))
155	lefcha	1.17	r = set_action(line, match);
156	lefcha	1.42	else if (!regexec(&creg[5], line, 5, match, 0))
157			r = set_mask(line, match, MASK_MATCH_1);
158			else if (!regexec(&creg[6], line, 6, match, 0))
159			r = set_mask(line, match, MASK_MATCH_2);
160			else if (!regexec(&creg[7], line, 7, match, 0))
161			r = set_mask(line, match, MASK_MATCH_3);
162			else if (!regexec(&creg[8], line, 6, match, 0))
163			r = set_mask(line, match, MASK_MATCH_4);
164	lefcha	1.15	else if (!regexec(&creg[9], line, 3, match, 0))
165	lefcha	1.17	r = set_job(line, match);
166	lefcha	1.26	else if (!regexec(&creg[10], line, 4, match, 0) \|\|
167	lefcha	1.27	!regexec(&creg[11], line, 4, match, 0) \|\|
168			!regexec(&creg[12], line, 4, match, 0))
169	lefcha	1.15	set_options(line, match);
170	lefcha	1.17	else
171	lefcha	1.18	return row;
172
173	lefcha	1.17	if (r == ERROR_CONFIG_PARSE)
174			return row;
175	lefcha	1.1	}
176	lefcha	1.3
177	lefcha	1.27	for (i = 0; i < 13; i++)
178	lefcha	1.12	regfree(&creg[i]);
179	lefcha	1.18
180	lefcha	1.15	destroy_data();
181	lefcha	1.6
182	lefcha	1.8	return 0;
183	lefcha	1.1	}
184
185
186			/*
187	lefcha	1.13	* Set other options found in config file.
188	lefcha	1.11	*/
189			void set_options(char line, regmatch_t match)
190			{
191	lefcha	1.41	if (!strncasecmp(line + match[2].rm_so, "logfile", 7)) {
192	lefcha	1.19	if (!*logfile)
193	lefcha	1.26	strncat(logfile, line + match[3].rm_so,
194			min((match[3].rm_eo - match[3].rm_so), PATH_MAX - 1));
195	lefcha	1.41	} else if (!strncasecmp(line + match[2].rm_so, "expunge", 7)) {
196			if (!strncasecmp(line + match[3].rm_so, "yes", 3))
197	lefcha	1.40	options \|= OPTION_EXPUNGE;
198			else
199			options &= ~(OPTION_EXPUNGE);
200	lefcha	1.41	} else if (!strncasecmp(line + match[2].rm_so, "header", 6)) {
201			if (!strncasecmp(line + match[3].rm_so, "yes", 3))
202	lefcha	1.19	options \|= OPTION_HEADERS;
203	lefcha	1.25	else
204			options &= ~(OPTION_HEADERS);
205	lefcha	1.41	} else if (!strncasecmp(line + match[2].rm_so, "namespace", 9)) {
206			if (!strncasecmp(line + match[3].rm_so, "yes", 3))
207	lefcha	1.28	options \|= OPTION_NAMESPACE;
208			else
209			options &= ~(OPTION_NAMESPACE);
210	lefcha	1.41	} else if (!strncasecmp(line + match[2].rm_so, "subscribe", 9)) {
211			if (!strncasecmp(line + match[2].rm_so, "yes", 3))
212	lefcha	1.40	options \|= OPTION_SUBSCRIBE;
213	lefcha	1.38	else
214	lefcha	1.40	options &= ~(OPTION_SUBSCRIBE);
215	lefcha	1.41	} else if (!strncasecmp(line + match[2].rm_so, "timeout", 7)) {
216	lefcha	1.27	errno = 0;
217			timeout = strtol(line + match[3].rm_so, NULL, 10);
218			if (errno)
219			timeout = 0;
220	lefcha	1.41	} else if (!strncasecmp(line + match[2].rm_so, "daemon", 6) &&
221	lefcha	1.34	!(options & OPTION_DAEMON_MODE)) {
222			options \|= OPTION_DAEMON_MODE;
223			errno = 0;
224			interval = strtoul(line + match[3].rm_so, NULL, 10);
225			if (errno)
226			interval = 0;
227	lefcha	1.19	}
228	lefcha	1.1	}
229	lefcha	1.29
230
231			#ifdef ENCRYPTED_PASSWORDS
232			/*
233			* Open password file and call parse_passwords().
234			*/
235			int read_passwords(void)
236			{
237			FILE *fd;
238			char pwfile[PATH_MAX];
239	lefcha	1.38
240	lefcha	1.34	if (!(flags & FLAG_BLANK_PASSWORD))
241	lefcha	1.36	return ERROR_CONFIG_PARSE;
242	lefcha	1.38
243			passphr = (char *)smalloc(PASSPHRASE_LEN);
244	lefcha	1.37	*passphr = 0;
245	lefcha	1.29
246			snprintf(pwfile, PATH_MAX, "%s/%s", home, ".imapfilter/passwords");
247			#ifdef DEBUG
248			printf("debug: passwords file: '%s'\n", pwfile);
249			#endif
250	lefcha	1.38
251	lefcha	1.29	if (!exists_file(pwfile))
252	lefcha	1.36	return ERROR_FILE_OPEN;
253	lefcha	1.38
254	lefcha	1.29	#ifdef CHECK_PERMISSIONS
255			check_file_perms(pwfile, S_IRUSR \| S_IWUSR);
256			#endif
257
258			fd = fopen(pwfile, "r");
259
260			if (!fd)
261			fatal(ERROR_FILE_OPEN, "imapfilter: opening passwords file %s; %s\n",
262			pwfile, strerror(errno));
263
264			parse_passwords(fd);
265
266			fclose(fd);
267
268			return 0;
269			}
270
271
272			/*
273			* Parse unencrypted password file.
274			*/
275			int parse_passwords(FILE * fd)
276			{
277			int t = 3;
278			char *pe = NULL;
279			char user[USERNAME_LEN], serv[SERVER_LEN];
280			unsigned char *buf;
281			char c, cp, *line;
282			regex_t creg;
283			regmatch_t match[4];
284			const char *reg = "([[:alnum:].-]+) ([[:graph:]]+) ([[:graph:]]+)";
285	lefcha	1.36	int r;
286	lefcha	1.29
287			do {
288	lefcha	1.36	fseek(fd, 0L, SEEK_SET);
289	lefcha	1.29	printf("Enter master passphrase: ");
290			get_password(passphr, PASSPHRASE_LEN);
291	lefcha	1.36	} while ((r = decrypt_passwords(&buf, fd)) && --t);
292	lefcha	1.38
293	lefcha	1.29	if (!t)
294			return ERROR_PASSPHRASE;
295
296	lefcha	1.31	c = cp = sstrdup(buf);
297	lefcha	1.38
298	lefcha	1.29	regcomp(&creg, reg, REG_EXTENDED \| REG_ICASE);
299
300			while ((line = strsep(&c, "\n")) &&
301			!regexec(&creg, line, 4, match, 0)) {
302			user[0] = serv[0] = 0;
303	lefcha	1.38
304	lefcha	1.29	strncat(serv, line + match[1].rm_so,
305			min(match[1].rm_eo - match[1].rm_so, SERVER_LEN - 1));
306			strncat(user, line + match[2].rm_so,
307			min(match[2].rm_eo - match[2].rm_so, USERNAME_LEN - 1));
308	lefcha	1.38
309			if ((pe = (char *)find_password(user, serv)))
310	lefcha	1.29	strncat(pe, line + match[3].rm_so,
311			min(match[3].rm_eo - match[3].rm_so, PASSWORD_LEN - 1));
312			}
313	lefcha	1.38
314	lefcha	1.29	regfree(&creg);
315	lefcha	1.38	sfree(cp);
316	lefcha	1.31	sfree(buf);
317	lefcha	1.29
318			return 0;
319			}
320
321
322			/*
323			* Store encrypted passwords to file.
324			*/
325			int store_passwords(account_t * accts[])
326			{
327			char pwfile[PATH_MAX];
328			FILE *fd;
329
330			snprintf(pwfile, PATH_MAX, "%s/%s", home, ".imapfilter/passwords");
331	lefcha	1.38
332	lefcha	1.32	create_file(pwfile, S_IRUSR \| S_IWUSR);
333	lefcha	1.29
334			fd = fopen(pwfile, "w");
335
336			if (!fd)
337			fatal(ERROR_FILE_OPEN, "imapfilter: opening passwords file %s; %s\n",
338			pwfile, strerror(errno));
339	lefcha	1.38
340	lefcha	1.29	encrypt_passwords(fd, accts);
341	lefcha	1.38
342	lefcha	1.29	fclose(fd);
343
344			return 0;
345			}
346	lefcha	1.38
347	lefcha	1.29	#endif
348	lefcha	1.31
349
350			/*
351			* Create $HOME/.imapfilter directory.
352			*/
353			int create_homedir(void)
354			{
355	lefcha	1.33	char *hdn = ".imapfilter";
356	lefcha	1.38
357	lefcha	1.31	if (home)
358			if (chdir(home))
359			error("imapfilter: could not change directory; %s\n",
360			strerror(errno));
361
362	lefcha	1.36	if (!exists_dir(hdn))
363			if (mkdir(hdn, S_IRUSR \| S_IWUSR \| S_IXUSR))
364			error("imapfilter: could not create directory %s; %s\n", hdn,
365			strerror(errno));
366
367	lefcha	1.31	return 0;
368			}
369
370
371			/*
372			* Check if a file exists.
373			*/
374			int exists_file(char *fname)
375			{
376			struct stat fs;
377	lefcha	1.38
378	lefcha	1.31	if (access(fname, F_OK))
379			return 0;
380	lefcha	1.38
381	lefcha	1.31	stat(fname, &fs);
382			if (!S_ISREG(fs.st_mode)) {
383			error("imapfilter: file %s not a regular file\n", fname);
384			return ERROR_FILE_OPEN;
385			}
386			return 1;
387			}
388
389
390	lefcha	1.38	/*
391	lefcha	1.31	* Check if a directory exists.
392			*/
393			int exists_dir(char *dname)
394			{
395			struct stat ds;
396	lefcha	1.38
397	lefcha	1.31	if (access(dname, F_OK))
398			return 0;
399	lefcha	1.38
400	lefcha	1.31	stat(dname, &ds);
401			if (!S_ISDIR(ds.st_mode)) {
402			error("imapfilter: file %s not a directory\n", dname);
403			return ERROR_FILE_OPEN;
404			}
405			return 1;
406			}
407
408
409			/*
410	lefcha	1.36	* Create a file with the specified permissions.
411	lefcha	1.31	*/
412			int create_file(char *fname, mode_t mode)
413			{
414			int fd = 0;
415	lefcha	1.38
416	lefcha	1.33	if (!exists_file(fname)) {
417			fd = open(fname, O_CREAT \| O_WRONLY \| O_TRUNC, mode);
418	lefcha	1.31	if (fd == -1) {
419			error("imapfilter: could not create file %s; %s\n", fname,
420			strerror(errno));
421			return ERROR_FILE_OPEN;
422			}
423			close(fd);
424	lefcha	1.33	}
425	lefcha	1.31	return 0;
426			}
427
428
429			#ifdef CHECK_PERMISSIONS
430			/*
431			* Check the permissions of a file.
432			*/
433			int check_file_perms(char *fname, mode_t mode)
434			{
435			struct stat fs;
436	lefcha	1.38
437	lefcha	1.31	if (stat(fname, &fs)) {
438			error("imapfilter: getting file %s status; %s\n", fname,
439			strerror(errno));
440			return ERROR_TRIVIAL;
441			}
442			if (!S_ISREG(fs.st_mode)) {
443			error("imapfilter: file %s not a regular file\n", fname);
444			return ERROR_TRIVIAL;
445			}
446			if ((fs.st_mode & 00777) != mode) {
447			error("imapfilter: warning: improper file %s permissions\n"
448			"imapfilter: warning: file's mode should be %o not %o\n",
449			fname, mode, fs.st_mode & 00777);
450			return ERROR_TRIVIAL;
451			}
452			return 0;
453			}
454
455
456			/*
457			* Check the permissions of a directory.
458			*/
459			int check_dir_perms(char *dname, mode_t mode)
460			{
461			struct stat ds;
462
463			if (stat(dname, &ds)) {
464			error("imapfilter: getting file %s status; %s\n", dname,
465			strerror(errno));
466			return ERROR_TRIVIAL;
467			}
468			if (!S_ISDIR(ds.st_mode)) {
469			error("imapfilter: file %s not a directory\n", dname);
470			return ERROR_TRIVIAL;
471			}
472			if ((ds.st_mode & 00777) != mode) {
473			error("imapfilter: warning: improper dir %s permissions\n"
474			"imapfilter: warning: file's mode should be %o not %o\n",
475			dname, mode, ds.st_mode & 00777);
476			return ERROR_TRIVIAL;
477			}
478			return 0;
479			}
480	lefcha	1.38
481	lefcha	1.31	#endif