beginning of the new mailer

8 files changed, 1967 insertions, 0 deletions

diff --git a/noncore/net/mail/libmailwrapper/imapwrapper.cpp b/noncore/net/mail/libmailwrapper/imapwrapper.cpp
new file mode 100644
index 0000000..16f4565
--- a/dev/null
+++ b/noncore/net/mail/libmailwrapper/imapwrapper.cpp
@@ -0,0 +1,411 @@
+
+#include <stdlib.h>
+
+#include "mailwrapper.h"
+
+
+IMAPwrapper::IMAPwrapper( IMAPaccount *a )
+{
+    account = a;
+}
+
+void imap_progress( size_t current, size_t maximum )
+{
+    qDebug( "IMAP: %i of %i", current, maximum );
+}
+
+void IMAPwrapper::listMessages(const QString&mailbox,Maillist&target )
+{
+    const char *server, *user, *pass, *mb;
+    uint16_t port;
+    int err = MAILIMAP_NO_ERROR;
+    clist *result;
+    clistcell *current;
+    mailimap_fetch_att *fetchAtt,*fetchAttFlags;
+    mailimap_fetch_type *fetchType;
+    mailimap_set *set;
+    
+    mb = mailbox.latin1();
+    server = account->getServer().latin1();
+    port = account->getPort().toUInt();
+    user = account->getUser().latin1();
+    pass = account->getPassword().latin1();
+    
+    mailimap *imap = mailimap_new( 20, &imap_progress ); 
+    if ( imap == NULL ) {
+        qDebug("IMAP Memory error");
+        return;
+    }
+
+    /* connect */
+    err = mailimap_socket_connect( imap, (char*)server, port );
+    if ( err != MAILIMAP_NO_ERROR &&  
+         err != MAILIMAP_NO_ERROR_AUTHENTICATED &&
+         err != MAILIMAP_NO_ERROR_NON_AUTHENTICATED ) {
+         qDebug("error connecting server: %s",imap->response);
+         mailimap_free( imap );
+         return;
+    }
+    
+    /* login */
+    err = mailimap_login_simple( imap, (char*)user, (char*)pass );
+    if ( err != MAILIMAP_NO_ERROR ) {
+        qDebug("error logging in imap: %s",imap->response);
+        err = mailimap_close( imap );
+        mailimap_free( imap );
+        return;
+    }
+    
+    /* select mailbox READONLY for operations */
+    err = mailimap_examine( imap, (char*)mb);
+    if ( err != MAILIMAP_NO_ERROR ) {
+        qDebug("error selecting mailbox: %s",imap->response);
+        err = mailimap_logout( imap );
+        err = mailimap_close( imap );
+        mailimap_free( imap );
+        return;
+    }
+
+    int last = imap->selection_info->exists;
+    if (last == 0) {
+        qDebug("mailbox has no mails");
+        err = mailimap_logout( imap );
+        err = mailimap_close( imap );
+        mailimap_free( imap );
+        return;
+    }
+    
+    
+    result = clist_new();  
+    /* the range has to start at 1!!! not with 0!!!! */
+    set = mailimap_set_new_interval( 1, last );
+    fetchAtt = mailimap_fetch_att_new_envelope();
+    fetchAttFlags = mailimap_fetch_att_new_flags();
+    
+    //fetchType = mailimap_fetch_type_new_fetch_att(fetchAtt);
+    fetchType = mailimap_fetch_type_new_fetch_att_list_empty();
+    mailimap_fetch_type_new_fetch_att_list_add(fetchType,fetchAtt);
+    mailimap_fetch_type_new_fetch_att_list_add(fetchType,fetchAttFlags);
+    
+    err = mailimap_fetch( imap, set, fetchType, &result );
+    mailimap_set_free( set );
+    mailimap_fetch_type_free( fetchType );
+
+    QString date,subject,from;
+
+    if ( err == MAILIMAP_NO_ERROR ) {
+        current = clist_begin(result);
+        mailimap_msg_att * msg_att;
+        int i = 0;
+        while ( current != 0 ) {
+            ++i;
+            msg_att = (mailimap_msg_att*)current->data;
+            RecMail*m = parse_list_result(msg_att);
+            if (m) {
+                m->setNumber(i);
+                target.append(m);
+            }
+            current = current->next;
+        }
+    } else {
+        qDebug("Error fetching headers: %s",imap->response);
+    }   
+
+    err = mailimap_logout( imap );
+    err = mailimap_close( imap );
+    clist_free(result);
+    mailimap_free( imap );
+}
+
+QList<IMAPFolder>* IMAPwrapper::listFolders()
+{
+    const char *server, *user, *pass, *path, *mask;
+    uint16_t port;
+    int err = MAILIMAP_NO_ERROR;
+    clist *result;
+    clistcell *current;
+   
+    QList<IMAPFolder> * folders = new QList<IMAPFolder>();
+    folders->setAutoDelete( true );
+        
+    server = account->getServer().latin1();
+    port = account->getPort().toUInt();
+    user = account->getUser().latin1();
+    pass = account->getPassword().latin1();
+    path = account->getPrefix().latin1();
+    
+    mailimap *imap = mailimap_new( 20, &imap_progress ); 
+    if ( imap == NULL ) {
+        qDebug("error mailimap_new");
+        return folders;
+    }
+    
+    err = mailimap_socket_connect( imap, (char*)server, port );
+    if ( err != MAILIMAP_NO_ERROR &&  
+         err != MAILIMAP_NO_ERROR_AUTHENTICATED &&
+         err != MAILIMAP_NO_ERROR_NON_AUTHENTICATED ) {
+         mailimap_free(imap);
+         qDebug("error imap_socket_connect: %s",imap->response);
+         return folders;
+    }
+        
+    err = mailimap_login_simple( imap, (char*)user, (char*)pass );
+    if ( err != MAILIMAP_NO_ERROR ) {
+        mailimap_free(imap);
+        qDebug("error logging in: %s",imap->response);
+        return folders;
+    }
+/*
+ * First we have to check for INBOX 'cause it sometimes it's not inside the path.
+ * We must not forget to filter them out in next loop!
+ * it seems like ugly code. and yes - it is ugly code. but the best way.
+ */
+    QString temp;
+    mask = "INBOX" ;
+    result = clist_new();
+    mailimap_mailbox_list *list;
+    err = mailimap_list( imap, (char*)"", (char*)mask, &result );
+    if ( err == MAILIMAP_NO_ERROR ) {
+        current = result->first;
+        for ( int i = result->count; i > 0; i-- ) {
+            list = (mailimap_mailbox_list *) current->data;
+            // it is better use the deep copy mechanism of qt itself
+            // instead of using strdup!
+            temp = list->mb;
+            folders->append( new IMAPFolder(temp));
+            current = current->next;
+        }
+    } else {
+        qDebug("error fetching folders: %s",imap->response);
+    }
+    mailimap_list_result_free( result );
+    
+/*
+ * second stage - get the other then inbox folders
+ */
+    mask = "*" ;    
+    result = clist_new();
+    err = mailimap_list( imap, (char*)path, (char*)mask, &result );
+    if ( err == MAILIMAP_NO_ERROR ) {
+        current = result->first;
+        for ( int i = result->count; i > 0; i-- ) {
+            list = (mailimap_mailbox_list *) current->data;
+            // it is better use the deep copy mechanism of qt itself
+            // instead of using strdup!
+            temp = list->mb;
+            current = current->next;
+            if (temp.lower()=="inbox")
+                continue;
+            folders->append(new IMAPFolder(temp));
+            
+        }
+    } else {
+        qDebug("error fetching folders");
+    }
+    mailimap_list_result_free( result );
+    err = mailimap_logout( imap );
+    err = mailimap_close( imap );
+    mailimap_free( imap );     
+    return folders;
+}
+
+RecMail*IMAPwrapper::parse_list_result(mailimap_msg_att* m_att)
+{
+    RecMail * m = 0;
+    mailimap_msg_att_item *item=0;
+    bool named_from = false;
+    QString from,date,subject;
+    date = from = subject = "";
+    clistcell *current,*c,*cf, *current_from = NULL;
+    mailimap_address * current_address = NULL;
+    mailimap_msg_att_dynamic*flist;
+    mailimap_flag_fetch*cflag;
+    QBitArray mFlags(7);
+    
+    if (!m_att) {
+        return m;
+    }
+
+#if 0
+   MAILIMAP_FLAG_KEYWORD,   /* keyword flag */
+   MAILIMAP_FLAG_EXTENSION, /* \extension flag */
+#endif
+    c = clist_begin(m_att->list);
+    while ( c ) {
+        current = c;
+        c = c->next;
+        item = (mailimap_msg_att_item*)current->data;
+        if (item->type!=MAILIMAP_MSG_ATT_ITEM_STATIC) {
+            flist = (mailimap_msg_att_dynamic*)item->msg_att_dyn;
+            if (!flist->list) {
+                continue;
+            }
+            cf = flist->list->first;
+            while (cf) {
+                cflag = (mailimap_flag_fetch*)cf->data;
+                if (cflag->type==MAILIMAP_FLAG_FETCH_OTHER && cflag->flag!=0) {
+                    switch (cflag->flag->type) {
+                    case MAILIMAP_FLAG_ANSWERED:  /* \Answered flag */
+                        mFlags.setBit(FLAG_ANSWERED);
+                        break;
+                    case MAILIMAP_FLAG_FLAGGED:   /* \Flagged flag */
+                        mFlags.setBit(FLAG_FLAGGED);
+                        break;
+                    case MAILIMAP_FLAG_DELETED:   /* \Deleted flag */
+                        mFlags.setBit(FLAG_DELETED);
+                        break;
+                    case MAILIMAP_FLAG_SEEN:      /* \Seen flag */
+                        mFlags.setBit(FLAG_SEEN);
+                        break;
+                    case MAILIMAP_FLAG_DRAFT:     /* \Draft flag */
+                        mFlags.setBit(FLAG_DRAFT);
+                        break;
+                    case MAILIMAP_FLAG_KEYWORD:   /* keyword flag */
+                        break;
+                    case MAILIMAP_FLAG_EXTENSION: /* \extension flag */
+                        break;
+                    default:
+                        break;
+                    }
+                } else if (cflag->type==MAILIMAP_FLAG_FETCH_RECENT) {
+                    mFlags.setBit(FLAG_RECENT);
+                }
+                
+                cf = cf->next;
+            }
+            continue;
+        }
+        if ( item->msg_att_static->type == MAILIMAP_MSG_ATT_RFC822_HEADER ) {
+            qDebug( "header: \n%s", item->msg_att_static->rfc822_header );
+        } else if (item->msg_att_static->type==MAILIMAP_MSG_ATT_ENVELOPE) {
+            mailimap_envelope * head = item->msg_att_static->env;
+            date = head->date;
+            subject = head->subject;
+            if (head->from!=NULL)
+                current_from = head->from->list->first;
+            while (current_from != NULL) {
+                from = "";
+                named_from = false;
+                current_address=(mailimap_address*)current_from->data;
+                current_from = current_from->next;
+                if (current_address->personal_name){
+                    from+=QString(current_address->personal_name);
+                    from+=" ";
+                    named_from = true;
+                }
+                if (named_from && (current_address->mailbox_name || current_address->host_name)) {
+                    from+="<";
+                }
+                if (current_address->mailbox_name) {
+                    from+=QString(current_address->mailbox_name);
+                    from+="@";
+                }
+                if (current_address->host_name) {
+                    from+=QString(current_address->host_name);
+                }
+                if (named_from && (current_address->mailbox_name || current_address->host_name)) {
+                    from+=">";
+                }
+            }
+            qDebug("header: \nFrom: %s\nSubject: %s\nDate: %s",
+                   from.latin1(),
+                   subject.latin1(),date.latin1());
+            m = new RecMail();
+            m->setSubject(subject);
+            m->setFrom(from);
+            m->setDate(date);
+        } else {
+            qDebug("Another type");
+        }
+    }
+    /* msg is already deleted */
+    if (mFlags.testBit(FLAG_DELETED) && m) {
+        delete m;
+        m = 0;
+    }
+    if (m) {
+        m->setFlags(mFlags);
+    }
+    return m;
+}
+
+QString IMAPwrapper::fetchBody(const QString & mailbox,const RecMail&mail)
+{
+    QString body = "";
+    const char *server, *user, *pass, *mb;
+    uint16_t port;
+    int err = MAILIMAP_NO_ERROR;
+    clist *result;
+    clistcell *current;
+    mailimap_fetch_att *fetchAtt;
+    mailimap_fetch_type *fetchType;
+    mailimap_set *set;
+    
+    mb = mailbox.latin1();
+    server = account->getServer().latin1();
+    port = account->getPort().toUInt();
+    user = account->getUser().latin1();
+    pass = account->getPassword().latin1();
+    
+    mailimap *imap = mailimap_new( 20, &imap_progress ); 
+    if ( imap == NULL ) {
+        qDebug("IMAP Memory error");
+        return body;
+    }
+
+    /* connect */
+    err = mailimap_socket_connect( imap, (char*)server, port );
+    if ( err != MAILIMAP_NO_ERROR &&  
+         err != MAILIMAP_NO_ERROR_AUTHENTICATED &&
+         err != MAILIMAP_NO_ERROR_NON_AUTHENTICATED ) {
+         qDebug("error connecting server: %s",imap->response);
+         mailimap_free( imap );
+         return body;
+    }
+    
+    /* login */
+    err = mailimap_login_simple( imap, (char*)user, (char*)pass );
+    if ( err != MAILIMAP_NO_ERROR ) {
+        qDebug("error logging in imap: %s",imap->response);
+        err = mailimap_close( imap );
+        mailimap_free( imap );
+        return body;
+    }
+    
+    /* select mailbox READONLY for operations */
+    err = mailimap_examine( imap, (char*)mb);
+    if ( err != MAILIMAP_NO_ERROR ) {
+        qDebug("error selecting mailbox: %s",imap->response);
+        err = mailimap_logout( imap );
+        err = mailimap_close( imap );
+        mailimap_free( imap );
+        return body;
+    }
+    result = clist_new();  
+    /* the range has to start at 1!!! not with 0!!!! */
+    set = mailimap_set_new_interval( mail.getNumber(),mail.getNumber() );
+    fetchAtt = mailimap_fetch_att_new_rfc822_text();
+    fetchType = mailimap_fetch_type_new_fetch_att(fetchAtt);
+    err = mailimap_fetch( 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*item = (mailimap_msg_att_item*)msg_att->list->first->data;
+
+        if (item->msg_att_static && item->msg_att_static->rfc822_text) {
+            body = item->msg_att_static->rfc822_text;
+        }
+    } else {
+        qDebug("error fetching text: %s",imap->response);
+    }
+    
+    err = mailimap_logout( imap );
+    err = mailimap_close( imap );
+    mailimap_free( imap );
+    clist_free(result);
+    
+    return body;
+}
diff --git a/noncore/net/mail/libmailwrapper/logindialog.cpp b/noncore/net/mail/libmailwrapper/logindialog.cpp
new file mode 100644
index 0000000..d2c6a07
--- a/dev/null
+++ b/noncore/net/mail/libmailwrapper/logindialog.cpp
@@ -0,0 +1,26 @@
+#include <qlineedit.h>
+
+#include "logindialog.h"
+
+LoginDialog::LoginDialog( QString user, QString pass, QWidget *parent, const char *name, bool modal, WFlags flags )
+    : LoginDialogUI( parent, name, modal, flags )
+{
+    userLine->setText( user );
+    passLine->setText( pass );
+    _user = user;
+    _pass = pass;
+
+    if ( user.isEmpty() ) {
+        userLine->setFocus();
+    } else {
+        passLine->setFocus();
+    }
+}
+
+void LoginDialog::accept()
+{
+    _user.replace( 0, _user.length(), userLine->text() );
+    _pass.replace( 0, _pass.length(), passLine->text() );
+
+    QDialog::accept();
+}
diff --git a/noncore/net/mail/libmailwrapper/logindialog.h b/noncore/net/mail/libmailwrapper/logindialog.h
new file mode 100644
index 0000000..7a0d1b0
--- a/dev/null
+++ b/noncore/net/mail/libmailwrapper/logindialog.h
@@ -0,0 +1,23 @@
+#ifndef LOGINDIALOG_H
+#define LOGINDIALOG_H
+
+#include "logindialogui.h"
+
+class LoginDialog : public LoginDialogUI
+{
+    Q_OBJECT
+
+public:
+    LoginDialog( QString user, QString pass, QWidget *parent = 0, const char *name = 0, bool modal = false, WFlags flags = 0 );
+    QString getUser() { return _user; }
+    QString getPassword() { return _pass; }
+
+protected slots:
+    void accept();
+
+private:
+    QString _user, _pass;
+
+};
+
+#endif
diff --git a/noncore/net/mail/libmailwrapper/logindialogui.ui b/noncore/net/mail/libmailwrapper/logindialogui.ui
new file mode 100644
index 0000000..565f777
--- a/dev/null
+++ b/noncore/net/mail/libmailwrapper/logindialogui.ui
@@ -0,0 +1,83 @@
+<!DOCTYPE UI><UI>
+<class>LoginDialogUI</class>
+<widget>
+    <class>QDialog</class>
+    <property stdset="1">
+        <name>name</name>
+        <cstring>LoginDialogUI</cstring>
+    </property>
+    <property stdset="1">
+        <name>geometry</name>
+        <rect>
+            <x>0</x>
+            <y>0</y>
+            <width>196</width>
+            <height>110</height>
+        </rect>
+    </property>
+    <property stdset="1">
+        <name>caption</name>
+        <string>Login</string>
+    </property>
+    <property>
+        <name>layoutMargin</name>
+    </property>
+    <property>
+        <name>layoutSpacing</name>
+    </property>
+    <grid>
+        <property stdset="1">
+            <name>margin</name>
+            <number>4</number>
+        </property>
+        <property stdset="1">
+            <name>spacing</name>
+            <number>3</number>
+        </property>
+        <widget row="0"  column="0" >
+            <class>QLabel</class>
+            <property stdset="1">
+                <name>name</name>
+                <cstring>userLabel</cstring>
+            </property>
+            <property stdset="1">
+                <name>text</name>
+                <string>User</string>
+            </property>
+        </widget>
+        <widget row="1"  column="0" >
+            <class>QLineEdit</class>
+            <property stdset="1">
+                <name>name</name>
+                <cstring>userLine</cstring>
+            </property>
+        </widget>
+        <widget row="3"  column="0" >
+            <class>QLineEdit</class>
+            <property stdset="1">
+                <name>name</name>
+                <cstring>passLine</cstring>
+            </property>
+            <property stdset="1">
+                <name>echoMode</name>
+                <enum>Password</enum>
+            </property>
+        </widget>
+        <widget row="2"  column="0" >
+            <class>QLabel</class>
+            <property stdset="1">
+                <name>name</name>
+                <cstring>passLabel</cstring>
+            </property>
+            <property stdset="1">
+                <name>text</name>
+                <string>Password</string>
+            </property>
+        </widget>
+    </grid>
+</widget>
+<tabstops>
+    <tabstop>userLine</tabstop>
+    <tabstop>passLine</tabstop>
+</tabstops>
+</UI>
diff --git a/noncore/net/mail/libmailwrapper/mailwrapper.cpp b/noncore/net/mail/libmailwrapper/mailwrapper.cpp
new file mode 100644
index 0000000..17bed65
--- a/dev/null
+++ b/noncore/net/mail/libmailwrapper/mailwrapper.cpp
@@ -0,0 +1,643 @@
+#include <qfileinfo.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <qdir.h>
+#include <qtextstream.h>
+
+#include "mailwrapper.h"
+#include "logindialog.h"
+#include "mail.h"
+#include "defines.h"
+
+Attachment::Attachment( DocLnk lnk )
+{ 
+    doc = lnk; 
+    size = QFileInfo( doc.file() ).size(); 
+}
+
+Folder::Folder(const QString&tmp_name )
+{
+    name = tmp_name;
+    nameDisplay = name;
+    
+    for ( int pos = nameDisplay.find( '&' ); pos != -1; 
+          pos = nameDisplay.find( '&' ) ) {
+        int end = nameDisplay.find( '-' );
+        if ( end == -1 || end <= pos ) break;
+        QString str64 = nameDisplay.mid( pos + 1, end - pos - 1 );
+        // TODO: do real base64 decoding here !
+        if ( str64.compare( "APw" ) == 0 ) {
+            nameDisplay = nameDisplay.replace( pos, end - pos + 1, "ue" );
+        } else if ( str64.compare( "APY" ) == 0 ) { 
+            nameDisplay = nameDisplay.replace( pos, end - pos + 1, "oe" );
+        }
+    }
+
+    qDebug( "folder " + name + " - displayed as " + nameDisplay );
+}
+
+MailWrapper::MailWrapper( Settings *s )
+    : QObject()
+{
+    settings = s;
+}
+
+QString MailWrapper::mailsmtpError( int errnum )
+{
+    switch ( errnum ) {
+        case MAILSMTP_NO_ERROR:
+            return tr( "No error" );
+        case MAILSMTP_ERROR_UNEXPECTED_CODE:
+            return tr( "Unexpected error code" );
+        case MAILSMTP_ERROR_SERVICE_NOT_AVAILABLE:
+            return tr( "Service not available" );
+        case MAILSMTP_ERROR_STREAM:
+            return tr( "Stream error" );
+        case MAILSMTP_ERROR_HOSTNAME:
+            return tr( "gethostname() failed" );
+        case MAILSMTP_ERROR_NOT_IMPLEMENTED:
+            return tr( "Not implemented" );
+        case MAILSMTP_ERROR_ACTION_NOT_TAKEN:
+            return tr( "Error, action not taken" );
+        case MAILSMTP_ERROR_EXCEED_STORAGE_ALLOCATION:
+            return tr( "Data exceeds storage allocation" );
+        case MAILSMTP_ERROR_IN_PROCESSING:
+            return tr( "Error in processing" );
+  //      case MAILSMTP_ERROR_INSUFFISANT_SYSTEM_STORAGE:
+    //        return tr( "Insufficient system storage" );
+        case MAILSMTP_ERROR_MAILBOX_UNAVAILABLE:
+            return tr( "Mailbox unavailable" );
+        case MAILSMTP_ERROR_MAILBOX_NAME_NOT_ALLOWED:
+            return tr( "Mailbox name not allowed" );
+        case MAILSMTP_ERROR_BAD_SEQUENCE_OF_COMMAND:
+            return tr( "Bad command sequence" );
+        case MAILSMTP_ERROR_USER_NOT_LOCAL:
+            return tr( "User not local" );
+        case MAILSMTP_ERROR_TRANSACTION_FAILED:
+            return tr( "Transaction failed" );
+        case MAILSMTP_ERROR_MEMORY:
+            return tr( "Memory error" );
+        case MAILSMTP_ERROR_CONNECTION_REFUSED:
+            return tr( "Connection refused" );
+        default:
+            return tr( "Unknown error code" );
+    }
+}
+
+mailimf_mailbox *MailWrapper::newMailbox(const QString&name, const QString&mail )
+{
+    return mailimf_mailbox_new( strdup( name.latin1() ), 
+                                strdup( mail.latin1() ) );
+}
+
+mailimf_address_list *MailWrapper::parseAddresses(const QString&addr )
+{
+    mailimf_address_list *addresses;
+        
+    if ( addr.isEmpty() ) return NULL;
+    
+    addresses = mailimf_address_list_new_empty();
+    
+    QStringList list = QStringList::split( ',', addr );
+    QStringList::Iterator it;
+    for ( it = list.begin(); it != list.end(); it++ ) {
+        char *str = strdup( (*it).latin1() );
+        int err = mailimf_address_list_add_parse( addresses, str );
+        if ( err != MAILIMF_NO_ERROR ) {
+            qDebug( "Error parsing" );
+            qDebug( *it );
+            free( str );
+        } else {
+            qDebug( "Parse success! :)" );
+        }
+    }
+    
+    return addresses;
+}
+
+mailimf_fields *MailWrapper::createImfFields( Mail *mail )
+{
+    mailimf_fields *fields;
+    mailimf_field *xmailer;
+    mailimf_mailbox *sender, *fromBox;
+    mailimf_mailbox_list *from;
+    mailimf_address_list *to, *cc, *bcc, *reply;
+    char *subject = strdup( mail->getSubject().latin1() );
+    int err;
+    
+    sender = newMailbox( mail->getName(), mail->getMail() );
+    if ( sender == NULL ) goto err_free;
+    
+    fromBox = newMailbox( mail->getName(), mail->getMail() );
+    if ( fromBox == NULL ) goto err_free_sender;
+    
+    from = mailimf_mailbox_list_new_empty();
+    if ( from == NULL ) goto err_free_fromBox;
+    
+    err = mailimf_mailbox_list_add( from, fromBox );
+    if ( err != MAILIMF_NO_ERROR ) goto err_free_from;
+    
+    to = parseAddresses( mail->getTo() );
+    if ( to == NULL ) goto err_free_from;
+
+    cc = parseAddresses( mail->getCC() );
+    bcc = parseAddresses( mail->getBCC() );
+    reply = parseAddresses( mail->getReply() );
+
+    fields = mailimf_fields_new_with_data( from, sender, reply, to, cc, bcc,
+                                           NULL, NULL, subject );
+    if ( fields == NULL ) goto err_free_reply;
+    
+    xmailer = mailimf_field_new_custom( strdup( "User-Agent" ),
+                                        strdup( USER_AGENT ) );
+    if ( xmailer == NULL ) goto err_free_fields;
+    
+    err = mailimf_fields_add( fields, xmailer );
+    if ( err != MAILIMF_NO_ERROR ) goto err_free_xmailer;
+    
+    return fields;      // Success :)
+
+err_free_xmailer:
+    mailimf_field_free( xmailer );
+err_free_fields:
+    mailimf_fields_free( fields );
+err_free_reply:
+    mailimf_address_list_free( reply );
+    mailimf_address_list_free( bcc );
+    mailimf_address_list_free( cc );
+    mailimf_address_list_free( to );
+err_free_from:
+    mailimf_mailbox_list_free( from );
+err_free_fromBox:
+    mailimf_mailbox_free( fromBox );
+err_free_sender:
+    mailimf_mailbox_free( sender );
+err_free:
+    free( subject );
+    qDebug( "createImfFields - error" );
+
+    return NULL;        // Error :(
+}
+
+mailmime *MailWrapper::buildTxtPart( QString str )
+{
+    mailmime *txtPart;
+    mailmime_fields *fields;
+    mailmime_content *content;
+    mailmime_parameter *param;
+    char *txt = strdup( str.latin1() );
+    int err;
+    
+    param = mailmime_parameter_new( strdup( "charset" ), 
+                                    strdup( "iso-8859-1" ) );
+    if ( param == NULL ) goto err_free;
+    
+    content = mailmime_content_new_with_str( "text/plain" );
+    if ( content == NULL ) goto err_free_param;
+    
+    err = clist_append( content->parameters, param );
+    if ( err != MAILIMF_NO_ERROR ) goto err_free_content;
+    
+    fields = mailmime_fields_new_encoding( MAILMIME_MECHANISM_8BIT );
+    if ( fields == NULL ) goto err_free_content;
+    
+    txtPart = mailmime_new_empty( content, fields );
+    if ( txtPart == NULL ) goto err_free_fields;
+    
+    err = mailmime_set_body_text( txtPart, txt, strlen( txt ) );
+    if ( err != MAILIMF_NO_ERROR ) goto err_free_txtPart;
+
+    return txtPart;     // Success :)
+
+err_free_txtPart:
+    mailmime_free( txtPart ); 
+err_free_fields:
+    mailmime_fields_free( fields );
+err_free_content:
+    mailmime_content_free( content ); 
+err_free_param:
+    mailmime_parameter_free( param );
+err_free:
+    free( txt );
+    qDebug( "buildTxtPart - error" );
+    
+    return NULL;        // Error :(
+}
+
+mailmime *MailWrapper::buildFilePart( QString filename, QString mimetype )
+{
+    mailmime * filePart;
+    mailmime_fields * fields;
+    mailmime_content * content;
+    mailmime_parameter * param = NULL;
+    int err;
+    
+    int pos = filename.findRev( '/' );
+    QString tmp = filename.right( filename.length() - ( pos + 1 ) );
+    char *name = strdup( tmp.latin1() );        // just filename
+    char *file = strdup( filename.latin1() );   // full name with path
+    char *mime = strdup( mimetype.latin1() );   // mimetype -e.g. text/plain
+ 
+    fields = mailmime_fields_new_filename( 
+        MAILMIME_DISPOSITION_TYPE_ATTACHMENT, name, 
+        MAILMIME_MECHANISM_BASE64 );
+    if ( fields == NULL ) goto err_free;
+    
+    content = mailmime_content_new_with_str( mime );
+    if ( content == NULL ) goto err_free_fields;
+    
+    if ( mimetype.compare( "text/plain" ) ==  0 ) {
+        param = mailmime_parameter_new( strdup( "charset" ), 
+                                        strdup( "iso-8859-1" ) );
+        if ( param == NULL ) goto err_free_content;
+    
+        err = clist_append( content->parameters, param );
+        if ( err != MAILIMF_NO_ERROR ) goto err_free_param;
+    }
+    
+    filePart = mailmime_new_empty( content, fields );
+    if ( filePart == NULL ) goto err_free_param;
+    
+    err = mailmime_set_body_file( filePart, file );
+    if ( err != MAILIMF_NO_ERROR ) goto err_free_filePart;
+    
+    return filePart;        // Success :)
+
+err_free_filePart:
+    mailmime_free( filePart );
+err_free_param:
+    if ( param != NULL ) mailmime_parameter_free( param );
+err_free_content:
+    mailmime_content_free( content );
+err_free_fields:
+    mailmime_fields_free( fields );
+err_free:
+    free( name );
+    free( mime );
+    free( file );
+    qDebug( "buildFilePart - error" );
+    
+    return NULL;            // Error :(
+}
+
+void MailWrapper::addFileParts( mailmime *message, QList<Attachment> files )
+{
+    Attachment *it;
+    for ( it = files.first(); it; it = files.next() ) {
+        qDebug( "Adding file" );
+        mailmime *filePart; 
+        int err;
+
+        filePart = buildFilePart( it->getFileName(), it->getMimeType() );
+        if ( filePart == NULL ) goto err_free;
+        
+        err = mailmime_smart_add_part( message, filePart );
+        if ( err != MAILIMF_NO_ERROR ) goto err_free_filePart;
+        
+        continue;           // Success :) 
+        
+    err_free_filePart:
+        mailmime_free( filePart );
+    err_free:
+        qDebug( "addFileParts: error adding file:" );
+        qDebug( it->getFileName() );
+    }
+}
+
+mailmime *MailWrapper::createMimeMail( Mail *mail )
+{
+    mailmime *message, *txtPart;
+    mailimf_fields *fields;
+    int err;
+
+    fields = createImfFields( mail );
+    if ( fields == NULL ) goto err_free;
+    
+    message = mailmime_new_message_data( NULL );
+    if ( message == NULL ) goto err_free_fields;
+    
+    mailmime_set_imf_fields( message, fields );
+
+    txtPart = buildTxtPart( mail->getMessage() );
+    if ( txtPart == NULL ) goto err_free_message;
+    
+    err = mailmime_smart_add_part( message, txtPart );
+    if ( err != MAILIMF_NO_ERROR ) goto err_free_txtPart;
+    
+    addFileParts( message, mail->getAttachments() );
+
+    return message;         // Success :)
+
+err_free_txtPart:
+    mailmime_free( txtPart );
+err_free_message:
+    mailmime_free( message );
+err_free_fields:
+    mailimf_fields_free( fields );
+err_free:
+    qDebug( "createMimeMail: error" );
+
+    return NULL;            // Error :(
+}
+
+mailimf_field *MailWrapper::getField( mailimf_fields *fields, int type )
+{
+    mailimf_field *field;
+    clistiter *it;
+
+    it = clist_begin( fields->list );
+    while ( it ) {
+        field = (mailimf_field *) it->data;
+        if ( field->type == type ) {
+            return field;
+        }
+        it = it->next;
+    }
+    
+    return NULL;
+}
+
+static void addRcpts( clist *list, mailimf_address_list *addr_list )
+{
+    clistiter *it, *it2;
+    
+    for ( it = clist_begin( addr_list->list ); it; it = it->next ) {
+        mailimf_address *addr;
+        addr = (mailimf_address *) it->data;
+        
+        if ( addr->type == MAILIMF_ADDRESS_MAILBOX ) {
+    	    esmtp_address_list_add( list, addr->mailbox->addr_spec, 0, NULL );
+        } else if ( addr->type == MAILIMF_ADDRESS_GROUP ) {
+            clist *l = addr->group->mb_list->list;
+    	    for ( it2 = clist_begin( l ); it2; it2 = it2->next ) {
+                mailimf_mailbox *mbox;
+    	        mbox = (mailimf_mailbox *) it2->data;
+	            esmtp_address_list_add( list, mbox->addr_spec, 0, NULL );
+	        }
+	    }
+    }
+}
+
+clist *MailWrapper::createRcptList( mailimf_fields *fields )
+{
+    clist *rcptList;
+    mailimf_field *field;
+
+    rcptList = esmtp_address_list_new();
+    
+    field = getField( fields, MAILIMF_FIELD_TO );
+    if ( field && (field->type == MAILIMF_FIELD_TO) 
+         && field->field.to->addr_list ) {
+        addRcpts( rcptList, field->field.to->addr_list );
+    }
+    
+    field = getField( fields, MAILIMF_FIELD_CC );
+    if ( field && (field->type == MAILIMF_FIELD_CC)
+         && field->field.cc->addr_list ) {
+        addRcpts( rcptList, field->field.cc->addr_list );
+    }
+    
+    field = getField( fields, MAILIMF_FIELD_BCC );
+    if ( field && (field->type == MAILIMF_FIELD_BCC) 
+         && field->field.bcc->addr_list ) {
+        addRcpts( rcptList, field->field.bcc->addr_list );
+    }
+
+    return rcptList;
+}
+
+char *MailWrapper::getFrom( mailmime *mail )
+{
+    char *from = NULL;
+
+    mailimf_field *ffrom;
+    ffrom = getField( mail->fields, MAILIMF_FIELD_FROM );
+    if ( ffrom && (ffrom->type == MAILIMF_FIELD_FROM) 
+         && ffrom->field.from->mb_list && ffrom->field.from->mb_list->list ) {
+        clist *cl = ffrom->field.from->mb_list->list;
+        clistiter *it;
+        for ( it = clist_begin( cl ); it; it = it->next ) {
+            mailimf_mailbox *mb = (mailimf_mailbox *) it->data;
+            from = strdup( mb->addr_spec );
+        }
+    }
+
+    return from;    
+}
+
+SMTPaccount *MailWrapper::getAccount( QString from )
+{
+    SMTPaccount *smtp;
+    
+    QList<Account> list = settings->getAccounts();
+    Account *it;
+    for ( it = list.first(); it; it = list.next() ) {
+        if ( it->getType().compare( "SMTP" ) == 0 ) {
+            smtp = static_cast<SMTPaccount *>(it);
+            if ( smtp->getMail().compare( from ) == 0 ) {
+                qDebug( "SMTPaccount found for" );
+                qDebug( from );
+                return smtp;
+            }
+        }
+    }
+    
+    return NULL;
+}
+
+QString MailWrapper::getTmpFile() {
+    int num = 0;
+    QString unique;
+    
+    QDir dir( "/tmp" );
+    QStringList::Iterator it;
+
+    QStringList list = dir.entryList( "opiemail-tmp-*" );
+    do {
+        unique.setNum( num++ );
+    } while ( list.contains( "opiemail-tmp-" + unique ) > 0 );
+    
+    return "/tmp/opiemail-tmp-" + unique;
+}
+
+void MailWrapper::writeToFile( QString file, mailmime *mail )
+{
+    FILE *f;
+    int err, col = 0;
+
+    f = fopen( file.latin1(), "w" );
+    if ( f == NULL ) {
+        qDebug( "writeToFile: error opening file" );
+        return;
+    }
+
+    err = mailmime_write( f, &col, mail );
+    if ( err != MAILIMF_NO_ERROR ) {
+        fclose( f );
+        qDebug( "writeToFile: error writing mailmime" );
+        return;
+    }
+
+    fclose( f );
+}
+
+void MailWrapper::readFromFile( QString file, char **data, size_t *size )
+{
+    char *buf;
+    struct stat st;
+    int fd, count = 0, total = 0;
+    
+    fd = open( file.latin1(), O_RDONLY, 0 );
+    if ( fd == -1 ) return;
+    
+    if ( fstat( fd, &st ) != 0 ) goto err_close;
+    if ( !st.st_size )  goto err_close;
+    
+    buf = (char *) malloc( st.st_size );
+    if ( !buf ) goto err_close;
+
+    while ( ( total < st.st_size ) && ( count >= 0 ) ) {
+        count = read( fd, buf + total, st.st_size - total );
+        total += count;
+    }
+    if ( count < 0 ) goto err_free;
+
+    *data = buf;
+    *size = st.st_size;
+    
+    close( fd );
+
+    return;             // Success :)
+        
+err_free:
+    free( buf );
+err_close:
+    close( fd );
+}
+
+void progress( size_t current, size_t maximum )
+{
+    qDebug( "Current: %i of %i", current, maximum );
+}
+
+void MailWrapper::smtpSend( mailmime *mail )
+{
+    mailsmtp *session;
+    clist *rcpts;
+    char *from, *data, *server, *user = NULL, *pass = NULL;
+    size_t size;
+    int err;
+    bool ssl;
+    uint16_t port;
+    
+
+    from = getFrom( mail );
+    SMTPaccount *smtp = getAccount( from );
+    if ( smtp == NULL ) {
+        free(from);
+        return;
+    }
+    server = strdup( smtp->getServer().latin1() );
+    ssl = smtp->getSSL();
+    port = smtp->getPort().toUInt();
+    rcpts = createRcptList( mail->fields );
+
+    QString file = getTmpFile();
+    writeToFile( file, mail );
+    readFromFile( file, &data, &size );
+    QFile f( file );
+    f.remove();
+    
+    session = mailsmtp_new( 20, &progress );
+    if ( session == NULL ) goto free_mem; 
+
+    qDebug( "Servername %s at port %i", server, port );
+    if ( ssl ) {
+        qDebug( "SSL session" );
+        err = mailsmtp_ssl_connect( session, server, port );
+    } else {
+        qDebug( "No SSL session" );
+        err = mailsmtp_socket_connect( session, server, port );
+    }
+    if ( err != MAILSMTP_NO_ERROR ) goto free_mem_session;
+
+    err = mailsmtp_init( session );
+    if ( err != MAILSMTP_NO_ERROR ) goto free_con_session;
+    
+    qDebug( "INIT OK" );
+    
+    if ( smtp->getLogin() ) {
+        if ( smtp->getUser().isEmpty() || smtp->getPassword().isEmpty() ) {
+            // get'em
+            LoginDialog login( smtp->getUser(), smtp->getPassword(), NULL, 0, true );
+            login.show();
+            if ( QDialog::Accepted == login.exec() ) {
+                // ok
+                user = strdup( login.getUser().latin1() );
+                pass = strdup( login.getPassword().latin1() );
+            } else {
+                goto free_con_session;
+            }
+        } else {
+            user = strdup( smtp->getUser().latin1() );
+            pass = strdup( smtp->getPassword().latin1() );
+        }
+        qDebug( "session->auth: %i", session->auth);
+        err = mailsmtp_auth( session, user, pass );
+        if ( err == MAILSMTP_NO_ERROR ) qDebug("auth ok");
+        qDebug( "Done auth!" );
+    }
+     
+    err = mailsmtp_send( session, from, rcpts, data, size );
+    if ( err != MAILSMTP_NO_ERROR ) goto free_con_session;
+
+    qDebug( "Mail sent." );
+    
+free_con_session:
+    mailsmtp_quit( session );
+free_mem_session:
+    mailsmtp_free( session );
+free_mem:
+    smtp_address_list_free( rcpts );
+    free( data );
+    free( server );
+    if ( smtp->getLogin() ) {
+        free( user );
+        free( pass );
+    }
+    free( from );
+}
+
+void MailWrapper::sendMail( Mail mail )
+{
+    mailmime *mimeMail;
+
+    mimeMail = createMimeMail( &mail );
+    if ( mimeMail == NULL ) {
+        qDebug( "sendMail: error creating mime mail" );
+    } else {
+        smtpSend( mimeMail );
+        mailmime_free( mimeMail );
+    } 
+}
+
+Mail::Mail()
+    :name(""), mail(""), to(""), cc(""), bcc(""), reply(""), subject(""), message("")
+{
+}
+
+RecMail::RecMail()
+    :subject(""),date(""),msg_number(0),msg_flags(7)
+{
+}
+
+#if 0
+void RecMail::setDate(const QString&aDate)
+{
+    mDate = QDateTime::fromString(aDate);
+}
+#endif
diff --git a/noncore/net/mail/libmailwrapper/mailwrapper.h b/noncore/net/mail/libmailwrapper/mailwrapper.h
new file mode 100644
index 0000000..3de28a0
--- a/dev/null
+++ b/noncore/net/mail/libmailwrapper/mailwrapper.h
@@ -0,0 +1,183 @@
+#ifndef MAILWRAPPER_H
+#define MAILWRAPPER_H
+
+#include <qpe/applnk.h>
+
+#include <mailmime.h>
+#include <mailimf.h>
+#include <mailsmtp.h>
+#include <mailimap.h>
+#include <mailstorage.h>
+#include <maildriver.h>
+#include <qbitarray.h>
+#include <qdatetime.h>
+
+#include "settings.h"
+
+class Attachment
+{
+public:
+    Attachment( DocLnk lnk ); 
+    virtual ~Attachment(){}
+    const QString getFileName()const{ return doc.file(); }
+    const QString getName()const{ return doc.name(); }
+    const QString getMimeType()const{ return doc.type(); }
+    const QPixmap getPixmap()const{ return doc.pixmap(); }
+    const int getSize()const { return size; }
+    DocLnk  getDocLnk() { return doc; }
+    
+protected:
+    DocLnk doc;
+    int size;
+
+};
+
+#define FLAG_ANSWERED 0
+#define FLAG_FLAGGED  1
+#define FLAG_DELETED  2
+#define FLAG_SEEN     3
+#define FLAG_DRAFT    4
+#define FLAG_RECENT   5
+
+/* a class to describe mails in a mailbox */
+class RecMail
+{
+public:
+    RecMail();
+    virtual ~RecMail(){}
+
+    const int getNumber()const{return msg_number;}
+    void setNumber(int number){msg_number=number;}
+    const QString&getDate()const{ return date; }
+    void setDate( const QString&a ) { date = a; }
+    const QString&getFrom()const{ return from; }
+    void setFrom( const QString&a ) { from = a; }
+    const QString&getSubject()const { return subject; }
+    void setSubject( const QString&s ) { subject = s; }
+    void setFlags(const QBitArray&flags){msg_flags = flags;}
+    const QBitArray&getFlags()const{return msg_flags;}
+
+#if 0    
+    void setDate(const QString&dstring);
+    void setDate(const QDateTime&date){mDate = date;}
+    QString getDate()const{return mDate.toString();}
+#endif
+protected:
+    QString subject,date,from;
+    int msg_number;
+    QBitArray msg_flags;
+#if 0
+    QDateTime mDate;
+#endif
+};
+
+typedef QList<RecMail> Maillist;
+
+class Mail
+{
+public:
+    Mail();
+    /* Possible that this destructor must not be declared virtual
+     * 'cause it seems that it will never have some child classes.
+     * in this case this object will not get a virtual table -> memory and
+     * speed will be a little bit better?
+     */
+    virtual ~Mail(){}
+    void addAttachment( Attachment *att ) { attList.append( att ); }
+    const QList<Attachment>& getAttachments()const { return attList; }
+    void removeAttachment( Attachment *att ) { attList.remove( att ); } 
+    const QString&getName()const { return name; }
+    void setName( QString s ) { name = s; }
+    const QString&getMail()const{ return mail; }
+    void setMail( const QString&s ) { mail = s; }
+    const QString&getTo()const{ return to; }
+    void setTo( const QString&s ) { to = s; }
+    const QString&getCC()const{ return cc; }
+    void setCC( const QString&s ) { cc = s; }
+    const QString&getBCC()const { return bcc; }
+    void setBCC( const QString&s ) { bcc = s; }
+    const QString&getMessage()const { return message; }
+    void setMessage( const QString&s ) { message = s; }
+    const QString&getSubject()const { return subject; }
+    void setSubject( const QString&s ) { subject = s; }
+    const QString&getReply()const{ return reply; }
+    void setReply( const QString&a ) { reply = a; }
+
+private:
+    QList<Attachment> attList;
+    QString name, mail, to, cc, bcc, reply, subject, message;
+};
+
+class Folder : public QObject
+{
+    Q_OBJECT
+
+public:
+    Folder( const QString&init_name );
+    const QString&getDisplayName()const { return nameDisplay; }
+    const QString&getName()const { return name; }
+    virtual bool may_select()const{return true;};    
+
+private:
+    QString nameDisplay, name;
+    
+};
+
+class IMAPFolder : public Folder
+{
+    public:
+        IMAPFolder( QString name,bool select=true ) : Folder( name ),m_MaySelect(select) {}
+        virtual bool may_select()const{return m_MaySelect;}
+    private:
+        bool m_MaySelect;
+};
+
+class MailWrapper : public QObject
+{
+    Q_OBJECT
+
+public:
+    MailWrapper( Settings *s ); 
+    void sendMail( Mail mail );
+
+private:
+    mailimf_mailbox *newMailbox(const QString&name,const QString&mail );
+    mailimf_address_list *parseAddresses(const QString&addr );
+    mailimf_fields *createImfFields( Mail *mail );
+    mailmime *buildTxtPart( QString str );
+    mailmime *buildFilePart( QString filename, QString mimetype );
+    void addFileParts( mailmime *message, QList<Attachment> files );
+    mailmime *createMimeMail( Mail *mail );
+    void smtpSend( mailmime *mail );
+    mailimf_field *getField( mailimf_fields *fields, int type );
+    clist *createRcptList( mailimf_fields *fields );
+    char *getFrom( mailmime *mail );
+    SMTPaccount *getAccount( QString from );
+    void writeToFile( QString file, mailmime *mail );
+    void readFromFile( QString file, char **data, size_t *size );
+    static QString mailsmtpError( int err );
+    static QString getTmpFile();
+
+    Settings *settings;
+        
+};
+
+class IMAPwrapper : public QObject
+{
+    Q_OBJECT
+
+public:
+    IMAPwrapper( IMAPaccount *a );
+    QList<IMAPFolder>* listFolders();
+    void listMessages(const QString & mailbox,Maillist&target );
+    QString fetchBody(const QString & mailbox,const RecMail&mail);
+
+protected:
+    RecMail*parse_list_result(mailimap_msg_att*);
+
+private:
+    IMAPaccount *account;
+    
+};
+
+#endif
diff --git a/noncore/net/mail/libmailwrapper/settings.cpp b/noncore/net/mail/libmailwrapper/settings.cpp
new file mode 100644
index 0000000..9632301
--- a/dev/null
+++ b/noncore/net/mail/libmailwrapper/settings.cpp
@@ -0,0 +1,432 @@
+#include <stdlib.h>
+#include <qdir.h>
+
+#include <qpe/config.h>
+
+#include "settings.h"
+#include "defines.h"
+
+Settings::Settings()
+    : QObject()
+{
+   updateAccounts();
+}
+
+void Settings::checkDirectory()
+{
+    if ( !QDir( (QString) getenv( "HOME" ) + "/Applications/opiemail/" ).exists() ) {
+        system( "mkdir -p $HOME/Applications/opiemail" );
+        qDebug( "$HOME/Applications/opiemail created" );
+    }
+}
+
+QList<Account> Settings::getAccounts()
+{
+    return accounts;
+}
+
+void Settings::addAccount( Account *account )
+{
+    accounts.append( account );
+}
+
+void Settings::delAccount( Account *account )
+{
+    accounts.remove( account );
+    account->remove();
+}
+
+void Settings::updateAccounts()
+{
+    accounts.clear();
+    QDir dir( (QString) getenv( "HOME" ) + "/Applications/opiemail" );
+    QStringList::Iterator it;
+
+    QStringList imap = dir.entryList( "imap-*" );
+    for ( it = imap.begin(); it != imap.end(); it++ ) {
+        qDebug( "Added IMAP account" );
+        IMAPaccount *account = new IMAPaccount( (*it).replace(0, 5, "") );
+        accounts.append( account );
+    }
+
+    QStringList pop3 = dir.entryList( "pop3-*" );
+    for ( it = pop3.begin(); it != pop3.end(); it++ ) {
+        qDebug( "Added POP account" );
+        POP3account *account = new POP3account( (*it).replace(0, 5, "") );
+        accounts.append( account );
+    }
+
+    QStringList smtp = dir.entryList( "smtp-*" );
+    for ( it = smtp.begin(); it != smtp.end(); it++ ) {
+        qDebug( "Added SMTP account" );
+        SMTPaccount *account = new SMTPaccount( (*it).replace(0, 5, "") );
+        accounts.append( account );
+    }
+    
+    QStringList nntp = dir.entryList( "nntp-*" );
+    for ( it = nntp.begin(); it != nntp.end(); it++ ) {
+        qDebug( "Added NNTP account" );
+        NNTPaccount *account = new NNTPaccount( (*it).replace(0, 5, "") );
+        accounts.append( account );
+    }
+    
+    readAccounts();
+}
+
+void Settings::saveAccounts()
+{
+    checkDirectory(); 
+    Account *it;
+
+    for ( it = accounts.first(); it; it = accounts.next() ) {
+        it->save();
+    }
+}
+
+void Settings::readAccounts()
+{
+    checkDirectory(); 
+    Account *it;
+
+    for ( it = accounts.first(); it; it = accounts.next() ) {
+        it->read();
+    }
+}
+
+Account::Account()
+{
+    accountName = "changeMe";
+    type = "changeMe";
+    ssl = false;
+}
+
+void Account::remove()
+{
+    QFile file( getFileName() );
+    file.remove();
+}
+
+IMAPaccount::IMAPaccount()
+    : Account()
+{
+    file = IMAPaccount::getUniqueFileName();
+    accountName = "New IMAP Account";
+    ssl = false;
+    type = "IMAP";
+    port = IMAP_PORT;
+}
+
+IMAPaccount::IMAPaccount( QString filename )
+    : Account()
+{
+    file = filename;
+    accountName = "New IMAP Account";
+    ssl = false;
+    type = "IMAP";
+    port = IMAP_PORT;
+}
+
+QString IMAPaccount::getUniqueFileName()
+{
+    int num = 0;
+    QString unique;
+    
+    QDir dir( (QString) getenv( "HOME" ) + "/Applications/opiemail" );
+    QStringList::Iterator it;
+
+    QStringList imap = dir.entryList( "imap-*" );
+    do {
+        unique.setNum( num++ );
+    } while ( imap.contains( "imap-" + unique ) > 0 );
+
+    return unique;
+}
+
+void IMAPaccount::read()
+{
+    Config *conf = new Config( getFileName(), Config::File );
+    conf->setGroup( "IMAP Account" );
+    accountName = conf->readEntry( "Account","" );
+    if (accountName.isNull()) accountName = "";
+    server = conf->readEntry( "Server","" );
+    if (server.isNull()) server="";
+    port = conf->readEntry( "Port","" );
+    if (port.isNull()) port="143";
+    ssl = conf->readBoolEntry( "SSL",false );
+    user = conf->readEntry( "User","" );
+    if (user.isNull()) user = "";
+    password = conf->readEntryCrypt( "Password","" );
+    if (password.isNull()) password = "";
+    prefix = conf->readEntry("MailPrefix","");
+    if (prefix.isNull()) prefix = "";
+}
+
+void IMAPaccount::save()
+{
+    qDebug( "saving " + getFileName() );
+    Settings::checkDirectory();
+    
+    Config *conf = new Config( getFileName(), Config::File );
+    conf->setGroup( "IMAP Account" );
+    conf->writeEntry( "Account", accountName );
+    conf->writeEntry( "Server", server );
+    conf->writeEntry( "Port", port );
+    conf->writeEntry( "SSL", ssl );
+    conf->writeEntry( "User", user );
+    conf->writeEntryCrypt( "Password", password );
+    conf->writeEntry( "MailPrefix",prefix);
+    conf->write();
+}
+
+
+QString IMAPaccount::getFileName()
+{
+    return (QString) getenv( "HOME" ) + "/Applications/opiemail/imap-" + file;
+}
+
+POP3account::POP3account()
+    : Account()
+{
+    file = POP3account::getUniqueFileName();
+    accountName = "New POP3 Account";
+    ssl = false;
+    type = "POP3";
+    port = POP3_PORT;
+}
+
+POP3account::POP3account( QString filename )
+    : Account()
+{
+    file = filename;
+    accountName = "New POP3 Account";
+    ssl = false;
+    type = "POP3";
+    port = POP3_PORT;
+}
+
+QString POP3account::getUniqueFileName()
+{
+    int num = 0;
+    QString unique;
+    
+    QDir dir( (QString) getenv( "HOME" ) + "/Applications/opiemail" );
+    QStringList::Iterator it;
+
+    QStringList imap = dir.entryList( "pop3-*" );
+    do {
+        unique.setNum( num++ );
+    } while ( imap.contains( "pop3-" + unique ) > 0 );
+
+    return unique;
+}
+
+void POP3account::read()
+{
+    Config *conf = new Config( getFileName(), Config::File );
+    conf->setGroup( "POP3 Account" );
+    accountName = conf->readEntry( "Account" );
+    server = conf->readEntry( "Server" );
+    port = conf->readEntry( "Port" );
+    ssl = conf->readBoolEntry( "SSL" );
+    user = conf->readEntry( "User" );
+    password = conf->readEntryCrypt( "Password" );
+}
+
+void POP3account::save()
+{
+    qDebug( "saving " + getFileName() );
+    Settings::checkDirectory();
+    
+    Config *conf = new Config( getFileName(), Config::File );
+    conf->setGroup( "POP3 Account" );
+    conf->writeEntry( "Account", accountName );
+    conf->writeEntry( "Server", server );
+    conf->writeEntry( "Port", port );
+    conf->writeEntry( "SSL", ssl );
+    conf->writeEntry( "User", user );
+    conf->writeEntryCrypt( "Password", password );
+    conf->write();
+}
+
+
+QString POP3account::getFileName()
+{
+    return (QString) getenv( "HOME" ) + "/Applications/opiemail/pop3-" + file;
+}
+
+SMTPaccount::SMTPaccount()
+    : Account()
+{
+    file = SMTPaccount::getUniqueFileName();
+    accountName = "New SMTP Account";
+    ssl = false;
+    login = false;
+    useCC = false;
+    useBCC = false;
+    useReply = false;
+    type = "SMTP";
+    port = SMTP_PORT;
+}
+
+SMTPaccount::SMTPaccount( QString filename )
+    : Account()
+{
+    file = filename;
+    accountName = "New SMTP Account";
+    ssl = false;
+    login = false;
+    useCC = false;
+    useBCC = false;
+    useReply = false;
+    type = "SMTP";
+    port = SMTP_PORT;
+}
+
+QString SMTPaccount::getUniqueFileName()
+{
+    int num = 0;
+    QString unique;
+    
+    QDir dir( (QString) getenv( "HOME" ) + "/Applications/opiemail" );
+    QStringList::Iterator it;
+
+    QStringList imap = dir.entryList( "smtp-*" );
+    do {
+        unique.setNum( num++ );
+    } while ( imap.contains( "smtp-" + unique ) > 0 );
+
+    return unique;
+}
+
+void SMTPaccount::read()
+{
+    Config *conf = new Config( getFileName(), Config::File );
+    conf->setGroup( "SMTP Account" );
+    accountName = conf->readEntry( "Account" );
+    server = conf->readEntry( "Server" );
+    port = conf->readEntry( "Port" );
+    ssl = conf->readBoolEntry( "SSL" );
+    login = conf->readBoolEntry( "Login" );
+    user = conf->readEntry( "User" );
+    password = conf->readEntryCrypt( "Password" );
+    useCC = conf->readBoolEntry( "useCC" );
+    useBCC = conf->readBoolEntry( "useBCC" );
+    useReply = conf->readBoolEntry( "useReply" );
+    name = conf->readEntry( "Name" );
+    mail = conf->readEntry( "Mail" );
+    org = conf->readEntry( "Org" );
+    cc = conf->readEntry( "CC" );
+    bcc = conf->readEntry( "BCC" );
+    reply = conf->readEntry( "Reply" );
+    signature = conf->readEntry( "Signature" );
+    signature = signature.replace( QRegExp( "<br>" ), "\n" );
+}
+
+void SMTPaccount::save()
+{
+    qDebug( "saving " + getFileName() );
+    Settings::checkDirectory();
+    
+    Config *conf = new Config( getFileName(), Config::File );
+    conf->setGroup( "SMTP Account" );
+    conf->writeEntry( "Account", accountName );
+    conf->writeEntry( "Server", server );
+    conf->writeEntry( "Port", port );
+    conf->writeEntry( "SSL", ssl );
+    conf->writeEntry( "Login", login );
+    conf->writeEntry( "User", user );
+    conf->writeEntryCrypt( "Password", password );
+    conf->writeEntry( "useCC", useCC );
+    conf->writeEntry( "useBCC", useBCC );
+    conf->writeEntry( "useReply", useReply );
+    conf->writeEntry( "Name", name );
+    conf->writeEntry( "Mail", mail );
+    conf->writeEntry( "Org", org );
+    conf->writeEntry( "CC", cc );
+    conf->writeEntry( "BCC", bcc );
+    conf->writeEntry( "Reply", reply );
+    conf->writeEntry( "Signature", 
+                      signature.replace( QRegExp( "\\n" ), "<br>" ) );
+    conf->write();
+}
+
+
+QString SMTPaccount::getFileName()
+{
+    return (QString) getenv( "HOME" ) + "/Applications/opiemail/smtp-" + file;
+}
+
+NNTPaccount::NNTPaccount()
+    : Account()
+{
+    file = NNTPaccount::getUniqueFileName();
+    accountName = "New NNTP Account";
+    ssl = false;
+    login = false;
+    type = "NNTP";
+    port = NNTP_PORT;
+}
+
+NNTPaccount::NNTPaccount( QString filename )
+    : Account()
+{
+    file = filename;
+    accountName = "New NNTP Account";
+    ssl = false;
+    login = false;
+    type = "NNTP";
+    port = NNTP_PORT;
+}
+
+QString NNTPaccount::getUniqueFileName()
+{
+    int num = 0;
+    QString unique;
+    
+    QDir dir( (QString) getenv( "HOME" ) + "/Applications/opiemail" );
+    QStringList::Iterator it;
+
+    QStringList imap = dir.entryList( "nntp-*" );
+    do {
+        unique.setNum( num++ );
+    } while ( imap.contains( "nntp-" + unique ) > 0 );
+
+    return unique;
+}
+
+void NNTPaccount::read()
+{
+    Config *conf = new Config( getFileName(), Config::File );
+    conf->setGroup( "NNTP Account" );
+    accountName = conf->readEntry( "Account" );
+    server = conf->readEntry( "Server" );
+    port = conf->readEntry( "Port" );
+    ssl = conf->readBoolEntry( "SSL" );
+    login = conf->readBoolEntry( "Login" );
+    user = conf->readEntry( "User" );
+    password = conf->readEntryCrypt( "Password" );
+}
+
+void NNTPaccount::save()
+{
+    qDebug( "saving " + getFileName() );
+    Settings::checkDirectory();
+    
+    Config *conf = new Config( getFileName(), Config::File );
+    conf->setGroup( "NNTP Account" );
+    conf->writeEntry( "Account", accountName );
+    conf->writeEntry( "Server", server );
+    conf->writeEntry( "Port", port );
+    conf->writeEntry( "SSL", ssl );
+    conf->writeEntry( "Login", login );
+    conf->writeEntry( "User", user );
+    conf->writeEntryCrypt( "Password", password );
+    conf->write();
+}
+
+
+QString NNTPaccount::getFileName()
+{
+    return (QString) getenv( "HOME" ) + "/Applications/opiemail/nntp-" + file;
+}
+
diff --git a/noncore/net/mail/libmailwrapper/settings.h b/noncore/net/mail/libmailwrapper/settings.h
new file mode 100644
index 0000000..22184a5
--- a/dev/null
+++ b/noncore/net/mail/libmailwrapper/settings.h
@@ -0,0 +1,166 @@
+#ifndef SETTINGS_H
+#define SETTINGS_H
+
+#include <qobject.h>
+#include <qlist.h>
+
+class Account 
+{
+    
+public:
+    Account();
+    virtual ~Account() {}
+
+    void remove();
+    void setAccountName( QString name ) { accountName = name; }
+    const QString&getAccountName()const{ return accountName; }
+    const QString&getType()const{ return type; }
+    
+    void setServer(const QString&str){ server = str; }
+    const QString&getServer()const{ return server; }
+    
+    void setPort(const QString&str) { port = str; }
+    const QString&getPort()const{ return port; }
+    
+    void setUser(const QString&str){ user = str; }
+    const QString&getUser()const{ return user; }
+    
+    void setPassword(const QString&str) { password = str; }
+    const QString&getPassword()const { return password; }
+    
+    void setSSL( bool b ) { ssl = b; }
+    bool getSSL() { return ssl; }
+
+    virtual QString getFileName() { return accountName; }
+    virtual void read() { qDebug( "base reading..." ); }
+    virtual void save() { qDebug( "base saving..." ); }
+
+protected:
+    QString accountName, type, server, port, user, password;
+    bool ssl;
+    
+};
+
+class IMAPaccount : public Account
+{
+        
+public:
+    IMAPaccount();
+    IMAPaccount( QString filename );
+
+    static QString getUniqueFileName();
+
+    virtual void read();
+    virtual void save();
+    virtual QString getFileName();
+
+    void setPrefix(const QString&str) {prefix=str;}
+    const QString&getPrefix()const{return prefix;}
+
+private:
+    QString file,prefix;
+
+};
+
+class POP3account : public Account
+{
+        
+public:
+    POP3account();
+    POP3account( QString filename );
+
+    static QString getUniqueFileName();
+
+    virtual void read();
+    virtual void save();
+    virtual QString getFileName();
+
+private:
+    QString file;
+    
+};
+
+class SMTPaccount : public Account
+{
+    
+public:
+    SMTPaccount();
+    SMTPaccount( QString filename );
+
+    static QString getUniqueFileName();
+
+    virtual void read();
+    virtual void save();
+    virtual QString getFileName();
+
+    void setName( QString str ) { name = str; }
+    QString getName() { return name; }
+    void setMail( QString str ) { mail = str; }
+    QString getMail() { return mail; }
+    void setOrg( QString str ) { org = str; }
+    QString getOrg() { return org; }
+    void setUseCC( bool b ) { useCC = b; }
+    bool getUseCC() { return useCC; }
+    void setCC( QString str ) { cc = str; }
+    QString getCC() { return cc; }
+    void setUseBCC( bool b ) { useBCC = b; }
+    bool getUseBCC() { return useBCC; }
+    void setBCC( QString str ) { bcc = str; }
+    QString getBCC() { return bcc; }
+    void setUseReply( bool b ) { useReply = b; }
+    bool getUseReply() { return useReply; }
+    void setReply( QString str ) { reply = str; }
+    QString getReply() { return reply; }
+    void setSignature( QString str ) { signature = str; }
+    QString getSignature() { return signature; }
+    void setLogin( bool b ) { login = b; }
+    bool getLogin() { return login; }
+
+private:
+    QString file, name, mail, org, cc, bcc, reply, signature;
+    bool useCC, useBCC, useReply, login;
+
+};
+
+class NNTPaccount : public Account
+{
+        
+public:
+    NNTPaccount();
+    NNTPaccount( QString filename );
+
+    static QString getUniqueFileName();
+
+    virtual void read();
+    virtual void save();
+    virtual QString getFileName();
+
+    void setLogin( bool b ) { login = b; }
+    bool getLogin() { return login; }
+
+private:
+    QString file;
+    bool login;
+
+};
+
+class Settings : public QObject
+{
+    Q_OBJECT
+
+public:
+    Settings();
+    QList<Account> getAccounts();
+    void addAccount(Account *account);
+    void delAccount(Account *account);
+    void saveAccounts();
+    void readAccounts();
+    static void checkDirectory();
+
+private:
+    void updateAccounts();
+    QList<Account> accounts;
+        
+};
+
+#endif