imapfilter/imapfilter/connect.c

#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <string.h>
#include <regex.h>

#include "config.h"
#include "imapfilter.h"
#include "connect.h"
#include "log.h"
#include "imap.h"


extern account_t *accounts;
extern int options;

int sock;


/*
 * Connects to mailserver.
 */
int init_connection(account_t * ca)
{
    struct sockaddr_in name;
    struct hostent *hostinfo;

    memset((char *) &name, 0, sizeof(struct sockaddr_in));

    sock = socket(PF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        error("imapfilter: create socket; %s\n", strerror(errno));
        return 1;
    }

    if (!(hostinfo = gethostbyname(ca->server))) {
        error("imapfilter: get network host entry; %s\n", strerror(errno));
        close_connection();
        return 1;
    }

    name.sin_family = AF_INET;
    name.sin_port = htons(ca->port);
    name.sin_addr = *(struct in_addr *) hostinfo->h_addr;

    if (connect(sock, (struct sockaddr *) &name, sizeof(struct sockaddr))) {
        error("imapfilter: initiating connection; %s\n", strerror(errno));
        close_connection();
        return 1;
    }

    verbose("Connected to %s.\n", hostinfo->h_name);

    return 0;
}


/*
 * Disconnects from mailserver.
 */
int close_connection(void)
{
    if (close(sock)) {
        error("imapfilter: closing socket; %s\n", strerror(errno));
        return 1;
    } else
        return 0;
}


/*
 * Reads (if any) data the server sent.
 */
int get_response(char *buf)
{
    int flags;
    fd_set rfds;
    struct timeval tv;

    memset(buf, 0, RESPONSE_BUF);

    tv.tv_sec = 10;
    tv.tv_usec = 0;

    flags = fcntl(sock, F_GETFL, 0);
    fcntl(sock, F_SETFL, flags | O_NONBLOCK);

    FD_ZERO(&rfds);
    FD_SET(sock, &rfds);

    if ((select(sock + 1, &rfds, NULL, NULL, &tv) > 0)
        && FD_ISSET(sock, &rfds)) {
        if (read(sock, buf, RESPONSE_BUF - 1) != -1) {
#ifdef DEBUG
            printf("\n%s\n", buf);
#endif
            if (options & OPT_DETAILS_VERBOSE)
                analyze_response(buf);

            fcntl(sock, F_SETFL, flags);
            return 0;
        }
    }

    fcntl(sock, F_SETFL, flags);

    return 1;
}


/*
 * Clears stream from any data server sent without processing them.
 */
int clear_stream(void)
{
    int r;
    unsigned int saveopt;
    char buf[RESPONSE_BUF];

    saveopt = options;          /* Needed so response won't be analyzed. */
    options &= OPT_DETAILS_CLEAR;

    r = get_response(buf);

    options = saveopt;

    return r;
}


/*
 * Proccesses the data that server sent due to IMAP SELSECT client request.
 */
int select_response(void)
{
    int r, i, s;
    char buf[RESPONSE_BUF];
    char exists[SELECT_BUF], recent[SELECT_BUF];
    regex_t creg[2];
    regmatch_t match[2];
    const char *reg[2] = {
        "\\* ([[:digit:]]+) EXISTS",
        "\\* ([[:digit:]]+) RECENT"
    };

    exists[0] = recent[0] = 0;

    r = get_response(buf);

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

    if (!regexec(&creg[0], buf, 2, match, 0)) {
        s = min(match[1].rm_eo - match[1].rm_so, SELECT_BUF - 1);
        strncpy(exists, buf + match[1].rm_so, s);
        exists[s] = 0;
    }

    if (!regexec(&creg[1], buf, 2, match, 0)) {
        s = min(match[1].rm_eo - match[1].rm_so, SELECT_BUF - 1);
        strncpy(recent, buf + match[1].rm_so, s);
        recent[s] = 0;
    }

    if (!(options & OPT_DETAILS_QUITE))
        printf("%s messages exist, %s of which recent.\n", exists, recent);

    return r;
}


/*
 * Processes the data that server sent due to IMAP SEARCH client request.
 */
int search_response(char *res)
{
    int r, s, len;
    char buf[RESPONSE_BUF];
    regex_t creg;
    regmatch_t match[2];
    const char *reg = "\\* SEARCH([[:digit:] ]*)";

    len = strlen(res);

    r = get_response(buf);

    regcomp(&creg, reg, REG_EXTENDED);

    if (!regexec(&creg, buf, 2, match, 0)) {
        s = min(match[1].rm_eo - match[1].rm_so, SEARCH_BUF - 1);
        strncpy(res + len, buf + match[1].rm_so, s);
        res[s + len] = 0;
    }
    return r;
}


