many ompi fixes

5 files changed, 41 insertions, 5 deletions

diff --git a/kmicromail/libmailwrapper/abstractmail.cpp b/kmicromail/libmailwrapper/abstractmail.cpp
index 8ee112c..ed5c898 100644
--- a/kmicromail/libmailwrapper/abstractmail.cpp
+++ b/kmicromail/libmailwrapper/abstractmail.cpp
@@ -1,230 +1,231 @@
 // CHANGED 2004-09-31 Lutz Rogowski
 #include "abstractmail.h"
 #include "imapwrapper.h"
 #include "pop3wrapper.h"
 #include "nntpwrapper.h"
 #include "mhwrapper.h"
 #include "mailtypes.h"
 #include <qpe/global.h>
 
 
 #include <qprogressbar.h>
 #include <qapplication.h>
 #include <qmessagebox.h>
 #include <klocale.h>
 #include <kdecore/kstandarddirs.h>
 #include <qfile.h>
 #include <qtextstream.h>
 #include <stdlib.h>
 #include <libetpan/mailmime_content.h>
 #include <libetpan/mailmime.h>
 
 using namespace Opie::Core;
 AbstractMail* AbstractMail::getWrapper(IMAPaccount *a)
 {
     return new IMAPwrapper(a);
 }
 
 AbstractMail* AbstractMail::getWrapper(POP3account *a)
 {
     return new POP3wrapper(a);
 }
 
 AbstractMail* AbstractMail::getWrapper(NNTPaccount *a)
 {
     return new NNTPwrapper(a);
 }
 
 AbstractMail* AbstractMail::getWrapper(const QString&a,const QString&name)
 {
     return new MHwrapper(a,name);
 }
 
 AbstractMail* AbstractMail::getWrapper(Account*a)
 {
     if (!a) return 0;
     switch (a->getType()) {
         case MAILLIB::A_IMAP:
             return new IMAPwrapper((IMAPaccount*)a);
             break;
         case MAILLIB::A_POP3:
             return new POP3wrapper((POP3account*)a);
             break;
         case MAILLIB::A_NNTP:
             return new NNTPwrapper((NNTPaccount*)a);
             break;
         default:
             return 0;
     }
 }
 
 encodedString* AbstractMail::decode_String(const encodedString*text,const QString&enc)
 {
     // odebug << "Decode string start" << oendl; 
     char*result_text;
     size_t index = 0;
     /* reset for recursive use! */
     size_t target_length = 0;
     result_text = 0;
     int mimetype = MAILMIME_MECHANISM_7BIT;
     if (enc.lower()=="quoted-printable") {
         mimetype = MAILMIME_MECHANISM_QUOTED_PRINTABLE;
     } else if (enc.lower()=="base64") {
         mimetype = MAILMIME_MECHANISM_BASE64;
     } else if (enc.lower()=="8bit") {
         mimetype = MAILMIME_MECHANISM_8BIT;
     } else if (enc.lower()=="binary") {
         mimetype = MAILMIME_MECHANISM_BINARY;
     }
-
     int err = mailmime_part_parse(text->Content(),text->Length(),&index,mimetype,
     &result_text,&target_length);
 
     encodedString* result = new encodedString();
     if (err == MAILIMF_NO_ERROR) {
         result->setContent(result_text,target_length);
     }
     //odebug << "Decode string finished" << oendl; 
     return result;
 }
 
 QString AbstractMail::convert_String(const char*text)
 {
     size_t index = 0;
     char*res = 0;
     int err = MAILIMF_NO_ERROR;
 
     QString result(text);
-
+    //qDebug("convert_String %s ", text);
+    //err = mailmime_encoded_phrase_parse("iso-8859-1",
+    //                                      text, strlen(text),&index, "iso-8859-1",&res);
     err = mailmime_encoded_phrase_parse("iso-8859-1",
-                                            text, strlen(text),&index, "iso-8859-1",&res);
+                                          text, strlen(text),&index, "utf-8",&res);
     if (err == MAILIMF_NO_ERROR && res && strlen(res)) {
-        result = QString(res);
+        result = QString::fromUtf8(res);
     }
     //qDebug("convert_String:%s ",result.latin1() );
     if (res) free(res);
     return result;
 }
 
 /* cp & paste from launcher */
 QString AbstractMail::gen_attachment_id()
 {
     QFile file( "/proc/sys/kernel/random/uuid" );
     if (!file.open(IO_ReadOnly ) )
         return QString::null;
 
     QTextStream stream(&file);
 
     return "{" + stream.read().stripWhiteSpace() + "}";
 }
 
 int AbstractMail::createMbox(const QString&,const FolderP&,const QString& ,bool)
 {
     return 0;
 }
 
 QString AbstractMail::defaultLocalfolder()
 {
     //  QString f = getenv( "HOME" );
     QString f = locateLocal( "data", "kopiemail/localmail");
     //  f += "/Applications/opiemail/localmail";
     return f;
 }
 
 QString AbstractMail::draftFolder()
 {
     return QString("Drafts");
 }
 
 /* temporary - will be removed when implemented in all classes */
 void AbstractMail::deleteMails(const QString &,const QValueList<Opie::Core::OSmartPointer<RecMail> > &)
 {
 }
 void AbstractMail::deleteMailList(const QValueList<RecMailP>&target)
 {
     //qDebug("AbstractMail::deleteMailList:: Please reimplement! ");
     // this is currently re-implemented in pop3wrapper and imapwrapper
     int iii = 0;
     int count = target.count(); 
     QProgressBar wid ( count );
     wid.setCaption( i18n("Deleting ..."));
     wid.show();
     while (iii < count ) {   
         Global::statusMessage(i18n("Delete message %1 of %2").arg(iii).arg(count)); 
         wid.setProgress( iii ); 
         wid.raise();
         qApp->processEvents();
         RecMailP mail = (*target.at( iii ));
         deleteMail(mail);
         ++iii;
     }
 }
 
 void AbstractMail::downloadNewMails(const FolderP&fromFolder, AbstractMail*targetMail )
 {
     //qDebug("AbstractMail::downloadNewMails %s ", fromFolder->getName().latin1());
     // get local folder
     Account * acc = getAccount();
     if ( !acc ) return;
     QString lfName = acc->getLocalFolder();
     if ( lfName.isEmpty() )
         lfName = acc->getAccountName();
     // create local folder
     if ( !targetMail->createMbox(lfName))
         {
             QMessageBox::critical(0,i18n("Error creating new Folder"),
                                   i18n("Error while creating new folder\n%1\n\nCancelling action.").arg(lfName));
             return;
         }
     QValueList<RecMailP> t;
     listMessages(fromFolder->getName(),t,acc->getMaxMailSize() );
     if ( t.count() == 0 ) {
         qDebug("There are no new messages %s", fromFolder->getName().latin1());
         Global::statusMessage(i18n("There are no new messages"));
         return;
     }
     QValueList<RecMailP> e;
     targetMail->listMessages(lfName,e,acc->getMaxMailSize() );
     //qDebug("target has mails %d ", e.count());
     QValueList<RecMailP> n; 
     int iii = 0;
     int count = t.count();  
     while (iii < count ) {  
         RecMailP r = (*t.at( iii ));
         bool found = false; 
         int jjj = 0;
         int countE = e.count();   
         while (jjj < countE ) { 
             RecMailP re = (*e.at( jjj )); 
             if (  re->isEqual(r) ) {
                 found = true;
                 break;
             }
             ++jjj;   
         }
         if ( !found ) {
             //qDebug("AAAdate  *%s*  ", r->isodate.latin1() );
             n.append( r );
         }
         ++iii;
     } 
     qDebug("Downloaded %d messages ",n.count() );
     if ( n.count() == 0 ) {
         Global::statusMessage(i18n("There are no new messages"));
         return;
     }
     mvcpMailList( n,lfName,targetMail,!acc->getLeaveOnServer());
     Global::statusMessage(i18n("Downloaded %1 messages").arg(n.count()));
     
 #if 0
  QValueList<RecMailP> t;
  listMessages(fromFolder->getName(),t, maxSizeInKb);
  mvcpMailList( t,targetFolder,targetWrapper,moveit);
 #endif 
 
 }
 void AbstractMail::mvcpAllMails(const FolderP&fromFolder,
     const QString&targetFolder,AbstractMail*targetWrapper,bool moveit, int maxSizeInKb)
 {
  QValueList<RecMailP> t;
  listMessages(fromFolder->getName(),t, maxSizeInKb);
diff --git a/kmicromail/libmailwrapper/genericwrapper.cpp b/kmicromail/libmailwrapper/genericwrapper.cpp
index d89a5f9..49227dd 100644
--- a/kmicromail/libmailwrapper/genericwrapper.cpp
+++ b/kmicromail/libmailwrapper/genericwrapper.cpp
@@ -95,381 +95,395 @@ void Genericwrapper::fillSingleBody(RecPartP&target,mailmessage*,mailmime*mime)
         switch(type->ct_type->tp_data.tp_discrete_type->dt_type) {
         case MAILMIME_DISCRETE_TYPE_TEXT:
             target->setType("text");
             break;
         case MAILMIME_DISCRETE_TYPE_IMAGE:
             target->setType("image");
             break;
         case MAILMIME_DISCRETE_TYPE_AUDIO:
             target->setType("audio");
             break;
         case MAILMIME_DISCRETE_TYPE_VIDEO:
             target->setType("video");
             break;
         case MAILMIME_DISCRETE_TYPE_APPLICATION:
             target->setType("application");
             break;
         case MAILMIME_DISCRETE_TYPE_EXTENSION:
         default:
             if (type->ct_type->tp_data.tp_discrete_type->dt_extension) {
                 target->setType(type->ct_type->tp_data.tp_discrete_type->dt_extension);
             }
             break;
         }
         if (type->ct_parameters) {
             fillParameters(target,type->ct_parameters);
         }
     }
     if (mime->mm_mime_fields && mime->mm_mime_fields->fld_list) {
         for (current=clist_begin(mime->mm_mime_fields->fld_list);current!=0;current=clist_next(current)) {
             field = (mailmime_field*)current->data;
             switch(field->fld_type) {
             case MAILMIME_FIELD_TRANSFER_ENCODING:
                 target->setEncoding(getencoding(field->fld_data.fld_encoding));
                 break;
             case MAILMIME_FIELD_ID:
                 target->setIdentifier(field->fld_data.fld_id);
                 break;
             case MAILMIME_FIELD_DESCRIPTION:
                 target->setDescription(field->fld_data.fld_description);
                 break;
             default:
                 break;
             }
         }
     }
 }
 
 void Genericwrapper::fillParameters(RecPartP&target,clist*parameters)
 {
     if (!parameters) {return;}
     clistcell*current=0;
     mailmime_parameter*param;
     for (current=clist_begin(parameters);current!=0;current=clist_next(current)) {
         param = (mailmime_parameter*)current->data;
         if (param) {
             target->addParameter(QString(param->pa_name).lower(),QString(param->pa_value));
         }
     }
 }
 
 QString Genericwrapper::getencoding(mailmime_mechanism*aEnc)
 {
     QString enc="7bit";
     if (!aEnc) return enc;
     switch(aEnc->enc_type) {
     case MAILMIME_MECHANISM_7BIT:
         enc = "7bit";
         break;
     case MAILMIME_MECHANISM_8BIT:
         enc = "8bit";
         break;
     case MAILMIME_MECHANISM_BINARY:
         enc = "binary";
         break;
     case MAILMIME_MECHANISM_QUOTED_PRINTABLE:
         enc = "quoted-printable";
         break;
     case MAILMIME_MECHANISM_BASE64:
         enc = "base64";
         break;
     case MAILMIME_MECHANISM_TOKEN:
     default:
         if (aEnc->enc_token) {
             enc = QString(aEnc->enc_token);
         }
         break;
     }
     return enc;
 }
 
 void Genericwrapper::traverseBody(RecBodyP&target,mailmessage*message,mailmime*mime,QValueList<int>recList,unsigned int current_rec,int current_count)
 {
     if (current_rec >= 10) {
         ; // odebug << "too deep recursion!" << oendl; 
     }
     if (!message || !mime) {
         return;
     }
     int r;
     char*data = 0;
     size_t len;
     clistiter * cur = 0;
     QString b;
     RecPartP part = new RecPart();
 
     switch (mime->mm_type) {
     case MAILMIME_SINGLE:
     {
         QValueList<int>countlist = recList;
         countlist.append(current_count);
         r = mailmessage_fetch_section(message,mime,&data,&len);
         part->setSize(len);
         part->setPositionlist(countlist);
         b = gen_attachment_id();
         part->setIdentifier(b);
         fillSingleBody(part,message,mime);
         if (part->Type()=="text" && target->Bodytext().isNull()) {
             encodedString*rs = new encodedString();
             rs->setContent(data,len);
             encodedString*res = decode_String(rs,part->Encoding());
             if (countlist.count()>2) {
                 bodyCache[b]=rs;
                 target->addPart(part);
             } else {
                 delete rs;
             }
             b = QString(res->Content());
             delete res;
+            size_t index = 0;
+            char*resu = 0;
+            int err = MAILIMF_NO_ERROR;
+            QString charset = part->searchParamter( "charset");
+            qDebug("CHARSET %s ",charset.latin1() );
+            if ( !charset.isEmpty() ) {
+                err = mailmime_encoded_phrase_parse(charset.latin1(),
+                                                    b.latin1(), b.length(),&index, "utf-8",&resu);
+                if (err == MAILIMF_NO_ERROR && resu && strlen(resu)) {
+                    //qDebug("res %d %s ", index, resu);
+                    b = QString::fromUtf8(resu);
+                }
+                if (resu) free(resu);
+            }
             target->setBodytext(b);
             target->setDescription(part);
         } else {
             bodyCache[b]=new encodedString(data,len);
             target->addPart(part);
         }
     }
     break;
     case MAILMIME_MULTIPLE:
     {
         unsigned int ccount = 1;
         mailmime*cbody=0;
         QValueList<int>countlist = recList;
         for (cur = clist_begin(mime->mm_data.mm_multipart.mm_mp_list) ; cur != NULL ; cur = clist_next(cur)) {
             cbody = (mailmime*)clist_content(cur);
             if (cbody->mm_type==MAILMIME_MULTIPLE) {
                 RecPartP targetPart = new RecPart();
                 targetPart->setType("multipart");
                 countlist.append(current_count);
                 targetPart->setPositionlist(countlist);
                 target->addPart(targetPart);
             }
             traverseBody(target,message, cbody,countlist,current_rec+1,ccount);
             if (cbody->mm_type==MAILMIME_MULTIPLE) {
                 countlist = recList;
             }
             ++ccount;
         }
     }
     break;
     case MAILMIME_MESSAGE:
     {
         QValueList<int>countlist = recList;
         countlist.append(current_count);
         /* the own header is always at recursion 0 - we don't need that */
         if (current_rec > 0) {
             part->setPositionlist(countlist);
             r = mailmessage_fetch_section(message,mime,&data,&len);
             part->setSize(len);
             part->setPositionlist(countlist);
             b = gen_attachment_id();
             part->setIdentifier(b);
             part->setType("message");
             part->setSubtype("rfc822");
             bodyCache[b]=new encodedString(data,len);
             target->addPart(part);
         }
         if (mime->mm_data.mm_message.mm_msg_mime != NULL) {
             traverseBody(target,message,mime->mm_data.mm_message.mm_msg_mime,countlist,current_rec+1);
         }
     }
     break;
     }
 }
 
 RecBodyP Genericwrapper::parseMail( mailmessage * msg )
 {
     int err = MAILIMF_NO_ERROR;
     //mailmime_single_fields fields;
     /* is bound to msg and will be freed there */
     mailmime * mime=0;
     RecBodyP body = new RecBody();
     //memset(&fields, 0, sizeof(struct mailmime_single_fields));
     err = mailmessage_get_bodystructure(msg,&mime);
     QValueList<int>recList;
     traverseBody(body,msg,mime,recList);
     return body;
 }
 
 
 QString Genericwrapper::parseAddressList( mailimf_address_list *list )
 {
     QString result( "" );
 
     bool first = true;
     if (list == 0) return result;
     for ( clistiter *current = clist_begin( list->ad_list ); current != NULL; current = current->next ) {
         mailimf_address *addr = (mailimf_address *) current->data;
 
         if ( !first ) {
             result.append( "," );
         } else {
             first = false;
         }
 
         switch ( addr->ad_type ) {
             case MAILIMF_ADDRESS_MAILBOX:
                 result.append( parseMailbox( addr->ad_data.ad_mailbox ) );
                 break;
             case MAILIMF_ADDRESS_GROUP:
                 result.append( parseGroup( addr->ad_data.ad_group ) );
                 break;
             default:
                 ; // odebug << "Generic: unkown mailimf address type" << oendl; 
                 break;
         }
     }
 
     return result;
 }
 
 QString Genericwrapper::parseGroup( mailimf_group *group )
 {
     QString result( "" );
 
     result.append( group->grp_display_name );
     result.append( ": " );
 
     if ( group->grp_mb_list != NULL ) {
         result.append( parseMailboxList( group->grp_mb_list ) );
     }
 
     result.append( ";" );
 
     return result;
 }
 
 QString Genericwrapper::parseMailbox( mailimf_mailbox *box )
 {
     QString result( "" );
 
     if ( box->mb_display_name == NULL ) {
         result.append( box->mb_addr_spec );
     } else {
-        result.append( convert_String(box->mb_display_name).latin1() );
+        result.append( convert_String(box->mb_display_name) );
         result.append( " <" );
         result.append( box->mb_addr_spec );
         result.append( ">" );
     }
 
     return result;
 }
 
 QString Genericwrapper::parseMailboxList( mailimf_mailbox_list *list )
 {
     QString result( "" );
 
     bool first = true;
     for ( clistiter *current = clist_begin( list->mb_list ); current != NULL; current = current->next ) {
         mailimf_mailbox *box = (mailimf_mailbox *) current->data;
 
         if ( !first ) {
             result.append( "," );
         } else {
             first = false;
         }
 
         result.append( parseMailbox( box ) );
     }
 
     return result;
 }
 
 encodedString* Genericwrapper::fetchDecodedPart(const RecMailP&,const RecPartP&part)
 {
     QMap<QString,encodedString*>::ConstIterator it = bodyCache.find(part->Identifier());
     if (it==bodyCache.end()) return new encodedString();
     encodedString*t = decode_String(it.data(),part->Encoding());
     return t;
 }
 
 encodedString* Genericwrapper::fetchRawPart(const RecMailP&,const RecPartP&part)
 {
     QMap<QString,encodedString*>::ConstIterator it = bodyCache.find(part->Identifier());
     if (it==bodyCache.end()) return new encodedString();
     encodedString*t = it.data();
     return t;
 }
 
 QString Genericwrapper::fetchTextPart(const RecMailP&mail,const RecPartP&part)
 {
     encodedString*t = fetchDecodedPart(mail,part);
     QString text=t->Content();
     delete t;
     return text;
 }
 
 void Genericwrapper::cleanMimeCache()
 {
     QMap<QString,encodedString*>::Iterator it = bodyCache.begin();
     for (;it!=bodyCache.end();++it) {
         encodedString*t = it.data();
         //it.setValue(0);
         if (t) delete t;
     }
     bodyCache.clear();
     ; // odebug << "Genericwrapper: cache cleaned" << oendl; 
 }
 
 QStringList Genericwrapper::parseInreplies(mailimf_in_reply_to * in_replies)
 {
     QStringList res;
     if (!in_replies || !in_replies->mid_list) return res;
     clistiter * current = 0;
     for ( current = clist_begin( in_replies->mid_list ); current != NULL; current = current->next ) {
         QString h((char*)current->data);
         while (h.length()>0 && h[0]=='<') {
             h.remove(0,1);
         }
         while (h.length()>0 && h[h.length()-1]=='>') {
             h.remove(h.length()-1,1);
         }
         if (h.length()>0) {
             res.append(h);
         }
     }
     return res;
 }
 
 void Genericwrapper::parseList(QValueList<Opie::Core::OSmartPointer<RecMail> > &target,mailsession*session,const QString&mailbox,bool mbox_as_to, int maxSizeInKb)
 {
     int r;
     mailmessage_list * env_list = 0;
     r = mailsession_get_messages_list(session,&env_list);
     if (r != MAIL_NO_ERROR) {
         ; // odebug << "Error message list" << oendl; 
         return;
     }
     r = mailsession_get_envelopes_list(session, env_list);
     if (r != MAIL_NO_ERROR) {
         ; // odebug << "Error filling message list" << oendl; 
         if (env_list) {
             mailmessage_list_free(env_list);
         }
         return;
     }
     mailimf_references * refs = 0;
     mailimf_in_reply_to * in_replies = 0;
     uint32_t i = 0;
     for(; i < carray_count(env_list->msg_tab) ; ++i) {
         mailmessage * msg;
         QBitArray mFlags(7);
         msg = (mailmessage*)carray_get(env_list->msg_tab, i);
         if (msg->msg_fields == NULL) {
             //; // odebug << "could not fetch envelope of message " << i << "" << oendl; 
             continue;
         }
         RecMailP mail = new RecMail();
         mail->setWrapper(this);
         mail_flags * flag_result = 0;
         r = mailmessage_get_flags(msg,&flag_result);
         if (r == MAIL_ERROR_NOT_IMPLEMENTED) {
             mFlags.setBit(FLAG_SEEN);
         }
         mailimf_single_fields single_fields;
         mailimf_single_fields_init(&single_fields, msg->msg_fields);
         mail->setMsgsize(msg->msg_size);
         mail->setFlags(mFlags);
         mail->setMbox(mailbox);
         mail->setNumber(msg->msg_index);
         if (single_fields.fld_subject)
             mail->setSubject( convert_String(single_fields.fld_subject->sbj_value));
         if (single_fields.fld_from)
diff --git a/kmicromail/libmailwrapper/imapwrapper.cpp b/kmicromail/libmailwrapper/imapwrapper.cpp
index d90a8d2..eb2b47d 100644
--- a/kmicromail/libmailwrapper/imapwrapper.cpp
+++ b/kmicromail/libmailwrapper/imapwrapper.cpp
@@ -627,256 +627,275 @@ QStringList IMAPwrapper::address_list_to_stringlist(clist*list)
         from = "";
         named_from = false;
         current_address=(mailimap_address*)current->data;
         if (current_address->ad_personal_name){
             from+=convert_String((const char*)current_address->ad_personal_name);
             from+=" ";
             named_from = true;
         }
         if (named_from && (current_address->ad_mailbox_name || current_address->ad_host_name)) {
             from+="<";
         }
         if (current_address->ad_mailbox_name) {
             from+=QString(current_address->ad_mailbox_name);
             from+="@";
         }
         if (current_address->ad_host_name) {
              from+=QString(current_address->ad_host_name);
         }
         if (named_from && (current_address->ad_mailbox_name || current_address->ad_host_name)) {
            from+=">";
         }
         l.append(QString(from));
         if (++count > 99) {
             break;
         }
     }
     return l;
 }
 
 encodedString*IMAPwrapper::fetchRawPart(const RecMailP&mail,const QValueList<int>&path,bool internal_call)
 {
     encodedString*res=new encodedString;
     int err;
     mailimap_fetch_type *fetchType;
     mailimap_set *set;
     clistcell*current,*cur;
     mailimap_section_part * section_part =  0;
     mailimap_section_spec * section_spec =  0;
     mailimap_section * section = 0;
     mailimap_fetch_att * fetch_att = 0;
 
     login();
     if (!m_imap) {
         return res;
     }
     if (!internal_call) {
         err = selectMbox(mail->getMbox());
         if ( err != MAILIMAP_NO_ERROR ) {
             return res;
         }
     }
     set = mailimap_set_new_single(mail->getNumber());
 
     clist*id_list = 0;
 
     /* if path == empty then its a request for the whole rfc822 mail and generates
        a "fetch <id> (body[])" statement on imap server */
     if (path.count()>0 ) {
         id_list = clist_new();
         for (unsigned j=0; j < path.count();++j) {
             uint32_t * p_id = (uint32_t *)malloc(sizeof(*p_id));
             *p_id = path[j];
             clist_append(id_list,p_id);
         }
         section_part =  mailimap_section_part_new(id_list);
         section_spec =  mailimap_section_spec_new(MAILIMAP_SECTION_SPEC_SECTION_PART, NULL, section_part, NULL);
     }
 
     section =  mailimap_section_new(section_spec);
     fetch_att = mailimap_fetch_att_new_body_section(section);
     fetchType = mailimap_fetch_type_new_fetch_att(fetch_att);
 
     clist*result = 0;
 
     err = mailimap_fetch( m_imap, set, fetchType, &result );
     mailimap_set_free( set );
     mailimap_fetch_type_free( fetchType );
 
     if (err == MAILIMAP_NO_ERROR && (current=clist_begin(result)) ) {
         mailimap_msg_att * msg_att;
         msg_att = (mailimap_msg_att*)current->data;
         mailimap_msg_att_item*msg_att_item;
         for(cur = clist_begin(msg_att->att_list) ; cur != NULL ; cur = clist_next(cur)) {
             msg_att_item = (mailimap_msg_att_item*)clist_content(cur);
             if (msg_att_item->att_type == MAILIMAP_MSG_ATT_ITEM_STATIC) {
                 if (msg_att_item->att_data.att_static->att_type == MAILIMAP_MSG_ATT_BODY_SECTION) {
                     char*text = msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part;
                     /* detach - we take over the content */
                     msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part = 0L;
                     res->setContent(text,msg_att_item->att_data.att_static->att_data.att_body_section->sec_length);
                 }
             }
         }
     } else {
         ;//odebug << "error fetching text: " << m_imap->imap_response << "" << oendl; 
     }
     if (result) mailimap_fetch_list_free(result);
     return res;
 }
 
 /* current_recursion is for recursive calls.
    current_count means the position inside the internal loop! */
 void IMAPwrapper::traverseBody(const RecMailP&mail,mailimap_body*body,RecBodyP&target_body,
     int current_recursion,QValueList<int>recList,int current_count)
 {
     if (!body || current_recursion>=10) {
         return;
     }
     switch (body->bd_type) {
     case MAILIMAP_BODY_1PART:
     {
         QValueList<int>countlist = recList;
         countlist.append(current_count);
         RecPartP currentPart = new RecPart();
         mailimap_body_type_1part*part1 = body->bd_data.bd_body_1part;
         QString id("");
         currentPart->setPositionlist(countlist);
         for (unsigned int j = 0; j < countlist.count();++j) {
             id+=(j>0?" ":"");
             id+=QString("%1").arg(countlist[j]);
         }
         //odebug << "ID = " << id.latin1() << "" << oendl; 
         currentPart->setIdentifier(id);
         fillSinglePart(currentPart,part1);
         /* important: Check for is NULL 'cause a body can be empty!
            And we put it only into the mail if it is the FIRST part */
         if (part1->bd_type==MAILIMAP_BODY_TYPE_1PART_TEXT && target_body->Bodytext().isNull() && countlist[0]==1) {
             QString body_text = fetchTextPart(mail,countlist,true,currentPart->Encoding());
+
+            size_t index = 0;
+            char*res = 0;
+            int err = MAILIMF_NO_ERROR;
+            
+            QString charset = currentPart->searchParamter( "charset");
+            qDebug("CHARSET %s ",charset.latin1() );
+            //if ( false ) {
+            if ( !charset.isEmpty() ) {
+                //err = mailmime_encoded_phrase_parse("iso-8859-1",
+                //                                      text, strlen(text),&index, "iso-8859-1",&res);
+                err = mailmime_encoded_phrase_parse(charset.latin1(),
+                                                    body_text.latin1(), body_text.length(),&index, "utf-8",&res);
+                if (err == MAILIMF_NO_ERROR && res && strlen(res)) {
+                    //qDebug("res %d %s ", index, res);
+                    body_text = QString::fromUtf8(res);
+                }
+                if (res) free(res);
+            }
             //qDebug("encoding %d text %s ",currentPart->Encoding().latin1(), body_text.latin1() );
             target_body->setDescription(currentPart);
             target_body->setBodytext(body_text);
             if (countlist.count()>1) {
                 target_body->addPart(currentPart);
             }
         } else {
             target_body->addPart(currentPart);
         }
         if (part1->bd_type==MAILIMAP_BODY_TYPE_1PART_MSG) {
             traverseBody(mail,part1->bd_data.bd_type_msg->bd_body,target_body,current_recursion+1,countlist);
         }
     }
     break;
     case MAILIMAP_BODY_MPART:
     {
         QValueList<int>countlist = recList;
         clistcell*current=0;
         mailimap_body*current_body=0;
         unsigned int ccount = 1;
         mailimap_body_type_mpart*mailDescription = body->bd_data.bd_body_mpart;
         for (current=clist_begin(mailDescription->bd_list);current!=0;current=clist_next(current)) {
             current_body = (mailimap_body*)current->data;
             if (current_body->bd_type==MAILIMAP_BODY_MPART) {
                 RecPartP targetPart = new RecPart();
                 targetPart->setType("multipart");
                 fillMultiPart(targetPart,mailDescription);
                 countlist.append(current_count);
                 targetPart->setPositionlist(countlist);
                 target_body->addPart(targetPart);
                 QString id("");
                 for (unsigned int j = 0; j < countlist.count();++j) {
                     id+=(j>0?" ":"");
                     id+=QString("%1").arg(countlist[j]);
                 }
                 // odebug << "ID(mpart) = " << id.latin1() << "" << oendl; 
             }
             traverseBody(mail,current_body,target_body,current_recursion+1,countlist,ccount);
             if (current_body->bd_type==MAILIMAP_BODY_MPART) {
                 countlist = recList;
             }
             ++ccount;
         }
     }
     break;
     default:
     break;
     }
 }
 
 void IMAPwrapper::fillSinglePart(RecPartP&target_part,mailimap_body_type_1part*Description)
 {
     if (!Description) {
         return;
     }
     switch (Description->bd_type) {
         case MAILIMAP_BODY_TYPE_1PART_TEXT:
             target_part->setType("text");
             fillSingleTextPart(target_part,Description->bd_data.bd_type_text);
             break;
         case MAILIMAP_BODY_TYPE_1PART_BASIC:
             fillSingleBasicPart(target_part,Description->bd_data.bd_type_basic);
             break;
         case MAILIMAP_BODY_TYPE_1PART_MSG:
             target_part->setType("message");
             fillSingleMsgPart(target_part,Description->bd_data.bd_type_msg);
             break;
         default:
             break;
     }
 }
 
 void IMAPwrapper::fillSingleTextPart(RecPartP&target_part,mailimap_body_type_text*which)
 {
     if (!which) {
         return;
     }
     QString sub;
     sub = which->bd_media_text;
     //odebug << "Type= text/" << which->bd_media_text << "" << oendl; 
     target_part->setSubtype(sub.lower());
     target_part->setLines(which->bd_lines);
     fillBodyFields(target_part,which->bd_fields);
 }
 
 void IMAPwrapper::fillSingleMsgPart(RecPartP&target_part,mailimap_body_type_msg*which)
 {
     if (!which) {
         return;
     }
     target_part->setSubtype("rfc822");
     //odebug << "Message part" << oendl; 
     /* we set this type to text/plain */
     target_part->setLines(which->bd_lines);
     fillBodyFields(target_part,which->bd_fields);
 }
 
 void IMAPwrapper::fillMultiPart(RecPartP&target_part,mailimap_body_type_mpart*which)
 {
     if (!which) return;
     QString sub = which->bd_media_subtype;
     target_part->setSubtype(sub.lower());
     if (which->bd_ext_mpart && which->bd_ext_mpart->bd_parameter && which->bd_ext_mpart->bd_parameter->pa_list) {
         clistcell*cur = 0;
         mailimap_single_body_fld_param*param=0;
         for (cur = clist_begin(which->bd_ext_mpart->bd_parameter->pa_list);cur!=NULL;cur=clist_next(cur)) {
             param = (mailimap_single_body_fld_param*)cur->data;
             if (param) {
                 target_part->addParameter(QString(param->pa_name).lower(),QString(param->pa_value));
             }
         }
     }
 }
 
 void IMAPwrapper::fillSingleBasicPart(RecPartP&target_part,mailimap_body_type_basic*which)
 {
     if (!which) {
         return;
     }
     QString type,sub;
     switch (which->bd_media_basic->med_type) {
     case MAILIMAP_MEDIA_BASIC_APPLICATION:
         type = "application";
         break;
     case MAILIMAP_MEDIA_BASIC_AUDIO:
         type = "audio";
         break;
     case MAILIMAP_MEDIA_BASIC_IMAGE:
diff --git a/kmicromail/libmailwrapper/mboxwrapper.cpp b/kmicromail/libmailwrapper/mboxwrapper.cpp
index 0cdbae4..87f8c8a 100644
--- a/kmicromail/libmailwrapper/mboxwrapper.cpp
+++ b/kmicromail/libmailwrapper/mboxwrapper.cpp
@@ -1,255 +1,256 @@
 #include "mboxwrapper.h"
 #include "mailtypes.h"
 #include "mailwrapper.h"
 #include <libetpan/libetpan.h>
 #include <qdir.h>
 #include <stdlib.h>
 #include <klocale.h>
 
 
 #include <qpe/global.h>
 
 using namespace Opie::Core;
 MBOXwrapper::MBOXwrapper(const QString & mbox_dir,const QString&mbox_name)
     : Genericwrapper(),MBOXPath(mbox_dir),MBOXName(mbox_name)
 {
     QDir dir(MBOXPath);
     if (!dir.exists()) {
         dir.mkdir(MBOXPath);
     }
 }
 
 MBOXwrapper::~MBOXwrapper()
 {
 }
 
 void MBOXwrapper::listMessages(const QString & mailbox, QValueList<RecMailP> &target )
 {
     mailstorage*storage = mailstorage_new(NULL);
     QString p = MBOXPath+"/";
     p+=mailbox;
 
     int r = mbox_mailstorage_init(storage,(char*)p.latin1(),0,0,0);
     mailfolder*folder;
     folder = mailfolder_new( storage,(char*)p.latin1(),NULL);
     r = mailfolder_connect(folder);
     if (r != MAIL_NO_ERROR) {
         //odebug << "Error initializing mbox" << oendl; 
         mailfolder_free(folder);
         mailstorage_free(storage);
         return;
     }
 
     parseList(target,folder->fld_session,mailbox);
 
     mailfolder_disconnect(folder);
     mailfolder_free(folder);
     mailstorage_free(storage);
     Global::statusMessage(i18n("Mailbox has %1 mail(s)").arg(target.count()));
 }
 
 QValueList<Opie::Core::OSmartPointer<Folder> >* MBOXwrapper::listFolders()
 {
     QValueList<Opie::Core::OSmartPointer<Folder> >* folders = new QValueList<Opie::Core::OSmartPointer<Folder> >();
     QDir dir(MBOXPath);
     if (!dir.exists()) return folders;
     dir.setFilter(QDir::Files|QDir::Writable|QDir::Readable);
     QStringList entries = dir.entryList();
     QStringList::ConstIterator it = entries.begin();
     for (;it!=entries.end();++it) {
         FolderP inb=new Folder(*it,"/");
         folders->append(inb);
     }
     return folders;
 }
 
 void MBOXwrapper::deleteMail(const RecMailP & mail)
 {
     mailstorage*storage = mailstorage_new(NULL);
     QString p = MBOXPath+"/";
     p+=mail->getMbox();
     int r = mbox_mailstorage_init(storage,(char*)p.latin1(),0,0,0);
     mailfolder*folder;
     folder = mailfolder_new( storage,(char*)p.latin1(),NULL);
     r = mailfolder_connect(folder);
     if (r != MAIL_NO_ERROR) {
         ; // << "Error initializing mbox" << oendl; 
         mailfolder_free(folder);
         mailstorage_free(storage);
         return;
     }
     r = mailsession_remove_message(folder->fld_session,mail->getNumber());
     if (r != MAIL_NO_ERROR) {
         ; // << "error deleting mail" << oendl; 
     }
     mailfolder_free(folder);
     mailstorage_free(storage);
 }
 
 void MBOXwrapper::answeredMail(const RecMailP&)
 {
 }
 
 RecBodyP MBOXwrapper::fetchBody( const RecMailP &mail )
 {
     RecBodyP body = new RecBody();
     mailstorage*storage = mailstorage_new(NULL);
     QString p = MBOXPath+"/";
     p+=mail->getMbox();
     mailmessage * msg;
     char*data=0;
     size_t size;
 
     int r = mbox_mailstorage_init(storage,(char*)p.latin1(),0,0,0);
     mailfolder*folder;
     folder = mailfolder_new( storage,(char*)p.latin1(),NULL);
     r = mailfolder_connect(folder);
     if (r != MAIL_NO_ERROR) {
         ; // << "Error initializing mbox" << oendl; 
         mailfolder_free(folder);
         mailstorage_free(storage);
         return body;
     }
     r = mailsession_get_message(folder->fld_session, mail->getNumber(), &msg);
     if (r != MAIL_NO_ERROR) {
         ; // << "Error fetching mail " << mail->getNumber() << "" << oendl; 
         mailfolder_free(folder);
         mailstorage_free(storage);
         return body;
     }
     r = mailmessage_fetch(msg,&data,&size);
     if (r != MAIL_NO_ERROR) {
         ; // << "Error fetching mail " << mail->getNumber() << "" << oendl; 
         mailfolder_free(folder);
         mailstorage_free(storage);
         mailmessage_free(msg);
         return body;
     }
+    qDebug("MBOXwrapper::fetchBody ");
     body = parseMail(msg);
     mailmessage_fetch_result_free(msg,data);
     mailfolder_free(folder);
     mailstorage_free(storage);
 
     return body;
 }
 
 void MBOXwrapper::mbox_progress( size_t current, size_t maximum )
 {
     ; // << "MBOX " << current << " von " << maximum << "" << oendl; 
 }
 
 int MBOXwrapper::createMbox(const QString&folder,const FolderP&,const QString&,bool )
 {
     QString p = MBOXPath+"/";
     p+=folder;
     QFileInfo fi(p);
     if (fi.exists()) {
         Global::statusMessage(i18n("Mailbox exists."));
         return 0;
     }
     mailmbox_folder*f = 0;
     if (mailmbox_init(p.latin1(),0,1,0,&f) != MAIL_NO_ERROR) {
         Global::statusMessage(i18n("Error init folder"));
         return 0;
     }
     if (f) mailmbox_done(f);
     return 1;
 }
 
 void MBOXwrapper::storeMessage(const char*msg,size_t length, const QString&folder)
 {
     QString p = MBOXPath+"/";
     p+=folder;
     mailmbox_folder*f = 0;
     int r = mailmbox_init(p.latin1(),0,1,0,&f);
     if (r != MAIL_NO_ERROR) {
         Global::statusMessage(i18n("Error init folder"));
         return;
     }
     r = mailmbox_append_message(f,msg,length);
     if (r != MAIL_NO_ERROR) {
         Global::statusMessage(i18n("Error writing to message folder"));
     }
     mailmbox_done(f);
 }
 
 encodedString* MBOXwrapper::fetchRawBody(const RecMailP&mail)
 {
     RecBody body;
     mailstorage*storage = mailstorage_new(NULL);
     QString p = MBOXPath+"/";
     p+=mail->getMbox();
     mailmessage * msg;
     char*data=0;
     size_t size;
 
     int r = mbox_mailstorage_init(storage,(char*)p.latin1(),0,0,0);
     mailfolder*folder;
     folder = mailfolder_new( storage,(char*)p.latin1(),NULL);
     r = mailfolder_connect(folder);
     if (r != MAIL_NO_ERROR) {
         Global::statusMessage(i18n("Error initializing mbox"));
         mailfolder_free(folder);
         mailstorage_free(storage);
         return 0;
     }
     r = mailsession_get_message(folder->fld_session, mail->getNumber(), &msg);
     if (r != MAIL_NO_ERROR) {
         Global::statusMessage(i18n("Error fetching mail %i").arg(mail->getNumber()));
         mailfolder_free(folder);
         mailstorage_free(storage);
         return 0;
     }
     r = mailmessage_fetch(msg,&data,&size);
     if (r != MAIL_NO_ERROR) {
         Global::statusMessage(i18n("Error fetching mail %i").arg(mail->getNumber()));
         mailfolder_free(folder);
         mailstorage_free(storage);
         mailmessage_free(msg);
         return 0;
     }
     encodedString*result = new encodedString(data,size);
 
     mailfolder_free(folder);
     mailstorage_free(storage);
     mailmessage_free(msg);
     return result;
 }
 
 void MBOXwrapper::deleteMails(const QString & mailbox,const QValueList<RecMailP> &target)
 {
     QString p = MBOXPath+"/";
     p+=mailbox;
     mailmbox_folder*f = 0;
     int r = mailmbox_init(p.latin1(),0,1,0,&f);
     if (r != MAIL_NO_ERROR) {
         ; // << "Error init folder" << oendl; 
         return;
     }
     deleteMails(f,target);
     mailmbox_done(f);
 }
 
 void MBOXwrapper::deleteMails(mailmbox_folder*f,const QValueList<RecMailP> &target)
 {
     if (!f) return;
     int r;
     QValueList<RecMailP>::ConstIterator it;
     for (it=target.begin(); it != target.end();++it) {
         r = mailmbox_delete_msg(f,(*it)->getNumber());
         if (r!=MAILMBOX_NO_ERROR) {
             ; // << "error delete mail" << oendl; 
         }
     }
     r = mailmbox_expunge(f);
     if (r != MAILMBOX_NO_ERROR) {
         ; // << "error expunge mailbox" << oendl; 
     }
 }
 
 int MBOXwrapper::deleteAllMail(const FolderP&tfolder)
 {
     if (!tfolder) return 0;
     QString p = MBOXPath+"/"+tfolder->getDisplayName();
     int res = 1;
 
diff --git a/kmicromail/libmailwrapper/mhwrapper.cpp b/kmicromail/libmailwrapper/mhwrapper.cpp
index 90b5d23..982d7a6 100644
--- a/kmicromail/libmailwrapper/mhwrapper.cpp
+++ b/kmicromail/libmailwrapper/mhwrapper.cpp
@@ -3,256 +3,257 @@
 #include "mailtypes.h"
 #include "mailwrapper.h"
 #include <libetpan/libetpan.h>
 #include <qdir.h>
 #include <qmessagebox.h>
 #include <stdlib.h>
 #include <qpe/global.h>
 #include <klocale.h>
 #include <kglobal.h>
 //#include <opie2/odebug.h> 
 
 using namespace Opie::Core;
 MHwrapper::MHwrapper(const QString & mbox_dir,const QString&mbox_name)
     : Genericwrapper(),MHPath(mbox_dir),MHName(mbox_name)
 {
     if (MHPath.length()>0) {
         if (MHPath[MHPath.length()-1]=='/') {
             MHPath=MHPath.left(MHPath.length()-1);
         }
         //odebug << MHPath << oendl; 
         QDir dir(MHPath);
         if (!dir.exists()) {
             dir.mkdir(MHPath);
         }
         init_storage();
     }
 }
 
 void MHwrapper::init_storage()
 {
     int r;
     QString pre = MHPath;
     if (!m_storage) {
         m_storage = mailstorage_new(NULL);
         r = mh_mailstorage_init(m_storage,(char*)pre.latin1(),0,0,0);
         if (r != MAIL_NO_ERROR) {
             qDebug(" error init storage  ");
             mailstorage_free(m_storage);
             m_storage = 0;
             return;
         }
     }
     r = mailstorage_connect(m_storage);
     if (r!=MAIL_NO_ERROR) {
         qDebug("error connecting storage ");
         mailstorage_free(m_storage);
         m_storage = 0;
     }
 }
 
 void MHwrapper::clean_storage()
 {
     if (m_storage) {
         mailstorage_disconnect(m_storage);
         mailstorage_free(m_storage);
         m_storage = 0;
     }
 }
 
 MHwrapper::~MHwrapper()
 {
     clean_storage();
 }
 
 void MHwrapper::listMessages(const QString & mailbox, QValueList<Opie::Core::OSmartPointer<RecMail> > &target, int maxSizeInKb  )
 {
     init_storage();
     if (!m_storage) {
         return;
     }
     QString f = buildPath(mailbox);
     int r = mailsession_select_folder(m_storage->sto_session,(char*)f.latin1());
     if (r!=MAIL_NO_ERROR) {
         qDebug("listMessages: error selecting folder! ");
         return;
     }
     parseList(target,m_storage->sto_session,f, false, maxSizeInKb );
     Global::statusMessage(i18n("Mailbox has %1 mail(s)").arg(target.count()));
 }
 
 QValueList<Opie::Core::OSmartPointer<Folder> >* MHwrapper::listFolders()
 {
     QValueList<Opie::Core::OSmartPointer<Folder> >* folders = new QValueList<Opie::Core::OSmartPointer<Folder> >();
     /* this is needed! */
     if (m_storage) mailstorage_disconnect(m_storage);
     init_storage();
     if (!m_storage) {
         return folders;
     }
     mail_list*flist = 0;
     clistcell*current=0;
     int r = mailsession_list_folders(m_storage->sto_session,NULL,&flist);
     if (r != MAIL_NO_ERROR || !flist) {
         qDebug("error getting folder list ");
         return folders;
     }
     for (current=clist_begin(flist->mb_list);current!=0;current=clist_next(current)) {
         QString t = (char*)current->data;
         t.replace(0,MHPath.length(),"");
         folders->append(new MHFolder(t,MHPath));
     }
     mail_list_free(flist);
     return folders;
 }
 
 void MHwrapper::deleteMail(const RecMailP&mail)
 {
     init_storage();
     if (!m_storage) {
         return;
     }
     int r = mailsession_select_folder(m_storage->sto_session,(char*)mail->getMbox().latin1());
     if (r!=MAIL_NO_ERROR) {
         qDebug("error selecting folder! ");
         return;
     }
     r = mailsession_remove_message(m_storage->sto_session,mail->getNumber());
     if (r != MAIL_NO_ERROR) {
         qDebug("error deleting mail ");
     }
 }
 
 void MHwrapper::answeredMail(const RecMailP&)
 {
 }
 
 RecBodyP MHwrapper::fetchBody( const RecMailP &mail )
 {
+    qDebug("MHwrapper::fetchBody ");
     RecBodyP body = new RecBody();
     init_storage();
     if (!m_storage) {
         return body;
     }
     mailmessage * msg;
     char*data=0;
 
     /* mail should hold the complete path! */
     int r = mailsession_select_folder(m_storage->sto_session,(char*)mail->getMbox().latin1());
     if (r != MAIL_NO_ERROR) {
         return body;
     }
     r = mailsession_get_message(m_storage->sto_session, mail->getNumber(), &msg);
     if (r != MAIL_NO_ERROR) {
         qDebug("Error fetching mail ");
        
         return body;
     }
     body = parseMail(msg);
     mailmessage_fetch_result_free(msg,data);
     return body;
 }
 
 void MHwrapper::mbox_progress( size_t current, size_t maximum )
 {
     qDebug("MBox Progress %d of %d",current,maximum );
     //odebug << "MH " << current << " von " << maximum << "" << oendl; 
 }
 
 QString MHwrapper::buildPath(const QString&p)
 {
     QString f="";
     if (p.length()==0||p=="/")
         return MHPath;
     if (!p.startsWith(MHPath)) {
         f+=MHPath;
     }
     if (!p.startsWith("/")) {
         f+="/";
     }
     f+=p;
     return f;
 }
 
 int MHwrapper::createMbox(const QString&folder,const FolderP&pfolder,const QString&,bool )
 {
     init_storage();
     if (!m_storage) {
         return 0;
     }
     QString f;
     if (!pfolder) {
         // toplevel folder
         f  = buildPath(folder);
     } else {
         f = pfolder->getName();
         f+="/";
         f+=folder;
     }
    
     int r = mailsession_create_folder(m_storage->sto_session,(char*)f.latin1());
     if (r != MAIL_NO_ERROR) {
         qDebug("error creating folder ");
         return 0;
     }
     return 1;
 }
 
 void MHwrapper::storeMessage(const char*msg,size_t length, const QString&Folder)
 {
     init_storage();
     if (!m_storage) {
         return;
     }
     QString f = buildPath(Folder);
     int r = mailsession_select_folder(m_storage->sto_session,(char*)f.latin1());
     if (r!=MAIL_NO_ERROR) {
         qDebug("error selecting folder! ");
         return;
     }
     r = mailsession_append_message(m_storage->sto_session,(char*)msg,length);
     if (r!=MAIL_NO_ERROR) {
         qDebug("error storing mail ");
     }
     return;
 }
 
 encodedString* MHwrapper::fetchRawBody(const RecMailP&mail)
 {
     encodedString*result = 0;
     init_storage();
     if (!m_storage) {
         return result;
     }
     mailmessage * msg = 0;
     char*data=0;
     size_t size;
     int r = mailsession_select_folder(m_storage->sto_session,(char*)mail->getMbox().latin1());
     if (r!=MAIL_NO_ERROR) {
         qDebug("error selecting folder! ");
         return result;
     }
     r = mailsession_get_message(m_storage->sto_session, mail->getNumber(), &msg);
     if (r != MAIL_NO_ERROR) {
         Global::statusMessage(i18n("Error fetching mail %i").arg(mail->getNumber()));
         return 0;
     }
     r = mailmessage_fetch(msg,&data,&size);
     if (r != MAIL_NO_ERROR) {
         Global::statusMessage(i18n("Error fetching mail %i").arg(mail->getNumber()));
         if (msg) mailmessage_free(msg);
         return 0;
     }
     result = new encodedString(data,size);
     if (msg) mailmessage_free(msg);
     return result;
 }
 
 void MHwrapper::deleteMails(const QString & mailbox,const QValueList<RecMailP> &target)
 {
     QString f = buildPath(mailbox);
     int r = mailsession_select_folder(m_storage->sto_session,(char*)f.latin1());
     if (r!=MAIL_NO_ERROR) {
         qDebug("deleteMails: error selecting folder! ");
         return;
     }
     QValueList<RecMailP>::ConstIterator it;