Diffstat (limited to 'noncore/net/mail/imapwrapper.cpp') (more/less context) (ignore whitespace changes)
-rw-r--r-- | noncore/net/mail/imapwrapper.cpp | 976 |
1 files changed, 0 insertions, 976 deletions
diff --git a/noncore/net/mail/imapwrapper.cpp b/noncore/net/mail/imapwrapper.cpp deleted file mode 100644 index f1d42c2..0000000 --- a/noncore/net/mail/imapwrapper.cpp +++ b/dev/null | |||
@@ -1,976 +0,0 @@ | |||
1 | #include <stdlib.h> | ||
2 | #include <libetpan/libetpan.h> | ||
3 | #include <qpe/global.h> | ||
4 | |||
5 | #include "imapwrapper.h" | ||
6 | #include "mailtypes.h" | ||
7 | #include "logindialog.h" | ||
8 | |||
9 | IMAPwrapper::IMAPwrapper( IMAPaccount *a ) | ||
10 | : AbstractMail() | ||
11 | { | ||
12 | account = a; | ||
13 | m_imap = 0; | ||
14 | } | ||
15 | |||
16 | IMAPwrapper::~IMAPwrapper() | ||
17 | { | ||
18 | logout(); | ||
19 | } | ||
20 | |||
21 | void IMAPwrapper::imap_progress( size_t current, size_t maximum ) | ||
22 | { | ||
23 | qDebug( "IMAP: %i of %i", current, maximum ); | ||
24 | } | ||
25 | |||
26 | void IMAPwrapper::login() | ||
27 | { | ||
28 | const char *server, *user, *pass; | ||
29 | uint16_t port; | ||
30 | int err = MAILIMAP_NO_ERROR; | ||
31 | |||
32 | /* we are connected this moment */ | ||
33 | /* TODO: setup a timer holding the line or if connection closed - delete the value */ | ||
34 | if (m_imap) { | ||
35 | err = mailimap_noop(m_imap); | ||
36 | if (err!=MAILIMAP_NO_ERROR) { | ||
37 | logout(); | ||
38 | } else { | ||
39 | mailstream_flush(m_imap->imap_stream); | ||
40 | return; | ||
41 | } | ||
42 | } | ||
43 | server = account->getServer().latin1(); | ||
44 | port = account->getPort().toUInt(); | ||
45 | if ( account->getUser().isEmpty() || account->getPassword().isEmpty() ) { | ||
46 | LoginDialog login( account->getUser(), account->getPassword(), NULL, 0, true ); | ||
47 | login.show(); | ||
48 | if ( QDialog::Accepted == login.exec() ) { | ||
49 | // ok | ||
50 | user = strdup( login.getUser().latin1() ); | ||
51 | pass = strdup( login.getPassword().latin1() ); | ||
52 | } else { | ||
53 | // cancel | ||
54 | qDebug( "IMAP: Login canceled" ); | ||
55 | return; | ||
56 | } | ||
57 | } else { | ||
58 | user = account->getUser().latin1(); | ||
59 | pass = account->getPassword().latin1(); | ||
60 | } | ||
61 | |||
62 | m_imap = mailimap_new( 20, &imap_progress ); | ||
63 | |||
64 | /* connect */ | ||
65 | if (account->getSSL()) { | ||
66 | err = mailimap_ssl_connect( m_imap, (char*)server, port ); | ||
67 | } else { | ||
68 | err = mailimap_socket_connect( m_imap, (char*)server, port ); | ||
69 | } | ||
70 | |||
71 | if ( err != MAILIMAP_NO_ERROR && | ||
72 | err != MAILIMAP_NO_ERROR_AUTHENTICATED && | ||
73 | err != MAILIMAP_NO_ERROR_NON_AUTHENTICATED ) { | ||
74 | QString failure = ""; | ||
75 | if (err == MAILIMAP_ERROR_CONNECTION_REFUSED) { | ||
76 | failure="Connection refused"; | ||
77 | } else { | ||
78 | failure="Unknown failure"; | ||
79 | } | ||
80 | Global::statusMessage(tr("error connecting imap server: %1").arg(failure)); | ||
81 | mailimap_free( m_imap ); | ||
82 | m_imap = 0; | ||
83 | return; | ||
84 | } | ||
85 | |||
86 | /* login */ | ||
87 | err = mailimap_login_simple( m_imap, (char*)user, (char*)pass ); | ||
88 | if ( err != MAILIMAP_NO_ERROR ) { | ||
89 | Global::statusMessage(tr("error logging in imap server: %1").arg(m_imap->imap_response)); | ||
90 | err = mailimap_close( m_imap ); | ||
91 | mailimap_free( m_imap ); | ||
92 | m_imap = 0; | ||
93 | } | ||
94 | } | ||
95 | |||
96 | void IMAPwrapper::logout() | ||
97 | { | ||
98 | int err = MAILIMAP_NO_ERROR; | ||
99 | if (!m_imap) return; | ||
100 | err = mailimap_logout( m_imap ); | ||
101 | err = mailimap_close( m_imap ); | ||
102 | mailimap_free( m_imap ); | ||
103 | m_imap = 0; | ||
104 | } | ||
105 | |||
106 | void IMAPwrapper::listMessages(const QString&mailbox,QList<RecMail> &target ) | ||
107 | { | ||
108 | const char *mb = 0; | ||
109 | int err = MAILIMAP_NO_ERROR; | ||
110 | clist *result = 0; | ||
111 | clistcell *current; | ||
112 | // mailimap_fetch_att *fetchAtt,*fetchAttFlags,*fetchAttDate,*fetchAttSize; | ||
113 | mailimap_fetch_type *fetchType = 0; | ||
114 | mailimap_set *set = 0; | ||
115 | |||
116 | mb = mailbox.latin1(); | ||
117 | login(); | ||
118 | if (!m_imap) { | ||
119 | return; | ||
120 | } | ||
121 | /* select mailbox READONLY for operations */ | ||
122 | err = mailimap_examine( m_imap, (char*)mb); | ||
123 | if ( err != MAILIMAP_NO_ERROR ) { | ||
124 | Global::statusMessage(tr("error selecting mailbox: %1").arg(m_imap->imap_response)); | ||
125 | return; | ||
126 | } | ||
127 | |||
128 | int last = m_imap->imap_selection_info->sel_exists; | ||
129 | |||
130 | if (last == 0) { | ||
131 | Global::statusMessage(tr("Mailbox has no mails")); | ||
132 | return; | ||
133 | } else { | ||
134 | Global::statusMessage(tr("Mailbox has %1 mails").arg(last)); | ||
135 | } | ||
136 | |||
137 | /* the range has to start at 1!!! not with 0!!!! */ | ||
138 | set = mailimap_set_new_interval( 1, last ); | ||
139 | fetchType = mailimap_fetch_type_new_fetch_att_list_empty(); | ||
140 | mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_envelope()); | ||
141 | mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_flags()); | ||
142 | mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_internaldate()); | ||
143 | mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_rfc822_size()); | ||
144 | |||
145 | err = mailimap_fetch( m_imap, set, fetchType, &result ); | ||
146 | mailimap_set_free( set ); | ||
147 | mailimap_fetch_type_free( fetchType ); | ||
148 | |||
149 | QString date,subject,from; | ||
150 | |||
151 | if ( err == MAILIMAP_NO_ERROR ) { | ||
152 | mailimap_msg_att * msg_att; | ||
153 | int i = 0; | ||
154 | for (current = clist_begin(result); current != 0; current=clist_next(current)) { | ||
155 | ++i; | ||
156 | msg_att = (mailimap_msg_att*)current->data; | ||
157 | RecMail*m = parse_list_result(msg_att); | ||
158 | if (m) { | ||
159 | m->setNumber(i); | ||
160 | m->setMbox(mailbox); | ||
161 | m->setWrapper(this); | ||
162 | target.append(m); | ||
163 | } | ||
164 | } | ||
165 | } else { | ||
166 | Global::statusMessage(tr("Error fetching headers: %1").arg(m_imap->imap_response)); | ||
167 | } | ||
168 | if (result) mailimap_fetch_list_free(result); | ||
169 | } | ||
170 | |||
171 | QList<Folder>* IMAPwrapper::listFolders() | ||
172 | { | ||
173 | const char *path, *mask; | ||
174 | int err = MAILIMAP_NO_ERROR; | ||
175 | clist *result = 0; | ||
176 | clistcell *current = 0; | ||
177 | clistcell*cur_flag = 0; | ||
178 | mailimap_mbx_list_flags*bflags = 0; | ||
179 | |||
180 | QList<Folder> * folders = new QList<Folder>(); | ||
181 | folders->setAutoDelete( false ); | ||
182 | login(); | ||
183 | if (!m_imap) { | ||
184 | return folders; | ||
185 | } | ||
186 | |||
187 | /* | ||
188 | * First we have to check for INBOX 'cause it sometimes it's not inside the path. | ||
189 | * We must not forget to filter them out in next loop! | ||
190 | * it seems like ugly code. and yes - it is ugly code. but the best way. | ||
191 | */ | ||
192 | QString temp; | ||
193 | mask = "INBOX" ; | ||
194 | mailimap_mailbox_list *list; | ||
195 | err = mailimap_list( m_imap, (char*)"", (char*)mask, &result ); | ||
196 | QString del; | ||
197 | bool selectable = true; | ||
198 | bool no_inferiors = false; | ||
199 | if ( err == MAILIMAP_NO_ERROR ) { | ||
200 | current = result->first; | ||
201 | for ( int i = result->count; i > 0; i-- ) { | ||
202 | list = (mailimap_mailbox_list *) current->data; | ||
203 | // it is better use the deep copy mechanism of qt itself | ||
204 | // instead of using strdup! | ||
205 | temp = list->mb_name; | ||
206 | del = list->mb_delimiter; | ||
207 | current = current->next; | ||
208 | if ( (bflags = list->mb_flag) ) { | ||
209 | selectable = !(bflags->mbf_type==MAILIMAP_MBX_LIST_FLAGS_SFLAG&& | ||
210 | bflags->mbf_sflag==MAILIMAP_MBX_LIST_SFLAG_NOSELECT); | ||
211 | for(cur_flag=clist_begin(bflags->mbf_oflags);cur_flag;cur_flag=clist_next(cur_flag)) { | ||
212 | if ( ((mailimap_mbx_list_oflag*)cur_flag->data)->of_type==MAILIMAP_MBX_LIST_OFLAG_NOINFERIORS) { | ||
213 | no_inferiors = true; | ||
214 | } | ||
215 | } | ||
216 | } | ||
217 | folders->append( new IMAPFolder(temp,del,selectable,no_inferiors,account->getPrefix())); | ||
218 | } | ||
219 | } else { | ||
220 | qDebug("error fetching folders: %s",m_imap->imap_response); | ||
221 | } | ||
222 | mailimap_list_result_free( result ); | ||
223 | |||
224 | /* | ||
225 | * second stage - get the other then inbox folders | ||
226 | */ | ||
227 | mask = "*" ; | ||
228 | path = account->getPrefix().latin1(); | ||
229 | if (!path) path = ""; | ||
230 | qDebug(path); | ||
231 | err = mailimap_list( m_imap, (char*)path, (char*)mask, &result ); | ||
232 | if ( err == MAILIMAP_NO_ERROR ) { | ||
233 | current = result->first; | ||
234 | for ( current=clist_begin(result);current!=NULL;current=clist_next(current)) { | ||
235 | no_inferiors = false; | ||
236 | list = (mailimap_mailbox_list *) current->data; | ||
237 | // it is better use the deep copy mechanism of qt itself | ||
238 | // instead of using strdup! | ||
239 | temp = list->mb_name; | ||
240 | if (temp.lower()=="inbox") | ||
241 | continue; | ||
242 | if (temp.lower()==account->getPrefix().lower()) | ||
243 | continue; | ||
244 | if ( (bflags = list->mb_flag) ) { | ||
245 | selectable = !(bflags->mbf_type==MAILIMAP_MBX_LIST_FLAGS_SFLAG&& | ||
246 | bflags->mbf_sflag==MAILIMAP_MBX_LIST_SFLAG_NOSELECT); | ||
247 | for(cur_flag=clist_begin(bflags->mbf_oflags);cur_flag;cur_flag=clist_next(cur_flag)) { | ||
248 | if ( ((mailimap_mbx_list_oflag*)cur_flag->data)->of_type==MAILIMAP_MBX_LIST_OFLAG_NOINFERIORS) { | ||
249 | no_inferiors = true; | ||
250 | } | ||
251 | } | ||
252 | } | ||
253 | del = list->mb_delimiter; | ||
254 | folders->append(new IMAPFolder(temp,del,selectable,no_inferiors,account->getPrefix())); | ||
255 | } | ||
256 | } else { | ||
257 | qDebug("error fetching folders %s",m_imap->imap_response); | ||
258 | } | ||
259 | if (result) mailimap_list_result_free( result ); | ||
260 | return folders; | ||
261 | } | ||
262 | |||
263 | RecMail*IMAPwrapper::parse_list_result(mailimap_msg_att* m_att) | ||
264 | { | ||
265 | RecMail * m = 0; | ||
266 | mailimap_msg_att_item *item=0; | ||
267 | clistcell *current,*c,*cf; | ||
268 | mailimap_msg_att_dynamic*flist; | ||
269 | mailimap_flag_fetch*cflag; | ||
270 | int size; | ||
271 | QBitArray mFlags(7); | ||
272 | QStringList addresslist; | ||
273 | |||
274 | if (!m_att) { | ||
275 | return m; | ||
276 | } | ||
277 | m = new RecMail(); | ||
278 | for (c = clist_begin(m_att->att_list); c!=NULL;c=clist_next(c) ) { | ||
279 | current = c; | ||
280 | size = 0; | ||
281 | item = (mailimap_msg_att_item*)current->data; | ||
282 | if (item->att_type!=MAILIMAP_MSG_ATT_ITEM_STATIC) { | ||
283 | flist = (mailimap_msg_att_dynamic*)item->att_data.att_dyn; | ||
284 | if (!flist->att_list) { | ||
285 | continue; | ||
286 | } | ||
287 | cf = flist->att_list->first; | ||
288 | for (cf = clist_begin(flist->att_list); cf!=NULL; cf = clist_next(cf)) { | ||
289 | cflag = (mailimap_flag_fetch*)cf->data; | ||
290 | if (cflag->fl_type==MAILIMAP_FLAG_FETCH_OTHER && cflag->fl_flag!=0) { | ||
291 | switch (cflag->fl_flag->fl_type) { | ||
292 | case MAILIMAP_FLAG_ANSWERED: /* \Answered flag */ | ||
293 | mFlags.setBit(FLAG_ANSWERED); | ||
294 | break; | ||
295 | case MAILIMAP_FLAG_FLAGGED: /* \Flagged flag */ | ||
296 | mFlags.setBit(FLAG_FLAGGED); | ||
297 | break; | ||
298 | case MAILIMAP_FLAG_DELETED: /* \Deleted flag */ | ||
299 | mFlags.setBit(FLAG_DELETED); | ||
300 | break; | ||
301 | case MAILIMAP_FLAG_SEEN: /* \Seen flag */ | ||
302 | mFlags.setBit(FLAG_SEEN); | ||
303 | break; | ||
304 | case MAILIMAP_FLAG_DRAFT: /* \Draft flag */ | ||
305 | mFlags.setBit(FLAG_DRAFT); | ||
306 | break; | ||
307 | case MAILIMAP_FLAG_KEYWORD: /* keyword flag */ | ||
308 | break; | ||
309 | case MAILIMAP_FLAG_EXTENSION: /* \extension flag */ | ||
310 | break; | ||
311 | default: | ||
312 | break; | ||
313 | } | ||
314 | } else if (cflag->fl_type==MAILIMAP_FLAG_FETCH_RECENT) { | ||
315 | mFlags.setBit(FLAG_RECENT); | ||
316 | } | ||
317 | } | ||
318 | continue; | ||
319 | } | ||
320 | if (item->att_data.att_static->att_type==MAILIMAP_MSG_ATT_ENVELOPE) { | ||
321 | mailimap_envelope * head = item->att_data.att_static->att_data.att_env; | ||
322 | m->setDate(head->env_date); | ||
323 | m->setSubject(convert_String((const char*)head->env_subject)); | ||
324 | //m->setSubject(head->env_subject); | ||
325 | if (head->env_from!=NULL) { | ||
326 | addresslist = address_list_to_stringlist(head->env_from->frm_list); | ||
327 | if (addresslist.count()) { | ||
328 | m->setFrom(addresslist.first()); | ||
329 | } | ||
330 | } | ||
331 | if (head->env_to!=NULL) { | ||
332 | addresslist = address_list_to_stringlist(head->env_to->to_list); | ||
333 | m->setTo(addresslist); | ||
334 | } | ||
335 | if (head->env_cc!=NULL) { | ||
336 | addresslist = address_list_to_stringlist(head->env_cc->cc_list); | ||
337 | m->setCC(addresslist); | ||
338 | } | ||
339 | if (head->env_bcc!=NULL) { | ||
340 | addresslist = address_list_to_stringlist(head->env_bcc->bcc_list); | ||
341 | m->setBcc(addresslist); | ||
342 | } | ||
343 | if (head->env_reply_to!=NULL) { | ||
344 | addresslist = address_list_to_stringlist(head->env_reply_to->rt_list); | ||
345 | if (addresslist.count()) { | ||
346 | m->setReplyto(addresslist.first()); | ||
347 | } | ||
348 | } | ||
349 | m->setMsgid(QString(head->env_message_id)); | ||
350 | } else if (item->att_data.att_static->att_type==MAILIMAP_MSG_ATT_INTERNALDATE) { | ||
351 | #if 0 | ||
352 | mailimap_date_time*d = item->att_data.att_static->att_data.att_internal_date; | ||
353 | QDateTime da(QDate(d->dt_year,d->dt_month,d->dt_day),QTime(d->dt_hour,d->dt_min,d->dt_sec)); | ||
354 | qDebug("%i %i %i - %i %i %i",d->dt_year,d->dt_month,d->dt_day,d->dt_hour,d->dt_min,d->dt_sec); | ||
355 | qDebug(da.toString()); | ||
356 | #endif | ||
357 | } else if (item->att_data.att_static->att_type==MAILIMAP_MSG_ATT_RFC822_SIZE) { | ||
358 | size = item->att_data.att_static->att_data.att_rfc822_size; | ||
359 | } | ||
360 | } | ||
361 | /* msg is already deleted */ | ||
362 | if (mFlags.testBit(FLAG_DELETED) && m) { | ||
363 | delete m; | ||
364 | m = 0; | ||
365 | } | ||
366 | if (m) { | ||
367 | m->setFlags(mFlags); | ||
368 | m->setMsgsize(size); | ||
369 | } | ||
370 | return m; | ||
371 | } | ||
372 | |||
373 | RecBody IMAPwrapper::fetchBody(const RecMail&mail) | ||
374 | { | ||
375 | RecBody body; | ||
376 | const char *mb; | ||
377 | int err = MAILIMAP_NO_ERROR; | ||
378 | clist *result = 0; | ||
379 | clistcell *current; | ||
380 | mailimap_fetch_att *fetchAtt = 0; | ||
381 | mailimap_fetch_type *fetchType = 0; | ||
382 | mailimap_set *set = 0; | ||
383 | mailimap_body*body_desc = 0; | ||
384 | |||
385 | mb = mail.getMbox().latin1(); | ||
386 | |||
387 | login(); | ||
388 | if (!m_imap) { | ||
389 | return body; | ||
390 | } | ||
391 | |||
392 | err = mailimap_select( m_imap, (char*)mb); | ||
393 | if ( err != MAILIMAP_NO_ERROR ) { | ||
394 | qDebug("error selecting mailbox: %s",m_imap->imap_response); | ||
395 | return body; | ||
396 | } | ||
397 | |||
398 | /* the range has to start at 1!!! not with 0!!!! */ | ||
399 | set = mailimap_set_new_interval( mail.getNumber(),mail.getNumber() ); | ||
400 | fetchAtt = mailimap_fetch_att_new_bodystructure(); | ||
401 | fetchType = mailimap_fetch_type_new_fetch_att(fetchAtt); | ||
402 | err = mailimap_fetch( m_imap, set, fetchType, &result ); | ||
403 | mailimap_set_free( set ); | ||
404 | mailimap_fetch_type_free( fetchType ); | ||
405 | |||
406 | if (err == MAILIMAP_NO_ERROR && (current=clist_begin(result)) ) { | ||
407 | mailimap_msg_att * msg_att; | ||
408 | msg_att = (mailimap_msg_att*)current->data; | ||
409 | mailimap_msg_att_item*item = (mailimap_msg_att_item*)msg_att->att_list->first->data; | ||
410 | QValueList<int> path; | ||
411 | body_desc = item->att_data.att_static->att_data.att_body; | ||
412 | traverseBody(mail,body_desc,body,0,path); | ||
413 | } else { | ||
414 | qDebug("error fetching body: %s",m_imap->imap_response); | ||
415 | } | ||
416 | if (result) mailimap_fetch_list_free(result); | ||
417 | return body; | ||
418 | } | ||
419 | |||
420 | QStringList IMAPwrapper::address_list_to_stringlist(clist*list) | ||
421 | { | ||
422 | QStringList l; | ||
423 | QString from; | ||
424 | bool named_from; | ||
425 | clistcell *current = NULL; | ||
426 | mailimap_address * current_address=NULL; | ||
427 | if (!list) { | ||
428 | return l; | ||
429 | } | ||
430 | unsigned int count = 0; | ||
431 | for (current=clist_begin(list);current!= NULL;current=clist_next(current)) { | ||
432 | from = ""; | ||
433 | named_from = false; | ||
434 | current_address=(mailimap_address*)current->data; | ||
435 | if (current_address->ad_personal_name){ | ||
436 | from+=convert_String((const char*)current_address->ad_personal_name); | ||
437 | from+=" "; | ||
438 | named_from = true; | ||
439 | } | ||
440 | if (named_from && (current_address->ad_mailbox_name || current_address->ad_host_name)) { | ||
441 | from+="<"; | ||
442 | } | ||
443 | if (current_address->ad_mailbox_name) { | ||
444 | from+=QString(current_address->ad_mailbox_name); | ||
445 | from+="@"; | ||
446 | } | ||
447 | if (current_address->ad_host_name) { | ||
448 | from+=QString(current_address->ad_host_name); | ||
449 | } | ||
450 | if (named_from && (current_address->ad_mailbox_name || current_address->ad_host_name)) { | ||
451 | from+=">"; | ||
452 | } | ||
453 | l.append(QString(from)); | ||
454 | if (++count > 99) { | ||
455 | break; | ||
456 | } | ||
457 | } | ||
458 | return l; | ||
459 | } | ||
460 | |||
461 | encodedString*IMAPwrapper::fetchRawPart(const RecMail&mail,const QValueList<int>&path,bool internal_call) | ||
462 | { | ||
463 | encodedString*res=new encodedString; | ||
464 | const char*mb; | ||
465 | int err; | ||
466 | mailimap_fetch_type *fetchType; | ||
467 | mailimap_set *set; | ||
468 | clistcell*current,*cur; | ||
469 | |||
470 | login(); | ||
471 | if (!m_imap) { | ||
472 | return res; | ||
473 | } | ||
474 | if (!internal_call) { | ||
475 | mb = mail.getMbox().latin1(); | ||
476 | err = mailimap_select( m_imap, (char*)mb); | ||
477 | if ( err != MAILIMAP_NO_ERROR ) { | ||
478 | qDebug("error selecting mailbox: %s",m_imap->imap_response); | ||
479 | return res; | ||
480 | } | ||
481 | } | ||
482 | set = mailimap_set_new_single(mail.getNumber()); | ||
483 | clist*id_list=clist_new(); | ||
484 | for (unsigned j=0; j < path.count();++j) { | ||
485 | uint32_t * p_id = (uint32_t *)malloc(sizeof(*p_id)); | ||
486 | *p_id = path[j]; | ||
487 | clist_append(id_list,p_id); | ||
488 | } | ||
489 | mailimap_section_part * section_part = mailimap_section_part_new(id_list); | ||
490 | mailimap_section_spec * section_spec = mailimap_section_spec_new(MAILIMAP_SECTION_SPEC_SECTION_PART, NULL, section_part, NULL); | ||
491 | mailimap_section * section = mailimap_section_new(section_spec); | ||
492 | mailimap_fetch_att * fetch_att = mailimap_fetch_att_new_body_section(section); | ||
493 | |||
494 | fetchType = mailimap_fetch_type_new_fetch_att(fetch_att); | ||
495 | |||
496 | clist*result = 0; | ||
497 | |||
498 | err = mailimap_fetch( m_imap, set, fetchType, &result ); | ||
499 | mailimap_set_free( set ); | ||
500 | mailimap_fetch_type_free( fetchType ); | ||
501 | |||
502 | if (err == MAILIMAP_NO_ERROR && (current=clist_begin(result)) ) { | ||
503 | mailimap_msg_att * msg_att; | ||
504 | msg_att = (mailimap_msg_att*)current->data; | ||
505 | mailimap_msg_att_item*msg_att_item; | ||
506 | for(cur = clist_begin(msg_att->att_list) ; cur != NULL ; cur = clist_next(cur)) { | ||
507 | msg_att_item = (mailimap_msg_att_item*)clist_content(cur); | ||
508 | if (msg_att_item->att_type == MAILIMAP_MSG_ATT_ITEM_STATIC) { | ||
509 | if (msg_att_item->att_data.att_static->att_type == MAILIMAP_MSG_ATT_BODY_SECTION) { | ||
510 | char*text = msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part; | ||
511 | /* detach - we take over the content */ | ||
512 | msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part = 0L; | ||
513 | res->setContent(text,msg_att_item->att_data.att_static->att_data.att_body_section->sec_length); | ||
514 | } | ||
515 | } | ||
516 | } | ||
517 | } else { | ||
518 | qDebug("error fetching text: %s",m_imap->imap_response); | ||
519 | } | ||
520 | if (result) mailimap_fetch_list_free(result); | ||
521 | return res; | ||
522 | } | ||
523 | |||
524 | /* current_recursion is for recursive calls. | ||
525 | current_count means the position inside the internal loop! */ | ||
526 | void IMAPwrapper::traverseBody(const RecMail&mail,mailimap_body*body,RecBody&target_body, | ||
527 | int current_recursion,QValueList<int>recList,int current_count) | ||
528 | { | ||
529 | if (!body || current_recursion>=10) { | ||
530 | return; | ||
531 | } | ||
532 | switch (body->bd_type) { | ||
533 | case MAILIMAP_BODY_1PART: | ||
534 | { | ||
535 | QValueList<int>countlist = recList; | ||
536 | countlist.append(current_count); | ||
537 | RecPart currentPart; | ||
538 | mailimap_body_type_1part*part1 = body->bd_data.bd_body_1part; | ||
539 | QString id(""); | ||
540 | currentPart.setPositionlist(countlist); | ||
541 | for (unsigned int j = 0; j < countlist.count();++j) { | ||
542 | id+=(j>0?" ":""); | ||
543 | id+=QString("%1").arg(countlist[j]); | ||
544 | } | ||
545 | qDebug("ID = %s",id.latin1()); | ||
546 | currentPart.setIdentifier(id); | ||
547 | fillSinglePart(currentPart,part1); | ||
548 | /* important: Check for is NULL 'cause a body can be empty! | ||
549 | And we put it only into the mail if it is the FIRST part */ | ||
550 | if (part1->bd_type==MAILIMAP_BODY_TYPE_1PART_TEXT && target_body.Bodytext().isNull() && countlist[0]==1) { | ||
551 | QString body_text = fetchTextPart(mail,countlist,true,currentPart.Encoding()); | ||
552 | target_body.setDescription(currentPart); | ||
553 | target_body.setBodytext(body_text); | ||
554 | if (countlist.count()>1) { | ||
555 | target_body.addPart(currentPart); | ||
556 | } | ||
557 | } else { | ||
558 | target_body.addPart(currentPart); | ||
559 | } | ||
560 | if (part1->bd_type==MAILIMAP_BODY_TYPE_1PART_MSG) { | ||
561 | traverseBody(mail,part1->bd_data.bd_type_msg->bd_body,target_body,current_recursion+1,countlist); | ||
562 | } | ||
563 | } | ||
564 | break; | ||
565 | case MAILIMAP_BODY_MPART: | ||
566 | { | ||
567 | QValueList<int>countlist = recList; | ||
568 | clistcell*current=0; | ||
569 | mailimap_body*current_body=0; | ||
570 | unsigned int ccount = 1; | ||
571 | mailimap_body_type_mpart*mailDescription = body->bd_data.bd_body_mpart; | ||
572 | for (current=clist_begin(mailDescription->bd_list);current!=0;current=clist_next(current)) { | ||
573 | current_body = (mailimap_body*)current->data; | ||
574 | if (current_body->bd_type==MAILIMAP_BODY_MPART) { | ||
575 | RecPart targetPart; | ||
576 | targetPart.setType("multipart"); | ||
577 | fillMultiPart(targetPart,mailDescription); | ||
578 | countlist.append(current_count); | ||
579 | targetPart.setPositionlist(countlist); | ||
580 | target_body.addPart(targetPart); | ||
581 | QString id(""); | ||
582 | for (unsigned int j = 0; j < countlist.count();++j) { | ||
583 | id+=(j>0?" ":""); | ||
584 | id+=QString("%1").arg(countlist[j]); | ||
585 | } | ||
586 | qDebug("ID(mpart) = %s",id.latin1()); | ||
587 | } | ||
588 | traverseBody(mail,current_body,target_body,current_recursion+1,countlist,ccount); | ||
589 | if (current_body->bd_type==MAILIMAP_BODY_MPART) { | ||
590 | countlist = recList; | ||
591 | } | ||
592 | ++ccount; | ||
593 | } | ||
594 | } | ||
595 | break; | ||
596 | default: | ||
597 | break; | ||
598 | } | ||
599 | } | ||
600 | |||
601 | void IMAPwrapper::fillSinglePart(RecPart&target_part,mailimap_body_type_1part*Description) | ||
602 | { | ||
603 | if (!Description) { | ||
604 | return; | ||
605 | } | ||
606 | switch (Description->bd_type) { | ||
607 | case MAILIMAP_BODY_TYPE_1PART_TEXT: | ||
608 | target_part.setType("text"); | ||
609 | fillSingleTextPart(target_part,Description->bd_data.bd_type_text); | ||
610 | break; | ||
611 | case MAILIMAP_BODY_TYPE_1PART_BASIC: | ||
612 | fillSingleBasicPart(target_part,Description->bd_data.bd_type_basic); | ||
613 | break; | ||
614 | case MAILIMAP_BODY_TYPE_1PART_MSG: | ||
615 | target_part.setType("message"); | ||
616 | fillSingleMsgPart(target_part,Description->bd_data.bd_type_msg); | ||
617 | break; | ||
618 | default: | ||
619 | break; | ||
620 | } | ||
621 | } | ||
622 | |||
623 | void IMAPwrapper::fillSingleTextPart(RecPart&target_part,mailimap_body_type_text*which) | ||
624 | { | ||
625 | if (!which) { | ||
626 | return; | ||
627 | } | ||
628 | QString sub; | ||
629 | sub = which->bd_media_text; | ||
630 | qDebug("Type= text/%s",which->bd_media_text); | ||
631 | target_part.setSubtype(sub.lower()); | ||
632 | target_part.setLines(which->bd_lines); | ||
633 | fillBodyFields(target_part,which->bd_fields); | ||
634 | } | ||
635 | |||
636 | void IMAPwrapper::fillSingleMsgPart(RecPart&target_part,mailimap_body_type_msg*which) | ||
637 | { | ||
638 | if (!which) { | ||
639 | return; | ||
640 | } | ||
641 | target_part.setSubtype("rfc822"); | ||
642 | qDebug("Message part"); | ||
643 | /* we set this type to text/plain */ | ||
644 | target_part.setLines(which->bd_lines); | ||
645 | fillBodyFields(target_part,which->bd_fields); | ||
646 | } | ||
647 | |||
648 | void IMAPwrapper::fillMultiPart(RecPart&target_part,mailimap_body_type_mpart*which) | ||
649 | { | ||
650 | if (!which) return; | ||
651 | QString sub = which->bd_media_subtype; | ||
652 | target_part.setSubtype(sub.lower()); | ||
653 | if (which->bd_ext_mpart && which->bd_ext_mpart->bd_parameter && which->bd_ext_mpart->bd_parameter->pa_list) { | ||
654 | clistcell*cur = 0; | ||
655 | mailimap_single_body_fld_param*param=0; | ||
656 | for (cur = clist_begin(which->bd_ext_mpart->bd_parameter->pa_list);cur!=NULL;cur=clist_next(cur)) { | ||
657 | param = (mailimap_single_body_fld_param*)cur->data; | ||
658 | if (param) { | ||
659 | target_part.addParameter(QString(param->pa_name).lower(),QString(param->pa_value)); | ||
660 | } | ||
661 | } | ||
662 | } | ||
663 | } | ||
664 | |||
665 | void IMAPwrapper::fillSingleBasicPart(RecPart&target_part,mailimap_body_type_basic*which) | ||
666 | { | ||
667 | if (!which) { | ||
668 | return; | ||
669 | } | ||
670 | QString type,sub; | ||
671 | switch (which->bd_media_basic->med_type) { | ||
672 | case MAILIMAP_MEDIA_BASIC_APPLICATION: | ||
673 | type = "application"; | ||
674 | break; | ||
675 | case MAILIMAP_MEDIA_BASIC_AUDIO: | ||
676 | type = "audio"; | ||
677 | break; | ||
678 | case MAILIMAP_MEDIA_BASIC_IMAGE: | ||
679 | type = "image"; | ||
680 | break; | ||
681 | case MAILIMAP_MEDIA_BASIC_MESSAGE: | ||
682 | type = "message"; | ||
683 | break; | ||
684 | case MAILIMAP_MEDIA_BASIC_VIDEO: | ||
685 | type = "video"; | ||
686 | break; | ||
687 | case MAILIMAP_MEDIA_BASIC_OTHER: | ||
688 | default: | ||
689 | if (which->bd_media_basic->med_basic_type) { | ||
690 | type = which->bd_media_basic->med_basic_type; | ||
691 | } else { | ||
692 | type = ""; | ||
693 | } | ||
694 | break; | ||
695 | } | ||
696 | if (which->bd_media_basic->med_subtype) { | ||
697 | sub = which->bd_media_basic->med_subtype; | ||
698 | } else { | ||
699 | sub = ""; | ||
700 | } | ||
701 | qDebug("Type = %s/%s",type.latin1(),sub.latin1()); | ||
702 | target_part.setType(type.lower()); | ||
703 | target_part.setSubtype(sub.lower()); | ||
704 | fillBodyFields(target_part,which->bd_fields); | ||
705 | } | ||
706 | |||
707 | void IMAPwrapper::fillBodyFields(RecPart&target_part,mailimap_body_fields*which) | ||
708 | { | ||
709 | if (!which) return; | ||
710 | if (which->bd_parameter && which->bd_parameter->pa_list && which->bd_parameter->pa_list->count>0) { | ||
711 | clistcell*cur; | ||
712 | mailimap_single_body_fld_param*param=0; | ||
713 | for (cur = clist_begin(which->bd_parameter->pa_list);cur!=NULL;cur=clist_next(cur)) { | ||
714 | param = (mailimap_single_body_fld_param*)cur->data; | ||
715 | if (param) { | ||
716 | target_part.addParameter(QString(param->pa_name).lower(),QString(param->pa_value)); | ||
717 | } | ||
718 | } | ||
719 | } | ||
720 | mailimap_body_fld_enc*enc = which->bd_encoding; | ||
721 | QString encoding(""); | ||
722 | switch (enc->enc_type) { | ||
723 | case MAILIMAP_BODY_FLD_ENC_7BIT: | ||
724 | encoding = "7bit"; | ||
725 | break; | ||
726 | case MAILIMAP_BODY_FLD_ENC_8BIT: | ||
727 | encoding = "8bit"; | ||
728 | break; | ||
729 | case MAILIMAP_BODY_FLD_ENC_BINARY: | ||
730 | encoding="binary"; | ||
731 | break; | ||
732 | case MAILIMAP_BODY_FLD_ENC_BASE64: | ||
733 | encoding="base64"; | ||
734 | break; | ||
735 | case MAILIMAP_BODY_FLD_ENC_QUOTED_PRINTABLE: | ||
736 | encoding="quoted-printable"; | ||
737 | break; | ||
738 | case MAILIMAP_BODY_FLD_ENC_OTHER: | ||
739 | default: | ||
740 | if (enc->enc_value) { | ||
741 | char*t=enc->enc_value; | ||
742 | encoding=QString(enc->enc_value); | ||
743 | enc->enc_value=0L; | ||
744 | free(t); | ||
745 | } | ||
746 | } | ||
747 | if (which->bd_description) { | ||
748 | target_part.setDescription(QString(which->bd_description)); | ||
749 | } | ||
750 | target_part.setEncoding(encoding); | ||
751 | target_part.setSize(which->bd_size); | ||
752 | } | ||
753 | |||
754 | void IMAPwrapper::deleteMail(const RecMail&mail) | ||
755 | { | ||
756 | mailimap_flag_list*flist; | ||
757 | mailimap_set *set; | ||
758 | mailimap_store_att_flags * store_flags; | ||
759 | int err; | ||
760 | login(); | ||
761 | if (!m_imap) { | ||
762 | return; | ||
763 | } | ||
764 | const char *mb = mail.getMbox().latin1(); | ||
765 | err = mailimap_select( m_imap, (char*)mb); | ||
766 | if ( err != MAILIMAP_NO_ERROR ) { | ||
767 | qDebug("error selecting mailbox for delete: %s",m_imap->imap_response); | ||
768 | return; | ||
769 | } | ||
770 | flist = mailimap_flag_list_new_empty(); | ||
771 | mailimap_flag_list_add(flist,mailimap_flag_new_deleted()); | ||
772 | store_flags = mailimap_store_att_flags_new_set_flags(flist); | ||
773 | set = mailimap_set_new_single(mail.getNumber()); | ||
774 | err = mailimap_store(m_imap,set,store_flags); | ||
775 | mailimap_set_free( set ); | ||
776 | mailimap_store_att_flags_free(store_flags); | ||
777 | |||
778 | if (err != MAILIMAP_NO_ERROR) { | ||
779 | qDebug("error deleting mail: %s",m_imap->imap_response); | ||
780 | return; | ||
781 | } | ||
782 | qDebug("deleting mail: %s",m_imap->imap_response); | ||
783 | /* should we realy do that at this moment? */ | ||
784 | err = mailimap_expunge(m_imap); | ||
785 | if (err != MAILIMAP_NO_ERROR) { | ||
786 | qDebug("error deleting mail: %s",m_imap->imap_response); | ||
787 | } | ||
788 | qDebug("Delete successfull %s",m_imap->imap_response); | ||
789 | } | ||
790 | |||
791 | void IMAPwrapper::answeredMail(const RecMail&mail) | ||
792 | { | ||
793 | mailimap_flag_list*flist; | ||
794 | mailimap_set *set; | ||
795 | mailimap_store_att_flags * store_flags; | ||
796 | int err; | ||
797 | login(); | ||
798 | if (!m_imap) { | ||
799 | return; | ||
800 | } | ||
801 | const char *mb = mail.getMbox().latin1(); | ||
802 | err = mailimap_select( m_imap, (char*)mb); | ||
803 | if ( err != MAILIMAP_NO_ERROR ) { | ||
804 | qDebug("error selecting mailbox for mark: %s",m_imap->imap_response); | ||
805 | return; | ||
806 | } | ||
807 | flist = mailimap_flag_list_new_empty(); | ||
808 | mailimap_flag_list_add(flist,mailimap_flag_new_answered()); | ||
809 | store_flags = mailimap_store_att_flags_new_add_flags(flist); | ||
810 | set = mailimap_set_new_single(mail.getNumber()); | ||
811 | err = mailimap_store(m_imap,set,store_flags); | ||
812 | mailimap_set_free( set ); | ||
813 | mailimap_store_att_flags_free(store_flags); | ||
814 | |||
815 | if (err != MAILIMAP_NO_ERROR) { | ||
816 | qDebug("error marking mail: %s",m_imap->imap_response); | ||
817 | return; | ||
818 | } | ||
819 | } | ||
820 | |||
821 | QString IMAPwrapper::fetchTextPart(const RecMail&mail,const QValueList<int>&path,bool internal_call,const QString&enc) | ||
822 | { | ||
823 | QString body(""); | ||
824 | encodedString*res = fetchRawPart(mail,path,internal_call); | ||
825 | encodedString*r = decode_String(res,enc); | ||
826 | delete res; | ||
827 | if (r) { | ||
828 | if (r->Length()>0) { | ||
829 | body = r->Content(); | ||
830 | } | ||
831 | delete r; | ||
832 | } | ||
833 | return body; | ||
834 | } | ||
835 | |||
836 | QString IMAPwrapper::fetchTextPart(const RecMail&mail,const RecPart&part) | ||
837 | { | ||
838 | return fetchTextPart(mail,part.Positionlist(),false,part.Encoding()); | ||
839 | } | ||
840 | |||
841 | encodedString* IMAPwrapper::fetchDecodedPart(const RecMail&mail,const RecPart&part) | ||
842 | { | ||
843 | encodedString*res = fetchRawPart(mail,part.Positionlist(),false); | ||
844 | encodedString*r = decode_String(res,part.Encoding()); | ||
845 | delete res; | ||
846 | return r; | ||
847 | } | ||
848 | |||
849 | encodedString* IMAPwrapper::fetchRawPart(const RecMail&mail,const RecPart&part) | ||
850 | { | ||
851 | return fetchRawPart(mail,part.Positionlist(),false); | ||
852 | } | ||
853 | |||
854 | int IMAPwrapper::deleteAllMail(const Folder*folder) | ||
855 | { | ||
856 | login(); | ||
857 | if (!m_imap) { | ||
858 | return 0; | ||
859 | } | ||
860 | mailimap_flag_list*flist; | ||
861 | mailimap_set *set; | ||
862 | mailimap_store_att_flags * store_flags; | ||
863 | int err = mailimap_select( m_imap, folder->getName().latin1()); | ||
864 | if ( err != MAILIMAP_NO_ERROR ) { | ||
865 | Global::statusMessage(tr("error selecting mailbox: %1").arg(m_imap->imap_response)); | ||
866 | return 0; | ||
867 | } | ||
868 | int last = m_imap->imap_selection_info->sel_exists; | ||
869 | if (last == 0) { | ||
870 | Global::statusMessage(tr("Mailbox has no mails!")); | ||
871 | return 0; | ||
872 | } | ||
873 | flist = mailimap_flag_list_new_empty(); | ||
874 | mailimap_flag_list_add(flist,mailimap_flag_new_deleted()); | ||
875 | store_flags = mailimap_store_att_flags_new_set_flags(flist); | ||
876 | set = mailimap_set_new_interval( 1, last ); | ||
877 | err = mailimap_store(m_imap,set,store_flags); | ||
878 | mailimap_set_free( set ); | ||
879 | mailimap_store_att_flags_free(store_flags); | ||
880 | if (err != MAILIMAP_NO_ERROR) { | ||
881 | Global::statusMessage(tr("error deleting mail: %s").arg(m_imap->imap_response)); | ||
882 | return 0; | ||
883 | } | ||
884 | qDebug("deleting mail: %s",m_imap->imap_response); | ||
885 | /* should we realy do that at this moment? */ | ||
886 | err = mailimap_expunge(m_imap); | ||
887 | if (err != MAILIMAP_NO_ERROR) { | ||
888 | Global::statusMessage(tr("error deleting mail: %s").arg(m_imap->imap_response)); | ||
889 | return 0; | ||
890 | } | ||
891 | qDebug("Delete successfull %s",m_imap->imap_response); | ||
892 | return 1; | ||
893 | } | ||
894 | |||
895 | int IMAPwrapper::createMbox(const QString&folder,const Folder*parentfolder,const QString& delemiter,bool getsubfolder) | ||
896 | { | ||
897 | if (folder.length()==0) return 0; | ||
898 | login(); | ||
899 | if (!m_imap) {return 0;} | ||
900 | QString pre = account->getPrefix(); | ||
901 | if (delemiter.length()>0 && pre.findRev(delemiter)!=pre.length()-1) { | ||
902 | pre+=delemiter; | ||
903 | } | ||
904 | if (parentfolder) { | ||
905 | pre += parentfolder->getDisplayName()+delemiter; | ||
906 | } | ||
907 | pre+=folder; | ||
908 | if (getsubfolder) { | ||
909 | if (delemiter.length()>0) { | ||
910 | pre+=delemiter; | ||
911 | } else { | ||
912 | Global::statusMessage(tr("Cannot create folder %1 for holding subfolders").arg(pre)); | ||
913 | return 0; | ||
914 | } | ||
915 | } | ||
916 | qDebug("Creating %s",pre.latin1()); | ||
917 | int res = mailimap_create(m_imap,pre.latin1()); | ||
918 | if (res != MAILIMAP_NO_ERROR) { | ||
919 | Global::statusMessage(tr("%1").arg(m_imap->imap_response)); | ||
920 | return 0; | ||
921 | } | ||
922 | return 1; | ||
923 | } | ||
924 | |||
925 | int IMAPwrapper::deleteMbox(const Folder*folder) | ||
926 | { | ||
927 | if (!folder) return 0; | ||
928 | login(); | ||
929 | if (!m_imap) {return 0;} | ||
930 | int res = mailimap_delete(m_imap,folder->getName()); | ||
931 | if (res != MAILIMAP_NO_ERROR) { | ||
932 | Global::statusMessage(tr("%1").arg(m_imap->imap_response)); | ||
933 | return 0; | ||
934 | } | ||
935 | return 1; | ||
936 | } | ||
937 | |||
938 | void IMAPwrapper::statusFolder(folderStat&target_stat,const QString & mailbox) | ||
939 | { | ||
940 | mailimap_status_att_list * att_list =0; | ||
941 | mailimap_mailbox_data_status * status=0; | ||
942 | clistiter * cur = 0; | ||
943 | int r = 0; | ||
944 | int res = 0; | ||
945 | target_stat.message_count = 0; | ||
946 | target_stat.message_unseen = 0; | ||
947 | target_stat.message_recent = 0; | ||
948 | login(); | ||
949 | if (!m_imap) { | ||
950 | return; | ||
951 | } | ||
952 | att_list = mailimap_status_att_list_new_empty(); | ||
953 | if (!att_list) return; | ||
954 | r = mailimap_status_att_list_add(att_list, MAILIMAP_STATUS_ATT_MESSAGES); | ||
955 | r = mailimap_status_att_list_add(att_list, MAILIMAP_STATUS_ATT_RECENT); | ||
956 | r = mailimap_status_att_list_add(att_list, MAILIMAP_STATUS_ATT_UNSEEN); | ||
957 | r = mailimap_status(m_imap, mailbox.latin1(), att_list, &status); | ||
958 | for (cur = clist_begin(status->st_info_list); | ||
959 | cur != NULL ; cur = clist_next(cur)) { | ||
960 | mailimap_status_info * status_info; | ||
961 | status_info = (mailimap_status_info *)clist_content(cur); | ||
962 | switch (status_info->st_att) { | ||
963 | case MAILIMAP_STATUS_ATT_MESSAGES: | ||
964 | target_stat.message_count = status_info->st_value; | ||
965 | break; | ||
966 | case MAILIMAP_STATUS_ATT_RECENT: | ||
967 | target_stat.message_recent = status_info->st_value; | ||
968 | break; | ||
969 | case MAILIMAP_STATUS_ATT_UNSEEN: | ||
970 | target_stat.message_unseen = status_info->st_value; | ||
971 | break; | ||
972 | } | ||
973 | } | ||
974 | mailimap_mailbox_data_status_free(status); | ||
975 | mailimap_status_att_list_free(att_list); | ||
976 | } | ||