/*
 * Processes the data that server sent due to IMAP FETCH client request.
 */
int fetch_response(char *res)
{
    int r, i, s, len = 0;
    char buf[RESPONSE_BUF];
    regex_t creg[3];
    regmatch_t match[1];
    const char *reg[3] = {
        "Date: [[:print:]]*",
        "From: [[:print:]]*",
        "Subject: [[:print:]]*"
    };

    r = get_response(buf);

    for (i = 0; i < 3; i++) {
        regcomp(&creg[i], reg[i], REG_EXTENDED);

        if (!regexec(&creg[i], buf, 1, match, 0)) {
            s = min(match[0].rm_eo - match[0].rm_so,
                    HEADERS_MAX - len - 1);
            strncpy(res + len, buf + match[0].rm_so, s);
            res[s + len] = '\n';
            res[s + len + 1] = 0;
            len = strlen(res);
        }
    }

    return r;
}


/*
 * Checks if response of server to client's request was succesfully
 * delivered or there was some kind of error.
 */
void analyze_response(char *buf)
{
    int s;
    regex_t creg;
    regmatch_t match[2];
    const char *reg = "[[:xdigit:]]{4,4} ([[:print:]]*)";
    char res[RESULTS_BUF];

    regcomp(&creg, reg, REG_EXTENDED);

    if (!regexec(&creg, buf, 2, match, 0)) {
        s = min(match[1].rm_eo - match[1].rm_so, RESULTS_BUF - 1);
        strncpy(res, buf + match[1].rm_so, s);
        res[s] = 0;
        printf("Server response: %s\n", res);
    }
}
1	#include <stdio.h>
2	#include <errno.h>
3	#include <unistd.h>
4	#include <sys/types.h>
5	#include <sys/time.h>
6	#include <sys/socket.h>
7	#include <fcntl.h>
8	#include <netdb.h>
9	#include <netinet/in.h>
10	#include <string.h>
11	#include <regex.h>
12
13	#include "config.h"
14	#include "imapfilter.h"
15	#include "connect.h"
16	#include "log.h"
17	#include "imap.h"
18
19
20	extern account_t *accounts;
21	extern int options;
22
23	int sock;
24
25
26	/*
27	* Connects to mailserver.
28	*/
29	int init_connection(account_t * ca)
30	{
31	struct sockaddr_in name;
32	struct hostent *hostinfo;
33
34	memset((char *) &name, 0, sizeof(struct sockaddr_in));
35
36	sock = socket(PF_INET, SOCK_STREAM, 0);
37	if (sock < 0) {
38	error("imapfilter: create socket; %s\n", strerror(errno));
39	return 1;
40	}
41
42	if (!(hostinfo = gethostbyname(ca->server))) {
43	error("imapfilter: get network host entry; %s\n", strerror(errno));
44	close_connection();
45	return 1;
46	}
47
48	name.sin_family = AF_INET;
49	name.sin_port = htons(ca->port);
50	name.sin_addr = (struct in_addr ) hostinfo->h_addr;
51
52	if (connect(sock, (struct sockaddr *) &name, sizeof(struct sockaddr))) {
53	error("imapfilter: initiating connection; %s\n", strerror(errno));
54	close_connection();
55	return 1;
56	}
57
58	verbose("Connected to %s.\n", hostinfo->h_name);
59
60	return 0;
61	}
62
63
64	/*
65	* Disconnects from mailserver.
66	*/
67	int close_connection(void)
68	{
69	if (close(sock)) {
70	error("imapfilter: closing socket; %s\n", strerror(errno));
71	return 1;
72	} else
73	return 0;
74	}
75
76
77	/*
78	* Reads (if any) data the server sent.
79	*/
80	int get_response(char *buf)
81	{
82	int flags;
83	fd_set rfds;
84	struct timeval tv;
85
86	memset(buf, 0, RESPONSE_BUF);
87
88	tv.tv_sec = 10;
89	tv.tv_usec = 0;
90
91	flags = fcntl(sock, F_GETFL, 0);
92	fcntl(sock, F_SETFL, flags \| O_NONBLOCK);
93
94	FD_ZERO(&rfds);
95	FD_SET(sock, &rfds);
96
97	if ((select(sock + 1, &rfds, NULL, NULL, &tv) > 0)
98	&& FD_ISSET(sock, &rfds)) {
99	if (read(sock, buf, RESPONSE_BUF - 1) != -1) {
100	#ifdef DEBUG
101	printf("\n%s\n", buf);
102	#endif
103	if (options & OPT_DETAILS_VERBOSE)
104	analyze_response(buf);
105
106	fcntl(sock, F_SETFL, flags);
107	return 0;
108	}
109	}
110
111	fcntl(sock, F_SETFL, flags);
112
113	return 1;
114	}
115
116
117	/*
118	* Clears stream from any data server sent without processing them.
119	*/
120	int clear_stream(void)
121	{
122	int r;
123	unsigned int saveopt;
124	char buf[RESPONSE_BUF];
125
126	saveopt = options; /* Needed so response won't be analyzed. */
127	options &= OPT_DETAILS_CLEAR;
128
129	r = get_response(buf);
130
131	options = saveopt;
132
133	return r;
134	}
135
136
137	/*
138	* Proccesses the data that server sent due to IMAP SELSECT client request.
139	*/
140	int select_response(void)
141	{
142	int r, i, s;
143	char buf[RESPONSE_BUF];
144	char exists[SELECT_BUF], recent[SELECT_BUF];
145	regex_t creg[2];
146	regmatch_t match[2];
147	const char *reg[2] = {
148	"\\* ([[:digit:]]+) EXISTS",
149	"\\* ([[:digit:]]+) RECENT"
150	};
151
152	exists[0] = recent[0] = 0;
153
154	r = get_response(buf);
155
156	for (i = 0; i < 2; i++)
157	regcomp(&creg[i], reg[i], REG_EXTENDED);
158
159	if (!regexec(&creg[0], buf, 2, match, 0)) {
160	s = min(match[1].rm_eo - match[1].rm_so, SELECT_BUF - 1);
161	strncpy(exists, buf + match[1].rm_so, s);
162	exists[s] = 0;
163	}
164
165	if (!regexec(&creg[1], buf, 2, match, 0)) {
166	s = min(match[1].rm_eo - match[1].rm_so, SELECT_BUF - 1);
167	strncpy(recent, buf + match[1].rm_so, s);
168	recent[s] = 0;
169	}
170
171	if (!(options & OPT_DETAILS_QUITE))
172	printf("%s messages exist, %s of which recent.\n", exists, recent);
173
174	return r;
175	}
176
177
178	/*
179	* Processes the data that server sent due to IMAP SEARCH client request.
180	*/
181	int search_response(char *res)
182	{
183	int r, s, len;
184	char buf[RESPONSE_BUF];
185	regex_t creg;
186	regmatch_t match[2];
187	const char reg = "\\ SEARCH([[:digit:] ]*)";
188
189	len = strlen(res);
190
191	r = get_response(buf);
192
193	regcomp(&creg, reg, REG_EXTENDED);
194
195	if (!regexec(&creg, buf, 2, match, 0)) {
196	s = min(match[1].rm_eo - match[1].rm_so, SEARCH_BUF - 1);
197	strncpy(res + len, buf + match[1].rm_so, s);
198	res[s + len] = 0;
199	}
200	return r;
201	}
202
203
204	/*
205	* Processes the data that server sent due to IMAP FETCH client request.
206	*/
207	int fetch_response(char *res)
208	{
209	int r, i, s, len = 0;
210	char buf[RESPONSE_BUF];
211	regex_t creg[3];
212	regmatch_t match[1];
213	const char *reg[3] = {
214	"Date: [[:print:]]*",
215	"From: [[:print:]]*",
216	"Subject: [[:print:]]*"
217	};
218
219	r = get_response(buf);
220
221	for (i = 0; i < 3; i++) {
222	regcomp(&creg[i], reg[i], REG_EXTENDED);
223
224	if (!regexec(&creg[i], buf, 1, match, 0)) {
225	s = min(match[0].rm_eo - match[0].rm_so,
226	HEADERS_MAX - len - 1);
227	strncpy(res + len, buf + match[0].rm_so, s);
228	res[s + len] = '\n';
229	res[s + len + 1] = 0;
230	len = strlen(res);
231	}
232	}
233
234	return r;
235	}
236
237
238	/*
239	* Checks if response of server to client's request was succesfully
240	* delivered or there was some kind of error.
241	*/
242	void analyze_response(char *buf)
243	{
244	int s;
245	regex_t creg;
246	regmatch_t match[2];
247	const char reg = "[[:xdigit:]]{4,4} ([[:print:]])";
248	char res[RESULTS_BUF];
249
250	regcomp(&creg, reg, REG_EXTENDED);
251
252	if (!regexec(&creg, buf, 2, match, 0)) {
253	s = min(match[1].rm_eo - match[1].rm_so, RESULTS_BUF - 1);
254	strncpy(res, buf + match[1].rm_so, s);
255	res[s] = 0;
256	printf("Server response: %s\n", res);
257	}
258	}