Fixes in password dislog handling

4 files changed, 34 insertions, 46 deletions

diff --git a/kmicromail/libmailwrapper/imapwrapper.cpp b/kmicromail/libmailwrapper/imapwrapper.cpp
index 11d3343..021633b 100644
--- a/kmicromail/libmailwrapper/imapwrapper.cpp
+++ b/kmicromail/libmailwrapper/imapwrapper.cpp
@@ -3,277 +3,277 @@
 #include <libetpan/libetpan.h>
 #include <qpe/global.h>
 #include <qapplication.h>
 #include "imapwrapper.h"
 #include "mailtypes.h"
 #include "logindialog.h"
 #include <qprogressbar.h>
 
 using namespace Opie::Core;
 IMAPwrapper::IMAPwrapper( IMAPaccount *a )
     : AbstractMail()
 {
     account = a;
     m_imap = 0;
     m_Lastmbox = "";
 }
 
 IMAPwrapper::~IMAPwrapper()
 {
     logout();
 }
 
 /* to avoid to often select statements in loops etc.
    we trust that we are logged in and connection is established!*/
 int IMAPwrapper::selectMbox(const QString&mbox)
 {
     if (mbox == m_Lastmbox) {
         return MAILIMAP_NO_ERROR;
     }
     int err = mailimap_select( m_imap, (char*)mbox.latin1());
     if ( err != MAILIMAP_NO_ERROR ) {
         m_Lastmbox = "";
         return err;
     }
     m_Lastmbox = mbox;
     return err;
 }
 
 void IMAPwrapper::imap_progress( size_t current, size_t maximum )
 {
     qApp->processEvents();
     qDebug("imap progress %d of %d ",current,maximum  );
 }
 
 bool IMAPwrapper::start_tls(bool force_tls)
 {
     int err;
     bool try_tls;
     mailimap_capability_data * cap_data = 0;
 
     err = mailimap_capability(m_imap,&cap_data);
     if (err != MAILIMAP_NO_ERROR) {
         Global::statusMessage("error getting capabilities!");
         return false;
     }
     clistiter * cur;
     for(cur = clist_begin(cap_data->cap_list) ; cur != NULL;cur = clist_next(cur)) {
         struct mailimap_capability * cap;
         cap  = (struct mailimap_capability *)clist_content(cur);
         if (cap->cap_type == MAILIMAP_CAPABILITY_NAME) {
             if (strcasecmp(cap->cap_data.cap_name, "STARTTLS") == 0) {
                 try_tls = true;
                 break;
             }
         }
     }
     if (cap_data) {
         mailimap_capability_data_free(cap_data);
     }
     if (try_tls) {
         err =  mailimap_starttls(m_imap);
         if (err != MAILIMAP_NO_ERROR && force_tls) {
             Global::statusMessage(tr("Server has no TLS support!"));
             try_tls = false;
         } else {
             mailstream_low * low;
             mailstream_low * new_low;
             low = mailstream_get_low(m_imap->imap_stream);
             if (!low) {
                 try_tls = false;
             } else {
                 int fd = mailstream_low_get_fd(low);
                 if (fd > -1 && (new_low = mailstream_low_ssl_open(fd))!=0) {
                     mailstream_low_free(low);
                     mailstream_set_low(m_imap->imap_stream, new_low);
                 } else {
                     try_tls = false;
                 }
             }
         }
    }
    return try_tls;
 }
 
 void IMAPwrapper::login()
 {
-    const char *server, *user, *pass;
+    QString server, user, pass;
     uint16_t port;
     int err = MAILIMAP_NO_ERROR;
 
     if (account->getOffline()) return;
     /* we are connected this moment */
     /* TODO: setup a timer holding the line or if connection closed - delete the value */
     if (m_imap) {
         err = mailimap_noop(m_imap);
         if (err!=MAILIMAP_NO_ERROR) {
             logout();
         } else {
             mailstream_flush(m_imap->imap_stream);
             return;
         }
     }
-    server = account->getServer().latin1();
+    server = account->getServer();
     port = account->getPort().toUInt();
     if ( account->getUser().isEmpty() || account->getPassword().isEmpty() ) {
       LoginDialog login( account->getUser(), account->getPassword(), NULL, 0, true );
       login.show();
       if ( QDialog::Accepted == login.exec() ) {
         // ok
-        user = login.getUser().latin1();
-        pass = login.getPassword().latin1();
+        user = login.getUser();
+        pass = login.getPassword();
       } else {
         // cancel
         return;
       }
     } else {
-      user = account->getUser().latin1();
-      pass = account->getPassword().latin1();
+      user = account->getUser();
+      pass = account->getPassword();
     }
 
     m_imap = mailimap_new( 20, &imap_progress );
 
     /* connect */
     bool ssl = false;
     bool try_tls = false;
     bool force_tls = false;
 
     if  ( account->ConnectionType() == 2 ) {
         ssl = true;
     }
     if (account->ConnectionType()==1) {
         force_tls = true;
     }
 
     if ( ssl ) {
         qDebug("using ssl ");
-        err = mailimap_ssl_connect( m_imap, (char*)server, port );
+        err = mailimap_ssl_connect( m_imap, (char*)server.latin1(), port );
     } else {
-        err = mailimap_socket_connect( m_imap, (char*)server, port );
+        err = mailimap_socket_connect( m_imap, (char*)server.latin1(), port );
     }
 
     if ( err != MAILIMAP_NO_ERROR &&
          err != MAILIMAP_NO_ERROR_AUTHENTICATED &&
          err != MAILIMAP_NO_ERROR_NON_AUTHENTICATED ) {
          QString failure = "";
          if (err == MAILIMAP_ERROR_CONNECTION_REFUSED) {
             failure="Connection refused";
          } else {
             failure="Unknown failure";
          }
          Global::statusMessage(tr("error connecting imap server: %1").arg(failure));
          mailimap_free( m_imap );
          m_imap = 0;
          return;
     }
 
     if (!ssl) {
         try_tls = start_tls(force_tls);
     }
 
     bool ok = true;
     if (force_tls && !try_tls) {
         Global::statusMessage(tr("Server has no TLS support!"));
         ok = false;
     }
 
 
     /* login */
 
     if (ok) {
-        err = mailimap_login_simple( m_imap, (char*)user, (char*)pass );
+        err = mailimap_login_simple( m_imap, (char*)user.latin1(), (char*)pass.latin1() );
         if ( err != MAILIMAP_NO_ERROR ) {
             Global::statusMessage(tr("error logging in imap server: %1").arg(m_imap->imap_response));
             ok = false;
         }
     }
     if (!ok) {
         err = mailimap_close( m_imap );
         mailimap_free( m_imap );
         m_imap = 0;
     }
 }
 
 void IMAPwrapper::logout()
 {
     int err = MAILIMAP_NO_ERROR;
     if (!m_imap) return;
     err = mailimap_logout( m_imap );
     err = mailimap_close( m_imap );
     mailimap_free( m_imap );
     m_imap = 0;
     m_Lastmbox = "";
 }
 
 void IMAPwrapper::listMessages(const QString&mailbox,QValueList<Opie::Core::OSmartPointer<RecMail> > &target , int maxSizeInKb)
 {
     int err = MAILIMAP_NO_ERROR;
     clist *result = 0;
     clistcell *current;
     mailimap_fetch_type *fetchType = 0;
     mailimap_set *set = 0;
 
     login();
     if (!m_imap) {
         return;
     }
     /* select mailbox READONLY for operations */
     err = selectMbox(mailbox);
     if ( err != MAILIMAP_NO_ERROR ) {
         return;
     }
 
     int last = m_imap->imap_selection_info->sel_exists;
 
     if (last == 0) {
         Global::statusMessage(tr("Mailbox has no mails"));
         return;
     } else {
     }
 
     /* the range has to start at 1!!! not with 0!!!! */
     set = mailimap_set_new_interval( 1, last );
     fetchType = mailimap_fetch_type_new_fetch_att_list_empty();
     mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_envelope());
     mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_flags());
     mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_internaldate());
     mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_rfc822_size());
 
     err = mailimap_fetch( m_imap, set, fetchType, &result );
     mailimap_set_free( set );
     mailimap_fetch_type_free( fetchType );
 
     QString date,subject,from;
 
     if ( err == MAILIMAP_NO_ERROR ) {
         mailimap_msg_att * msg_att;
         int i = 0;
         for (current = clist_begin(result); current != 0; current=clist_next(current)) {
             ++i;
             msg_att = (mailimap_msg_att*)current->data;
             RecMail*m = parse_list_result(msg_att);
             if (m) {
                 if ( maxSizeInKb == 0 || m->Msgsize()<=maxSizeInKb*1024 ) {
                     m->setNumber(i);
                     m->setMbox(mailbox);
                     m->setWrapper(this);
                     target.append(m);
                 }
             }
         }
         Global::statusMessage(tr("Mailbox has %1 mails").arg(target.count()));
     } else {
         Global::statusMessage(tr("Error fetching headers: %1").arg(m_imap->imap_response));
     }
     if (result) mailimap_fetch_list_free(result);
 }
 
 QValueList<Opie::Core::OSmartPointer<Folder> >* IMAPwrapper::listFolders()
 {
     const char *path, *mask;
     int err = MAILIMAP_NO_ERROR;
     clist *result = 0;
     clistcell *current = 0;
     clistcell*cur_flag = 0;
     mailimap_mbx_list_flags*bflags = 0;
 
     QValueList<FolderP>* folders = new QValueList<FolderP>();
diff --git a/kmicromail/libmailwrapper/nntpwrapper.cpp b/kmicromail/libmailwrapper/nntpwrapper.cpp
index f5d7f16..93cd2b5 100644
--- a/kmicromail/libmailwrapper/nntpwrapper.cpp
+++ b/kmicromail/libmailwrapper/nntpwrapper.cpp
@@ -24,244 +24,235 @@ NNTPwrapper::NNTPwrapper( NNTPaccount *a )
 
 NNTPwrapper::~NNTPwrapper() {
     logout();
     QFile msg_cache(msgTempName);
     if (msg_cache.exists()) {
         msg_cache.remove();
     }
 }
 
 void NNTPwrapper::nntp_progress( size_t current, size_t maximum ) {
     ; // << "NNTP: " << current << " of " << maximum << "" << oendl; 
 }
 
 
 RecBodyP NNTPwrapper::fetchBody( const RecMailP &mail ) {
     int err = NEWSNNTP_NO_ERROR;
     char *message = 0;
     size_t length = 0;
 
     RecBodyP body = new RecBody();
     login();
     if ( !m_nntp ) {
         return body;
     }
 
     mailmessage * mailmsg;
     if (mail->Msgsize()>HARD_MSG_SIZE_LIMIT) {
         ; // << "Message to large: " << mail->Msgsize() << "" << oendl; 
         return body;
     }
 
     QFile msg_cache(msgTempName);
 
     cleanMimeCache();
 
     if (mail->getNumber()!=last_msg_id) {
         if (msg_cache.exists()) {
             msg_cache.remove();
         }
         msg_cache.open(IO_ReadWrite|IO_Truncate);
         last_msg_id = mail->getNumber();
         err = mailsession_get_message(m_nntp->sto_session, mail->getNumber(), &mailmsg);
         err = mailmessage_fetch(mailmsg,&message,&length);
         msg_cache.writeBlock(message,length);
     } else {
         QString msg="";
         msg_cache.open(IO_ReadOnly);
         message = new char[4096];
         memset(message,0,4096);
         while (msg_cache.readBlock(message,4095)>0) {
             msg+=message;
             memset(message,0,4096);
         }
         delete message;
         message = (char*)malloc(msg.length()+1*sizeof(char));
         memset(message,0,msg.length()+1);
         memcpy(message,msg.latin1(),msg.length());
         /* transform to libetpan stuff */
         mailmsg = mailmessage_new();
         mailmessage_init(mailmsg, NULL, data_message_driver, 0, strlen(message));
         generic_message_t * msg_data;
         msg_data = (generic_message_t *)mailmsg->msg_data;
         msg_data->msg_fetched = 1;
         msg_data->msg_message = message;
         msg_data->msg_length = strlen(message);
     }
     body = parseMail(mailmsg);
 
     /* clean up */
     if (mailmsg)
         mailmessage_free(mailmsg);
     if (message)
         free(message);
 
     return body;
 }
 
 
 void NNTPwrapper::listMessages(const QString & which, QValueList<Opie::Core::OSmartPointer<RecMail> > &target, int maxSizeInKb)
 {
     login();
     if (!m_nntp)
         return;
     uint32_t res_messages,res_recent,res_unseen;
     mailsession_status_folder(m_nntp->sto_session,(char*)which.latin1(),&res_messages,&res_recent,&res_unseen);
     parseList(target,m_nntp->sto_session,which,true, maxSizeInKb);
 }
 
 void NNTPwrapper::login()
 {
     if (account->getOffline())
         return;
     /* we'll hold the line */
     if ( m_nntp != NULL )
         return;
 
-    const char *server, *user, *pass;
+    QString server;
     QString User,Pass;
     uint16_t port;
     int err = NEWSNNTP_NO_ERROR;
 
-    server = account->getServer().latin1();
+    server = account->getServer();
     port = account->getPort().toUInt();
 
-    user = pass = 0;
-
     if ( ( account->getUser().isEmpty() || account->getPassword().isEmpty() ) && account->getLogin() ) {
         LoginDialog login( account->getUser(), account->getPassword(), NULL, 0, true );
         login.show();
         if ( QDialog::Accepted == login.exec() ) {
             // ok
-            User = login.getUser().latin1();
-            Pass = login.getPassword().latin1();
+            User = login.getUser();
+            Pass = login.getPassword();
         } else {
             // cancel
             ; // << "NNTP: Login canceled" << oendl; 
             return;
         }
     } else {
-        User = account->getUser().latin1();
-        Pass = account->getPassword().latin1();
+        User = account->getUser();
+        Pass = account->getPassword();
     }
 
-    if (User.isEmpty()) {
-        user=0;
-        pass = 0;
-    } else {
-        user=User.latin1();
-        pass=Pass.latin1();
-    }
     //  bool ssl = account->getSSL();
 
     m_nntp=mailstorage_new(NULL);
 
     int conntypeset = account->ConnectionType();
     int conntype = 0;
     if ( conntypeset == 3 ) {
         conntype = CONNECTION_TYPE_COMMAND;
     } else if ( conntypeset == 2 ) {
         conntype = CONNECTION_TYPE_TLS;
     } else if ( conntypeset == 1 ) {
         conntype = CONNECTION_TYPE_STARTTLS;
     } else if ( conntypeset == 0 ) {
         conntype = CONNECTION_TYPE_TRY_STARTTLS;
     }
 
-   nntp_mailstorage_init(m_nntp,(char*)server, port, NULL, CONNECTION_TYPE_PLAIN, NNTP_AUTH_TYPE_PLAIN,
-                          (char*)user,(char*)pass,0,0,0);
+    nntp_mailstorage_init(m_nntp,(char*)server.latin1(), port, NULL, CONNECTION_TYPE_PLAIN, NNTP_AUTH_TYPE_PLAIN,
+                          (char*)User.latin1(),(char*)Pass.latin1(),0,0,0);
 
     err = mailstorage_connect( m_nntp );
 
    if (err != NEWSNNTP_NO_ERROR) {
         ; // << QString( "FEHLERNUMMER %1" ).arg(  err ) << oendl; 
      //   Global::statusMessage(tr("Error initializing folder"));
         mailstorage_free(m_nntp);
         m_nntp = 0;
 
     } else {
         mailsession * session = m_nntp->sto_session;
         newsnntp * news =  ( (  nntp_session_state_data * )session->sess_data )->nntp_session;
         news->nntp_progr_fun = &nntp_progress;
     }
 
 }
 
 void NNTPwrapper::logout()
 {
     int err = NEWSNNTP_NO_ERROR;
     if ( m_nntp == NULL )
         return;
     mailstorage_free(m_nntp);
    m_nntp = 0;
 }
 
 QValueList<Opie::Core::OSmartPointer<Folder> >* NNTPwrapper::listFolders() {
 
     QValueList<Opie::Core::OSmartPointer<Folder> >* folders = new QValueList<Opie::Core::OSmartPointer<Folder> >();
     QStringList groups;
     if (account) {
         groups = account->getGroups();
     }
     for ( QStringList::Iterator it = groups.begin(); it != groups.end(); ++it ) {
         folders->append(new Folder((*it),"."));
     }
     return folders;
 }
 
 /* we made this method in raw nntp access of etpan and not via generic interface
  * 'cause in that case there will be doubled copy operations. eg. the etpan would
  * copy that stuff into its own structures and we must copy it into useable c++
  * structures for our frontend. this would not make sense, so it is better to reimplement
  * the stuff from generic interface of etpan but copy it direct to qt classes.
  */
 QStringList NNTPwrapper::listAllNewsgroups(const QString&mask) {
     login();
     QStringList res;
     clist *result = 0;
     clistcell *current = 0;
     newsnntp_group_description *group;
 
     if ( m_nntp )   {
         mailsession * session = m_nntp->sto_session;
         newsnntp * news =  ( (  nntp_session_state_data * )session->sess_data )->nntp_session;
         int err = NEWSNNTP_NO_ERROR;
         if (mask.isEmpty()) {
             err = newsnntp_list(news, &result);
         } else {
             /* taken from generic wrapper of etpan */
             QString nmask = mask+".*";
             err = newsnntp_list_active(news, nmask.latin1(), &result);
         }
         if ( err == NEWSNNTP_NO_ERROR && result) {
             for ( current=clist_begin(result);current!=NULL;current=clist_next(current) ) {
                 group = (  newsnntp_group_description* ) current->data;
                 if (!group||!group->grp_name||strlen(group->grp_name)==0) continue;
                 res.append(group->grp_name);
             }
         }
     }
     if (result) {
         newsnntp_list_free(result);
     }
     return res;
 }
 
 void NNTPwrapper::answeredMail(const RecMailP&) {}
 
 void NNTPwrapper::statusFolder(folderStat&target_stat,const QString&) {
     login();
     target_stat.message_count = 0;
     target_stat.message_unseen = 0;
     target_stat.message_recent = 0;
     if (!m_nntp)
         return;
     int r = mailsession_status_folder(m_nntp->sto_session,0,&target_stat.message_count,
                                       &target_stat.message_recent,&target_stat.message_unseen);
 }
 
 
 encodedString* NNTPwrapper::fetchRawBody(const RecMailP&mail) {
     char*target=0;
     size_t length=0;
     encodedString*res = 0;
     mailmessage * mailmsg = 0;
diff --git a/kmicromail/libmailwrapper/pop3wrapper.cpp b/kmicromail/libmailwrapper/pop3wrapper.cpp
index 0e6612c..f430121 100644
--- a/kmicromail/libmailwrapper/pop3wrapper.cpp
+++ b/kmicromail/libmailwrapper/pop3wrapper.cpp
@@ -25,237 +25,235 @@ POP3wrapper::POP3wrapper( POP3account *a )
 
 POP3wrapper::~POP3wrapper() {
     logout();
     QFile msg_cache(msgTempName);
     if (msg_cache.exists()) {
         msg_cache.remove();
     }
 }
 
 void POP3wrapper::pop3_progress( size_t current, size_t maximum ) {
     ; // odebug << "POP3: " << current << " of " << maximum << "" << oendl; 
 }
 
 RecBodyP POP3wrapper::fetchBody( const RecMailP &mail ) {
     int err = MAILPOP3_NO_ERROR;
     char *message = 0;
     size_t length = 0;
 
     RecBodyP body = new RecBody();
 
     login();
     if ( !m_pop3 ) {
         return body;
     }
 
     mailmessage * mailmsg;
     if (mail->Msgsize()>HARD_MSG_SIZE_LIMIT) {
         ; // odebug << "Message to large: " << mail->Msgsize() << "" << oendl; 
         return body;
     }
 
     QFile msg_cache(msgTempName);
 
     cleanMimeCache();
 
     if (mail->getNumber()!=last_msg_id) {
         if (msg_cache.exists()) {
             msg_cache.remove();
         }
         msg_cache.open(IO_ReadWrite|IO_Truncate);
         last_msg_id = mail->getNumber();
         err = mailsession_get_message(m_pop3->sto_session, mail->getNumber(), &mailmsg);
         err = mailmessage_fetch(mailmsg,&message,&length);
         msg_cache.writeBlock(message,length);
     } else {
         QString msg="";
         msg_cache.open(IO_ReadOnly);
         message = new char[4096];
         memset(message,0,4096);
         while (msg_cache.readBlock(message,4095)>0) {
             msg+=message;
             memset(message,0,4096);
         }
         delete message;
         message = (char*)malloc(msg.length()+1*sizeof(char));
         memset(message,0,msg.length()+1);
         memcpy(message,msg.latin1(),msg.length());
         /* transform to libetpan stuff */
         mailmsg = mailmessage_new();
         mailmessage_init(mailmsg, NULL, data_message_driver, 0, strlen(message));
         generic_message_t * msg_data;
         msg_data = (generic_message_t *)mailmsg->msg_data;
         msg_data->msg_fetched = 1;
         msg_data->msg_message = message;
         msg_data->msg_length = strlen(message);
     }
     body = parseMail(mailmsg);
 
     /* clean up */
     if (mailmsg)
         mailmessage_free(mailmsg);
     if (message)
         free(message);
 
     return body;
 }
 
 void POP3wrapper::listMessages(const QString &, QValueList<Opie::Core::OSmartPointer<RecMail> > &target, int maxSizeInKb )
 {
     login();
     if (!m_pop3)
         return;
     uint32_t res_messages,res_recent,res_unseen;
     mailsession_status_folder(m_pop3->sto_session,"INBOX",&res_messages,&res_recent,&res_unseen);
     parseList(target,m_pop3->sto_session,"INBOX", false, maxSizeInKb);
     Global::statusMessage( tr("Mailbox contains %1 mail(s)").arg(res_messages));
 }
 
 void POP3wrapper::login()
 {
     if (account->getOffline())
         return;
     /* we'll hold the line */
     if ( m_pop3 != NULL )
         return;
 
-    const char *server, *user, *pass;
+    QString server,user, pass;
     uint16_t port;
     int err = MAILPOP3_NO_ERROR;
 
     server = account->getServer().latin1();
     port = account->getPort().toUInt();
 
     if ( account->getUser().isEmpty() || account->getPassword().isEmpty() ) {
         LoginDialog login( account->getUser(), account->getPassword(), NULL, 0, true );
         login.show();
         if ( QDialog::Accepted == login.exec() ) {
             // ok
-            user = login.getUser().latin1();
-            pass = login.getPassword().latin1();
+            qDebug("ok ");
+            user = login.getUser();
+            pass = login.getPassword();
         } else {
             // cancel
             ; // odebug << "POP3: Login canceled" << oendl; 
             return;
         }
     } else {
-        user = account->getUser().latin1();
-        pass = account->getPassword().latin1();
+        user = account->getUser();
+        pass = account->getPassword();
     }
-
     //  bool ssl = account->getSSL();
 
     m_pop3=mailstorage_new(NULL);
-
     int conntypeset = account->ConnectionType();
     int conntype = 0;
     if ( conntypeset == 3 ) {
         conntype = CONNECTION_TYPE_COMMAND;
     } else if ( conntypeset == 2 ) {
         conntype = CONNECTION_TYPE_TLS;
     } else if ( conntypeset == 1 ) {
         conntype = CONNECTION_TYPE_STARTTLS;
     } else if ( conntypeset == 0 ) {
         conntype = CONNECTION_TYPE_TRY_STARTTLS;
     }
 
     //(ssl?CONNECTION_TYPE_TLS:CONNECTION_TYPE_PLAIN);
 
-    pop3_mailstorage_init(m_pop3,(char*)server, port, NULL, conntype, POP3_AUTH_TYPE_PLAIN,
-                          (char*)user,(char*)pass,0,0,0);
-
+    pop3_mailstorage_init(m_pop3,(char*)server.latin1(), port, NULL, conntype, POP3_AUTH_TYPE_PLAIN,
+                          (char*)user.latin1(),(char*)pass.latin1(),0,0,0);
 
     err = mailstorage_connect(m_pop3);
     if (err != MAIL_NO_ERROR) {
         ; // odebug << QString( "FEHLERNUMMER %1" ).arg(  err ) << oendl; 
         Global::statusMessage(tr("Error initializing folder"));
         mailstorage_free(m_pop3);
         m_pop3 = 0;
     } else {
         mailsession * session = m_pop3->sto_session;
         mailpop3 * mail =  ( (  pop3_session_state_data * )session->sess_data )->pop3_session;
         if (mail) {
             mail->pop3_progr_fun = &pop3_progress;
         }
     }
 }
 
 void POP3wrapper::logout()
 {
     if ( m_pop3 == NULL )
         return;
     mailstorage_free(m_pop3);
     m_pop3 = 0;
 }
 
 
 QValueList<Opie::Core::OSmartPointer<Folder> >* POP3wrapper::listFolders() {
     QValueList<Opie::Core::OSmartPointer<Folder> >* folders = new QValueList<FolderP>();
     FolderP inb=new Folder("INBOX","/");
     folders->append(inb);
     return folders;
 }
 
 void POP3wrapper::deleteMailList(const QValueList<RecMailP>&target)
 {
     login();
     if (!m_pop3)
         return;
     int iii = 0;
     int count = target.count(); 
     QProgressBar bar( count,0 );
     bar.setCaption (("Removing mails - close to abort!") );
     int w = 300;
     if ( QApplication::desktop()->width() < 320 )
         w = 220;
     int h = bar.sizeHint().height() ;
     int dw = QApplication::desktop()->width();
     int dh = QApplication::desktop()->height();
     bar.setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
     bar.show();
     int modulo = (count/10)+1;
     int incCounter = 0;
     while (iii < count ) {  
         if ( ! bar.isVisible() )
             return ;  
         if ( incCounter % modulo == 0 )
             bar.setProgress( incCounter );
         ++incCounter;
         qApp->processEvents();
         //qDebug("delete ");
         RecMailP mail = (*target.at( iii ));
         int err = mailsession_remove_message(m_pop3->sto_session,mail->getNumber());
         if (err != MAIL_NO_ERROR) {
             Global::statusMessage(tr("Error deleting mail"));
         }
         ++iii;
     }
 }
 void POP3wrapper::deleteMail(const RecMailP&mail) {
     login();
     if (!m_pop3)
         return;
     int err = mailsession_remove_message(m_pop3->sto_session,mail->getNumber());
     if (err != MAIL_NO_ERROR) {
         Global::statusMessage(tr("error deleting mail"));
     }
 }
 
 void POP3wrapper::answeredMail(const RecMailP&) {}
 
 int POP3wrapper::deleteAllMail(const FolderP&) {
     login();
     if (!m_pop3)
         return 0;
     int res = 1;
 
     uint32_t result = 0;
     int err = mailsession_messages_number(m_pop3->sto_session,NULL,&result);
     if (err != MAIL_NO_ERROR) {
         Global::statusMessage(tr("Error getting folder info"));
         return 0;
     }
     QProgressBar bar( result,0 );
     bar.setCaption (("Deleting mails - close to abort!") );
     int w = 300;
     if ( QApplication::desktop()->width() < 320 )
         w = 220;
diff --git a/kmicromail/libmailwrapper/smtpwrapper.cpp b/kmicromail/libmailwrapper/smtpwrapper.cpp
index 6a1b505..d5a528c 100644
--- a/kmicromail/libmailwrapper/smtpwrapper.cpp
+++ b/kmicromail/libmailwrapper/smtpwrapper.cpp
@@ -89,281 +89,280 @@ void SMTPwrapper::progress( size_t current, size_t maximum ) {
     if (SMTPwrapper::sendProgress) {
         SMTPwrapper::sendProgress->setSingleMail(current, maximum );
         qApp->processEvents();
     }
 }
 
 void SMTPwrapper::storeMail(const char*mail, size_t length, const QString&box) {
     if (!mail)
         return;
     QString localfolders = AbstractMail::defaultLocalfolder();
     AbstractMail*wrap = AbstractMail::getWrapper(localfolders);
     wrap->createMbox(box);
     wrap->storeMessage(mail,length,box);
     delete wrap;
 }
 
 bool SMTPwrapper::smtpSend( mailmime *mail,bool later) {
     clist *rcpts = 0;
     char *from, *data;
     size_t size;
 
     from = data = 0;
 
     mailmessage * msg = 0;
     msg = mime_message_init(mail);
     mime_message_set_tmpdir(msg,getenv( "HOME" ));
     int r = mailmessage_fetch(msg,&data,&size);
     mime_message_detach_mime(msg);
     mailmessage_free(msg);
     if (r != MAIL_NO_ERROR || !data) {
         if (data)
             free(data);
         qDebug("Error fetching mime... ");
         return false;
     }
     msg = 0;
     if (later) {
         storeMail(data,size,"Outgoing");
         if (data)
             free( data );
         Config cfg( "mail" );
         cfg.setGroup( "Status" );
         cfg.writeEntry( "outgoing", ++m_queuedMail );
         emit queuedMails( m_queuedMail );
         return true;
     }
     from = getFrom( mail );
     rcpts = createRcptList( mail->mm_data.mm_message.mm_fields );
     bool result = smtpSend(from,rcpts,data,size);
     if (data) {
         free(data);
     }
     if (from) {
         free(from);
     }
     if (rcpts)
         smtp_address_list_free( rcpts );
     return result;
 }
 
 void SMTPwrapper::storeFailedMail(const char*data,unsigned int size, const char*failuremessage)
 {
     if (data) {
         storeMail(data,size,"Sendfailed");
     }
     if (failuremessage) {
         QMessageBox::critical(0,tr("Error sending mail"),
             tr("<center>%1</center>").arg(failuremessage));
     }
 }
 
 int SMTPwrapper::start_smtp_tls()
 {
     if (!m_smtp) {
         return MAILSMTP_ERROR_IN_PROCESSING;
     }
     int err = mailesmtp_starttls(m_smtp);
     if (err != MAILSMTP_NO_ERROR) return err;
     mailstream_low * low;
     mailstream_low * new_low;
     low = mailstream_get_low(m_smtp->stream);
     if (!low) {
         return MAILSMTP_ERROR_IN_PROCESSING;
     }
     int fd = mailstream_low_get_fd(low);
     if (fd > -1 && (new_low = mailstream_low_ssl_open(fd))!=0) {
         mailstream_low_free(low);
         mailstream_set_low(m_smtp->stream, new_low);
     } else {
         return MAILSMTP_ERROR_IN_PROCESSING;
     }
     return err;
 }
 
 void SMTPwrapper::connect_server()
 {
-    const char *server, *user, *pass;
+    QString server, user, pass;
     bool ssl;
     uint16_t port;
     ssl = false;
     bool try_tls = true;
     bool force_tls=false;
-    server = user = pass = 0;
     QString failuretext = "";
 
     if (m_smtp || !m_SmtpAccount) {
         return;
     }
-    server = m_SmtpAccount->getServer().latin1();
+    server = m_SmtpAccount->getServer();
     if  ( m_SmtpAccount->ConnectionType() == 2 ) {
         ssl = true;
         try_tls = false;
     } else if (m_SmtpAccount->ConnectionType() == 1) {
         force_tls = true;
     }
     int result = 1;
     port = m_SmtpAccount->getPort().toUInt();
 
     m_smtp = mailsmtp_new( 20, &progress );
     if ( m_smtp == NULL ) {
         /* no failure message cause this happens when problems with memory - than we
            we can not display any messagebox */
         return;
     }
 
     int err = MAILSMTP_NO_ERROR;
     ; // odebug << "Servername " << server << " at port " << port << "" << oendl; 
     if ( ssl ) {
         ; // odebug << "SSL session" << oendl; 
-        err = mailsmtp_ssl_connect( m_smtp, server, port );
+        err = mailsmtp_ssl_connect( m_smtp, server.latin1(), port );
     } else {
         ; // odebug << "No SSL session" << oendl; 
-        err = mailsmtp_socket_connect( m_smtp, server, port );
+        err = mailsmtp_socket_connect( m_smtp, server.latin1(), port );
     }
     if ( err != MAILSMTP_NO_ERROR ) {
         ; // odebug << "Error init connection" << oendl; 
         failuretext = tr("Error init SMTP connection: %1").arg(mailsmtpError(err));
         result = 0;
     }
 
     /* switch to tls after init 'cause there it will send the ehlo */
     if (result) {
         err = mailsmtp_init( m_smtp );
         if (err != MAILSMTP_NO_ERROR) {
             result = 0;
             failuretext = tr("Error init SMTP connection: %1").arg(mailsmtpError(err));
         }
     }
 
     if (try_tls) {
         err = start_smtp_tls();
         if (err != MAILSMTP_NO_ERROR) {
             try_tls = false;
         } else {
             err = mailesmtp_ehlo(m_smtp);
         }
     }
 
     if (!try_tls && force_tls) {
         result = 0;
         failuretext = tr("Error init SMTP tls: %1").arg(mailsmtpError(err));
     }
 
     if (result==1 && m_SmtpAccount->getLogin() ) {
         ; // odebug << "smtp with auth" << oendl; 
         if ( m_SmtpAccount->getUser().isEmpty() || m_SmtpAccount->getPassword().isEmpty() ) {
             // get'em
             LoginDialog login( m_SmtpAccount->getUser(),
                 m_SmtpAccount->getPassword(), NULL, 0, true );
             login.show();
             if ( QDialog::Accepted == login.exec() ) {
                 // ok
-                user = login.getUser().latin1();
-                pass = login.getPassword().latin1();
+                user = login.getUser();
+                pass = login.getPassword();
             } else {
                 result = 0;
                 failuretext=tr("Login aborted - storing mail to localfolder");
             }
         } else {
-            user = m_SmtpAccount->getUser().latin1();
-            pass = m_SmtpAccount->getPassword().latin1();
+            user = m_SmtpAccount->getUser();
+            pass = m_SmtpAccount->getPassword();
         }
         ; // odebug << "session->auth: " << m_smtp->auth << "" << oendl; 
         if (result) {
-            err = mailsmtp_auth( m_smtp, (char*)user, (char*)pass );
+            err = mailsmtp_auth( m_smtp, (char*)user.latin1(), (char*)pass.latin1() );
             if ( err == MAILSMTP_NO_ERROR ) {
                 ; // odebug << "auth ok" << oendl; 
             } else {
                 failuretext = tr("Authentification failed");
                 result = 0;
             }
         }
     }
 }
 
 void SMTPwrapper::disc_server()
 {
     if (m_smtp) {
         mailsmtp_quit( m_smtp );
         mailsmtp_free( m_smtp );
         m_smtp = 0;
     }
 }
 
 int SMTPwrapper::smtpSend(char*from,clist*rcpts,const char*data,size_t size )
 {
     int err,result;
     QString failuretext = "";
 
     connect_server();
 
     result = 1;
     if (m_smtp) {
         err = mailsmtp_send( m_smtp, from, rcpts, data, size );
         if ( err != MAILSMTP_NO_ERROR ) {
             failuretext=tr("Error sending mail: %1").arg(mailsmtpError(err));
             result = 0;
         }
     } else {
         result = 0;
     }
 
     if (!result) {
         storeFailedMail(data,size,failuretext);
     } else {
         ; // odebug << "Mail sent." << oendl; 
         storeMail(data,size,"Sent");
     }
     return result;
 }
 
 bool SMTPwrapper::sendMail(const Opie::Core::OSmartPointer<Mail>&mail,bool later )
 {
     mailmime * mimeMail;
     bool result = true;
     mimeMail = createMimeMail(mail );
     if ( mimeMail == 0 ) {
         qDebug("SMTP wrapper:Error creating mail! ");
         return false;
     } else {
         sendProgress = new progressMailSend();
         sendProgress->show();
         sendProgress->setMaxMails(1);
         result = smtpSend( mimeMail,later);
         ; // odebug << "Clean up done" << oendl; 
         sendProgress->hide();
         delete sendProgress;
         sendProgress = 0;
         mailmime_free( mimeMail );
     }
     return result;
 }
 
 int SMTPwrapper::sendQueuedMail(AbstractMail*wrap,const RecMailP&which) {
     size_t curTok = 0;
     mailimf_fields *fields = 0;
     mailimf_field*ffrom = 0;
     clist *rcpts = 0;
     char*from = 0;
     int res = 0;
 
     encodedString * data = wrap->fetchRawBody(which);
     if (!data)
         return 0;
     int err = mailimf_fields_parse( data->Content(), data->Length(), &curTok, &fields );
     if (err != MAILIMF_NO_ERROR) {
         delete data;
         delete wrap;
         return 0;
     }
 
     rcpts = createRcptList( fields );
     ffrom = getField(fields, MAILIMF_FIELD_FROM );
     from = getFrom(ffrom);
 
     if (rcpts && from) {
         res = smtpSend(from,rcpts,data->Content(),data->Length());
     }
     if (fields) {
         mailimf_fields_free(fields);
         fields = 0;