author | zautrix <zautrix> | 2004-07-03 16:33:12 (UTC) |
---|---|---|
committer | zautrix <zautrix> | 2004-07-03 16:33:12 (UTC) |
commit | e3b89230f065c48c84b48c88edb6eb088374c487 (patch) (unidiff) | |
tree | 162ea2ef909a6f82ccfcedf45d80d6c821174912 /kmicromail/libetpan/generic/maildriver_types.c | |
parent | 2dd6ac0b2d24c91d35ce674a6c26351352df2b15 (diff) | |
download | kdepimpi-e3b89230f065c48c84b48c88edb6eb088374c487.zip kdepimpi-e3b89230f065c48c84b48c88edb6eb088374c487.tar.gz kdepimpi-e3b89230f065c48c84b48c88edb6eb088374c487.tar.bz2 |
Initial revision
Diffstat (limited to 'kmicromail/libetpan/generic/maildriver_types.c') (more/less context) (ignore whitespace changes)
-rw-r--r-- | kmicromail/libetpan/generic/maildriver_types.c | 340 |
1 files changed, 340 insertions, 0 deletions
diff --git a/kmicromail/libetpan/generic/maildriver_types.c b/kmicromail/libetpan/generic/maildriver_types.c new file mode 100644 index 0000000..7b3b348 --- a/dev/null +++ b/kmicromail/libetpan/generic/maildriver_types.c | |||
@@ -0,0 +1,340 @@ | |||
1 | /* | ||
2 | * libEtPan! -- a mail stuff library | ||
3 | * | ||
4 | * Copyright (C) 2001, 2002 - DINH Viet Hoa | ||
5 | * All rights reserved. | ||
6 | * | ||
7 | * Redistribution and use in source and binary forms, with or without | ||
8 | * modification, are permitted provided that the following conditions | ||
9 | * are met: | ||
10 | * 1. Redistributions of source code must retain the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer. | ||
12 | * 2. Redistributions in binary form must reproduce the above copyright | ||
13 | * notice, this list of conditions and the following disclaimer in the | ||
14 | * documentation and/or other materials provided with the distribution. | ||
15 | * 3. Neither the name of the libEtPan! project nor the names of its | ||
16 | * contributors may be used to endorse or promote products derived | ||
17 | * from this software without specific prior written permission. | ||
18 | * | ||
19 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
20 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
21 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
22 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
23 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
24 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
25 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
26 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
27 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
28 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
29 | * SUCH DAMAGE. | ||
30 | */ | ||
31 | |||
32 | /* | ||
33 | * $Id$ | ||
34 | */ | ||
35 | |||
36 | #include "maildriver_types.h" | ||
37 | #include <time.h> | ||
38 | #include <stdlib.h> | ||
39 | #include "mailmessage.h" | ||
40 | |||
41 | struct mailmessage_list * mailmessage_list_new(carray * msg_tab) | ||
42 | { | ||
43 | struct mailmessage_list * env_list; | ||
44 | |||
45 | env_list = malloc(sizeof(* env_list)); | ||
46 | if (env_list == NULL) | ||
47 | return NULL; | ||
48 | |||
49 | env_list->msg_tab = msg_tab; | ||
50 | |||
51 | return env_list; | ||
52 | } | ||
53 | |||
54 | void mailmessage_list_free(struct mailmessage_list * env_list) | ||
55 | { | ||
56 | unsigned int i; | ||
57 | |||
58 | for(i = 0 ; i < carray_count(env_list->msg_tab) ; i ++) { | ||
59 | mailmessage * msg; | ||
60 | |||
61 | msg = carray_get(env_list->msg_tab, i); | ||
62 | if (msg != NULL) | ||
63 | mailmessage_free(msg); | ||
64 | } | ||
65 | carray_free(env_list->msg_tab); | ||
66 | free(env_list); | ||
67 | } | ||
68 | |||
69 | struct mail_list * mail_list_new(clist * list) | ||
70 | { | ||
71 | struct mail_list * resp; | ||
72 | |||
73 | resp = malloc(sizeof(* resp)); | ||
74 | if (resp == NULL) | ||
75 | return NULL; | ||
76 | resp->mb_list = list; | ||
77 | |||
78 | return resp; | ||
79 | } | ||
80 | |||
81 | void mail_list_free(struct mail_list * resp) | ||
82 | { | ||
83 | clist_foreach(resp->mb_list, (clist_func) free, NULL); | ||
84 | clist_free(resp->mb_list); | ||
85 | free(resp); | ||
86 | } | ||
87 | |||
88 | static int32_t mailimf_date_time_to_int(struct mailimf_date_time * date) | ||
89 | { | ||
90 | return date->dt_year * 12 * 30 * 24 * 60 * 60 + | ||
91 | date->dt_month * 30 * 24 * 60 * 60 + date->dt_day * 24 * 60 * 60 + | ||
92 | (date->dt_hour - date->dt_zone) * 60 * 60 + | ||
93 | date->dt_min * 60 + date->dt_sec; | ||
94 | } | ||
95 | |||
96 | int32_t mailimf_date_time_comp(struct mailimf_date_time * date1, | ||
97 | struct mailimf_date_time * date2) | ||
98 | { | ||
99 | return mailimf_date_time_to_int(date1) - mailimf_date_time_to_int(date2); | ||
100 | } | ||
101 | |||
102 | |||
103 | |||
104 | |||
105 | |||
106 | |||
107 | |||
108 | #if 0 | ||
109 | struct mail_search_key * | ||
110 | mail_search_key_new(int sk_type, | ||
111 | char * sk_bcc, | ||
112 | struct mailimf_date_time * sk_before, | ||
113 | char * sk_body, | ||
114 | char * sk_cc, | ||
115 | char * sk_from, | ||
116 | struct mailimf_date_time * sk_on, | ||
117 | struct mailimf_date_time * sk_since, | ||
118 | char * sk_subject, | ||
119 | char * sk_text, | ||
120 | char * sk_to, | ||
121 | char * sk_header_name, | ||
122 | char * sk_header_value, | ||
123 | size_t sk_larger, | ||
124 | struct mail_search_key * sk_not, | ||
125 | struct mail_search_key * sk_or1, | ||
126 | struct mail_search_key * sk_or2, | ||
127 | size_t sk_smaller, | ||
128 | clist * sk_multiple) | ||
129 | { | ||
130 | struct mail_search_key * key; | ||
131 | |||
132 | key = malloc(sizeof(* key)); | ||
133 | if (key == NULL) | ||
134 | return NULL; | ||
135 | |||
136 | key->sk_type = sk_type; | ||
137 | key->sk_bcc = sk_bcc; | ||
138 | key->sk_before = sk_before; | ||
139 | key->sk_body = sk_body; | ||
140 | key->sk_cc = sk_cc; | ||
141 | key->sk_from = sk_from; | ||
142 | key->sk_on = sk_on; | ||
143 | key->sk_since = sk_since; | ||
144 | key->sk_subject = sk_subject; | ||
145 | key->sk_text = sk_text; | ||
146 | key->sk_to = sk_to; | ||
147 | key->sk_header_name = sk_header_name; | ||
148 | key->sk_header_value = sk_header_value; | ||
149 | key->sk_larger = sk_larger; | ||
150 | key->sk_not = sk_not; | ||
151 | key->sk_or1 = sk_or1; | ||
152 | key->sk_or2 = sk_or2; | ||
153 | key->sk_smaller = sk_smaller; | ||
154 | key->sk_multiple = sk_multiple; | ||
155 | |||
156 | return key; | ||
157 | } | ||
158 | |||
159 | |||
160 | void mail_search_key_free(struct mail_search_key * key) | ||
161 | { | ||
162 | if (key->sk_bcc) | ||
163 | free(key->sk_bcc); | ||
164 | if (key->sk_before) | ||
165 | mailimf_date_time_free(key->sk_before); | ||
166 | if (key->sk_body) | ||
167 | free(key->sk_body); | ||
168 | if (key->sk_cc) | ||
169 | free(key->sk_cc); | ||
170 | if (key->sk_from) | ||
171 | free(key->sk_from); | ||
172 | if (key->sk_on) | ||
173 | mailimf_date_time_free(key->sk_on); | ||
174 | if (key->sk_since) | ||
175 | mailimf_date_time_free(key->sk_since); | ||
176 | if (key->sk_subject) | ||
177 | free(key->sk_subject); | ||
178 | if (key->sk_text) | ||
179 | free(key->sk_text); | ||
180 | if (key->sk_to) | ||
181 | free(key->sk_to); | ||
182 | if (key->sk_header_name) | ||
183 | free(key->sk_header_name); | ||
184 | if (key->sk_header_value) | ||
185 | free(key->sk_header_value); | ||
186 | if (key->sk_not) | ||
187 | mail_search_key_free(key->sk_not); | ||
188 | if (key->sk_or1) | ||
189 | mail_search_key_free(key->sk_or1); | ||
190 | if (key->sk_or2) | ||
191 | mail_search_key_free(key->sk_or2); | ||
192 | if (key->sk_multiple) { | ||
193 | clist_foreach(key->sk_multiple, (clist_func) mail_search_key_free, NULL); | ||
194 | clist_free(key->sk_multiple); | ||
195 | } | ||
196 | |||
197 | free(key); | ||
198 | } | ||
199 | |||
200 | |||
201 | struct mail_search_result * mail_search_result_new(clist * list) | ||
202 | { | ||
203 | struct mail_search_result * search_result; | ||
204 | |||
205 | search_result = malloc(sizeof(* search_result)); | ||
206 | if (search_result == NULL) | ||
207 | return NULL; | ||
208 | search_result->list = list; | ||
209 | |||
210 | return search_result; | ||
211 | } | ||
212 | |||
213 | void mail_search_result_free(struct mail_search_result * search_result) | ||
214 | { | ||
215 | clist_foreach(search_result->list, (clist_func) free, NULL); | ||
216 | clist_free(search_result->list); | ||
217 | free(search_result); | ||
218 | } | ||
219 | #endif | ||
220 | |||
221 | struct error_message { | ||
222 | int code; | ||
223 | char * message; | ||
224 | }; | ||
225 | |||
226 | static struct error_message message_tab[] = { | ||
227 | { MAIL_NO_ERROR, "no error" }, | ||
228 | { MAIL_NO_ERROR_AUTHENTICATED, "no error - authenticated" }, | ||
229 | { MAIL_NO_ERROR_NON_AUTHENTICATED, "no error - not authenticated" }, | ||
230 | { MAIL_ERROR_NOT_IMPLEMENTED, "not implemented" }, | ||
231 | { MAIL_ERROR_UNKNOWN, "unknown"}, | ||
232 | { MAIL_ERROR_CONNECT, "connect"}, | ||
233 | { MAIL_ERROR_BAD_STATE, "bad state"}, | ||
234 | { MAIL_ERROR_FILE, "file error - file could not be accessed" }, | ||
235 | { MAIL_ERROR_STREAM, "stream error - socket could not be read or written" }, | ||
236 | { MAIL_ERROR_LOGIN, "login error" }, | ||
237 | { MAIL_ERROR_CREATE, "create error" }, | ||
238 | { MAIL_ERROR_DELETE, /* 10 */ "delete error" }, | ||
239 | { MAIL_ERROR_LOGOUT, "logout error" }, | ||
240 | { MAIL_ERROR_NOOP, "noop error" }, | ||
241 | { MAIL_ERROR_RENAME, "rename error" }, | ||
242 | { MAIL_ERROR_CHECK, "check error" }, | ||
243 | { MAIL_ERROR_EXAMINE, "examine error" }, | ||
244 | { MAIL_ERROR_SELECT, "select error - folder does not exist" }, | ||
245 | { MAIL_ERROR_MEMORY, "not enough memory" }, | ||
246 | { MAIL_ERROR_STATUS, "status error" }, | ||
247 | { MAIL_ERROR_SUBSCRIBE, "subscribe error" }, | ||
248 | { MAIL_ERROR_UNSUBSCRIBE, /* 20 */ "unsubscribe error" }, | ||
249 | { MAIL_ERROR_LIST, "list error" }, | ||
250 | { MAIL_ERROR_LSUB, "lsub error" }, | ||
251 | { MAIL_ERROR_APPEND, "append error - mail could not be appended" }, | ||
252 | { MAIL_ERROR_COPY, "copy error" }, | ||
253 | { MAIL_ERROR_FETCH, "fetch error" }, | ||
254 | { MAIL_ERROR_STORE, "store error" }, | ||
255 | { MAIL_ERROR_SEARCH, "search error" }, | ||
256 | { MAIL_ERROR_DISKSPACE, " error: not enough diskspace" }, | ||
257 | { MAIL_ERROR_MSG_NOT_FOUND, "message not found" }, | ||
258 | { MAIL_ERROR_PARSE, /* 30 */ "parse error" }, | ||
259 | { MAIL_ERROR_INVAL, "invalid parameter for the function" }, | ||
260 | { MAIL_ERROR_PART_NOT_FOUND, "mime part of the message is not found" }, | ||
261 | { MAIL_ERROR_REMOVE, "remove error - the message did not exist" }, | ||
262 | { MAIL_ERROR_FOLDER_NOT_FOUND, "folder not found" }, | ||
263 | { MAIL_ERROR_MOVE, "move error" }, | ||
264 | { MAIL_ERROR_STARTTLS, "starttls error" }, | ||
265 | { MAIL_ERROR_CACHE_MISS, "mail cache missed" }, | ||
266 | { MAIL_ERROR_NO_TLS, "no starttls" }, | ||
267 | { MAIL_ERROR_EXPUNGE, "expunge error" }, | ||
268 | { MAIL_ERROR_PROTOCOL, "protocol error - server did not respect the protocol" }, | ||
269 | { MAIL_ERROR_CAPABILITY, "capability error" }, | ||
270 | { MAIL_ERROR_CLOSE, "close error" }, | ||
271 | { MAIL_ERROR_FATAL, "fatal error" }, | ||
272 | { MAIL_ERROR_READONLY, "mailbox is readonly" }, | ||
273 | { MAIL_ERROR_NO_APOP, "pop3 error - no apop" }, | ||
274 | { MAIL_ERROR_COMMAND_NOT_SUPPORTED, "nntp error - command not supported" }, | ||
275 | { MAIL_ERROR_NO_PERMISSION, "nntp error - no permission" }, | ||
276 | { MAIL_ERROR_PROGRAM_ERROR, "nntp error - program error" }, | ||
277 | { MAIL_ERROR_SUBJECT_NOT_FOUND, "internal threading error - subject not found" }}; | ||
278 | |||
279 | const char * maildriver_strerror(int err) | ||
280 | { | ||
281 | int count; | ||
282 | int i; | ||
283 | |||
284 | count = sizeof(message_tab) / sizeof(struct error_message); | ||
285 | |||
286 | for(i = 0 ; i < count ; i++) { | ||
287 | if (message_tab[i].code == err) { | ||
288 | return message_tab[i].message; | ||
289 | } | ||
290 | } | ||
291 | |||
292 | return "unknown error"; | ||
293 | } | ||
294 | |||
295 | |||
296 | struct mail_flags * mail_flags_new_empty(void) | ||
297 | { | ||
298 | struct mail_flags * flags; | ||
299 | |||
300 | flags = malloc(sizeof(* flags)); | ||
301 | if (flags == NULL) | ||
302 | goto err; | ||
303 | |||
304 | flags->fl_flags = MAIL_FLAG_NEW; | ||
305 | flags->fl_extension = clist_new(); | ||
306 | if (flags->fl_extension == NULL) | ||
307 | goto free; | ||
308 | |||
309 | return flags; | ||
310 | |||
311 | free: | ||
312 | free(flags); | ||
313 | err: | ||
314 | return NULL; | ||
315 | } | ||
316 | |||
317 | struct mail_flags * mail_flags_new(uint32_t fl_flags, clist * fl_extension) | ||
318 | { | ||
319 | struct mail_flags * flags; | ||
320 | |||
321 | flags = malloc(sizeof(* flags)); | ||
322 | if (flags == NULL) | ||
323 | goto err; | ||
324 | |||
325 | flags->fl_flags = fl_flags; | ||
326 | flags->fl_extension = fl_extension; | ||
327 | |||
328 | return flags; | ||
329 | |||
330 | err: | ||
331 | return NULL; | ||
332 | } | ||
333 | |||
334 | void mail_flags_free(struct mail_flags * flags) | ||
335 | { | ||
336 | clist_foreach(flags->fl_extension, (clist_func) free, NULL); | ||
337 | clist_free(flags->fl_extension); | ||
338 | free(flags); | ||
339 | } | ||
340 | |||