summaryrefslogtreecommitdiffabout
path: root/kmicromail/libmailwrapper
Unidiff
Diffstat (limited to 'kmicromail/libmailwrapper') (more/less context) (ignore whitespace changes)
-rw-r--r--kmicromail/libmailwrapper/abstractmail.cpp1
-rw-r--r--kmicromail/libmailwrapper/genericwrapper.cpp35
-rw-r--r--kmicromail/libmailwrapper/genericwrapper.h2
-rw-r--r--kmicromail/libmailwrapper/imapwrapper.cpp17
-rw-r--r--kmicromail/libmailwrapper/mailtypes.cpp20
-rw-r--r--kmicromail/libmailwrapper/mailtypes.h4
6 files changed, 56 insertions, 23 deletions
diff --git a/kmicromail/libmailwrapper/abstractmail.cpp b/kmicromail/libmailwrapper/abstractmail.cpp
index 8f67566..88545f8 100644
--- a/kmicromail/libmailwrapper/abstractmail.cpp
+++ b/kmicromail/libmailwrapper/abstractmail.cpp
@@ -1,277 +1,278 @@
1// CHANGED 2004-09-31 Lutz Rogowski 1// CHANGED 2004-09-31 Lutz Rogowski
2#include "abstractmail.h" 2#include "abstractmail.h"
3#include "imapwrapper.h" 3#include "imapwrapper.h"
4#include "pop3wrapper.h" 4#include "pop3wrapper.h"
5#include "nntpwrapper.h" 5#include "nntpwrapper.h"
6#include "mhwrapper.h" 6#include "mhwrapper.h"
7#include "mailtypes.h" 7#include "mailtypes.h"
8#include <qpe/global.h> 8#include <qpe/global.h>
9 9
10 10
11#include <qprogressbar.h> 11#include <qprogressbar.h>
12#include <qapplication.h> 12#include <qapplication.h>
13#include <qmessagebox.h> 13#include <qmessagebox.h>
14 14
15#include <kdecore/kstandarddirs.h> 15#include <kdecore/kstandarddirs.h>
16#include <qfile.h> 16#include <qfile.h>
17#include <qtextstream.h> 17#include <qtextstream.h>
18#include <stdlib.h> 18#include <stdlib.h>
19#include <libetpan/mailmime_content.h> 19#include <libetpan/mailmime_content.h>
20#include <libetpan/mailmime.h> 20#include <libetpan/mailmime.h>
21 21
22using namespace Opie::Core; 22using namespace Opie::Core;
23AbstractMail* AbstractMail::getWrapper(IMAPaccount *a) 23AbstractMail* AbstractMail::getWrapper(IMAPaccount *a)
24{ 24{
25 return new IMAPwrapper(a); 25 return new IMAPwrapper(a);
26} 26}
27 27
28AbstractMail* AbstractMail::getWrapper(POP3account *a) 28AbstractMail* AbstractMail::getWrapper(POP3account *a)
29{ 29{
30 return new POP3wrapper(a); 30 return new POP3wrapper(a);
31} 31}
32 32
33AbstractMail* AbstractMail::getWrapper(NNTPaccount *a) 33AbstractMail* AbstractMail::getWrapper(NNTPaccount *a)
34{ 34{
35 return new NNTPwrapper(a); 35 return new NNTPwrapper(a);
36} 36}
37 37
38AbstractMail* AbstractMail::getWrapper(const QString&a,const QString&name) 38AbstractMail* AbstractMail::getWrapper(const QString&a,const QString&name)
39{ 39{
40 return new MHwrapper(a,name); 40 return new MHwrapper(a,name);
41} 41}
42 42
43AbstractMail* AbstractMail::getWrapper(Account*a) 43AbstractMail* AbstractMail::getWrapper(Account*a)
44{ 44{
45 if (!a) return 0; 45 if (!a) return 0;
46 switch (a->getType()) { 46 switch (a->getType()) {
47 case MAILLIB::A_IMAP: 47 case MAILLIB::A_IMAP:
48 return new IMAPwrapper((IMAPaccount*)a); 48 return new IMAPwrapper((IMAPaccount*)a);
49 break; 49 break;
50 case MAILLIB::A_POP3: 50 case MAILLIB::A_POP3:
51 return new POP3wrapper((POP3account*)a); 51 return new POP3wrapper((POP3account*)a);
52 break; 52 break;
53 case MAILLIB::A_NNTP: 53 case MAILLIB::A_NNTP:
54 return new NNTPwrapper((NNTPaccount*)a); 54 return new NNTPwrapper((NNTPaccount*)a);
55 break; 55 break;
56 default: 56 default:
57 return 0; 57 return 0;
58 } 58 }
59} 59}
60 60
61encodedString* AbstractMail::decode_String(const encodedString*text,const QString&enc) 61encodedString* AbstractMail::decode_String(const encodedString*text,const QString&enc)
62{ 62{
63 // odebug << "Decode string start" << oendl; 63 // odebug << "Decode string start" << oendl;
64 char*result_text; 64 char*result_text;
65 size_t index = 0; 65 size_t index = 0;
66 /* reset for recursive use! */ 66 /* reset for recursive use! */
67 size_t target_length = 0; 67 size_t target_length = 0;
68 result_text = 0; 68 result_text = 0;
69 int mimetype = MAILMIME_MECHANISM_7BIT; 69 int mimetype = MAILMIME_MECHANISM_7BIT;
70 if (enc.lower()=="quoted-printable") { 70 if (enc.lower()=="quoted-printable") {
71 mimetype = MAILMIME_MECHANISM_QUOTED_PRINTABLE; 71 mimetype = MAILMIME_MECHANISM_QUOTED_PRINTABLE;
72 } else if (enc.lower()=="base64") { 72 } else if (enc.lower()=="base64") {
73 mimetype = MAILMIME_MECHANISM_BASE64; 73 mimetype = MAILMIME_MECHANISM_BASE64;
74 } else if (enc.lower()=="8bit") { 74 } else if (enc.lower()=="8bit") {
75 mimetype = MAILMIME_MECHANISM_8BIT; 75 mimetype = MAILMIME_MECHANISM_8BIT;
76 } else if (enc.lower()=="binary") { 76 } else if (enc.lower()=="binary") {
77 mimetype = MAILMIME_MECHANISM_BINARY; 77 mimetype = MAILMIME_MECHANISM_BINARY;
78 } 78 }
79 79
80 int err = mailmime_part_parse(text->Content(),text->Length(),&index,mimetype, 80 int err = mailmime_part_parse(text->Content(),text->Length(),&index,mimetype,
81 &result_text,&target_length); 81 &result_text,&target_length);
82 82
83 encodedString* result = new encodedString(); 83 encodedString* result = new encodedString();
84 if (err == MAILIMF_NO_ERROR) { 84 if (err == MAILIMF_NO_ERROR) {
85 result->setContent(result_text,target_length); 85 result->setContent(result_text,target_length);
86 } 86 }
87 //odebug << "Decode string finished" << oendl; 87 //odebug << "Decode string finished" << oendl;
88 return result; 88 return result;
89} 89}
90 90
91QString AbstractMail::convert_String(const char*text) 91QString AbstractMail::convert_String(const char*text)
92{ 92{
93 //size_t index = 0; 93 //size_t index = 0;
94 char*res = 0; 94 char*res = 0;
95 int err = MAILIMF_NO_ERROR; 95 int err = MAILIMF_NO_ERROR;
96 96
97 QString result(text); 97 QString result(text);
98 98
99 /* due a bug in libetpan it isn't usable this moment */ 99 /* due a bug in libetpan it isn't usable this moment */
100/* int err = mailmime_encoded_phrase_parse("iso-8859-1", 100/* int err = mailmime_encoded_phrase_parse("iso-8859-1",
101 text, strlen(text),&index, "iso-8859-1",&res);*/ 101 text, strlen(text),&index, "iso-8859-1",&res);*/
102 //odebug << "Input: " << text << "" << oendl; 102 //odebug << "Input: " << text << "" << oendl;
103 if (err == MAILIMF_NO_ERROR && res && strlen(res)) { 103 if (err == MAILIMF_NO_ERROR && res && strlen(res)) {
104// result = QString(res); 104// result = QString(res);
105// odebug << "Res: " << res << ", length: " << strlen(res) << "" << oendl; 105// odebug << "Res: " << res << ", length: " << strlen(res) << "" << oendl;
106 } 106 }
107 if (res) free(res); 107 if (res) free(res);
108 return result; 108 return result;
109} 109}
110 110
111/* cp & paste from launcher */ 111/* cp & paste from launcher */
112QString AbstractMail::gen_attachment_id() 112QString AbstractMail::gen_attachment_id()
113{ 113{
114 QFile file( "/proc/sys/kernel/random/uuid" ); 114 QFile file( "/proc/sys/kernel/random/uuid" );
115 if (!file.open(IO_ReadOnly ) ) 115 if (!file.open(IO_ReadOnly ) )
116 return QString::null; 116 return QString::null;
117 117
118 QTextStream stream(&file); 118 QTextStream stream(&file);
119 119
120 return "{" + stream.read().stripWhiteSpace() + "}"; 120 return "{" + stream.read().stripWhiteSpace() + "}";
121} 121}
122 122
123int AbstractMail::createMbox(const QString&,const FolderP&,const QString& ,bool) 123int AbstractMail::createMbox(const QString&,const FolderP&,const QString& ,bool)
124{ 124{
125 return 0; 125 return 0;
126} 126}
127 127
128QString AbstractMail::defaultLocalfolder() 128QString AbstractMail::defaultLocalfolder()
129{ 129{
130 // QString f = getenv( "HOME" ); 130 // QString f = getenv( "HOME" );
131 QString f = locateLocal( "data", "kopiemail/localmail"); 131 QString f = locateLocal( "data", "kopiemail/localmail");
132 // f += "/Applications/opiemail/localmail"; 132 // f += "/Applications/opiemail/localmail";
133 return f; 133 return f;
134} 134}
135 135
136QString AbstractMail::draftFolder() 136QString AbstractMail::draftFolder()
137{ 137{
138 return QString("Drafts"); 138 return QString("Drafts");
139} 139}
140 140
141/* temporary - will be removed when implemented in all classes */ 141/* temporary - will be removed when implemented in all classes */
142void AbstractMail::deleteMails(const QString &,const QValueList<Opie::Core::OSmartPointer<RecMail> > &) 142void AbstractMail::deleteMails(const QString &,const QValueList<Opie::Core::OSmartPointer<RecMail> > &)
143{ 143{
144} 144}
145void AbstractMail::deleteMailList(const QValueList<RecMailP>&target) 145void AbstractMail::deleteMailList(const QValueList<RecMailP>&target)
146{ 146{
147 //qDebug("AbstractMail::deleteMailList:: Please reimplement! "); 147 //qDebug("AbstractMail::deleteMailList:: Please reimplement! ");
148 // this is currently re-implemented in pop3wrapper and imapwrapper 148 // this is currently re-implemented in pop3wrapper and imapwrapper
149 int iii = 0; 149 int iii = 0;
150 int count = target.count(); 150 int count = target.count();
151 QProgressBar wid ( count ); 151 QProgressBar wid ( count );
152 wid.setCaption( tr("Deleting ...")); 152 wid.setCaption( tr("Deleting ..."));
153 wid.show(); 153 wid.show();
154 while (iii < count ) { 154 while (iii < count ) {
155 Global::statusMessage(tr("Delete message %1 of %2").arg(iii).arg(count)); 155 Global::statusMessage(tr("Delete message %1 of %2").arg(iii).arg(count));
156 wid.setProgress( iii ); 156 wid.setProgress( iii );
157 wid.raise(); 157 wid.raise();
158 qApp->processEvents(); 158 qApp->processEvents();
159 RecMailP mail = (*target.at( iii )); 159 RecMailP mail = (*target.at( iii ));
160 deleteMail(mail); 160 deleteMail(mail);
161 ++iii; 161 ++iii;
162 } 162 }
163} 163}
164 164
165void AbstractMail::downloadNewMails(const FolderP&fromFolder, AbstractMail*targetMail ) 165void AbstractMail::downloadNewMails(const FolderP&fromFolder, AbstractMail*targetMail )
166{ 166{
167 //qDebug("AbstractMail::downloadNewMails %s ", fromFolder->getName().latin1()); 167 //qDebug("AbstractMail::downloadNewMails %s ", fromFolder->getName().latin1());
168 // get local folder 168 // get local folder
169 Account * acc = getAccount(); 169 Account * acc = getAccount();
170 if ( !acc ) return; 170 if ( !acc ) return;
171 QString lfName = acc->getLocalFolder(); 171 QString lfName = acc->getLocalFolder();
172 if ( lfName.isEmpty() ) 172 if ( lfName.isEmpty() )
173 lfName = acc->getAccountName(); 173 lfName = acc->getAccountName();
174 // create local folder 174 // create local folder
175 if ( !targetMail->createMbox(lfName)) 175 if ( !targetMail->createMbox(lfName))
176 { 176 {
177 QMessageBox::critical(0,tr("Error creating new Folder"), 177 QMessageBox::critical(0,tr("Error creating new Folder"),
178 tr("Error while creating new folder\n%1\n\nCancelling action.").arg(lfName)); 178 tr("Error while creating new folder\n%1\n\nCancelling action.").arg(lfName));
179 return; 179 return;
180 } 180 }
181 QValueList<RecMailP> t; 181 QValueList<RecMailP> t;
182 listMessages(fromFolder->getName(),t,acc->getMaxMailSize() ); 182 listMessages(fromFolder->getName(),t,acc->getMaxMailSize() );
183 if ( t.count() == 0 ) { 183 if ( t.count() == 0 ) {
184 Global::statusMessage(tr("There are no new messages")); 184 Global::statusMessage(tr("There are no new messages"));
185 return; 185 return;
186 } 186 }
187 QValueList<RecMailP> e; 187 QValueList<RecMailP> e;
188 targetMail->listMessages(lfName,e,acc->getMaxMailSize() ); 188 targetMail->listMessages(lfName,e,acc->getMaxMailSize() );
189 //qDebug("target has mails %d ", e.count()); 189 //qDebug("target has mails %d ", e.count());
190 QValueList<RecMailP> n; 190 QValueList<RecMailP> n;
191 int iii = 0; 191 int iii = 0;
192 int count = t.count(); 192 int count = t.count();
193 while (iii < count ) { 193 while (iii < count ) {
194 RecMailP r = (*t.at( iii )); 194 RecMailP r = (*t.at( iii ));
195 bool found = false; 195 bool found = false;
196 int jjj = 0; 196 int jjj = 0;
197 int countE = e.count(); 197 int countE = e.count();
198 while (jjj < countE ) { 198 while (jjj < countE ) {
199 RecMailP re = (*e.at( jjj )); 199 RecMailP re = (*e.at( jjj ));
200 if ( re->isEqual(r) ) { 200 if ( re->isEqual(r) ) {
201 found = true; 201 found = true;
202 break; 202 break;
203 } 203 }
204 ++jjj; 204 ++jjj;
205 } 205 }
206 if ( !found ) { 206 if ( !found ) {
207 //qDebug("AAAdate *%s* ", r->isodate.latin1() );
207 n.append( r ); 208 n.append( r );
208 } 209 }
209 ++iii; 210 ++iii;
210 } 211 }
211 if ( n.count() == 0 ) { 212 if ( n.count() == 0 ) {
212 Global::statusMessage(tr("There are no new messages")); 213 Global::statusMessage(tr("There are no new messages"));
213 return; 214 return;
214 } 215 }
215 mvcpMailList( n,lfName,targetMail,!acc->getLeaveOnServer()); 216 mvcpMailList( n,lfName,targetMail,!acc->getLeaveOnServer());
216 Global::statusMessage(tr("Downloaded %1 messages").arg(n.count())); 217 Global::statusMessage(tr("Downloaded %1 messages").arg(n.count()));
217 218
218#if 0 219#if 0
219 QValueList<RecMailP> t; 220 QValueList<RecMailP> t;
220 listMessages(fromFolder->getName(),t, maxSizeInKb); 221 listMessages(fromFolder->getName(),t, maxSizeInKb);
221 mvcpMailList( t,targetFolder,targetWrapper,moveit); 222 mvcpMailList( t,targetFolder,targetWrapper,moveit);
222#endif 223#endif
223 224
224} 225}
225void AbstractMail::mvcpAllMails(const FolderP&fromFolder, 226void AbstractMail::mvcpAllMails(const FolderP&fromFolder,
226 const QString&targetFolder,AbstractMail*targetWrapper,bool moveit, int maxSizeInKb) 227 const QString&targetFolder,AbstractMail*targetWrapper,bool moveit, int maxSizeInKb)
227{ 228{
228 QValueList<RecMailP> t; 229 QValueList<RecMailP> t;
229 listMessages(fromFolder->getName(),t, maxSizeInKb); 230 listMessages(fromFolder->getName(),t, maxSizeInKb);
230 mvcpMailList( t,targetFolder,targetWrapper,moveit); 231 mvcpMailList( t,targetFolder,targetWrapper,moveit);
231 232
232} 233}
233void AbstractMail::mvcpMailList(const QValueList<RecMailP>& t, 234void AbstractMail::mvcpMailList(const QValueList<RecMailP>& t,
234 const QString&targetFolder,AbstractMail*targetWrapper,bool moveit) 235 const QString&targetFolder,AbstractMail*targetWrapper,bool moveit)
235{ 236{
236 encodedString*st = 0; 237 encodedString*st = 0;
237 int iii = 0; 238 int iii = 0;
238 int count = t.count(); 239 int count = t.count();
239 if ( count == 0 ) 240 if ( count == 0 )
240 return; 241 return;
241 // wel, processevents is qite strange, we need a widget for getting 242 // wel, processevents is qite strange, we need a widget for getting
242 // Global::statusMessage(tr("Copy2 message %1").arg(iii)); displaye 243 // Global::statusMessage(tr("Copy2 message %1").arg(iii)); displaye
243 244
244 QProgressBar wid ( count ); 245 QProgressBar wid ( count );
245 wid.setCaption( tr("Copying ...")); 246 wid.setCaption( tr("Copying ..."));
246 wid.show(); 247 wid.show();
247 while (iii < count ) { 248 while (iii < count ) {
248 Global::statusMessage(tr("Copy message %1 of %2").arg(iii).arg(count)); 249 Global::statusMessage(tr("Copy message %1 of %2").arg(iii).arg(count));
249 wid.setProgress( iii ); 250 wid.setProgress( iii );
250 wid.raise(); 251 wid.raise();
251 qApp->processEvents(); 252 qApp->processEvents();
252 RecMailP r = (*t.at( iii )); 253 RecMailP r = (*t.at( iii ));
253 st = fetchRawBody(r); 254 st = fetchRawBody(r);
254 if (st) { 255 if (st) {
255 targetWrapper->storeMessage(st->Content(),st->Length(),targetFolder); 256 targetWrapper->storeMessage(st->Content(),st->Length(),targetFolder);
256 delete st; 257 delete st;
257 } 258 }
258 ++iii; 259 ++iii;
259 } 260 }
260 if (moveit) { 261 if (moveit) {
261 deleteMailList( t ); 262 deleteMailList( t );
262 //deleteAllMail(fromFolder); 263 //deleteAllMail(fromFolder);
263 } 264 }
264} 265}
265 266
266void AbstractMail::mvcpMail(const RecMailP&mail,const QString&targetFolder,AbstractMail*targetWrapper,bool moveit) 267void AbstractMail::mvcpMail(const RecMailP&mail,const QString&targetFolder,AbstractMail*targetWrapper,bool moveit)
267{ 268{
268 encodedString*st = 0; 269 encodedString*st = 0;
269 st = fetchRawBody(mail); 270 st = fetchRawBody(mail);
270 if (st) { 271 if (st) {
271 targetWrapper->storeMessage(st->Content(),st->Length(),targetFolder); 272 targetWrapper->storeMessage(st->Content(),st->Length(),targetFolder);
272 delete st; 273 delete st;
273 } 274 }
274 if (moveit) { 275 if (moveit) {
275 deleteMail(mail); 276 deleteMail(mail);
276 } 277 }
277} 278}
diff --git a/kmicromail/libmailwrapper/genericwrapper.cpp b/kmicromail/libmailwrapper/genericwrapper.cpp
index c3a1627..d99c6a3 100644
--- a/kmicromail/libmailwrapper/genericwrapper.cpp
+++ b/kmicromail/libmailwrapper/genericwrapper.cpp
@@ -1,533 +1,548 @@
1// CHANGED 2004-09-31 Lutz Rogowski 1// CHANGED 2004-09-31 Lutz Rogowski
2#include "genericwrapper.h" 2#include "genericwrapper.h"
3#include <libetpan/libetpan.h> 3#include <libetpan/libetpan.h>
4#include "mailtypes.h" 4#include "mailtypes.h"
5 5
6#include <kconfig.h> 6#include <kconfig.h>
7#include <kglobal.h> 7#include <kglobal.h>
8#include <kstandarddirs.h> 8#include <kstandarddirs.h>
9 9
10 10
11using namespace Opie::Core; 11using namespace Opie::Core;
12Genericwrapper::Genericwrapper() 12Genericwrapper::Genericwrapper()
13 : AbstractMail() 13 : AbstractMail()
14{ 14{
15 bodyCache.clear(); 15 bodyCache.clear();
16 m_storage = 0; 16 m_storage = 0;
17 m_folder = 0; 17 m_folder = 0;
18} 18}
19 19
20Genericwrapper::~Genericwrapper() 20Genericwrapper::~Genericwrapper()
21{ 21{
22 if (m_folder) { 22 if (m_folder) {
23 mailfolder_free(m_folder); 23 mailfolder_free(m_folder);
24 } 24 }
25 if (m_storage) { 25 if (m_storage) {
26 mailstorage_free(m_storage); 26 mailstorage_free(m_storage);
27 } 27 }
28 cleanMimeCache(); 28 cleanMimeCache();
29} 29}
30QString Genericwrapper::parseDateTime( mailimf_date_time *date ) 30const QDateTime Genericwrapper::parseDateTime( mailimf_date_time *date )
31{ 31{
32 static bool init = false ; 32 static bool init = false ;
33 if ( ! init ) { 33 if ( ! init ) {
34 KConfig kon ( locateLocal( "config", "korganizerrc" ) ); 34 KConfig kon ( locateLocal( "config", "korganizerrc" ) );
35 kon.setGroup("Locale"); 35 kon.setGroup("Locale");
36 KGlobal::locale()->setIntDateFormat( (KLocale::IntDateFormat)kon.readNumEntry( "PreferredDate",0) ); 36 KGlobal::locale()->setIntDateFormat( (KLocale::IntDateFormat)kon.readNumEntry( "PreferredDate",0) );
37 QString dummy = kon.readEntry( "UserDateFormatShort","%aK %d.%m.%y" );// kon.readEntry( ""); 37 QString dummy = kon.readEntry( "UserDateFormatShort","%aK %d.%m.%y" );// kon.readEntry( "");
38 KGlobal::locale()->setHore24Format( !kon.readBoolEntry( "PreferredTime",0 ) ); 38 KGlobal::locale()->setHore24Format( !kon.readBoolEntry( "PreferredTime",0 ) );
39 KGlobal::locale()->setDateFormatShort(dummy.replace( QRegExp("K"), QString(",") )); 39 KGlobal::locale()->setDateFormatShort(dummy.replace( QRegExp("K"), QString(",") ));
40 dummy = kon.readEntry( "UserDateFormatLong","%A %d %b %y" ); 40 dummy = kon.readEntry( "UserDateFormatLong","%A %d %b %y" );
41 KGlobal::locale()->setDateFormat(dummy.replace( QRegExp("K"), QString(",") )); 41 KGlobal::locale()->setDateFormat(dummy.replace( QRegExp("K"), QString(",") ));
42 kon.setGroup("Time & Date"); 42 kon.setGroup("Time & Date");
43 KGlobal::locale()->setDaylightSaving( kon.readBoolEntry( "UseDaylightsaving", true ), 43 KGlobal::locale()->setDaylightSaving( kon.readBoolEntry( "UseDaylightsaving", true ),
44 kon.readNumEntry( "DaylightsavingStart", 90), 44 kon.readNumEntry( "DaylightsavingStart", 90),
45 kon.readNumEntry( "DaylightsavingEnd",304) ); 45 kon.readNumEntry( "DaylightsavingEnd",304) );
46 KGlobal::locale()->setTimezone( kon.readEntry( "TimeZoneName" ," 00:00 Europe/London(UTC)") ); 46 KGlobal::locale()->setTimezone( kon.readEntry( "TimeZoneName" ," 00:00 Europe/London(UTC)") );
47 47
48 init = true; 48 init = true;
49 49
50 } 50 }
51 QDate da (date->dt_year,date->dt_month, date->dt_day ); 51 QDate da (date->dt_year,date->dt_month, date->dt_day );
52 QTime ti ( date->dt_hour, date->dt_min, date->dt_sec ); 52 QTime ti ( date->dt_hour, date->dt_min, date->dt_sec );
53 QDateTime dt ( da ,ti ); 53 QDateTime dt ( da ,ti );
54 int addsec = -date->dt_zone*36;
55 //qDebug("adsec1 %d ",addsec );
56 dt = dt.addSecs( addsec );
54 int off = KGlobal::locale()->localTimeOffset( dt ); 57 int off = KGlobal::locale()->localTimeOffset( dt );
55 //dt = dt.addSecs( off*60 ); 58 //qDebug("adsec2 %d ",off*60 );
59
60 dt = dt.addSecs( off*60 );
61 return dt;
62#if 0
56 QString ret; 63 QString ret;
57 if ( da == QDate::currentDate () ) 64 if ( dt.date() == QDate::currentDate () )
58 ret = KGlobal::locale()->formatTime( ti,true); 65 ret = KGlobal::locale()->formatTime( dt.time(),true);
59 66
60 else { 67 else {
61 ret = KGlobal::locale()->formatDateTime( dt,true,true); 68 ret = KGlobal::locale()->formatDateTime( dt,true,true);
62 } 69 }
70#endif
63#if 0 71#if 0
64 if ( off < 0 ) 72 if ( off < 0 )
65 ret += " -"; 73 ret += " -";
66 else 74 else
67 ret += " +"; 75 ret += " +";
68 ret += QString::number( off / 60 ); 76 ret += QString::number( off / 60 );
69 ret += "h"; 77 ret += "h";
70#endif 78#endif
71#if 0 79#if 0
72 char tmp[23]; 80 char tmp[23];
73 81
74 // snprintf( tmp, 23, "%02i.%02i.%04i %02i:%02i:%02i %+05i", 82 // snprintf( tmp, 23, "%02i.%02i.%04i %02i:%02i:%02i %+05i",
75 // date->dt_day, date->dt_month, date->dt_year, date->dt_hour, date->dt_min, date->dt_sec, date->dt_zone ); 83 // date->dt_day, date->dt_month, date->dt_year, date->dt_hour, date->dt_min, date->dt_sec, date->dt_zone );
76 snprintf( tmp, 23, "%04i-%02i-%02i %02i:%02i:%02i %+05i", 84 snprintf( tmp, 23, "%04i-%02i-%02i %02i:%02i:%02i %+05i",
77 date->dt_year,date->dt_month, date->dt_day, date->dt_hour, date->dt_min, date->dt_sec, date->dt_zone ); 85 date->dt_year,date->dt_month, date->dt_day, date->dt_hour, date->dt_min, date->dt_sec, date->dt_zone );
78 86
79 87
80 return QString( tmp ); 88 return QString( tmp );
81#endif 89#endif
82 return ret; 90 //return ret;
83} 91}
84 92
85void Genericwrapper::fillSingleBody(RecPartP&target,mailmessage*,mailmime*mime) 93void Genericwrapper::fillSingleBody(RecPartP&target,mailmessage*,mailmime*mime)
86{ 94{
87 if (!mime) { 95 if (!mime) {
88 return; 96 return;
89 } 97 }
90 mailmime_field*field = 0; 98 mailmime_field*field = 0;
91 mailmime_single_fields fields; 99 mailmime_single_fields fields;
92 memset(&fields, 0, sizeof(struct mailmime_single_fields)); 100 memset(&fields, 0, sizeof(struct mailmime_single_fields));
93 if (mime->mm_mime_fields != NULL) { 101 if (mime->mm_mime_fields != NULL) {
94 mailmime_single_fields_init(&fields, mime->mm_mime_fields, 102 mailmime_single_fields_init(&fields, mime->mm_mime_fields,
95 mime->mm_content_type); 103 mime->mm_content_type);
96 } 104 }
97 105
98 mailmime_content*type = fields.fld_content; 106 mailmime_content*type = fields.fld_content;
99 clistcell*current; 107 clistcell*current;
100 if (!type) { 108 if (!type) {
101 target->setType("text"); 109 target->setType("text");
102 target->setSubtype("plain"); 110 target->setSubtype("plain");
103 } else { 111 } else {
104 target->setSubtype(type->ct_subtype); 112 target->setSubtype(type->ct_subtype);
105 switch(type->ct_type->tp_data.tp_discrete_type->dt_type) { 113 switch(type->ct_type->tp_data.tp_discrete_type->dt_type) {
106 case MAILMIME_DISCRETE_TYPE_TEXT: 114 case MAILMIME_DISCRETE_TYPE_TEXT:
107 target->setType("text"); 115 target->setType("text");
108 break; 116 break;
109 case MAILMIME_DISCRETE_TYPE_IMAGE: 117 case MAILMIME_DISCRETE_TYPE_IMAGE:
110 target->setType("image"); 118 target->setType("image");
111 break; 119 break;
112 case MAILMIME_DISCRETE_TYPE_AUDIO: 120 case MAILMIME_DISCRETE_TYPE_AUDIO:
113 target->setType("audio"); 121 target->setType("audio");
114 break; 122 break;
115 case MAILMIME_DISCRETE_TYPE_VIDEO: 123 case MAILMIME_DISCRETE_TYPE_VIDEO:
116 target->setType("video"); 124 target->setType("video");
117 break; 125 break;
118 case MAILMIME_DISCRETE_TYPE_APPLICATION: 126 case MAILMIME_DISCRETE_TYPE_APPLICATION:
119 target->setType("application"); 127 target->setType("application");
120 break; 128 break;
121 case MAILMIME_DISCRETE_TYPE_EXTENSION: 129 case MAILMIME_DISCRETE_TYPE_EXTENSION:
122 default: 130 default:
123 if (type->ct_type->tp_data.tp_discrete_type->dt_extension) { 131 if (type->ct_type->tp_data.tp_discrete_type->dt_extension) {
124 target->setType(type->ct_type->tp_data.tp_discrete_type->dt_extension); 132 target->setType(type->ct_type->tp_data.tp_discrete_type->dt_extension);
125 } 133 }
126 break; 134 break;
127 } 135 }
128 if (type->ct_parameters) { 136 if (type->ct_parameters) {
129 fillParameters(target,type->ct_parameters); 137 fillParameters(target,type->ct_parameters);
130 } 138 }
131 } 139 }
132 if (mime->mm_mime_fields && mime->mm_mime_fields->fld_list) { 140 if (mime->mm_mime_fields && mime->mm_mime_fields->fld_list) {
133 for (current=clist_begin(mime->mm_mime_fields->fld_list);current!=0;current=clist_next(current)) { 141 for (current=clist_begin(mime->mm_mime_fields->fld_list);current!=0;current=clist_next(current)) {
134 field = (mailmime_field*)current->data; 142 field = (mailmime_field*)current->data;
135 switch(field->fld_type) { 143 switch(field->fld_type) {
136 case MAILMIME_FIELD_TRANSFER_ENCODING: 144 case MAILMIME_FIELD_TRANSFER_ENCODING:
137 target->setEncoding(getencoding(field->fld_data.fld_encoding)); 145 target->setEncoding(getencoding(field->fld_data.fld_encoding));
138 break; 146 break;
139 case MAILMIME_FIELD_ID: 147 case MAILMIME_FIELD_ID:
140 target->setIdentifier(field->fld_data.fld_id); 148 target->setIdentifier(field->fld_data.fld_id);
141 break; 149 break;
142 case MAILMIME_FIELD_DESCRIPTION: 150 case MAILMIME_FIELD_DESCRIPTION:
143 target->setDescription(field->fld_data.fld_description); 151 target->setDescription(field->fld_data.fld_description);
144 break; 152 break;
145 default: 153 default:
146 break; 154 break;
147 } 155 }
148 } 156 }
149 } 157 }
150} 158}
151 159
152void Genericwrapper::fillParameters(RecPartP&target,clist*parameters) 160void Genericwrapper::fillParameters(RecPartP&target,clist*parameters)
153{ 161{
154 if (!parameters) {return;} 162 if (!parameters) {return;}
155 clistcell*current=0; 163 clistcell*current=0;
156 mailmime_parameter*param; 164 mailmime_parameter*param;
157 for (current=clist_begin(parameters);current!=0;current=clist_next(current)) { 165 for (current=clist_begin(parameters);current!=0;current=clist_next(current)) {
158 param = (mailmime_parameter*)current->data; 166 param = (mailmime_parameter*)current->data;
159 if (param) { 167 if (param) {
160 target->addParameter(QString(param->pa_name).lower(),QString(param->pa_value)); 168 target->addParameter(QString(param->pa_name).lower(),QString(param->pa_value));
161 } 169 }
162 } 170 }
163} 171}
164 172
165QString Genericwrapper::getencoding(mailmime_mechanism*aEnc) 173QString Genericwrapper::getencoding(mailmime_mechanism*aEnc)
166{ 174{
167 QString enc="7bit"; 175 QString enc="7bit";
168 if (!aEnc) return enc; 176 if (!aEnc) return enc;
169 switch(aEnc->enc_type) { 177 switch(aEnc->enc_type) {
170 case MAILMIME_MECHANISM_7BIT: 178 case MAILMIME_MECHANISM_7BIT:
171 enc = "7bit"; 179 enc = "7bit";
172 break; 180 break;
173 case MAILMIME_MECHANISM_8BIT: 181 case MAILMIME_MECHANISM_8BIT:
174 enc = "8bit"; 182 enc = "8bit";
175 break; 183 break;
176 case MAILMIME_MECHANISM_BINARY: 184 case MAILMIME_MECHANISM_BINARY:
177 enc = "binary"; 185 enc = "binary";
178 break; 186 break;
179 case MAILMIME_MECHANISM_QUOTED_PRINTABLE: 187 case MAILMIME_MECHANISM_QUOTED_PRINTABLE:
180 enc = "quoted-printable"; 188 enc = "quoted-printable";
181 break; 189 break;
182 case MAILMIME_MECHANISM_BASE64: 190 case MAILMIME_MECHANISM_BASE64:
183 enc = "base64"; 191 enc = "base64";
184 break; 192 break;
185 case MAILMIME_MECHANISM_TOKEN: 193 case MAILMIME_MECHANISM_TOKEN:
186 default: 194 default:
187 if (aEnc->enc_token) { 195 if (aEnc->enc_token) {
188 enc = QString(aEnc->enc_token); 196 enc = QString(aEnc->enc_token);
189 } 197 }
190 break; 198 break;
191 } 199 }
192 return enc; 200 return enc;
193} 201}
194 202
195void Genericwrapper::traverseBody(RecBodyP&target,mailmessage*message,mailmime*mime,QValueList<int>recList,unsigned int current_rec,int current_count) 203void Genericwrapper::traverseBody(RecBodyP&target,mailmessage*message,mailmime*mime,QValueList<int>recList,unsigned int current_rec,int current_count)
196{ 204{
197 if (current_rec >= 10) { 205 if (current_rec >= 10) {
198 ; // odebug << "too deep recursion!" << oendl; 206 ; // odebug << "too deep recursion!" << oendl;
199 } 207 }
200 if (!message || !mime) { 208 if (!message || !mime) {
201 return; 209 return;
202 } 210 }
203 int r; 211 int r;
204 char*data = 0; 212 char*data = 0;
205 size_t len; 213 size_t len;
206 clistiter * cur = 0; 214 clistiter * cur = 0;
207 QString b; 215 QString b;
208 RecPartP part = new RecPart(); 216 RecPartP part = new RecPart();
209 217
210 switch (mime->mm_type) { 218 switch (mime->mm_type) {
211 case MAILMIME_SINGLE: 219 case MAILMIME_SINGLE:
212 { 220 {
213 QValueList<int>countlist = recList; 221 QValueList<int>countlist = recList;
214 countlist.append(current_count); 222 countlist.append(current_count);
215 r = mailmessage_fetch_section(message,mime,&data,&len); 223 r = mailmessage_fetch_section(message,mime,&data,&len);
216 part->setSize(len); 224 part->setSize(len);
217 part->setPositionlist(countlist); 225 part->setPositionlist(countlist);
218 b = gen_attachment_id(); 226 b = gen_attachment_id();
219 part->setIdentifier(b); 227 part->setIdentifier(b);
220 fillSingleBody(part,message,mime); 228 fillSingleBody(part,message,mime);
221 if (part->Type()=="text" && target->Bodytext().isNull()) { 229 if (part->Type()=="text" && target->Bodytext().isNull()) {
222 encodedString*rs = new encodedString(); 230 encodedString*rs = new encodedString();
223 rs->setContent(data,len); 231 rs->setContent(data,len);
224 encodedString*res = decode_String(rs,part->Encoding()); 232 encodedString*res = decode_String(rs,part->Encoding());
225 if (countlist.count()>2) { 233 if (countlist.count()>2) {
226 bodyCache[b]=rs; 234 bodyCache[b]=rs;
227 target->addPart(part); 235 target->addPart(part);
228 } else { 236 } else {
229 delete rs; 237 delete rs;
230 } 238 }
231 b = QString(res->Content()); 239 b = QString(res->Content());
232 delete res; 240 delete res;
233 target->setBodytext(b); 241 target->setBodytext(b);
234 target->setDescription(part); 242 target->setDescription(part);
235 } else { 243 } else {
236 bodyCache[b]=new encodedString(data,len); 244 bodyCache[b]=new encodedString(data,len);
237 target->addPart(part); 245 target->addPart(part);
238 } 246 }
239 } 247 }
240 break; 248 break;
241 case MAILMIME_MULTIPLE: 249 case MAILMIME_MULTIPLE:
242 { 250 {
243 unsigned int ccount = 1; 251 unsigned int ccount = 1;
244 mailmime*cbody=0; 252 mailmime*cbody=0;
245 QValueList<int>countlist = recList; 253 QValueList<int>countlist = recList;
246 for (cur = clist_begin(mime->mm_data.mm_multipart.mm_mp_list) ; cur != NULL ; cur = clist_next(cur)) { 254 for (cur = clist_begin(mime->mm_data.mm_multipart.mm_mp_list) ; cur != NULL ; cur = clist_next(cur)) {
247 cbody = (mailmime*)clist_content(cur); 255 cbody = (mailmime*)clist_content(cur);
248 if (cbody->mm_type==MAILMIME_MULTIPLE) { 256 if (cbody->mm_type==MAILMIME_MULTIPLE) {
249 RecPartP targetPart = new RecPart(); 257 RecPartP targetPart = new RecPart();
250 targetPart->setType("multipart"); 258 targetPart->setType("multipart");
251 countlist.append(current_count); 259 countlist.append(current_count);
252 targetPart->setPositionlist(countlist); 260 targetPart->setPositionlist(countlist);
253 target->addPart(targetPart); 261 target->addPart(targetPart);
254 } 262 }
255 traverseBody(target,message, cbody,countlist,current_rec+1,ccount); 263 traverseBody(target,message, cbody,countlist,current_rec+1,ccount);
256 if (cbody->mm_type==MAILMIME_MULTIPLE) { 264 if (cbody->mm_type==MAILMIME_MULTIPLE) {
257 countlist = recList; 265 countlist = recList;
258 } 266 }
259 ++ccount; 267 ++ccount;
260 } 268 }
261 } 269 }
262 break; 270 break;
263 case MAILMIME_MESSAGE: 271 case MAILMIME_MESSAGE:
264 { 272 {
265 QValueList<int>countlist = recList; 273 QValueList<int>countlist = recList;
266 countlist.append(current_count); 274 countlist.append(current_count);
267 /* the own header is always at recursion 0 - we don't need that */ 275 /* the own header is always at recursion 0 - we don't need that */
268 if (current_rec > 0) { 276 if (current_rec > 0) {
269 part->setPositionlist(countlist); 277 part->setPositionlist(countlist);
270 r = mailmessage_fetch_section(message,mime,&data,&len); 278 r = mailmessage_fetch_section(message,mime,&data,&len);
271 part->setSize(len); 279 part->setSize(len);
272 part->setPositionlist(countlist); 280 part->setPositionlist(countlist);
273 b = gen_attachment_id(); 281 b = gen_attachment_id();
274 part->setIdentifier(b); 282 part->setIdentifier(b);
275 part->setType("message"); 283 part->setType("message");
276 part->setSubtype("rfc822"); 284 part->setSubtype("rfc822");
277 bodyCache[b]=new encodedString(data,len); 285 bodyCache[b]=new encodedString(data,len);
278 target->addPart(part); 286 target->addPart(part);
279 } 287 }
280 if (mime->mm_data.mm_message.mm_msg_mime != NULL) { 288 if (mime->mm_data.mm_message.mm_msg_mime != NULL) {
281 traverseBody(target,message,mime->mm_data.mm_message.mm_msg_mime,countlist,current_rec+1); 289 traverseBody(target,message,mime->mm_data.mm_message.mm_msg_mime,countlist,current_rec+1);
282 } 290 }
283 } 291 }
284 break; 292 break;
285 } 293 }
286} 294}
287 295
288RecBodyP Genericwrapper::parseMail( mailmessage * msg ) 296RecBodyP Genericwrapper::parseMail( mailmessage * msg )
289{ 297{
290 int err = MAILIMF_NO_ERROR; 298 int err = MAILIMF_NO_ERROR;
291 mailmime_single_fields fields; 299 mailmime_single_fields fields;
292 /* is bound to msg and will be freed there */ 300 /* is bound to msg and will be freed there */
293 mailmime * mime=0; 301 mailmime * mime=0;
294 RecBodyP body = new RecBody(); 302 RecBodyP body = new RecBody();
295 memset(&fields, 0, sizeof(struct mailmime_single_fields)); 303 memset(&fields, 0, sizeof(struct mailmime_single_fields));
296 err = mailmessage_get_bodystructure(msg,&mime); 304 err = mailmessage_get_bodystructure(msg,&mime);
297 QValueList<int>recList; 305 QValueList<int>recList;
298 traverseBody(body,msg,mime,recList); 306 traverseBody(body,msg,mime,recList);
299 return body; 307 return body;
300} 308}
301 309
302 310
303QString Genericwrapper::parseAddressList( mailimf_address_list *list ) 311QString Genericwrapper::parseAddressList( mailimf_address_list *list )
304{ 312{
305 QString result( "" ); 313 QString result( "" );
306 314
307 bool first = true; 315 bool first = true;
308 if (list == 0) return result; 316 if (list == 0) return result;
309 for ( clistiter *current = clist_begin( list->ad_list ); current != NULL; current = current->next ) { 317 for ( clistiter *current = clist_begin( list->ad_list ); current != NULL; current = current->next ) {
310 mailimf_address *addr = (mailimf_address *) current->data; 318 mailimf_address *addr = (mailimf_address *) current->data;
311 319
312 if ( !first ) { 320 if ( !first ) {
313 result.append( "," ); 321 result.append( "," );
314 } else { 322 } else {
315 first = false; 323 first = false;
316 } 324 }
317 325
318 switch ( addr->ad_type ) { 326 switch ( addr->ad_type ) {
319 case MAILIMF_ADDRESS_MAILBOX: 327 case MAILIMF_ADDRESS_MAILBOX:
320 result.append( parseMailbox( addr->ad_data.ad_mailbox ) ); 328 result.append( parseMailbox( addr->ad_data.ad_mailbox ) );
321 break; 329 break;
322 case MAILIMF_ADDRESS_GROUP: 330 case MAILIMF_ADDRESS_GROUP:
323 result.append( parseGroup( addr->ad_data.ad_group ) ); 331 result.append( parseGroup( addr->ad_data.ad_group ) );
324 break; 332 break;
325 default: 333 default:
326 ; // odebug << "Generic: unkown mailimf address type" << oendl; 334 ; // odebug << "Generic: unkown mailimf address type" << oendl;
327 break; 335 break;
328 } 336 }
329 } 337 }
330 338
331 return result; 339 return result;
332} 340}
333 341
334QString Genericwrapper::parseGroup( mailimf_group *group ) 342QString Genericwrapper::parseGroup( mailimf_group *group )
335{ 343{
336 QString result( "" ); 344 QString result( "" );
337 345
338 result.append( group->grp_display_name ); 346 result.append( group->grp_display_name );
339 result.append( ": " ); 347 result.append( ": " );
340 348
341 if ( group->grp_mb_list != NULL ) { 349 if ( group->grp_mb_list != NULL ) {
342 result.append( parseMailboxList( group->grp_mb_list ) ); 350 result.append( parseMailboxList( group->grp_mb_list ) );
343 } 351 }
344 352
345 result.append( ";" ); 353 result.append( ";" );
346 354
347 return result; 355 return result;
348} 356}
349 357
350QString Genericwrapper::parseMailbox( mailimf_mailbox *box ) 358QString Genericwrapper::parseMailbox( mailimf_mailbox *box )
351{ 359{
352 QString result( "" ); 360 QString result( "" );
353 361
354 if ( box->mb_display_name == NULL ) { 362 if ( box->mb_display_name == NULL ) {
355 result.append( box->mb_addr_spec ); 363 result.append( box->mb_addr_spec );
356 } else { 364 } else {
357 result.append( convert_String(box->mb_display_name).latin1() ); 365 result.append( convert_String(box->mb_display_name).latin1() );
358 result.append( " <" ); 366 result.append( " <" );
359 result.append( box->mb_addr_spec ); 367 result.append( box->mb_addr_spec );
360 result.append( ">" ); 368 result.append( ">" );
361 } 369 }
362 370
363 return result; 371 return result;
364} 372}
365 373
366QString Genericwrapper::parseMailboxList( mailimf_mailbox_list *list ) 374QString Genericwrapper::parseMailboxList( mailimf_mailbox_list *list )
367{ 375{
368 QString result( "" ); 376 QString result( "" );
369 377
370 bool first = true; 378 bool first = true;
371 for ( clistiter *current = clist_begin( list->mb_list ); current != NULL; current = current->next ) { 379 for ( clistiter *current = clist_begin( list->mb_list ); current != NULL; current = current->next ) {
372 mailimf_mailbox *box = (mailimf_mailbox *) current->data; 380 mailimf_mailbox *box = (mailimf_mailbox *) current->data;
373 381
374 if ( !first ) { 382 if ( !first ) {
375 result.append( "," ); 383 result.append( "," );
376 } else { 384 } else {
377 first = false; 385 first = false;
378 } 386 }
379 387
380 result.append( parseMailbox( box ) ); 388 result.append( parseMailbox( box ) );
381 } 389 }
382 390
383 return result; 391 return result;
384} 392}
385 393
386encodedString* Genericwrapper::fetchDecodedPart(const RecMailP&,const RecPartP&part) 394encodedString* Genericwrapper::fetchDecodedPart(const RecMailP&,const RecPartP&part)
387{ 395{
388 QMap<QString,encodedString*>::ConstIterator it = bodyCache.find(part->Identifier()); 396 QMap<QString,encodedString*>::ConstIterator it = bodyCache.find(part->Identifier());
389 if (it==bodyCache.end()) return new encodedString(); 397 if (it==bodyCache.end()) return new encodedString();
390 encodedString*t = decode_String(it.data(),part->Encoding()); 398 encodedString*t = decode_String(it.data(),part->Encoding());
391 return t; 399 return t;
392} 400}
393 401
394encodedString* Genericwrapper::fetchRawPart(const RecMailP&,const RecPartP&part) 402encodedString* Genericwrapper::fetchRawPart(const RecMailP&,const RecPartP&part)
395{ 403{
396 QMap<QString,encodedString*>::ConstIterator it = bodyCache.find(part->Identifier()); 404 QMap<QString,encodedString*>::ConstIterator it = bodyCache.find(part->Identifier());
397 if (it==bodyCache.end()) return new encodedString(); 405 if (it==bodyCache.end()) return new encodedString();
398 encodedString*t = it.data(); 406 encodedString*t = it.data();
399 return t; 407 return t;
400} 408}
401 409
402QString Genericwrapper::fetchTextPart(const RecMailP&mail,const RecPartP&part) 410QString Genericwrapper::fetchTextPart(const RecMailP&mail,const RecPartP&part)
403{ 411{
404 encodedString*t = fetchDecodedPart(mail,part); 412 encodedString*t = fetchDecodedPart(mail,part);
405 QString text=t->Content(); 413 QString text=t->Content();
406 delete t; 414 delete t;
407 return text; 415 return text;
408} 416}
409 417
410void Genericwrapper::cleanMimeCache() 418void Genericwrapper::cleanMimeCache()
411{ 419{
412 QMap<QString,encodedString*>::Iterator it = bodyCache.begin(); 420 QMap<QString,encodedString*>::Iterator it = bodyCache.begin();
413 for (;it!=bodyCache.end();++it) { 421 for (;it!=bodyCache.end();++it) {
414 encodedString*t = it.data(); 422 encodedString*t = it.data();
415 //it.setValue(0); 423 //it.setValue(0);
416 if (t) delete t; 424 if (t) delete t;
417 } 425 }
418 bodyCache.clear(); 426 bodyCache.clear();
419 ; // odebug << "Genericwrapper: cache cleaned" << oendl; 427 ; // odebug << "Genericwrapper: cache cleaned" << oendl;
420} 428}
421 429
422QStringList Genericwrapper::parseInreplies(mailimf_in_reply_to * in_replies) 430QStringList Genericwrapper::parseInreplies(mailimf_in_reply_to * in_replies)
423{ 431{
424 QStringList res; 432 QStringList res;
425 if (!in_replies || !in_replies->mid_list) return res; 433 if (!in_replies || !in_replies->mid_list) return res;
426 clistiter * current = 0; 434 clistiter * current = 0;
427 for ( current = clist_begin( in_replies->mid_list ); current != NULL; current = current->next ) { 435 for ( current = clist_begin( in_replies->mid_list ); current != NULL; current = current->next ) {
428 QString h((char*)current->data); 436 QString h((char*)current->data);
429 while (h.length()>0 && h[0]=='<') { 437 while (h.length()>0 && h[0]=='<') {
430 h.remove(0,1); 438 h.remove(0,1);
431 } 439 }
432 while (h.length()>0 && h[h.length()-1]=='>') { 440 while (h.length()>0 && h[h.length()-1]=='>') {
433 h.remove(h.length()-1,1); 441 h.remove(h.length()-1,1);
434 } 442 }
435 if (h.length()>0) { 443 if (h.length()>0) {
436 res.append(h); 444 res.append(h);
437 } 445 }
438 } 446 }
439 return res; 447 return res;
440} 448}
441 449
442void Genericwrapper::parseList(QValueList<Opie::Core::OSmartPointer<RecMail> > &target,mailsession*session,const QString&mailbox,bool mbox_as_to, int maxSizeInKb) 450void Genericwrapper::parseList(QValueList<Opie::Core::OSmartPointer<RecMail> > &target,mailsession*session,const QString&mailbox,bool mbox_as_to, int maxSizeInKb)
443{ 451{
444 int r; 452 int r;
445 mailmessage_list * env_list = 0; 453 mailmessage_list * env_list = 0;
446 r = mailsession_get_messages_list(session,&env_list); 454 r = mailsession_get_messages_list(session,&env_list);
447 if (r != MAIL_NO_ERROR) { 455 if (r != MAIL_NO_ERROR) {
448 ; // odebug << "Error message list" << oendl; 456 ; // odebug << "Error message list" << oendl;
449 return; 457 return;
450 } 458 }
451 r = mailsession_get_envelopes_list(session, env_list); 459 r = mailsession_get_envelopes_list(session, env_list);
452 if (r != MAIL_NO_ERROR) { 460 if (r != MAIL_NO_ERROR) {
453 ; // odebug << "Error filling message list" << oendl; 461 ; // odebug << "Error filling message list" << oendl;
454 if (env_list) { 462 if (env_list) {
455 mailmessage_list_free(env_list); 463 mailmessage_list_free(env_list);
456 } 464 }
457 return; 465 return;
458 } 466 }
459 mailimf_references * refs = 0; 467 mailimf_references * refs = 0;
460 mailimf_in_reply_to * in_replies = 0; 468 mailimf_in_reply_to * in_replies = 0;
461 uint32_t i = 0; 469 uint32_t i = 0;
462 for(; i < carray_count(env_list->msg_tab) ; ++i) { 470 for(; i < carray_count(env_list->msg_tab) ; ++i) {
463 mailmessage * msg; 471 mailmessage * msg;
464 QBitArray mFlags(7); 472 QBitArray mFlags(7);
465 msg = (mailmessage*)carray_get(env_list->msg_tab, i); 473 msg = (mailmessage*)carray_get(env_list->msg_tab, i);
466 if (msg->msg_fields == NULL) { 474 if (msg->msg_fields == NULL) {
467 //; // odebug << "could not fetch envelope of message " << i << "" << oendl; 475 //; // odebug << "could not fetch envelope of message " << i << "" << oendl;
468 continue; 476 continue;
469 } 477 }
470 RecMailP mail = new RecMail(); 478 RecMailP mail = new RecMail();
471 mail->setWrapper(this); 479 mail->setWrapper(this);
472 mail_flags * flag_result = 0; 480 mail_flags * flag_result = 0;
473 r = mailmessage_get_flags(msg,&flag_result); 481 r = mailmessage_get_flags(msg,&flag_result);
474 if (r == MAIL_ERROR_NOT_IMPLEMENTED) { 482 if (r == MAIL_ERROR_NOT_IMPLEMENTED) {
475 mFlags.setBit(FLAG_SEEN); 483 mFlags.setBit(FLAG_SEEN);
476 } 484 }
477 mailimf_single_fields single_fields; 485 mailimf_single_fields single_fields;
478 mailimf_single_fields_init(&single_fields, msg->msg_fields); 486 mailimf_single_fields_init(&single_fields, msg->msg_fields);
479 mail->setMsgsize(msg->msg_size); 487 mail->setMsgsize(msg->msg_size);
480 mail->setFlags(mFlags); 488 mail->setFlags(mFlags);
481 mail->setMbox(mailbox); 489 mail->setMbox(mailbox);
482 mail->setNumber(msg->msg_index); 490 mail->setNumber(msg->msg_index);
483 if (single_fields.fld_subject) 491 if (single_fields.fld_subject)
484 mail->setSubject( convert_String(single_fields.fld_subject->sbj_value)); 492 mail->setSubject( convert_String(single_fields.fld_subject->sbj_value));
485 if (single_fields.fld_from) 493 if (single_fields.fld_from)
486 mail->setFrom(parseMailboxList(single_fields.fld_from->frm_mb_list)); 494 mail->setFrom(parseMailboxList(single_fields.fld_from->frm_mb_list));
487 if (!mbox_as_to) { 495 if (!mbox_as_to) {
488 if (single_fields.fld_to) 496 if (single_fields.fld_to)
489 mail->setTo( parseAddressList( single_fields.fld_to->to_addr_list ) ); 497 mail->setTo( parseAddressList( single_fields.fld_to->to_addr_list ) );
490 } else { 498 } else {
491 mail->setTo(mailbox); 499 mail->setTo(mailbox);
492 } 500 }
493 if (single_fields.fld_cc) 501 if (single_fields.fld_cc)
494 mail->setCC( parseAddressList( single_fields.fld_cc->cc_addr_list ) ); 502 mail->setCC( parseAddressList( single_fields.fld_cc->cc_addr_list ) );
495 if (single_fields.fld_bcc) 503 if (single_fields.fld_bcc)
496 mail->setBcc( parseAddressList( single_fields.fld_bcc->bcc_addr_list ) ); 504 mail->setBcc( parseAddressList( single_fields.fld_bcc->bcc_addr_list ) );
497 if (single_fields.fld_orig_date) { 505 if (single_fields.fld_orig_date) {
498 mail->setDate( parseDateTime( single_fields.fld_orig_date->dt_date_time ) ); 506 QDateTime dt = Genericwrapper::parseDateTime( single_fields.fld_orig_date->dt_date_time );
499 char tmp[23]; 507 QString ret;
500 struct mailimf_date_time* date = single_fields.fld_orig_date->dt_date_time; 508 if ( dt.date() == QDate::currentDate () )
501 snprintf( tmp, 23, "%04i-%02i-%02i %02i:%02i:%02i %05i", 509 ret = KGlobal::locale()->formatTime( dt.time(),true);
502 date->dt_year,date->dt_month, date->dt_day, date->dt_hour, date->dt_min, date->dt_sec, date->dt_zone ); 510 else {
511 ret = KGlobal::locale()->formatDateTime( dt,true,true);
512 }
513 mail->setDate( ret );
514 char tmp[20];
515 snprintf( tmp, 20, "%04i-%02i-%02i %02i:%02i:%02i",
516 dt.date().year(),dt.date().month(), dt.date().day(), dt.time().hour(), dt.time().minute(), dt.time().second() );
517 //qDebug(" iso %s ", tmp);
503 mail->setIsoDate( QString( tmp ) ); 518 mail->setIsoDate( QString( tmp ) );
504 } 519 }
505 // crashes when accessing pop3 account? 520 // crashes when accessing pop3 account?
506 if (single_fields.fld_message_id) { 521 if (single_fields.fld_message_id) {
507 mail->setMsgid(QString(single_fields.fld_message_id->mid_value)); 522 mail->setMsgid(QString(single_fields.fld_message_id->mid_value));
508 ; // odebug << "Msgid == " << mail->Msgid().latin1() << "" << oendl; 523 ; // odebug << "Msgid == " << mail->Msgid().latin1() << "" << oendl;
509 } 524 }
510 if (single_fields.fld_reply_to) { 525 if (single_fields.fld_reply_to) {
511 QStringList t = parseAddressList(single_fields.fld_reply_to->rt_addr_list); 526 QStringList t = parseAddressList(single_fields.fld_reply_to->rt_addr_list);
512 if (t.count()>0) { 527 if (t.count()>0) {
513 mail->setReplyto(t[0]); 528 mail->setReplyto(t[0]);
514 } 529 }
515 } 530 }
516#if 0 531#if 0
517 refs = single_fields.fld_references; 532 refs = single_fields.fld_references;
518 if (refs && refs->mid_list && clist_count(refs->mid_list)) { 533 if (refs && refs->mid_list && clist_count(refs->mid_list)) {
519 char * text = (char*)refs->mid_list->first->data; 534 char * text = (char*)refs->mid_list->first->data;
520 mail->setReplyto(QString(text)); 535 mail->setReplyto(QString(text));
521 } 536 }
522#endif 537#endif
523 if (single_fields.fld_in_reply_to && single_fields.fld_in_reply_to->mid_list && 538 if (single_fields.fld_in_reply_to && single_fields.fld_in_reply_to->mid_list &&
524 clist_count(single_fields.fld_in_reply_to->mid_list)) { 539 clist_count(single_fields.fld_in_reply_to->mid_list)) {
525 mail->setInreply(parseInreplies(single_fields.fld_in_reply_to)); 540 mail->setInreply(parseInreplies(single_fields.fld_in_reply_to));
526 } 541 }
527 if ( maxSizeInKb == 0 || mail->Msgsize()<=maxSizeInKb*1024 ) 542 if ( maxSizeInKb == 0 || mail->Msgsize()<=maxSizeInKb*1024 )
528 target.append(mail); 543 target.append(mail);
529 } 544 }
530 if (env_list) { 545 if (env_list) {
531 mailmessage_list_free(env_list); 546 mailmessage_list_free(env_list);
532 } 547 }
533} 548}
diff --git a/kmicromail/libmailwrapper/genericwrapper.h b/kmicromail/libmailwrapper/genericwrapper.h
index 244212f..c35a6da 100644
--- a/kmicromail/libmailwrapper/genericwrapper.h
+++ b/kmicromail/libmailwrapper/genericwrapper.h
@@ -1,68 +1,68 @@
1// CHANGED 2004-09-31 Lutz Rogowski 1// CHANGED 2004-09-31 Lutz Rogowski
2#ifndef __GENERIC_WRAPPER_H 2#ifndef __GENERIC_WRAPPER_H
3#define __GENERIC_WRAPPER_H 3#define __GENERIC_WRAPPER_H
4 4
5#include "abstractmail.h" 5#include "abstractmail.h"
6#include <qmap.h> 6#include <qmap.h>
7#include <qstring.h> 7#include <qstring.h>
8#include <libetpan/clist.h> 8#include <libetpan/clist.h>
9 9
10class RecMail; 10class RecMail;
11class RecBody; 11class RecBody;
12class encodedString; 12class encodedString;
13struct mailpop3; 13struct mailpop3;
14struct mailmessage; 14struct mailmessage;
15struct mailmime; 15struct mailmime;
16struct mailmime_mechanism; 16struct mailmime_mechanism;
17struct mailimf_mailbox_list; 17struct mailimf_mailbox_list;
18struct mailimf_mailbox; 18struct mailimf_mailbox;
19struct mailimf_date_time; 19struct mailimf_date_time;
20struct mailimf_group; 20struct mailimf_group;
21struct mailimf_address_list; 21struct mailimf_address_list;
22struct mailsession; 22struct mailsession;
23struct mailstorage; 23struct mailstorage;
24struct mailfolder; 24struct mailfolder;
25struct mailimf_in_reply_to; 25struct mailimf_in_reply_to;
26 26
27/* this class hold just the funs shared between 27/* this class hold just the funs shared between
28 * mbox and pop3 (later mh, too) mail access. 28 * mbox and pop3 (later mh, too) mail access.
29 * it is not desigend to make a instance of it! 29 * it is not desigend to make a instance of it!
30 */ 30 */
31class Genericwrapper : public AbstractMail 31class Genericwrapper : public AbstractMail
32{ 32{
33 Q_OBJECT 33 Q_OBJECT
34public: 34public:
35 Genericwrapper(); 35 Genericwrapper();
36 virtual ~Genericwrapper(); 36 virtual ~Genericwrapper();
37 37
38 virtual encodedString* fetchDecodedPart(const RecMailP&mail,const RecPartP&part); 38 virtual encodedString* fetchDecodedPart(const RecMailP&mail,const RecPartP&part);
39 virtual encodedString* fetchRawPart(const RecMailP&mail,const RecPartP&part); 39 virtual encodedString* fetchRawPart(const RecMailP&mail,const RecPartP&part);
40 virtual QString fetchTextPart(const RecMailP&mail,const RecPartP&part); 40 virtual QString fetchTextPart(const RecMailP&mail,const RecPartP&part);
41 virtual void cleanMimeCache(); 41 virtual void cleanMimeCache();
42 virtual int deleteMbox(const Opie::Core::OSmartPointer<Folder>&){return 1;} 42 virtual int deleteMbox(const Opie::Core::OSmartPointer<Folder>&){return 1;}
43 virtual void logout(){}; 43 virtual void logout(){};
44 virtual void storeMessage(const char*msg,size_t length, const QString&folder){}; 44 virtual void storeMessage(const char*msg,size_t length, const QString&folder){};
45 static QString parseDateTime( mailimf_date_time *date ); 45 static const QDateTime parseDateTime( mailimf_date_time *date );
46 46
47protected: 47protected:
48 RecBodyP parseMail( mailmessage * msg ); 48 RecBodyP parseMail( mailmessage * msg );
49 QString parseMailboxList( mailimf_mailbox_list *list ); 49 QString parseMailboxList( mailimf_mailbox_list *list );
50 QString parseMailbox( mailimf_mailbox *box ); 50 QString parseMailbox( mailimf_mailbox *box );
51 QString parseGroup( mailimf_group *group ); 51 QString parseGroup( mailimf_group *group );
52 QString parseAddressList( mailimf_address_list *list ); 52 QString parseAddressList( mailimf_address_list *list );
53 53
54 void traverseBody(RecBodyP&target,mailmessage*message,mailmime*mime,QValueList<int>recList,unsigned int current_rek=0,int current_count=1); 54 void traverseBody(RecBodyP&target,mailmessage*message,mailmime*mime,QValueList<int>recList,unsigned int current_rek=0,int current_count=1);
55 static void fillSingleBody(RecPartP&target,mailmessage*message,mailmime*mime); 55 static void fillSingleBody(RecPartP&target,mailmessage*message,mailmime*mime);
56 static void fillParameters(RecPartP&target,clist*parameters); 56 static void fillParameters(RecPartP&target,clist*parameters);
57 static QString getencoding(mailmime_mechanism*aEnc); 57 static QString getencoding(mailmime_mechanism*aEnc);
58 virtual void parseList(QValueList<Opie::Core::OSmartPointer<RecMail> > &target,mailsession*session,const QString&mailbox,bool mbox_as_to=false, int maxSizeInKb = 0); 58 virtual void parseList(QValueList<Opie::Core::OSmartPointer<RecMail> > &target,mailsession*session,const QString&mailbox,bool mbox_as_to=false, int maxSizeInKb = 0);
59 QStringList parseInreplies(mailimf_in_reply_to * in_replies); 59 QStringList parseInreplies(mailimf_in_reply_to * in_replies);
60 60
61 QString msgTempName; 61 QString msgTempName;
62 unsigned int last_msg_id; 62 unsigned int last_msg_id;
63 QMap<QString,encodedString*> bodyCache; 63 QMap<QString,encodedString*> bodyCache;
64 mailstorage * m_storage; 64 mailstorage * m_storage;
65 mailfolder*m_folder; 65 mailfolder*m_folder;
66}; 66};
67 67
68#endif 68#endif
diff --git a/kmicromail/libmailwrapper/imapwrapper.cpp b/kmicromail/libmailwrapper/imapwrapper.cpp
index d79df4f..b0dd1b8 100644
--- a/kmicromail/libmailwrapper/imapwrapper.cpp
+++ b/kmicromail/libmailwrapper/imapwrapper.cpp
@@ -1,727 +1,736 @@
1// CHANGED 2004-09-31 Lutz Rogowski 1// CHANGED 2004-09-31 Lutz Rogowski
2#include <stdlib.h> 2#include <stdlib.h>
3#include <libetpan/libetpan.h> 3#include <libetpan/libetpan.h>
4#include <qpe/global.h> 4#include <qpe/global.h>
5#include <qapplication.h> 5#include <qapplication.h>
6#include "imapwrapper.h" 6#include "imapwrapper.h"
7#include "mailtypes.h" 7#include "mailtypes.h"
8#include "logindialog.h" 8#include "logindialog.h"
9#include <qprogressbar.h> 9#include <qprogressbar.h>
10#include "genericwrapper.h" 10#include "genericwrapper.h"
11#include <kglobal.h>
11 12
12using namespace Opie::Core; 13using namespace Opie::Core;
13int IMAPwrapper::mMax = 0; 14int IMAPwrapper::mMax = 0;
14int IMAPwrapper::mCurrent = 0; 15int IMAPwrapper::mCurrent = 0;
15 16
16IMAPwrapper::IMAPwrapper( IMAPaccount *a ) 17IMAPwrapper::IMAPwrapper( IMAPaccount *a )
17 : AbstractMail() 18 : AbstractMail()
18{ 19{
19 account = a; 20 account = a;
20 m_imap = 0; 21 m_imap = 0;
21 m_Lastmbox = ""; 22 m_Lastmbox = "";
22 mCurrent = 0; 23 mCurrent = 0;
23 mMax = 0; 24 mMax = 0;
24} 25}
25 26
26IMAPwrapper::~IMAPwrapper() 27IMAPwrapper::~IMAPwrapper()
27{ 28{
28 logout(); 29 logout();
29} 30}
30 31
31/* to avoid to often select statements in loops etc. 32/* to avoid to often select statements in loops etc.
32 we trust that we are logged in and connection is established!*/ 33 we trust that we are logged in and connection is established!*/
33int IMAPwrapper::selectMbox(const QString&mbox) 34int IMAPwrapper::selectMbox(const QString&mbox)
34{ 35{
35 if (mbox == m_Lastmbox) { 36 if (mbox == m_Lastmbox) {
36 return MAILIMAP_NO_ERROR; 37 return MAILIMAP_NO_ERROR;
37 } 38 }
38 int err = mailimap_select( m_imap, (char*)mbox.latin1()); 39 int err = mailimap_select( m_imap, (char*)mbox.latin1());
39 if ( err != MAILIMAP_NO_ERROR ) { 40 if ( err != MAILIMAP_NO_ERROR ) {
40 m_Lastmbox = ""; 41 m_Lastmbox = "";
41 return err; 42 return err;
42 } 43 }
43 m_Lastmbox = mbox; 44 m_Lastmbox = mbox;
44 return err; 45 return err;
45} 46}
46 47
47void IMAPwrapper::imap_progress( size_t current, size_t maximum ) 48void IMAPwrapper::imap_progress( size_t current, size_t maximum )
48{ 49{
49 //qDebug("imap progress %d of %d ",current,maximum ); 50 //qDebug("imap progress %d of %d ",current,maximum );
50 //Global::statusMessage(tr("Downloading message %1 of %2").arg( current).arg(maximum)); 51 //Global::statusMessage(tr("Downloading message %1 of %2").arg( current).arg(maximum));
51 //qApp->processEvents() 52 //qApp->processEvents()
52 static int last = 0; 53 static int last = 0;
53 if ( last != current ) 54 if ( last != current )
54 IMAPwrapper::progress(); 55 IMAPwrapper::progress();
55 last = current; 56 last = current;
56} 57}
57void IMAPwrapper::progress( QString m ) 58void IMAPwrapper::progress( QString m )
58{ 59{
59 60
60 static QString mProgrMess; 61 static QString mProgrMess;
61 if ( m != QString::null ) { 62 if ( m != QString::null ) {
62 mProgrMess = m; 63 mProgrMess = m;
63 mCurrent = 0; 64 mCurrent = 0;
64 return; 65 return;
65 } 66 }
66 QString mess; 67 QString mess;
67 //qDebug("progress "); 68 //qDebug("progress ");
68 if ( mMax ) mess = mProgrMess +tr(" message %1 of %2").arg( mCurrent++).arg(mMax); 69 if ( mMax ) mess = mProgrMess +tr(" message %1 of %2").arg( mCurrent++).arg(mMax);
69 else mess = mProgrMess +tr(" message %1").arg( mCurrent++); 70 else mess = mProgrMess +tr(" message %1").arg( mCurrent++);
70 Global::statusMessage(mess); 71 Global::statusMessage(mess);
71 qApp->processEvents(); 72 qApp->processEvents();
72} 73}
73bool IMAPwrapper::start_tls(bool force_tls) 74bool IMAPwrapper::start_tls(bool force_tls)
74{ 75{
75 int err; 76 int err;
76 bool try_tls; 77 bool try_tls;
77 mailimap_capability_data * cap_data = 0; 78 mailimap_capability_data * cap_data = 0;
78 79
79 err = mailimap_capability(m_imap,&cap_data); 80 err = mailimap_capability(m_imap,&cap_data);
80 if (err != MAILIMAP_NO_ERROR) { 81 if (err != MAILIMAP_NO_ERROR) {
81 Global::statusMessage("error getting capabilities!"); 82 Global::statusMessage("error getting capabilities!");
82 return false; 83 return false;
83 } 84 }
84 clistiter * cur; 85 clistiter * cur;
85 for(cur = clist_begin(cap_data->cap_list) ; cur != NULL;cur = clist_next(cur)) { 86 for(cur = clist_begin(cap_data->cap_list) ; cur != NULL;cur = clist_next(cur)) {
86 struct mailimap_capability * cap; 87 struct mailimap_capability * cap;
87 cap = (struct mailimap_capability *)clist_content(cur); 88 cap = (struct mailimap_capability *)clist_content(cur);
88 if (cap->cap_type == MAILIMAP_CAPABILITY_NAME) { 89 if (cap->cap_type == MAILIMAP_CAPABILITY_NAME) {
89 if (strcasecmp(cap->cap_data.cap_name, "STARTTLS") == 0) { 90 if (strcasecmp(cap->cap_data.cap_name, "STARTTLS") == 0) {
90 try_tls = true; 91 try_tls = true;
91 break; 92 break;
92 } 93 }
93 } 94 }
94 } 95 }
95 if (cap_data) { 96 if (cap_data) {
96 mailimap_capability_data_free(cap_data); 97 mailimap_capability_data_free(cap_data);
97 } 98 }
98 if (try_tls) { 99 if (try_tls) {
99 err = mailimap_starttls(m_imap); 100 err = mailimap_starttls(m_imap);
100 if (err != MAILIMAP_NO_ERROR && force_tls) { 101 if (err != MAILIMAP_NO_ERROR && force_tls) {
101 Global::statusMessage(tr("Server has no TLS support!")); 102 Global::statusMessage(tr("Server has no TLS support!"));
102 try_tls = false; 103 try_tls = false;
103 } else { 104 } else {
104 mailstream_low * low; 105 mailstream_low * low;
105 mailstream_low * new_low; 106 mailstream_low * new_low;
106 low = mailstream_get_low(m_imap->imap_stream); 107 low = mailstream_get_low(m_imap->imap_stream);
107 if (!low) { 108 if (!low) {
108 try_tls = false; 109 try_tls = false;
109 } else { 110 } else {
110 int fd = mailstream_low_get_fd(low); 111 int fd = mailstream_low_get_fd(low);
111 if (fd > -1 && (new_low = mailstream_low_ssl_open(fd))!=0) { 112 if (fd > -1 && (new_low = mailstream_low_ssl_open(fd))!=0) {
112 mailstream_low_free(low); 113 mailstream_low_free(low);
113 mailstream_set_low(m_imap->imap_stream, new_low); 114 mailstream_set_low(m_imap->imap_stream, new_low);
114 } else { 115 } else {
115 try_tls = false; 116 try_tls = false;
116 } 117 }
117 } 118 }
118 } 119 }
119 } 120 }
120 return try_tls; 121 return try_tls;
121} 122}
122 123
123void IMAPwrapper::login() 124void IMAPwrapper::login()
124{ 125{
125 QString server, user, pass; 126 QString server, user, pass;
126 uint16_t port; 127 uint16_t port;
127 int err = MAILIMAP_NO_ERROR; 128 int err = MAILIMAP_NO_ERROR;
128 129
129 if (account->getOffline()) return; 130 if (account->getOffline()) return;
130 /* we are connected this moment */ 131 /* we are connected this moment */
131 /* TODO: setup a timer holding the line or if connection closed - delete the value */ 132 /* TODO: setup a timer holding the line or if connection closed - delete the value */
132 if (m_imap) { 133 if (m_imap) {
133 err = mailimap_noop(m_imap); 134 err = mailimap_noop(m_imap);
134 if (err!=MAILIMAP_NO_ERROR) { 135 if (err!=MAILIMAP_NO_ERROR) {
135 logout(); 136 logout();
136 } else { 137 } else {
137 mailstream_flush(m_imap->imap_stream); 138 mailstream_flush(m_imap->imap_stream);
138 return; 139 return;
139 } 140 }
140 } 141 }
141 server = account->getServer(); 142 server = account->getServer();
142 port = account->getPort().toUInt(); 143 port = account->getPort().toUInt();
143 if ( account->getUser().isEmpty() || account->getPassword().isEmpty() ) { 144 if ( account->getUser().isEmpty() || account->getPassword().isEmpty() ) {
144 LoginDialog login( account->getUser(), account->getPassword(), NULL, 0, true ); 145 LoginDialog login( account->getUser(), account->getPassword(), NULL, 0, true );
145 login.show(); 146 login.show();
146 if ( QDialog::Accepted == login.exec() ) { 147 if ( QDialog::Accepted == login.exec() ) {
147 // ok 148 // ok
148 user = login.getUser(); 149 user = login.getUser();
149 pass = login.getPassword(); 150 pass = login.getPassword();
150 } else { 151 } else {
151 // cancel 152 // cancel
152 return; 153 return;
153 } 154 }
154 } else { 155 } else {
155 user = account->getUser(); 156 user = account->getUser();
156 pass = account->getPassword(); 157 pass = account->getPassword();
157 } 158 }
158 159
159 m_imap = mailimap_new( 20, &imap_progress ); 160 m_imap = mailimap_new( 20, &imap_progress );
160 161
161 /* connect */ 162 /* connect */
162 bool ssl = false; 163 bool ssl = false;
163 bool try_tls = false; 164 bool try_tls = false;
164 bool force_tls = false; 165 bool force_tls = false;
165 166
166 if ( account->ConnectionType() == 2 ) { 167 if ( account->ConnectionType() == 2 ) {
167 ssl = true; 168 ssl = true;
168 } 169 }
169 if (account->ConnectionType()==1) { 170 if (account->ConnectionType()==1) {
170 force_tls = true; 171 force_tls = true;
171 } 172 }
172 173
173 if ( ssl ) { 174 if ( ssl ) {
174 //qDebug("using ssl "); 175 //qDebug("using ssl ");
175 err = mailimap_ssl_connect( m_imap, (char*)server.latin1(), port ); 176 err = mailimap_ssl_connect( m_imap, (char*)server.latin1(), port );
176 } else { 177 } else {
177 err = mailimap_socket_connect( m_imap, (char*)server.latin1(), port ); 178 err = mailimap_socket_connect( m_imap, (char*)server.latin1(), port );
178 } 179 }
179 180
180 if ( err != MAILIMAP_NO_ERROR && 181 if ( err != MAILIMAP_NO_ERROR &&
181 err != MAILIMAP_NO_ERROR_AUTHENTICATED && 182 err != MAILIMAP_NO_ERROR_AUTHENTICATED &&
182 err != MAILIMAP_NO_ERROR_NON_AUTHENTICATED ) { 183 err != MAILIMAP_NO_ERROR_NON_AUTHENTICATED ) {
183 QString failure = ""; 184 QString failure = "";
184 if (err == MAILIMAP_ERROR_CONNECTION_REFUSED) { 185 if (err == MAILIMAP_ERROR_CONNECTION_REFUSED) {
185 failure="Connection refused"; 186 failure="Connection refused";
186 } else { 187 } else {
187 failure="Unknown failure"; 188 failure="Unknown failure";
188 } 189 }
189 Global::statusMessage(tr("error connecting imap server: %1").arg(failure)); 190 Global::statusMessage(tr("error connecting imap server: %1").arg(failure));
190 mailimap_free( m_imap ); 191 mailimap_free( m_imap );
191 m_imap = 0; 192 m_imap = 0;
192 return; 193 return;
193 } 194 }
194 195
195 if (!ssl) { 196 if (!ssl) {
196 try_tls = start_tls(force_tls); 197 try_tls = start_tls(force_tls);
197 } 198 }
198 199
199 bool ok = true; 200 bool ok = true;
200 if (force_tls && !try_tls) { 201 if (force_tls && !try_tls) {
201 Global::statusMessage(tr("Server has no TLS support!")); 202 Global::statusMessage(tr("Server has no TLS support!"));
202 ok = false; 203 ok = false;
203 } 204 }
204 205
205 206
206 /* login */ 207 /* login */
207 208
208 if (ok) { 209 if (ok) {
209 err = mailimap_login_simple( m_imap, (char*)user.latin1(), (char*)pass.latin1() ); 210 err = mailimap_login_simple( m_imap, (char*)user.latin1(), (char*)pass.latin1() );
210 if ( err != MAILIMAP_NO_ERROR ) { 211 if ( err != MAILIMAP_NO_ERROR ) {
211 Global::statusMessage(tr("error logging in imap server: %1").arg(m_imap->imap_response)); 212 Global::statusMessage(tr("error logging in imap server: %1").arg(m_imap->imap_response));
212 ok = false; 213 ok = false;
213 } 214 }
214 } 215 }
215 if (!ok) { 216 if (!ok) {
216 err = mailimap_close( m_imap ); 217 err = mailimap_close( m_imap );
217 mailimap_free( m_imap ); 218 mailimap_free( m_imap );
218 m_imap = 0; 219 m_imap = 0;
219 } 220 }
220} 221}
221 222
222void IMAPwrapper::logout() 223void IMAPwrapper::logout()
223{ 224{
224 int err = MAILIMAP_NO_ERROR; 225 int err = MAILIMAP_NO_ERROR;
225 if (!m_imap) return; 226 if (!m_imap) return;
226 err = mailimap_logout( m_imap ); 227 err = mailimap_logout( m_imap );
227 err = mailimap_close( m_imap ); 228 err = mailimap_close( m_imap );
228 mailimap_free( m_imap ); 229 mailimap_free( m_imap );
229 m_imap = 0; 230 m_imap = 0;
230 m_Lastmbox = ""; 231 m_Lastmbox = "";
231} 232}
232 233
233void IMAPwrapper::listMessages(const QString&mailbox,QValueList<Opie::Core::OSmartPointer<RecMail> > &target , int maxSizeInKb) 234void IMAPwrapper::listMessages(const QString&mailbox,QValueList<Opie::Core::OSmartPointer<RecMail> > &target , int maxSizeInKb)
234{ 235{
235 int err = MAILIMAP_NO_ERROR; 236 int err = MAILIMAP_NO_ERROR;
236 clist *result = 0; 237 clist *result = 0;
237 clistcell *current; 238 clistcell *current;
238 mailimap_fetch_type *fetchType = 0; 239 mailimap_fetch_type *fetchType = 0;
239 mailimap_set *set = 0; 240 mailimap_set *set = 0;
240 241
241 login(); 242 login();
242 if (!m_imap) { 243 if (!m_imap) {
243 return; 244 return;
244 } 245 }
245 /* select mailbox READONLY for operations */ 246 /* select mailbox READONLY for operations */
246 err = selectMbox(mailbox); 247 err = selectMbox(mailbox);
247 if ( err != MAILIMAP_NO_ERROR ) { 248 if ( err != MAILIMAP_NO_ERROR ) {
248 return; 249 return;
249 } 250 }
250 251
251 int last = m_imap->imap_selection_info->sel_exists; 252 int last = m_imap->imap_selection_info->sel_exists;
252 253
253 if (last == 0) { 254 if (last == 0) {
254 Global::statusMessage(tr("Mailbox has no mails")); 255 Global::statusMessage(tr("Mailbox has no mails"));
255 return; 256 return;
256 } else { 257 } else {
257 } 258 }
258 259
259 Global::statusMessage(tr("Fetching header list")); 260 Global::statusMessage(tr("Fetching header list"));
260 qApp->processEvents(); 261 qApp->processEvents();
261 /* the range has to start at 1!!! not with 0!!!! */ 262 /* the range has to start at 1!!! not with 0!!!! */
262 set = mailimap_set_new_interval( 1, last ); 263 set = mailimap_set_new_interval( 1, last );
263 fetchType = mailimap_fetch_type_new_fetch_att_list_empty(); 264 fetchType = mailimap_fetch_type_new_fetch_att_list_empty();
264 mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_envelope()); 265 mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_envelope());
265 mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_flags()); 266 mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_flags());
266 mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_internaldate()); 267 mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_internaldate());
267 mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_rfc822_size()); 268 mailimap_fetch_type_new_fetch_att_list_add(fetchType,mailimap_fetch_att_new_rfc822_size());
268 269
269 err = mailimap_fetch( m_imap, set, fetchType, &result ); 270 err = mailimap_fetch( m_imap, set, fetchType, &result );
270 mailimap_set_free( set ); 271 mailimap_set_free( set );
271 mailimap_fetch_type_free( fetchType ); 272 mailimap_fetch_type_free( fetchType );
272 273
273 QString date,subject,from; 274 QString date,subject,from;
274 275
275 if ( err == MAILIMAP_NO_ERROR ) { 276 if ( err == MAILIMAP_NO_ERROR ) {
276 mailimap_msg_att * msg_att; 277 mailimap_msg_att * msg_att;
277 int i = 0; 278 int i = 0;
278 for (current = clist_begin(result); current != 0; current=clist_next(current)) { 279 for (current = clist_begin(result); current != 0; current=clist_next(current)) {
279 ++i; 280 ++i;
280 msg_att = (mailimap_msg_att*)current->data; 281 msg_att = (mailimap_msg_att*)current->data;
281 RecMail*m = parse_list_result(msg_att); 282 RecMail*m = parse_list_result(msg_att);
282 if (m) { 283 if (m) {
283 if ( maxSizeInKb == 0 || m->Msgsize()<=maxSizeInKb*1024 ) { 284 if ( maxSizeInKb == 0 || m->Msgsize()<=maxSizeInKb*1024 ) {
284 m->setNumber(i); 285 m->setNumber(i);
285 m->setMbox(mailbox); 286 m->setMbox(mailbox);
286 m->setWrapper(this); 287 m->setWrapper(this);
287 target.append(m); 288 target.append(m);
288 } 289 }
289 } 290 }
290 } 291 }
291 Global::statusMessage(tr("Mailbox has %1 mails").arg(target.count())); 292 Global::statusMessage(tr("Mailbox has %1 mails").arg(target.count()));
292 } else { 293 } else {
293 Global::statusMessage(tr("Error fetching headers: %1").arg(m_imap->imap_response)); 294 Global::statusMessage(tr("Error fetching headers: %1").arg(m_imap->imap_response));
294 } 295 }
295 if (result) mailimap_fetch_list_free(result); 296 if (result) mailimap_fetch_list_free(result);
296} 297}
297 298
298QValueList<Opie::Core::OSmartPointer<Folder> >* IMAPwrapper::listFolders() 299QValueList<Opie::Core::OSmartPointer<Folder> >* IMAPwrapper::listFolders()
299{ 300{
300 const char *path, *mask; 301 const char *path, *mask;
301 int err = MAILIMAP_NO_ERROR; 302 int err = MAILIMAP_NO_ERROR;
302 clist *result = 0; 303 clist *result = 0;
303 clistcell *current = 0; 304 clistcell *current = 0;
304 clistcell*cur_flag = 0; 305 clistcell*cur_flag = 0;
305 mailimap_mbx_list_flags*bflags = 0; 306 mailimap_mbx_list_flags*bflags = 0;
306 307
307 QValueList<FolderP>* folders = new QValueList<FolderP>(); 308 QValueList<FolderP>* folders = new QValueList<FolderP>();
308 login(); 309 login();
309 if (!m_imap) { 310 if (!m_imap) {
310 return folders; 311 return folders;
311 } 312 }
312 313
313/* 314/*
314 * First we have to check for INBOX 'cause it sometimes it's not inside the path. 315 * First we have to check for INBOX 'cause it sometimes it's not inside the path.
315 * We must not forget to filter them out in next loop! 316 * We must not forget to filter them out in next loop!
316 * it seems like ugly code. and yes - it is ugly code. but the best way. 317 * it seems like ugly code. and yes - it is ugly code. but the best way.
317 */ 318 */
318 Global::statusMessage(tr("Fetching folder list")); 319 Global::statusMessage(tr("Fetching folder list"));
319 qApp->processEvents(); 320 qApp->processEvents();
320 QString temp; 321 QString temp;
321 mask = "INBOX" ; 322 mask = "INBOX" ;
322 mailimap_mailbox_list *list; 323 mailimap_mailbox_list *list;
323 err = mailimap_list( m_imap, (char*)"", (char*)mask, &result ); 324 err = mailimap_list( m_imap, (char*)"", (char*)mask, &result );
324 QString del; 325 QString del;
325 bool selectable = true; 326 bool selectable = true;
326 bool no_inferiors = false; 327 bool no_inferiors = false;
327 if ( err == MAILIMAP_NO_ERROR ) { 328 if ( err == MAILIMAP_NO_ERROR ) {
328 current = result->first; 329 current = result->first;
329 for ( int i = result->count; i > 0; i-- ) { 330 for ( int i = result->count; i > 0; i-- ) {
330 list = (mailimap_mailbox_list *) current->data; 331 list = (mailimap_mailbox_list *) current->data;
331 // it is better use the deep copy mechanism of qt itself 332 // it is better use the deep copy mechanism of qt itself
332 // instead of using strdup! 333 // instead of using strdup!
333 temp = list->mb_name; 334 temp = list->mb_name;
334 del = list->mb_delimiter; 335 del = list->mb_delimiter;
335 current = current->next; 336 current = current->next;
336 if ( (bflags = list->mb_flag) ) { 337 if ( (bflags = list->mb_flag) ) {
337 selectable = !(bflags->mbf_type==MAILIMAP_MBX_LIST_FLAGS_SFLAG&& 338 selectable = !(bflags->mbf_type==MAILIMAP_MBX_LIST_FLAGS_SFLAG&&
338 bflags->mbf_sflag==MAILIMAP_MBX_LIST_SFLAG_NOSELECT); 339 bflags->mbf_sflag==MAILIMAP_MBX_LIST_SFLAG_NOSELECT);
339 for(cur_flag=clist_begin(bflags->mbf_oflags);cur_flag;cur_flag=clist_next(cur_flag)) { 340 for(cur_flag=clist_begin(bflags->mbf_oflags);cur_flag;cur_flag=clist_next(cur_flag)) {
340 if ( ((mailimap_mbx_list_oflag*)cur_flag->data)->of_type==MAILIMAP_MBX_LIST_OFLAG_NOINFERIORS) { 341 if ( ((mailimap_mbx_list_oflag*)cur_flag->data)->of_type==MAILIMAP_MBX_LIST_OFLAG_NOINFERIORS) {
341 no_inferiors = true; 342 no_inferiors = true;
342 } 343 }
343 } 344 }
344 } 345 }
345 folders->append( new IMAPFolder(temp,del,selectable,no_inferiors,account->getPrefix())); 346 folders->append( new IMAPFolder(temp,del,selectable,no_inferiors,account->getPrefix()));
346 } 347 }
347 } else { 348 } else {
348 qDebug("error fetching folders: "); 349 qDebug("error fetching folders: ");
349 350
350 } 351 }
351 mailimap_list_result_free( result ); 352 mailimap_list_result_free( result );
352 353
353/* 354/*
354 * second stage - get the other then inbox folders 355 * second stage - get the other then inbox folders
355 */ 356 */
356 mask = "*" ; 357 mask = "*" ;
357 path = account->getPrefix().latin1(); 358 path = account->getPrefix().latin1();
358 if (!path) path = ""; 359 if (!path) path = "";
359 err = mailimap_list( m_imap, (char*)path, (char*)mask, &result ); 360 err = mailimap_list( m_imap, (char*)path, (char*)mask, &result );
360 if ( err == MAILIMAP_NO_ERROR ) { 361 if ( err == MAILIMAP_NO_ERROR ) {
361 current = result->first; 362 current = result->first;
362 for ( current=clist_begin(result);current!=NULL;current=clist_next(current)) { 363 for ( current=clist_begin(result);current!=NULL;current=clist_next(current)) {
363 no_inferiors = false; 364 no_inferiors = false;
364 list = (mailimap_mailbox_list *) current->data; 365 list = (mailimap_mailbox_list *) current->data;
365 // it is better use the deep copy mechanism of qt itself 366 // it is better use the deep copy mechanism of qt itself
366 // instead of using strdup! 367 // instead of using strdup!
367 temp = list->mb_name; 368 temp = list->mb_name;
368 if (temp.lower()=="inbox") 369 if (temp.lower()=="inbox")
369 continue; 370 continue;
370 if (temp.lower()==account->getPrefix().lower()) 371 if (temp.lower()==account->getPrefix().lower())
371 continue; 372 continue;
372 if ( (bflags = list->mb_flag) ) { 373 if ( (bflags = list->mb_flag) ) {
373 selectable = !(bflags->mbf_type==MAILIMAP_MBX_LIST_FLAGS_SFLAG&& 374 selectable = !(bflags->mbf_type==MAILIMAP_MBX_LIST_FLAGS_SFLAG&&
374 bflags->mbf_sflag==MAILIMAP_MBX_LIST_SFLAG_NOSELECT); 375 bflags->mbf_sflag==MAILIMAP_MBX_LIST_SFLAG_NOSELECT);
375 for(cur_flag=clist_begin(bflags->mbf_oflags);cur_flag;cur_flag=clist_next(cur_flag)) { 376 for(cur_flag=clist_begin(bflags->mbf_oflags);cur_flag;cur_flag=clist_next(cur_flag)) {
376 if ( ((mailimap_mbx_list_oflag*)cur_flag->data)->of_type==MAILIMAP_MBX_LIST_OFLAG_NOINFERIORS) { 377 if ( ((mailimap_mbx_list_oflag*)cur_flag->data)->of_type==MAILIMAP_MBX_LIST_OFLAG_NOINFERIORS) {
377 no_inferiors = true; 378 no_inferiors = true;
378 } 379 }
379 } 380 }
380 } 381 }
381 del = list->mb_delimiter; 382 del = list->mb_delimiter;
382 folders->append(new IMAPFolder(temp,del,selectable,no_inferiors,account->getPrefix())); 383 folders->append(new IMAPFolder(temp,del,selectable,no_inferiors,account->getPrefix()));
383 } 384 }
384 } else { 385 } else {
385 qDebug("error fetching folders "); 386 qDebug("error fetching folders ");
386 387
387 } 388 }
388 if (result) mailimap_list_result_free( result ); 389 if (result) mailimap_list_result_free( result );
389 return folders; 390 return folders;
390} 391}
391 392
392RecMail*IMAPwrapper::parse_list_result(mailimap_msg_att* m_att) 393RecMail*IMAPwrapper::parse_list_result(mailimap_msg_att* m_att)
393{ 394{
394 RecMail * m = 0; 395 RecMail * m = 0;
395 mailimap_msg_att_item *item=0; 396 mailimap_msg_att_item *item=0;
396 clistcell *current,*c,*cf; 397 clistcell *current,*c,*cf;
397 mailimap_msg_att_dynamic*flist; 398 mailimap_msg_att_dynamic*flist;
398 mailimap_flag_fetch*cflag; 399 mailimap_flag_fetch*cflag;
399 int size; 400 int size;
400 QBitArray mFlags(7); 401 QBitArray mFlags(7);
401 QStringList addresslist; 402 QStringList addresslist;
402 403
403 if (!m_att) { 404 if (!m_att) {
404 return m; 405 return m;
405 } 406 }
406 m = new RecMail(); 407 m = new RecMail();
407 for (c = clist_begin(m_att->att_list); c!=NULL;c=clist_next(c) ) { 408 for (c = clist_begin(m_att->att_list); c!=NULL;c=clist_next(c) ) {
408 current = c; 409 current = c;
409 size = 0; 410 size = 0;
410 item = (mailimap_msg_att_item*)current->data; 411 item = (mailimap_msg_att_item*)current->data;
411 if ( !item ) 412 if ( !item )
412 continue; 413 continue;
413 if (item->att_type!=MAILIMAP_MSG_ATT_ITEM_STATIC) { 414 if (item->att_type!=MAILIMAP_MSG_ATT_ITEM_STATIC) {
414 flist = (mailimap_msg_att_dynamic*)item->att_data.att_dyn; 415 flist = (mailimap_msg_att_dynamic*)item->att_data.att_dyn;
415 if (!flist || !flist->att_list) { 416 if (!flist || !flist->att_list) {
416 continue; 417 continue;
417 } 418 }
418 cf = flist->att_list->first; 419 cf = flist->att_list->first;
419 if( ! cf ) 420 if( ! cf )
420 for (cf = clist_begin(flist->att_list); cf!=NULL; cf = clist_next(cf)) { 421 for (cf = clist_begin(flist->att_list); cf!=NULL; cf = clist_next(cf)) {
421 cflag = (mailimap_flag_fetch*)cf->data; 422 cflag = (mailimap_flag_fetch*)cf->data;
422 if( ! cflag ) 423 if( ! cflag )
423 qDebug("imap:not cflag "); 424 qDebug("imap:not cflag ");
424 if (cflag->fl_type==MAILIMAP_FLAG_FETCH_OTHER && cflag->fl_flag!=0) { 425 if (cflag->fl_type==MAILIMAP_FLAG_FETCH_OTHER && cflag->fl_flag!=0) {
425 switch (cflag->fl_flag->fl_type) { 426 switch (cflag->fl_flag->fl_type) {
426 case MAILIMAP_FLAG_ANSWERED: /* \Answered flag */ 427 case MAILIMAP_FLAG_ANSWERED: /* \Answered flag */
427 mFlags.setBit(FLAG_ANSWERED); 428 mFlags.setBit(FLAG_ANSWERED);
428 break; 429 break;
429 case MAILIMAP_FLAG_FLAGGED: /* \Flagged flag */ 430 case MAILIMAP_FLAG_FLAGGED: /* \Flagged flag */
430 mFlags.setBit(FLAG_FLAGGED); 431 mFlags.setBit(FLAG_FLAGGED);
431 break; 432 break;
432 case MAILIMAP_FLAG_DELETED: /* \Deleted flag */ 433 case MAILIMAP_FLAG_DELETED: /* \Deleted flag */
433 mFlags.setBit(FLAG_DELETED); 434 mFlags.setBit(FLAG_DELETED);
434 break; 435 break;
435 case MAILIMAP_FLAG_SEEN: /* \Seen flag */ 436 case MAILIMAP_FLAG_SEEN: /* \Seen flag */
436 mFlags.setBit(FLAG_SEEN); 437 mFlags.setBit(FLAG_SEEN);
437 break; 438 break;
438 case MAILIMAP_FLAG_DRAFT: /* \Draft flag */ 439 case MAILIMAP_FLAG_DRAFT: /* \Draft flag */
439 mFlags.setBit(FLAG_DRAFT); 440 mFlags.setBit(FLAG_DRAFT);
440 break; 441 break;
441 case MAILIMAP_FLAG_KEYWORD: /* keyword flag */ 442 case MAILIMAP_FLAG_KEYWORD: /* keyword flag */
442 break; 443 break;
443 case MAILIMAP_FLAG_EXTENSION: /* \extension flag */ 444 case MAILIMAP_FLAG_EXTENSION: /* \extension flag */
444 break; 445 break;
445 default: 446 default:
446 break; 447 break;
447 } 448 }
448 } else if (cflag->fl_type==MAILIMAP_FLAG_FETCH_RECENT) { 449 } else if (cflag->fl_type==MAILIMAP_FLAG_FETCH_RECENT) {
449 mFlags.setBit(FLAG_RECENT); 450 mFlags.setBit(FLAG_RECENT);
450 } 451 }
451 } 452 }
452 continue; 453 continue;
453 } 454 }
454 if ( item->att_data.att_static == NULL ) 455 if ( item->att_data.att_static == NULL )
455 continue; 456 continue;
456 if (item->att_data.att_static->att_type==MAILIMAP_MSG_ATT_ENVELOPE) { 457 if (item->att_data.att_static->att_type==MAILIMAP_MSG_ATT_ENVELOPE) {
457 mailimap_envelope * head = item->att_data.att_static->att_data.att_env; 458 mailimap_envelope * head = item->att_data.att_static->att_data.att_env;
458 if ( head == NULL ) 459 if ( head == NULL )
459 continue; 460 continue;
460 if ( head->env_date != NULL ) { 461 if ( head->env_date != NULL ) {
461 m->setDate(head->env_date); 462 m->setDate(head->env_date);
462 struct mailimf_date_time result; 463 struct mailimf_date_time result;
463 struct mailimf_date_time* date = &result; 464 struct mailimf_date_time* date = &result;
464 struct mailimf_date_time **re = &date; 465 struct mailimf_date_time **re = &date;
465 size_t length = m->getDate().length(); 466 size_t length = m->getDate().length();
466 size_t index = 0; 467 size_t index = 0;
467 if ( mailimf_date_time_parse(head->env_date, length,&index, re ) == MAILIMF_NO_ERROR ) { 468 if ( mailimf_date_time_parse(head->env_date, length,&index, re ) == MAILIMF_NO_ERROR ) {
468 m->setDate( Genericwrapper::parseDateTime( date ) ); 469 QDateTime dt = Genericwrapper::parseDateTime( date );
469 char tmp[23]; 470 QString ret;
470 snprintf( tmp, 23, "%04i-%02i-%02i %02i:%02i:%02i %05i", 471 if ( dt.date() == QDate::currentDate () )
471 date->dt_year,date->dt_month, date->dt_day, date->dt_hour, date->dt_min, date->dt_sec, date->dt_zone ); 472 ret = KGlobal::locale()->formatTime( dt.time(),true);
473 else {
474 ret = KGlobal::locale()->formatDateTime( dt,true,true);
475 }
476 m->setDate( ret );
477 char tmp[20];
478 snprintf( tmp, 20, "%04i-%02i-%02i %02i:%02i:%02i",
479 dt.date().year(),dt.date().month(), dt.date().day(), dt.time().hour(), dt.time().minute(), dt.time().second() );
480 //qDebug("%d iso %s %s ", date->dt_zone, tmp, head->env_date);
472 m->setIsoDate( QString( tmp ) ); 481 m->setIsoDate( QString( tmp ) );
473 } else { 482 } else {
474 m->setIsoDate(head->env_date); 483 m->setIsoDate(head->env_date);
475 } 484 }
476 } 485 }
477 if ( head->env_subject != NULL ) 486 if ( head->env_subject != NULL )
478 m->setSubject(convert_String((const char*)head->env_subject)); 487 m->setSubject(convert_String((const char*)head->env_subject));
479 //m->setSubject(head->env_subject); 488 //m->setSubject(head->env_subject);
480 if (head->env_from!=NULL) { 489 if (head->env_from!=NULL) {
481 addresslist = address_list_to_stringlist(head->env_from->frm_list); 490 addresslist = address_list_to_stringlist(head->env_from->frm_list);
482 if (addresslist.count()) { 491 if (addresslist.count()) {
483 m->setFrom(addresslist.first()); 492 m->setFrom(addresslist.first());
484 } 493 }
485 } 494 }
486 if (head->env_to!=NULL) { 495 if (head->env_to!=NULL) {
487 addresslist = address_list_to_stringlist(head->env_to->to_list); 496 addresslist = address_list_to_stringlist(head->env_to->to_list);
488 m->setTo(addresslist); 497 m->setTo(addresslist);
489 } 498 }
490 if (head->env_cc!=NULL) { 499 if (head->env_cc!=NULL) {
491 addresslist = address_list_to_stringlist(head->env_cc->cc_list); 500 addresslist = address_list_to_stringlist(head->env_cc->cc_list);
492 m->setCC(addresslist); 501 m->setCC(addresslist);
493 } 502 }
494 if (head->env_bcc!=NULL) { 503 if (head->env_bcc!=NULL) {
495 addresslist = address_list_to_stringlist(head->env_bcc->bcc_list); 504 addresslist = address_list_to_stringlist(head->env_bcc->bcc_list);
496 m->setBcc(addresslist); 505 m->setBcc(addresslist);
497 } 506 }
498 /* reply to address, eg. email. */ 507 /* reply to address, eg. email. */
499 if (head->env_reply_to!=NULL) { 508 if (head->env_reply_to!=NULL) {
500 addresslist = address_list_to_stringlist(head->env_reply_to->rt_list); 509 addresslist = address_list_to_stringlist(head->env_reply_to->rt_list);
501 if (addresslist.count()) { 510 if (addresslist.count()) {
502 m->setReplyto(addresslist.first()); 511 m->setReplyto(addresslist.first());
503 } 512 }
504 } 513 }
505 if (head->env_in_reply_to!=NULL) { 514 if (head->env_in_reply_to!=NULL) {
506 QString h(head->env_in_reply_to); 515 QString h(head->env_in_reply_to);
507 while (h.length()>0 && h[0]=='<') { 516 while (h.length()>0 && h[0]=='<') {
508 h.remove(0,1); 517 h.remove(0,1);
509 } 518 }
510 while (h.length()>0 && h[h.length()-1]=='>') { 519 while (h.length()>0 && h[h.length()-1]=='>') {
511 h.remove(h.length()-1,1); 520 h.remove(h.length()-1,1);
512 } 521 }
513 if (h.length()>0) { 522 if (h.length()>0) {
514 m->setInreply(QStringList(h)); 523 m->setInreply(QStringList(h));
515 } 524 }
516 } 525 }
517 if (head->env_message_id != NULL) { 526 if (head->env_message_id != NULL) {
518 m->setMsgid(QString(head->env_message_id)); 527 m->setMsgid(QString(head->env_message_id));
519 } 528 }
520 } else if (item->att_data.att_static->att_type==MAILIMAP_MSG_ATT_INTERNALDATE) { 529 } else if (item->att_data.att_static->att_type==MAILIMAP_MSG_ATT_INTERNALDATE) {
521#if 0 530#if 0
522 mailimap_date_time*d = item->att_data.att_static->att_data.att_internal_date; 531 mailimap_date_time*d = item->att_data.att_static->att_data.att_internal_date;
523 QDateTime da(QDate(d->dt_year,d->dt_month,d->dt_day),QTime(d->dt_hour,d->dt_min,d->dt_sec)); 532 QDateTime da(QDate(d->dt_year,d->dt_month,d->dt_day),QTime(d->dt_hour,d->dt_min,d->dt_sec));
524 qDebug("time %s ",da.toString().latin1() ); 533 qDebug("time %s ",da.toString().latin1() );
525#endif 534#endif
526 } else if (item->att_data.att_static->att_type==MAILIMAP_MSG_ATT_RFC822_SIZE) { 535 } else if (item->att_data.att_static->att_type==MAILIMAP_MSG_ATT_RFC822_SIZE) {
527 size = item->att_data.att_static->att_data.att_rfc822_size; 536 size = item->att_data.att_static->att_data.att_rfc822_size;
528 } 537 }
529 } 538 }
530 /* msg is already deleted */ 539 /* msg is already deleted */
531 if (mFlags.testBit(FLAG_DELETED) && m) { 540 if (mFlags.testBit(FLAG_DELETED) && m) {
532 delete m; 541 delete m;
533 m = 0; 542 m = 0;
534 } 543 }
535 if (m) { 544 if (m) {
536 m->setFlags(mFlags); 545 m->setFlags(mFlags);
537 m->setMsgsize(size); 546 m->setMsgsize(size);
538 } 547 }
539 return m; 548 return m;
540} 549}
541 550
542RecBodyP IMAPwrapper::fetchBody(const RecMailP&mail) 551RecBodyP IMAPwrapper::fetchBody(const RecMailP&mail)
543{ 552{
544 RecBodyP body = new RecBody(); 553 RecBodyP body = new RecBody();
545 const char *mb; 554 const char *mb;
546 int err = MAILIMAP_NO_ERROR; 555 int err = MAILIMAP_NO_ERROR;
547 clist *result = 0; 556 clist *result = 0;
548 clistcell *current; 557 clistcell *current;
549 mailimap_fetch_att *fetchAtt = 0; 558 mailimap_fetch_att *fetchAtt = 0;
550 mailimap_fetch_type *fetchType = 0; 559 mailimap_fetch_type *fetchType = 0;
551 mailimap_set *set = 0; 560 mailimap_set *set = 0;
552 mailimap_body*body_desc = 0; 561 mailimap_body*body_desc = 0;
553 562
554 mb = mail->getMbox().latin1(); 563 mb = mail->getMbox().latin1();
555 564
556 login(); 565 login();
557 if (!m_imap) { 566 if (!m_imap) {
558 return body; 567 return body;
559 } 568 }
560 err = selectMbox(mail->getMbox()); 569 err = selectMbox(mail->getMbox());
561 if ( err != MAILIMAP_NO_ERROR ) { 570 if ( err != MAILIMAP_NO_ERROR ) {
562 return body; 571 return body;
563 } 572 }
564 573
565 /* the range has to start at 1!!! not with 0!!!! */ 574 /* the range has to start at 1!!! not with 0!!!! */
566 set = mailimap_set_new_interval( mail->getNumber(),mail->getNumber() ); 575 set = mailimap_set_new_interval( mail->getNumber(),mail->getNumber() );
567 fetchAtt = mailimap_fetch_att_new_bodystructure(); 576 fetchAtt = mailimap_fetch_att_new_bodystructure();
568 fetchType = mailimap_fetch_type_new_fetch_att(fetchAtt); 577 fetchType = mailimap_fetch_type_new_fetch_att(fetchAtt);
569 err = mailimap_fetch( m_imap, set, fetchType, &result ); 578 err = mailimap_fetch( m_imap, set, fetchType, &result );
570 mailimap_set_free( set ); 579 mailimap_set_free( set );
571 mailimap_fetch_type_free( fetchType ); 580 mailimap_fetch_type_free( fetchType );
572 581
573 if (err == MAILIMAP_NO_ERROR && (current=clist_begin(result)) ) { 582 if (err == MAILIMAP_NO_ERROR && (current=clist_begin(result)) ) {
574 mailimap_msg_att * msg_att; 583 mailimap_msg_att * msg_att;
575 msg_att = (mailimap_msg_att*)current->data; 584 msg_att = (mailimap_msg_att*)current->data;
576 mailimap_msg_att_item*item = (mailimap_msg_att_item*)msg_att->att_list->first->data; 585 mailimap_msg_att_item*item = (mailimap_msg_att_item*)msg_att->att_list->first->data;
577 QValueList<int> path; 586 QValueList<int> path;
578 body_desc = item->att_data.att_static->att_data.att_body; 587 body_desc = item->att_data.att_static->att_data.att_body;
579 traverseBody(mail,body_desc,body,0,path); 588 traverseBody(mail,body_desc,body,0,path);
580 } else { 589 } else {
581 //odebug << "error fetching body: " << m_imap->imap_response << "" << oendl; 590 //odebug << "error fetching body: " << m_imap->imap_response << "" << oendl;
582 } 591 }
583 if (result) mailimap_fetch_list_free(result); 592 if (result) mailimap_fetch_list_free(result);
584 return body; 593 return body;
585} 594}
586 595
587QStringList IMAPwrapper::address_list_to_stringlist(clist*list) 596QStringList IMAPwrapper::address_list_to_stringlist(clist*list)
588{ 597{
589 QStringList l; 598 QStringList l;
590 QString from; 599 QString from;
591 bool named_from; 600 bool named_from;
592 clistcell *current = NULL; 601 clistcell *current = NULL;
593 mailimap_address * current_address=NULL; 602 mailimap_address * current_address=NULL;
594 if (!list) { 603 if (!list) {
595 return l; 604 return l;
596 } 605 }
597 unsigned int count = 0; 606 unsigned int count = 0;
598 for (current=clist_begin(list);current!= NULL;current=clist_next(current)) { 607 for (current=clist_begin(list);current!= NULL;current=clist_next(current)) {
599 from = ""; 608 from = "";
600 named_from = false; 609 named_from = false;
601 current_address=(mailimap_address*)current->data; 610 current_address=(mailimap_address*)current->data;
602 if (current_address->ad_personal_name){ 611 if (current_address->ad_personal_name){
603 from+=convert_String((const char*)current_address->ad_personal_name); 612 from+=convert_String((const char*)current_address->ad_personal_name);
604 from+=" "; 613 from+=" ";
605 named_from = true; 614 named_from = true;
606 } 615 }
607 if (named_from && (current_address->ad_mailbox_name || current_address->ad_host_name)) { 616 if (named_from && (current_address->ad_mailbox_name || current_address->ad_host_name)) {
608 from+="<"; 617 from+="<";
609 } 618 }
610 if (current_address->ad_mailbox_name) { 619 if (current_address->ad_mailbox_name) {
611 from+=QString(current_address->ad_mailbox_name); 620 from+=QString(current_address->ad_mailbox_name);
612 from+="@"; 621 from+="@";
613 } 622 }
614 if (current_address->ad_host_name) { 623 if (current_address->ad_host_name) {
615 from+=QString(current_address->ad_host_name); 624 from+=QString(current_address->ad_host_name);
616 } 625 }
617 if (named_from && (current_address->ad_mailbox_name || current_address->ad_host_name)) { 626 if (named_from && (current_address->ad_mailbox_name || current_address->ad_host_name)) {
618 from+=">"; 627 from+=">";
619 } 628 }
620 l.append(QString(from)); 629 l.append(QString(from));
621 if (++count > 99) { 630 if (++count > 99) {
622 break; 631 break;
623 } 632 }
624 } 633 }
625 return l; 634 return l;
626} 635}
627 636
628encodedString*IMAPwrapper::fetchRawPart(const RecMailP&mail,const QValueList<int>&path,bool internal_call) 637encodedString*IMAPwrapper::fetchRawPart(const RecMailP&mail,const QValueList<int>&path,bool internal_call)
629{ 638{
630 encodedString*res=new encodedString; 639 encodedString*res=new encodedString;
631 int err; 640 int err;
632 mailimap_fetch_type *fetchType; 641 mailimap_fetch_type *fetchType;
633 mailimap_set *set; 642 mailimap_set *set;
634 clistcell*current,*cur; 643 clistcell*current,*cur;
635 mailimap_section_part * section_part = 0; 644 mailimap_section_part * section_part = 0;
636 mailimap_section_spec * section_spec = 0; 645 mailimap_section_spec * section_spec = 0;
637 mailimap_section * section = 0; 646 mailimap_section * section = 0;
638 mailimap_fetch_att * fetch_att = 0; 647 mailimap_fetch_att * fetch_att = 0;
639 648
640 login(); 649 login();
641 if (!m_imap) { 650 if (!m_imap) {
642 return res; 651 return res;
643 } 652 }
644 if (!internal_call) { 653 if (!internal_call) {
645 err = selectMbox(mail->getMbox()); 654 err = selectMbox(mail->getMbox());
646 if ( err != MAILIMAP_NO_ERROR ) { 655 if ( err != MAILIMAP_NO_ERROR ) {
647 return res; 656 return res;
648 } 657 }
649 } 658 }
650 set = mailimap_set_new_single(mail->getNumber()); 659 set = mailimap_set_new_single(mail->getNumber());
651 660
652 clist*id_list = 0; 661 clist*id_list = 0;
653 662
654 /* if path == empty then its a request for the whole rfc822 mail and generates 663 /* if path == empty then its a request for the whole rfc822 mail and generates
655 a "fetch <id> (body[])" statement on imap server */ 664 a "fetch <id> (body[])" statement on imap server */
656 if (path.count()>0 ) { 665 if (path.count()>0 ) {
657 id_list = clist_new(); 666 id_list = clist_new();
658 for (unsigned j=0; j < path.count();++j) { 667 for (unsigned j=0; j < path.count();++j) {
659 uint32_t * p_id = (uint32_t *)malloc(sizeof(*p_id)); 668 uint32_t * p_id = (uint32_t *)malloc(sizeof(*p_id));
660 *p_id = path[j]; 669 *p_id = path[j];
661 clist_append(id_list,p_id); 670 clist_append(id_list,p_id);
662 } 671 }
663 section_part = mailimap_section_part_new(id_list); 672 section_part = mailimap_section_part_new(id_list);
664 section_spec = mailimap_section_spec_new(MAILIMAP_SECTION_SPEC_SECTION_PART, NULL, section_part, NULL); 673 section_spec = mailimap_section_spec_new(MAILIMAP_SECTION_SPEC_SECTION_PART, NULL, section_part, NULL);
665 } 674 }
666 675
667 section = mailimap_section_new(section_spec); 676 section = mailimap_section_new(section_spec);
668 fetch_att = mailimap_fetch_att_new_body_section(section); 677 fetch_att = mailimap_fetch_att_new_body_section(section);
669 fetchType = mailimap_fetch_type_new_fetch_att(fetch_att); 678 fetchType = mailimap_fetch_type_new_fetch_att(fetch_att);
670 679
671 clist*result = 0; 680 clist*result = 0;
672 681
673 err = mailimap_fetch( m_imap, set, fetchType, &result ); 682 err = mailimap_fetch( m_imap, set, fetchType, &result );
674 mailimap_set_free( set ); 683 mailimap_set_free( set );
675 mailimap_fetch_type_free( fetchType ); 684 mailimap_fetch_type_free( fetchType );
676 685
677 if (err == MAILIMAP_NO_ERROR && (current=clist_begin(result)) ) { 686 if (err == MAILIMAP_NO_ERROR && (current=clist_begin(result)) ) {
678 mailimap_msg_att * msg_att; 687 mailimap_msg_att * msg_att;
679 msg_att = (mailimap_msg_att*)current->data; 688 msg_att = (mailimap_msg_att*)current->data;
680 mailimap_msg_att_item*msg_att_item; 689 mailimap_msg_att_item*msg_att_item;
681 for(cur = clist_begin(msg_att->att_list) ; cur != NULL ; cur = clist_next(cur)) { 690 for(cur = clist_begin(msg_att->att_list) ; cur != NULL ; cur = clist_next(cur)) {
682 msg_att_item = (mailimap_msg_att_item*)clist_content(cur); 691 msg_att_item = (mailimap_msg_att_item*)clist_content(cur);
683 if (msg_att_item->att_type == MAILIMAP_MSG_ATT_ITEM_STATIC) { 692 if (msg_att_item->att_type == MAILIMAP_MSG_ATT_ITEM_STATIC) {
684 if (msg_att_item->att_data.att_static->att_type == MAILIMAP_MSG_ATT_BODY_SECTION) { 693 if (msg_att_item->att_data.att_static->att_type == MAILIMAP_MSG_ATT_BODY_SECTION) {
685 char*text = msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part; 694 char*text = msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part;
686 /* detach - we take over the content */ 695 /* detach - we take over the content */
687 msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part = 0L; 696 msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part = 0L;
688 res->setContent(text,msg_att_item->att_data.att_static->att_data.att_body_section->sec_length); 697 res->setContent(text,msg_att_item->att_data.att_static->att_data.att_body_section->sec_length);
689 } 698 }
690 } 699 }
691 } 700 }
692 } else { 701 } else {
693 ;//odebug << "error fetching text: " << m_imap->imap_response << "" << oendl; 702 ;//odebug << "error fetching text: " << m_imap->imap_response << "" << oendl;
694 } 703 }
695 if (result) mailimap_fetch_list_free(result); 704 if (result) mailimap_fetch_list_free(result);
696 return res; 705 return res;
697} 706}
698 707
699/* current_recursion is for recursive calls. 708/* current_recursion is for recursive calls.
700 current_count means the position inside the internal loop! */ 709 current_count means the position inside the internal loop! */
701void IMAPwrapper::traverseBody(const RecMailP&mail,mailimap_body*body,RecBodyP&target_body, 710void IMAPwrapper::traverseBody(const RecMailP&mail,mailimap_body*body,RecBodyP&target_body,
702 int current_recursion,QValueList<int>recList,int current_count) 711 int current_recursion,QValueList<int>recList,int current_count)
703{ 712{
704 if (!body || current_recursion>=10) { 713 if (!body || current_recursion>=10) {
705 return; 714 return;
706 } 715 }
707 switch (body->bd_type) { 716 switch (body->bd_type) {
708 case MAILIMAP_BODY_1PART: 717 case MAILIMAP_BODY_1PART:
709 { 718 {
710 QValueList<int>countlist = recList; 719 QValueList<int>countlist = recList;
711 countlist.append(current_count); 720 countlist.append(current_count);
712 RecPartP currentPart = new RecPart(); 721 RecPartP currentPart = new RecPart();
713 mailimap_body_type_1part*part1 = body->bd_data.bd_body_1part; 722 mailimap_body_type_1part*part1 = body->bd_data.bd_body_1part;
714 QString id(""); 723 QString id("");
715 currentPart->setPositionlist(countlist); 724 currentPart->setPositionlist(countlist);
716 for (unsigned int j = 0; j < countlist.count();++j) { 725 for (unsigned int j = 0; j < countlist.count();++j) {
717 id+=(j>0?" ":""); 726 id+=(j>0?" ":"");
718 id+=QString("%1").arg(countlist[j]); 727 id+=QString("%1").arg(countlist[j]);
719 } 728 }
720 //odebug << "ID = " << id.latin1() << "" << oendl; 729 //odebug << "ID = " << id.latin1() << "" << oendl;
721 currentPart->setIdentifier(id); 730 currentPart->setIdentifier(id);
722 fillSinglePart(currentPart,part1); 731 fillSinglePart(currentPart,part1);
723 /* important: Check for is NULL 'cause a body can be empty! 732 /* important: Check for is NULL 'cause a body can be empty!
724 And we put it only into the mail if it is the FIRST part */ 733 And we put it only into the mail if it is the FIRST part */
725 if (part1->bd_type==MAILIMAP_BODY_TYPE_1PART_TEXT && target_body->Bodytext().isNull() && countlist[0]==1) { 734 if (part1->bd_type==MAILIMAP_BODY_TYPE_1PART_TEXT && target_body->Bodytext().isNull() && countlist[0]==1) {
726 QString body_text = fetchTextPart(mail,countlist,true,currentPart->Encoding()); 735 QString body_text = fetchTextPart(mail,countlist,true,currentPart->Encoding());
727 target_body->setDescription(currentPart); 736 target_body->setDescription(currentPart);
diff --git a/kmicromail/libmailwrapper/mailtypes.cpp b/kmicromail/libmailwrapper/mailtypes.cpp
index 1a4ffd1..af3b9d0 100644
--- a/kmicromail/libmailwrapper/mailtypes.cpp
+++ b/kmicromail/libmailwrapper/mailtypes.cpp
@@ -1,301 +1,307 @@
1#include "mailtypes.h" 1#include "mailtypes.h"
2 2
3//#include <opie2/odebug.h> 3//#include <opie2/odebug.h>
4 4
5#include <stdlib.h> 5#include <stdlib.h>
6 6
7using namespace Opie::Core; 7using namespace Opie::Core;
8RecMail::RecMail() 8RecMail::RecMail()
9 :Opie::Core::ORefCount(),subject(""),date(""),from(""),mbox(""),msg_id(""),msg_number(0),msg_size(0),msg_flags(7) 9 :Opie::Core::ORefCount(),subject(""),date(""),from(""),mbox(""),msg_id(""),msg_number(0),msg_size(0),msg_flags(7)
10{ 10{
11 init(); 11 init();
12} 12}
13 13
14RecMail::RecMail(const RecMail&old) 14RecMail::RecMail(const RecMail&old)
15 :Opie::Core::ORefCount(),subject(""),date(""),from(""),mbox(""),msg_id(""),msg_number(0),msg_flags(7) 15 :Opie::Core::ORefCount(),subject(""),date(""),from(""),mbox(""),msg_id(""),msg_number(0),msg_flags(7)
16{ 16{
17 init(); 17 init();
18 copy_old(old); 18 copy_old(old);
19 // odebug << "Copy constructor RecMail" << oendl; 19 // odebug << "Copy constructor RecMail" << oendl;
20} 20}
21 21
22RecMail::~RecMail() 22RecMail::~RecMail()
23{ 23{
24 wrapper = 0; 24 wrapper = 0;
25} 25}
26static bool stringCompareRec( const QString& s1, const QString& s2 ) 26static bool stringCompareRec( const QString& s1, const QString& s2 )
27{ 27{
28 if ( s1.isEmpty() && s2.isEmpty() ) 28 if ( s1.isEmpty() && s2.isEmpty() )
29 return true; 29 return true;
30 return s1 == s2; 30 return s1 == s2;
31} 31}
32 32
33bool RecMail::isEqual( RecMail* r1 ) 33bool RecMail::isEqual( RecMail* r1 )
34{ 34{
35 if ( !stringCompareRec( isodate, r1->isodate ) ) { 35 if ( !stringCompareRec( isodate, r1->isodate ) ) {
36 // qDebug("date *%s* *%s* ", isodate.latin1(), r1->isodate.latin1()); 36 //qDebug("date *%s* *%s* ", isodate.latin1(), r1->isodate.latin1());
37 return false; 37 return false;
38 } 38 }
39 if ( !stringCompareRec( from, r1->from ) ) { 39 if ( !stringCompareRec( subject.left(40), r1->subject.left(40) ) ) {
40 //qDebug("from *%s* *%s* ", from.latin1(), r1->from.latin1()); 40 //qDebug("sub *%s* *%s*", subject.latin1(), r1->subject.latin1());
41 return false; 41 return false;
42 } 42 }
43 if ( !stringCompareRec( subject, r1->subject ) ) { 43
44 //qDebug("sub "); 44 //qDebug("date *%s* *%s* ", isodate.latin1(), r1->isodate.latin1());
45 return false; 45 if ( !stringCompareRec( from.left(40), r1->from.left(40)) ) {
46 if ( r1->from.find ( from ) < 0 ) {
47 if ( !stringCompareRec( from.simplifyWhiteSpace ().left(40), r1->from.simplifyWhiteSpace ().left(40)) ) {
48 //qDebug("from *%s* *%s* ", from.left(40).latin1(), r1->from.left(20).latin1());
49 return false;
50 }
51 }
46 } 52 }
47 53
48 return true; 54 return true;
49} 55}
50void RecMail::copy_old(const RecMail&old) 56void RecMail::copy_old(const RecMail&old)
51{ 57{
52 subject = old.subject; 58 subject = old.subject;
53 date = old.date; 59 date = old.date;
54 mbox = old.mbox; 60 mbox = old.mbox;
55 msg_id = old.msg_id; 61 msg_id = old.msg_id;
56 msg_size = old.msg_size; 62 msg_size = old.msg_size;
57 msg_number = old.msg_number; 63 msg_number = old.msg_number;
58 from = old.from; 64 from = old.from;
59 msg_flags = old.msg_flags; 65 msg_flags = old.msg_flags;
60 to = old.to; 66 to = old.to;
61 cc = old.cc; 67 cc = old.cc;
62 bcc = old.bcc; 68 bcc = old.bcc;
63 wrapper = old.wrapper; 69 wrapper = old.wrapper;
64 in_reply_to = old.in_reply_to; 70 in_reply_to = old.in_reply_to;
65 references = old.references; 71 references = old.references;
66 replyto = old.replyto; 72 replyto = old.replyto;
67} 73}
68 74
69void RecMail::init() 75void RecMail::init()
70{ 76{
71 to.clear(); 77 to.clear();
72 cc.clear(); 78 cc.clear();
73 bcc.clear(); 79 bcc.clear();
74 in_reply_to.clear(); 80 in_reply_to.clear();
75 references.clear(); 81 references.clear();
76 wrapper = 0; 82 wrapper = 0;
77} 83}
78 84
79void RecMail::setWrapper(AbstractMail*awrapper) 85void RecMail::setWrapper(AbstractMail*awrapper)
80{ 86{
81 wrapper = awrapper; 87 wrapper = awrapper;
82} 88}
83 89
84AbstractMail* RecMail::Wrapper() 90AbstractMail* RecMail::Wrapper()
85{ 91{
86 return wrapper; 92 return wrapper;
87} 93}
88 94
89void RecMail::setTo(const QStringList&list) 95void RecMail::setTo(const QStringList&list)
90{ 96{
91 to = list; 97 to = list;
92} 98}
93 99
94const QStringList&RecMail::To()const 100const QStringList&RecMail::To()const
95{ 101{
96 return to; 102 return to;
97} 103}
98 104
99void RecMail::setCC(const QStringList&list) 105void RecMail::setCC(const QStringList&list)
100{ 106{
101 cc = list; 107 cc = list;
102} 108}
103 109
104const QStringList&RecMail::CC()const 110const QStringList&RecMail::CC()const
105{ 111{
106 return cc; 112 return cc;
107} 113}
108 114
109void RecMail::setBcc(const QStringList&list) 115void RecMail::setBcc(const QStringList&list)
110{ 116{
111 bcc = list; 117 bcc = list;
112} 118}
113 119
114const QStringList& RecMail::Bcc()const 120const QStringList& RecMail::Bcc()const
115{ 121{
116 return bcc; 122 return bcc;
117} 123}
118 124
119void RecMail::setInreply(const QStringList&list) 125void RecMail::setInreply(const QStringList&list)
120{ 126{
121 in_reply_to = list; 127 in_reply_to = list;
122} 128}
123 129
124const QStringList& RecMail::Inreply()const 130const QStringList& RecMail::Inreply()const
125{ 131{
126 return in_reply_to; 132 return in_reply_to;
127} 133}
128 134
129void RecMail::setReferences(const QStringList&list) 135void RecMail::setReferences(const QStringList&list)
130{ 136{
131 references = list; 137 references = list;
132} 138}
133 139
134const QStringList& RecMail::References()const 140const QStringList& RecMail::References()const
135{ 141{
136 return references; 142 return references;
137} 143}
138 144
139RecPart::RecPart() 145RecPart::RecPart()
140 : Opie::Core::ORefCount(), 146 : Opie::Core::ORefCount(),
141 m_type(""),m_subtype(""),m_identifier(""),m_encoding(""),m_description(""),m_lines(0),m_size(0) 147 m_type(""),m_subtype(""),m_identifier(""),m_encoding(""),m_description(""),m_lines(0),m_size(0)
142{ 148{
143 m_Parameters.clear(); 149 m_Parameters.clear();
144 m_poslist.clear(); 150 m_poslist.clear();
145} 151}
146 152
147RecPart::RecPart(const RecPart&old) 153RecPart::RecPart(const RecPart&old)
148 : Opie::Core::ORefCount(), 154 : Opie::Core::ORefCount(),
149 m_type(""),m_subtype(""),m_identifier(""),m_encoding(""),m_description(""),m_lines(0),m_size(0) 155 m_type(""),m_subtype(""),m_identifier(""),m_encoding(""),m_description(""),m_lines(0),m_size(0)
150{ 156{
151 m_type = old.m_type; 157 m_type = old.m_type;
152 m_subtype = old.m_subtype; 158 m_subtype = old.m_subtype;
153 m_identifier = old.m_identifier; 159 m_identifier = old.m_identifier;
154 m_encoding = old.m_encoding; 160 m_encoding = old.m_encoding;
155 m_description = old.m_description; 161 m_description = old.m_description;
156 m_lines = old.m_lines; 162 m_lines = old.m_lines;
157 m_size = old.m_size; 163 m_size = old.m_size;
158 m_Parameters = old.m_Parameters; 164 m_Parameters = old.m_Parameters;
159 m_poslist = old.m_poslist; 165 m_poslist = old.m_poslist;
160 // odebug << "RecPart copy constructor" << oendl; 166 // odebug << "RecPart copy constructor" << oendl;
161} 167}
162 168
163RecPart::~RecPart() 169RecPart::~RecPart()
164{ 170{
165} 171}
166 172
167void RecPart::setSize(unsigned int size) 173void RecPart::setSize(unsigned int size)
168{ 174{
169 m_size = size; 175 m_size = size;
170} 176}
171 177
172const unsigned int RecPart::Size()const 178const unsigned int RecPart::Size()const
173{ 179{
174 return m_size; 180 return m_size;
175} 181}
176 182
177void RecPart::setLines(unsigned int lines) 183void RecPart::setLines(unsigned int lines)
178{ 184{
179 m_lines = lines; 185 m_lines = lines;
180} 186}
181 187
182const unsigned int RecPart::Lines()const 188const unsigned int RecPart::Lines()const
183{ 189{
184 return m_lines; 190 return m_lines;
185} 191}
186 192
187const QString& RecPart::Type()const 193const QString& RecPart::Type()const
188{ 194{
189 return m_type; 195 return m_type;
190} 196}
191 197
192void RecPart::setType(const QString&type) 198void RecPart::setType(const QString&type)
193{ 199{
194 m_type = type; 200 m_type = type;
195} 201}
196 202
197const QString& RecPart::Subtype()const 203const QString& RecPart::Subtype()const
198{ 204{
199 return m_subtype; 205 return m_subtype;
200} 206}
201 207
202void RecPart::setSubtype(const QString&subtype) 208void RecPart::setSubtype(const QString&subtype)
203{ 209{
204 m_subtype = subtype; 210 m_subtype = subtype;
205} 211}
206 212
207const QString& RecPart::Identifier()const 213const QString& RecPart::Identifier()const
208{ 214{
209 return m_identifier; 215 return m_identifier;
210} 216}
211 217
212void RecPart::setIdentifier(const QString&identifier) 218void RecPart::setIdentifier(const QString&identifier)
213{ 219{
214 m_identifier = identifier; 220 m_identifier = identifier;
215} 221}
216 222
217const QString& RecPart::Encoding()const 223const QString& RecPart::Encoding()const
218{ 224{
219 return m_encoding; 225 return m_encoding;
220} 226}
221 227
222void RecPart::setEncoding(const QString&encoding) 228void RecPart::setEncoding(const QString&encoding)
223{ 229{
224 m_encoding = encoding; 230 m_encoding = encoding;
225} 231}
226 232
227const QString& RecPart::Description()const 233const QString& RecPart::Description()const
228{ 234{
229 return m_description; 235 return m_description;
230} 236}
231 237
232void RecPart::setDescription(const QString&desc) 238void RecPart::setDescription(const QString&desc)
233{ 239{
234 m_description = desc; 240 m_description = desc;
235} 241}
236 242
237void RecPart::setParameters(const part_plist_t&list) 243void RecPart::setParameters(const part_plist_t&list)
238{ 244{
239 m_Parameters = list; 245 m_Parameters = list;
240} 246}
241 247
242const part_plist_t& RecPart::Parameters()const 248const part_plist_t& RecPart::Parameters()const
243{ 249{
244 return m_Parameters; 250 return m_Parameters;
245} 251}
246 252
247void RecPart::addParameter(const QString&key,const QString&value) 253void RecPart::addParameter(const QString&key,const QString&value)
248{ 254{
249 m_Parameters[key]=value; 255 m_Parameters[key]=value;
250} 256}
251 257
252const QString RecPart::searchParamter(const QString&key)const 258const QString RecPart::searchParamter(const QString&key)const
253{ 259{
254 QString value(""); 260 QString value("");
255 part_plist_t::ConstIterator it = m_Parameters.find(key); 261 part_plist_t::ConstIterator it = m_Parameters.find(key);
256 if (it != m_Parameters.end()) { 262 if (it != m_Parameters.end()) {
257 value = it.data(); 263 value = it.data();
258 } 264 }
259 return value; 265 return value;
260} 266}
261 267
262void RecPart::setPositionlist(const QValueList<int>&poslist) 268void RecPart::setPositionlist(const QValueList<int>&poslist)
263{ 269{
264 m_poslist = poslist; 270 m_poslist = poslist;
265} 271}
266 272
267const QValueList<int>& RecPart::Positionlist()const 273const QValueList<int>& RecPart::Positionlist()const
268{ 274{
269 return m_poslist; 275 return m_poslist;
270} 276}
271 277
272RecBody::RecBody() 278RecBody::RecBody()
273 : Opie::Core::ORefCount(),m_BodyText(),m_description(new RecPart()) 279 : Opie::Core::ORefCount(),m_BodyText(),m_description(new RecPart())
274{ 280{
275 m_PartsList.clear(); 281 m_PartsList.clear();
276} 282}
277 283
278RecBody::RecBody(const RecBody&old) 284RecBody::RecBody(const RecBody&old)
279 :Opie::Core::ORefCount(),m_BodyText(),m_PartsList(),m_description(new RecPart()) 285 :Opie::Core::ORefCount(),m_BodyText(),m_PartsList(),m_description(new RecPart())
280{ 286{
281 m_BodyText = old.m_BodyText; 287 m_BodyText = old.m_BodyText;
282 m_PartsList = old.m_PartsList; 288 m_PartsList = old.m_PartsList;
283 m_description = old.m_description; 289 m_description = old.m_description;
284 // odebug << "Recbody copy constructor" << oendl; 290 // odebug << "Recbody copy constructor" << oendl;
285} 291}
286 292
287RecBody::~RecBody() 293RecBody::~RecBody()
288{ 294{
289} 295}
290 296
291void RecBody::setBodytext(const QString&bodyText) 297void RecBody::setBodytext(const QString&bodyText)
292{ 298{
293 m_BodyText = bodyText; 299 m_BodyText = bodyText;
294} 300}
295 301
296const QString& RecBody::Bodytext()const 302const QString& RecBody::Bodytext()const
297{ 303{
298 return m_BodyText; 304 return m_BodyText;
299} 305}
300 306
301void RecBody::setParts(const QValueList<RecPartP>&parts) 307void RecBody::setParts(const QValueList<RecPartP>&parts)
diff --git a/kmicromail/libmailwrapper/mailtypes.h b/kmicromail/libmailwrapper/mailtypes.h
index 020278d..c1c1a74 100644
--- a/kmicromail/libmailwrapper/mailtypes.h
+++ b/kmicromail/libmailwrapper/mailtypes.h
@@ -1,209 +1,211 @@
1#ifndef __MAIL_TYPES_H 1#ifndef __MAIL_TYPES_H
2#define __MAIL_TYPES_H 2#define __MAIL_TYPES_H
3 3
4#define FLAG_ANSWERED 0 4#define FLAG_ANSWERED 0
5#define FLAG_FLAGGED 1 5#define FLAG_FLAGGED 1
6#define FLAG_DELETED 2 6#define FLAG_DELETED 2
7#define FLAG_SEEN 3 7#define FLAG_SEEN 3
8#define FLAG_DRAFT 4 8#define FLAG_DRAFT 4
9#define FLAG_RECENT 5 9#define FLAG_RECENT 5
10 10
11#include <opie2/osmartpointer.h> 11#include <opie2/osmartpointer.h>
12 12
13#include <qbitarray.h> 13#include <qbitarray.h>
14#include <qstring.h> 14#include <qstring.h>
15#include <qstringlist.h> 15#include <qstringlist.h>
16#include <qmap.h> 16#include <qmap.h>
17#include <qvaluelist.h> 17#include <qvaluelist.h>
18 18
19class AbstractMail; 19class AbstractMail;
20/* a class to describe mails in a mailbox */ 20/* a class to describe mails in a mailbox */
21/* Attention! 21/* Attention!
22 From programmers point of view it would make sense to 22 From programmers point of view it would make sense to
23 store the mail body into this class, too. 23 store the mail body into this class, too.
24 But: not from the point of view of the device. 24 But: not from the point of view of the device.
25 Mailbodies can be real large. So we request them when 25 Mailbodies can be real large. So we request them when
26 needed from the mail-wrapper class direct from the server itself 26 needed from the mail-wrapper class direct from the server itself
27 (imap) or from a file-based cache (pop3?) 27 (imap) or from a file-based cache (pop3?)
28 So there is no interface "const QString&body()" but you should 28 So there is no interface "const QString&body()" but you should
29 make a request to the mailwrapper with this class as parameter to 29 make a request to the mailwrapper with this class as parameter to
30 get the body. Same words for the attachments. 30 get the body. Same words for the attachments.
31*/ 31*/
32class RecMail:public Opie::Core::ORefCount 32class RecMail:public Opie::Core::ORefCount
33{ 33{
34public: 34public:
35 RecMail(); 35 RecMail();
36 RecMail(const RecMail&old); 36 RecMail(const RecMail&old);
37 virtual ~RecMail(); 37 virtual ~RecMail();
38 bool isEqual( RecMail* r1 ); 38 bool isEqual( RecMail* r1 );
39 39
40 const unsigned int getNumber()const{return msg_number;} 40 const unsigned int getNumber()const{return msg_number;}
41 void setNumber(unsigned int number){msg_number=number;} 41 void setNumber(unsigned int number){msg_number=number;}
42 const QString&getDate()const{ return date; } 42 const QString&getDate()const{ return date; }
43 void setDate( const QString&a ) { date = a; } 43 void setDate( const QString&a ) { date = a; }
44 const QString&getIsoDate()const{ return isodate; } 44 const QString&getIsoDate()const{ return isodate; }
45 void setIsoDate( const QString&a ) { isodate = a; } 45 void setIsoDate( const QString&a ) { isodate = a; }
46 const QString&getFrom()const{ return from; } 46 const QString&getFrom()const{ return from; }
47 void setFrom( const QString&a ) { from = a; } 47 void setFrom( const QString&a ) { from = a; }
48 const QString&getSubject()const { return subject; } 48 const QString&getSubject()const { return subject; }
49 void setSubject( const QString&s ) { subject = s; } 49 void setSubject( const QString&s ) { subject = s; }
50 const QString&getMbox()const{return mbox;} 50 const QString&getMbox()const{return mbox;}
51 void setMbox(const QString&box){mbox = box;} 51 void setMbox(const QString&box){mbox = box;}
52 void setMsgid(const QString&id){msg_id=id;} 52 void setMsgid(const QString&id){msg_id=id;}
53 const QString&Msgid()const{return msg_id;} 53 const QString&Msgid()const{return msg_id;}
54 void setReplyto(const QString&reply){replyto=reply;} 54 void setReplyto(const QString&reply){replyto=reply;}
55 const QString&Replyto()const{return replyto;} 55 const QString&Replyto()const{return replyto;}
56 void setMsgsize(unsigned int size){msg_size = size;} 56 void setMsgsize(unsigned int size){msg_size = size;}
57 const unsigned int Msgsize()const{return msg_size;} 57 const unsigned int Msgsize()const{return msg_size;}
58 58
59 59
60 void setTo(const QStringList&list); 60 void setTo(const QStringList&list);
61 const QStringList&To()const; 61 const QStringList&To()const;
62 void setCC(const QStringList&list); 62 void setCC(const QStringList&list);
63 const QStringList&CC()const; 63 const QStringList&CC()const;
64 void setBcc(const QStringList&list); 64 void setBcc(const QStringList&list);
65 const QStringList&Bcc()const; 65 const QStringList&Bcc()const;
66 void setInreply(const QStringList&list); 66 void setInreply(const QStringList&list);
67 const QStringList&Inreply()const; 67 const QStringList&Inreply()const;
68 void setReferences(const QStringList&list); 68 void setReferences(const QStringList&list);
69 const QStringList&References()const; 69 const QStringList&References()const;
70 70
71 const QBitArray&getFlags()const{return msg_flags;} 71 const QBitArray&getFlags()const{return msg_flags;}
72 void setFlags(const QBitArray&flags){msg_flags = flags;} 72 void setFlags(const QBitArray&flags){msg_flags = flags;}
73 73
74 void setWrapper(AbstractMail*wrapper); 74 void setWrapper(AbstractMail*wrapper);
75 AbstractMail* Wrapper(); 75 AbstractMail* Wrapper();
76 // public for debugging
77 QString subject,date,isodate,from,mbox,msg_id,replyto;
76 78
77protected: 79protected:
78 QString subject,date,isodate,from,mbox,msg_id,replyto; 80 //QString subject,date,isodate,from,mbox,msg_id,replyto;
79 unsigned int msg_number,msg_size; 81 unsigned int msg_number,msg_size;
80 QBitArray msg_flags; 82 QBitArray msg_flags;
81 QStringList to,cc,bcc,in_reply_to,references; 83 QStringList to,cc,bcc,in_reply_to,references;
82 AbstractMail*wrapper; 84 AbstractMail*wrapper;
83 void init(); 85 void init();
84 void copy_old(const RecMail&old); 86 void copy_old(const RecMail&old);
85}; 87};
86 88
87typedef Opie::Core::OSmartPointer<RecMail> RecMailP; 89typedef Opie::Core::OSmartPointer<RecMail> RecMailP;
88typedef QMap<QString,QString> part_plist_t; 90typedef QMap<QString,QString> part_plist_t;
89 91
90class RecPart:public Opie::Core::ORefCount 92class RecPart:public Opie::Core::ORefCount
91{ 93{
92protected: 94protected:
93 QString m_type,m_subtype,m_identifier,m_encoding,m_description; 95 QString m_type,m_subtype,m_identifier,m_encoding,m_description;
94 unsigned int m_lines,m_size; 96 unsigned int m_lines,m_size;
95 part_plist_t m_Parameters; 97 part_plist_t m_Parameters;
96 /* describes the position in the mail */ 98 /* describes the position in the mail */
97 QValueList<int> m_poslist; 99 QValueList<int> m_poslist;
98 100
99public: 101public:
100 RecPart(); 102 RecPart();
101 RecPart(const RecPart&); 103 RecPart(const RecPart&);
102 virtual ~RecPart(); 104 virtual ~RecPart();
103 105
104 const QString&Type()const; 106 const QString&Type()const;
105 void setType(const QString&type); 107 void setType(const QString&type);
106 const QString&Subtype()const; 108 const QString&Subtype()const;
107 void setSubtype(const QString&subtype); 109 void setSubtype(const QString&subtype);
108 const QString&Identifier()const; 110 const QString&Identifier()const;
109 void setIdentifier(const QString&identifier); 111 void setIdentifier(const QString&identifier);
110 const QString&Encoding()const; 112 const QString&Encoding()const;
111 void setEncoding(const QString&encoding); 113 void setEncoding(const QString&encoding);
112 const QString&Description()const; 114 const QString&Description()const;
113 void setDescription(const QString&desc); 115 void setDescription(const QString&desc);
114 void setLines(unsigned int lines); 116 void setLines(unsigned int lines);
115 const unsigned int Lines()const; 117 const unsigned int Lines()const;
116 void setSize(unsigned int size); 118 void setSize(unsigned int size);
117 const unsigned int Size()const; 119 const unsigned int Size()const;
118 120
119 121
120 void setParameters(const part_plist_t&list); 122 void setParameters(const part_plist_t&list);
121 const part_plist_t&Parameters()const; 123 const part_plist_t&Parameters()const;
122 void addParameter(const QString&key,const QString&value); 124 void addParameter(const QString&key,const QString&value);
123 const QString searchParamter(const QString&key)const; 125 const QString searchParamter(const QString&key)const;
124 void setPositionlist(const QValueList<int>&poslist); 126 void setPositionlist(const QValueList<int>&poslist);
125 const QValueList<int>& Positionlist()const; 127 const QValueList<int>& Positionlist()const;
126}; 128};
127 129
128typedef Opie::Core::OSmartPointer<RecPart> RecPartP; 130typedef Opie::Core::OSmartPointer<RecPart> RecPartP;
129 131
130class RecBody:public Opie::Core::ORefCount 132class RecBody:public Opie::Core::ORefCount
131{ 133{
132protected: 134protected:
133 QString m_BodyText; 135 QString m_BodyText;
134 QValueList<RecPartP> m_PartsList; 136 QValueList<RecPartP> m_PartsList;
135 RecPartP m_description; 137 RecPartP m_description;
136 138
137public: 139public:
138 RecBody(); 140 RecBody();
139 RecBody(const RecBody&old); 141 RecBody(const RecBody&old);
140 virtual ~RecBody(); 142 virtual ~RecBody();
141 void setBodytext(const QString&); 143 void setBodytext(const QString&);
142 const QString& Bodytext()const; 144 const QString& Bodytext()const;
143 145
144 void setDescription(const RecPartP&des); 146 void setDescription(const RecPartP&des);
145 const RecPartP& Description()const; 147 const RecPartP& Description()const;
146 148
147 void setParts(const QValueList<RecPartP>&parts); 149 void setParts(const QValueList<RecPartP>&parts);
148 const QValueList<RecPartP>& Parts()const; 150 const QValueList<RecPartP>& Parts()const;
149 void addPart(const RecPartP&part); 151 void addPart(const RecPartP&part);
150}; 152};
151 153
152typedef Opie::Core::OSmartPointer<RecBody> RecBodyP; 154typedef Opie::Core::OSmartPointer<RecBody> RecBodyP;
153 155
154class encodedString 156class encodedString
155{ 157{
156public: 158public:
157 encodedString(); 159 encodedString();
158 /* 160 /*
159 creates an new content string. 161 creates an new content string.
160 it makes a deep copy of it! 162 it makes a deep copy of it!
161 */ 163 */
162 encodedString(const char*nContent,unsigned int length); 164 encodedString(const char*nContent,unsigned int length);
163 /* 165 /*
164 Take over the nContent. Means: it will just copy the pointer, not the content. 166 Take over the nContent. Means: it will just copy the pointer, not the content.
165 so make sure: No one else frees the string, the string has allocated with 167 so make sure: No one else frees the string, the string has allocated with
166 malloc for compatibility with c-based libs 168 malloc for compatibility with c-based libs
167 */ 169 */
168 encodedString(char*nContent,unsigned int nSize); 170 encodedString(char*nContent,unsigned int nSize);
169 /* copy construkor - makes ALWAYS a deep copy!!!! */ 171 /* copy construkor - makes ALWAYS a deep copy!!!! */
170 encodedString(const encodedString&old); 172 encodedString(const encodedString&old);
171 /* assign operator - makes ALWAYS a deep copy!!!! */ 173 /* assign operator - makes ALWAYS a deep copy!!!! */
172 encodedString& operator=(const encodedString&old); 174 encodedString& operator=(const encodedString&old);
173 /* destructor - cleans the content */ 175 /* destructor - cleans the content */
174 virtual ~encodedString(); 176 virtual ~encodedString();
175 177
176 /* returns a pointer to the content - do not delete yoursel! */ 178 /* returns a pointer to the content - do not delete yoursel! */
177 const char*Content()const; 179 const char*Content()const;
178 /* returns the lengths of the content 'cause it must not be a null-terminated string! */ 180 /* returns the lengths of the content 'cause it must not be a null-terminated string! */
179 const int Length()const; 181 const int Length()const;
180 182
181 /* 183 /*
182 makes a deep copy of nContent! 184 makes a deep copy of nContent!
183 */ 185 */
184 void setContent(const char*nContent,int nSize); 186 void setContent(const char*nContent,int nSize);
185 /* 187 /*
186 Take over the nContent. Means: it will just copy the pointer, not the content. 188 Take over the nContent. Means: it will just copy the pointer, not the content.
187 so make sure: No one else frees the string, the string has allocated with 189 so make sure: No one else frees the string, the string has allocated with
188 malloc for compatibility with c-based libs 190 malloc for compatibility with c-based libs
189 */ 191 */
190 void setContent(char*nContent,int nSize); 192 void setContent(char*nContent,int nSize);
191 193
192protected: 194protected:
193 char * content; 195 char * content;
194 unsigned int size; 196 unsigned int size;
195 197
196 void init(); 198 void init();
197 void copy_old(const encodedString&old); 199 void copy_old(const encodedString&old);
198 void clean(); 200 void clean();
199}; 201};
200 202
201struct folderStat 203struct folderStat
202{ 204{
203 unsigned int message_count; 205 unsigned int message_count;
204 unsigned int message_unseen; 206 unsigned int message_unseen;
205 unsigned int message_recent; 207 unsigned int message_recent;
206 folderStat&operator=(const folderStat&old); 208 folderStat&operator=(const folderStat&old);
207}; 209};
208 210
209#endif 211#endif