summaryrefslogtreecommitdiff
path: root/noncore/net/mail/imapwrapper.cpp
Unidiff
Diffstat (limited to 'noncore/net/mail/imapwrapper.cpp') (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/net/mail/imapwrapper.cpp976
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
9IMAPwrapper::IMAPwrapper( IMAPaccount *a )
10 : AbstractMail()
11{
12 account = a;
13 m_imap = 0;
14}
15
16IMAPwrapper::~IMAPwrapper()
17{
18 logout();
19}
20
21void IMAPwrapper::imap_progress( size_t current, size_t maximum )
22{
23 qDebug( "IMAP: %i of %i", current, maximum );
24}
25
26void 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
96void 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
106void 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
171QList<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
263RecMail*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
373RecBody 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
420QStringList 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
461encodedString*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! */
526void 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
601void 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
623void 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
636void 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
648void 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
665void 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
707void 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
754void 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
791void 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
821QString 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
836QString IMAPwrapper::fetchTextPart(const RecMail&mail,const RecPart&part)
837{
838 return fetchTextPart(mail,part.Positionlist(),false,part.Encoding());
839}
840
841encodedString* 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
849encodedString* IMAPwrapper::fetchRawPart(const RecMail&mail,const RecPart&part)
850{
851 return fetchRawPart(mail,part.Positionlist(),false);
852}
853
854int 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
895int 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
925int 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
938void 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}