+2004-12-02 Not Zed <NotZed@Ximian.com>

+ ** See bug #69533.

+

+ * providers/imap/camel-imap-command.c (imap_read_untagged): gross

+ hack, if we get a blank line after a literal, assume the server

+ (read: groupwise) made a mistake. Given the complexity of this

+ code i'm not sure it is the server anyway but what can you do.

+ ** See bug #69982 (maybe).

+

+ * evolution-2.0.2/camel/providers/imap4/camel-imap4-engine.c (engine_parse_capability)

+2004-11-19 Not Zed <NotZed@Ximian.com>

+ * providers/imap/camel-imap-store.c (connect_to_server): if we

+ have CAMEL_IMAP_BRAINDAMAGED set, then treat the server as

+ braindamaged ok. Testing for #69533.

+ * providers/pop3/camel-pop3-store.c (connect_to_server):

+ * providers/imap/camel-imap-store.c (connect_to_server):

+ * providers/nntp/camel-nntp-store.c (connect_to_server):

+ * providers/smtp/camel-smtp-transport.c (connect_to_server):

+ * providers/groupwise/camel-gw-listner.c (add_esource) :

+ add the source uid to list of selected calendar and tasks

+ so that groupwise calendar and tasks are automatically selected

+ Fixes #62053

+ unmatched folder and associated locks/etc, fixed all the code up

+#include <gal/util/e-iconv.h>

+

+#include "e-util/e-sexp.h"

+#include "e-util/e-memory.h"

+#include "e-util/e-msgport.h" /* for edlist */

+ camel_tag_set (&p->info->user_tags, "colour", argv[0]->value.string);

+ camel_tag_set (&p->info->user_tags, "score", value);

+ p->info->flags |= flags | CAMEL_MESSAGE_FOLDER_FLAGGED;

+ p->info->flags = (p->info->flags & ~flags) | CAMEL_MESSAGE_FOLDER_FLAGGED;

+ info = camel_message_info_new_from_header(((CamelMimePart *)msg)->headers);

+ info->size = camel_mime_parser_tell(mp) - last;

+ info = camel_message_info_new_from_header (h);

+ if (info->flags & CAMEL_MESSAGE_DELETED)

+ info->flags |= CAMEL_MESSAGE_DELETED|CAMEL_MESSAGE_SEEN|CAMEL_MESSAGE_FOLDER_FLAGGED;

+#include <e-util/e-sexp.h>

+

+#include <gal/util/e-iconv.h>

+

+ && camel_flag_get (&fms->info->user_flags, argv[i]->value.string)) {

+ r->value.bool = camel_system_flag_get (fms->info->flags, argv[0]->value.string);

+ tag = camel_tag_get (&fms->info->user_tags, argv[0]->value.string);

+ r->value.number = fms->info->size / 1024;

+#include "e-util/e-memory.h"

+ sprintf(strbuf, "%d", (int)search->current->date_sent);

+ && camel_flag_get(&search->current->user_flags, argv[i]->value.string)) {

+ truth = camel_system_flag_get (search->current->flags, argv[0]->value.string);

+ value = camel_tag_get (&search->current->user_tags, argv[0]->value.string);

+ r->value.number = s->current->date_sent;

+ r->value.number = s->current->date_received;

+ r->value.number = s->current->size / 1024;

+#include <gal/util/e-iconv.h>

+#include "e-util/md5-utils.h"

+#include "e-util/e-memory.h"

+static CamelMessageInfo * message_info_new(CamelFolderSummary *, struct _camel_header_raw *);

+static CamelMessageContentInfo * content_info_new(CamelFolderSummary *, struct _camel_header_raw *);

+camel_folder_summary_class_init (CamelFolderSummaryClass *klass)

+{

+ camel_folder_summary_parent = camel_type_get_global_classfuncs (camel_object_get_type ());

+

+ klass->summary_header_load = summary_header_load;

+ klass->summary_header_save = summary_header_save;

+

+ klass->message_info_new = message_info_new;

+ klass->message_info_new_from_parser = message_info_new_from_parser;

+ klass->message_info_new_from_message = message_info_new_from_message;

+ klass->message_info_load = message_info_load;

+ klass->message_info_save = message_info_save;

+ klass->message_info_free = message_info_free;

+

+ klass->content_info_new = content_info_new;

+ klass->content_info_new_from_parser = content_info_new_from_parser;

+ klass->content_info_new_from_message = content_info_new_from_message;

+ klass->content_info_load = content_info_load;

+ klass->content_info_save = content_info_save;

+ klass->content_info_free = content_info_free;

+

+ klass->next_uid_string = next_uid_string;

+}

+

+static void

+ s->message_info_size = sizeof(CamelMessageInfo);

+camel_folder_summary_new (void)

+ CamelFolderSummary *new = CAMEL_FOLDER_SUMMARY ( camel_object_new (camel_folder_summary_get_type ())); return new;

+

+ * It must be freed using camel_folder_summary_info_free().

+ camel_folder_summary_info_free(s, array->pdata[i]);

+ * It must be freed using camel_folder_summary_info_free().

+ mi->content = perform_content_info_load(s, in);

+ if (mi->content == NULL) {

+ camel_folder_summary_info_free(s, mi);

+ if (perform_content_info_save (s, out, mi->content) == -1)

+ camel_message_info_set_uid(info, camel_folder_summary_next_uid_string(s));

+ uid = camel_message_info_uid(info);

+ camel_message_info_set_uid(info, camel_folder_summary_next_uid_string(s));

+ uid = camel_message_info_uid(info);

+ info->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED;

+ * Return value: Guess? This info record MUST be freed using

+ * camel_folder_summary_info_free(), camel_message_info_free() will not work.

+ return ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s))) -> message_info_new(s, h);

+ * Return value: Guess? This info record MUST be freed using

+ * camel_folder_summary_info_free(), camel_message_info_free() will not work.

+ info->content = summary_build_content_info(s, info, mp);

+ info->size = camel_mime_parser_tell(mp) - start;

+ info->content = summary_build_content_info_message(s, info, (CamelMimePart *)msg);

+ * camel_folder_summary_info_free:

+ * @s:

+ * @mi:

+ *

+ * Unref and potentially free the message info @mi, and all associated memory.

+ **/

+void camel_folder_summary_info_free(CamelFolderSummary *s, CamelMessageInfo *mi)

+{

+ CamelMessageContentInfo *ci;

+

+ g_assert(mi);

+ g_assert(s);

+

+ CAMEL_SUMMARY_LOCK(s, ref_lock);

+

+ g_assert(mi->refcount >= 1);

+

+ mi->refcount--;

+ if (mi->refcount > 0) {

+ CAMEL_SUMMARY_UNLOCK(s, ref_lock);

+ return;

+ }

+

+ CAMEL_SUMMARY_UNLOCK(s, ref_lock);

+

+ ci = mi->content;

+

+ ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->message_info_free(s, mi);

+ if (s->build_content && ci) {

+ camel_folder_summary_content_info_free(s, ci);

+ }

+}

+

+/**

+ * camel_folder_summary_info_ref:

+ * @s:

+ * @mi:

+ *

+ * Add an extra reference to @mi.

+ **/

+void camel_folder_summary_info_ref(CamelFolderSummary *s, CamelMessageInfo *mi)

+{

+ g_assert(mi);

+ g_assert(s);

+

+ CAMEL_SUMMARY_LOCK(s, ref_lock);

+ g_assert(mi->refcount >= 1);

+ mi->refcount++;

+ CAMEL_SUMMARY_UNLOCK(s, ref_lock);

+}

+

+/**

+ camel_folder_summary_info_free(s, s->messages->pdata[i]);

+ camel_folder_summary_info_free(s, info);

+ camel_folder_summary_info_free(s, oldinfo);

+ camel_folder_summary_info_free(s, info);

+ camel_folder_summary_info_free(s, infos[i-start]);

+ if ((info->flags & CAMEL_MESSAGE_SEEN) == 0)

+ if ((info->flags & CAMEL_MESSAGE_DELETED) != 0)

+ if ((info->flags & CAMEL_MESSAGE_JUNK) != 0)

+ camel_folder_summary_info_free(s, info);

+ mi = ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->message_info_new(s, camel_mime_parser_headers_raw(mp));

+ ci = ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->content_info_new(s, camel_mime_parser_headers_raw(mp));

+ mi = ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->message_info_new(s, ((CamelMimePart *)msg)->headers);

+ ci = ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->content_info_new(s, mp->headers);

+ * camel_folder_summary_info_new:

+ * @s:

+ *

+ * Allocate a new camel message info, suitable for adding

+ * to this summary.

+ *

+ * Return value:

+ **/

+CamelMessageInfo *

+camel_folder_summary_info_new(CamelFolderSummary *s)

+{

+ CamelMessageInfo *mi;

+

+ CAMEL_SUMMARY_LOCK(s, alloc_lock);

+ if (s->message_info_chunks == NULL)

+ s->message_info_chunks = e_memchunk_new(32, s->message_info_size);

+ mi = e_memchunk_alloc(s->message_info_chunks);

+ CAMEL_SUMMARY_UNLOCK(s, alloc_lock);

+

+ memset(mi, 0, s->message_info_size);

+#ifdef DOEPOOLV

+ mi->strings = e_poolv_new (s->message_info_strings);

+#endif

+#ifdef DOESTRV

+ mi->strings = e_strv_new(s->message_info_strings);

+#endif

+ mi->refcount = 1;

+ return mi;

+}

+

+/**

+message_info_new(CamelFolderSummary *s, struct _camel_header_raw *h)

+ CamelMessageInfo *mi;

+ mi = camel_folder_summary_info_new(s);

+#ifdef DOEPOOLV

+ e_poolv_set(mi->strings, CAMEL_MESSAGE_INFO_SUBJECT, subject, TRUE);

+ e_poolv_set(mi->strings, CAMEL_MESSAGE_INFO_FROM, from, TRUE);

+ e_poolv_set(mi->strings, CAMEL_MESSAGE_INFO_TO, to, TRUE);

+ e_poolv_set(mi->strings, CAMEL_MESSAGE_INFO_CC, cc, TRUE);

+ e_poolv_set(mi->strings, CAMEL_MESSAGE_INFO_MLIST, mlist, TRUE);

+#elif defined (DOESTRV)

+ e_strv_set_ref_free(mi->strings, CAMEL_MESSAGE_INFO_SUBJECT, subject);

+ e_strv_set_ref_free(mi->strings, CAMEL_MESSAGE_INFO_FROM, from);

+ e_strv_set_ref_free(mi->strings, CAMEL_MESSAGE_INFO_TO, to);

+ e_strv_set_ref_free(mi->strings, CAMEL_MESSAGE_INFO_CC, cc);

+ e_strv_set_ref_free(mi->strings, CAMEL_MESSAGE_INFO_MLIST, mlist);

+#else

+ mi->subject = subject;

+ mi->from = from;

+ mi->to = to;

+ mi->cc = cc;

+ mi->mlist = mlist;

+#endif

+ return mi;

+

+ CamelMessageInfo *mi;

+ mi = camel_folder_summary_info_new(s);

+#ifdef DOEPOOLV

+ e_poolv_set(mi->strings, CAMEL_MESSAGE_INFO_UID, uid, TRUE);

+ e_poolv_set(mi->strings, CAMEL_MESSAGE_INFO_SUBJECT, subject, TRUE);

+ e_poolv_set(mi->strings, CAMEL_MESSAGE_INFO_FROM, from, TRUE);

+ e_poolv_set(mi->strings, CAMEL_MESSAGE_INFO_TO, to, TRUE);

+ e_poolv_set(mi->strings, CAMEL_MESSAGE_INFO_CC, cc, TRUE);

+ e_poolv_set(mi->strings, CAMEL_MESSAGE_INFO_MLIST, mlist, TRUE);

+#elif defined (DOESTRV)

+ e_strv_set_ref_free(mi->strings, CAMEL_MESSAGE_INFO_UID, uid);

+ e_strv_set_ref_free(mi->strings, CAMEL_MESSAGE_INFO_SUBJECT, subject);

+ e_strv_set_ref_free(mi->strings, CAMEL_MESSAGE_INFO_FROM, from);

+ e_strv_set_ref_free(mi->strings, CAMEL_MESSAGE_INFO_TO, to);

+ e_strv_set_ref_free(mi->strings, CAMEL_MESSAGE_INFO_CC, cc);

+ e_strv_set_ref_free(mi->strings, CAMEL_MESSAGE_INFO_MLIST, mlist);

+#else

+ mi->subject = subject;

+ mi->from = from;

+ mi->to = to;

+ mi->cc = cc;

+ mi->mlist = mlist;

+#endif

+ return mi;

+ camel_folder_summary_info_free(s, mi);

+message_info_save(CamelFolderSummary *s, FILE *out, CamelMessageInfo *mi)

+message_info_free(CamelFolderSummary *s, CamelMessageInfo *mi)

+#ifdef DOEPOOLV

+ e_poolv_destroy(mi->strings);

+#elif defined (DOESTRV)

+ e_strv_destroy(mi->strings);

+#else

+ g_free(mi->subject);

+ g_free(mi->from);

+ g_free(mi->to);

+ g_free(mi->cc);

+ g_free(mi->mlist);

+#endif

+ e_memchunk_free(s->message_info_chunks, mi);

+content_info_new (CamelFolderSummary *s, struct _camel_header_raw *h)

+ msginfo->flags |= CAMEL_MESSAGE_SECURE;

+ if (!strcasecmp(encoding, "base64")) {

+ } else if (!strcasecmp (encoding, "x-uuencode")) {

+ || strcasecmp(charset, "utf-8")==0)) {

+ msginfo->flags |= CAMEL_MESSAGE_ATTACHMENTS;

+ msginfo->flags |= CAMEL_MESSAGE_SECURE;

+ msginfo->flags |= CAMEL_MESSAGE_ATTACHMENTS;

+ msginfo->flags |= CAMEL_MESSAGE_ATTACHMENTS;

+ msginfo->flags |= CAMEL_MESSAGE_SECURE;

+ msginfo->flags |= CAMEL_MESSAGE_SECURE;

+CamelMessageInfo *

+camel_message_info_new (void)

+

+ info = g_malloc0(sizeof(*info));

+#ifdef DOEPOOLV

+ info->strings = e_poolv_new(CAMEL_MESSAGE_INFO_LAST);

+#endif

+#ifdef DOESTRV

+ info->strings = e_strv_new (CAMEL_MESSAGE_INFO_LAST);

+#endif

+ *

+ * NOTE: This interface is not MT-SAFE, like the others.

+void camel_message_info_ref(CamelMessageInfo *info)

+ GLOBAL_INFO_LOCK(info);

+ info->refcount++;

+ GLOBAL_INFO_UNLOCK(info);

+camel_message_info_new_from_header (struct _camel_header_raw *header)

+ CamelMessageInfo *info;

+ char *subject, *from, *to, *cc, *mlist;

+ CamelContentType *ct = NULL;

+ const char *content, *date, *charset = NULL;

+

+ if ((content = camel_header_raw_find(&header, "Content-Type", NULL))

+ && (ct = camel_content_type_decode(content))

+ && (charset = camel_content_type_param(ct, "charset"))

+ && (g_ascii_strcasecmp(charset, "us-ascii") == 0))

+ charset = NULL;

+

+ charset = charset ? e_iconv_charset_name (charset) : NULL;

+

+ subject = summary_format_string(header, "subject", charset);

+ from = summary_format_address(header, "from", charset);

+ to = summary_format_address(header, "to", charset);

+ cc = summary_format_address(header, "cc", charset);

+ date = camel_header_raw_find(&header, "date", NULL);

+ mlist = camel_header_raw_check_mailing_list(&header);

+

+ if (ct)

+ camel_content_type_unref(ct);

+

+ info = camel_message_info_new();

+

+ camel_message_info_set_subject(info, subject);

+ camel_message_info_set_from(info, from);

+ camel_message_info_set_to(info, to);

+ camel_message_info_set_cc(info, cc);

+ camel_message_info_set_mlist(info, mlist);

+

+ if (date)

+ info->date_sent = camel_header_decode_date (date, NULL);

+ else

+ info->date_sent = time (NULL);

+

+ date = camel_header_raw_find (&header, "received", NULL);

+ if (date && (date = strrchr (date, ';')))

+ date++;

+

+ if (date)

+ info->date_received = camel_header_decode_date (date, NULL);

+ info->date_received = time (NULL);

+

+ return info;

+ * camel_message_info_dup_to:

+ * @from: source message info

+ * @to: destination message info

+ * Duplicates the contents of one CamelMessageInfo structure into another.

+ * (The destination is assumed to be empty: its contents are not freed.)

+ * The slightly odd interface is to allow this to be used to initialize

+ * "subclasses" of CamelMessageInfo.

+camel_message_info_dup_to(const CamelMessageInfo *from, CamelMessageInfo *to)

+ /* Copy numbers */

+ /* Copy strings */

+#ifdef DOEPOOLV

+ to->strings = e_poolv_cpy (to->strings, from->strings);

+#elif defined (DOESTRV)

+ /* to->strings = e_strv_new(CAMEL_MESSAGE_INFO_LAST); */

+ e_strv_set(to->strings, CAMEL_MESSAGE_INFO_SUBJECT, camel_message_info_subject(from));

+ e_strv_set(to->strings, CAMEL_MESSAGE_INFO_FROM, camel_message_info_from(from));

+ e_strv_set(to->strings, CAMEL_MESSAGE_INFO_TO, camel_message_info_to(from));

+ e_strv_set(to->strings, CAMEL_MESSAGE_INFO_CC, camel_message_info_cc(from));

+ e_strv_set(to->strings, CAMEL_MESSAGE_INFO_UID, camel_message_info_uid(from));

+ e_strv_set(to->strings, CAMEL_MESSAGE_INFO_UID, camel_message_info_mlist(from));

+#else

+ to->subject = g_strdup(from->subject);

+ to->from = g_strdup(from->from);

+ to->to = g_strdup(from->to);

+ to->cc = g_strdup(from->cc);

+ to->uid = g_strdup(from->uid);

+ to->mlist = g_strdup(from->mlist);

+#endif

+ memcpy(&to->message_id, &from->message_id, sizeof(from->message_id));

+ /* Copy structures */

+ } else {

+ to->references = NULL;

+ /* No, this is impossible without knowing the class of summary we came from */

+ /* FIXME some day */

+ to->content = NULL;

+/**

+ * camel_message_info_free:

+ * @mi: the message info

+ *

+ * Unref's and potentially frees a CamelMessageInfo and its contents.

+ *

+ * Can only be used to free CamelMessageInfo's created with

+ * camel_message_info_dup_to.

+ *

+ * NOTE: This interface is not MT-SAFE, like the others.

+ *

+ **/

+void

+camel_message_info_free(CamelMessageInfo *mi)

+ g_return_if_fail(mi != NULL);

+ GLOBAL_INFO_LOCK(info);

+ mi->refcount--;

+ if (mi->refcount > 0) {

+ GLOBAL_INFO_UNLOCK(info);

+ return;

+ GLOBAL_INFO_UNLOCK(info);

+#ifdef DOEPOOLV

+ e_poolv_destroy(mi->strings);

+#elif defined (DOESTRV)

+ e_strv_destroy(mi->strings);

+#else

+ g_free(mi->uid);

+ g_free(mi->subject);

+ g_free(mi->from);

+ g_free(mi->to);

+ g_free(mi->cc);

+ g_free(mi->mlist);

+#endif

+ g_free(mi->references);

+ camel_flag_list_free(&mi->user_flags);

+ camel_tag_list_free(&mi->user_tags);

+ /* FIXME: content info? */

+ g_free(mi);

+#if defined (DOEPOOLV) || defined (DOESTRV)

+const char *

+camel_message_info_string (const CamelMessageInfo *mi, int type)

+ g_assert (mi != NULL);

+

+ if (mi->strings == NULL)

+ return "";

+#ifdef DOEPOOLV

+ return e_poolv_get (mi->strings, type);

+#else

+ return e_strv_get (mi->strings, type);

+#endif

+void

+camel_message_info_set_string (CamelMessageInfo *mi, int type, char *str)

+ g_assert (mi != NULL);

+ g_assert (mi->strings != NULL);

+#ifdef DOEPOOLV

+ e_poolv_set (mi->strings, type, str, TRUE);

+#else

+ mi->strings = e_strv_set_ref_free (mi->strings, type, str);

+#endif

+#endif

+ printf("Flags: %04x\n", mi->flags & 0xffff);

+ camel_content_info_dump(mi->content, 0);

+#include "gal/util/e-iconv.h"

+

+#include <gal/util/e-iconv.h>

+#include <e-util/e-time-utils.h>

+#include "camel-service.h" /* for camel_gethostbyname() */

+

+

+#include "md5-utils.h"

+/* See rfc3156, section 2 and others */

+/* We do this simply: Anything not base64 must be qp

+ This is so that we can safely translate any occurance of "From "

+ into the quoted-printable escaped version safely. */

+static void

+prepare_sign(CamelMimePart *mime_part)

+{

+ CamelDataWrapper *wrapper;

+ CamelTransferEncoding encoding;

+ int parts, i;

+

+ wrapper = camel_medium_get_content_object (CAMEL_MEDIUM (mime_part));

+ if (!wrapper)

+ return;

+

+ if (CAMEL_IS_MULTIPART (wrapper)) {

+ parts = camel_multipart_get_number((CamelMultipart *)wrapper);

+ for (i = 0; i < parts; i++)

+ prepare_sign(camel_multipart_get_part((CamelMultipart *)wrapper, i));

+ } else if (CAMEL_IS_MIME_MESSAGE (wrapper)) {

+ prepare_sign((CamelMimePart *)wrapper);

+ } else {

+ encoding = camel_mime_part_get_encoding(mime_part);

+

+ if (encoding != CAMEL_TRANSFER_ENCODING_BASE64

+ && encoding != CAMEL_TRANSFER_ENCODING_QUOTEDPRINTABLE) {

+ camel_mime_part_set_encoding(mime_part, CAMEL_TRANSFER_ENCODING_QUOTEDPRINTABLE);

+ }

+ }

+}

+

+/**

+ * camel_multipart_signed_sign:

+ * @mps:

+ * @context: The CipherContext to use for signing.

+ * @content: CamelMimePart content you wish to sign/transport.

+ * @userid: The id of the signing key to use.

+ * @hash: The algorithm to use.

+ * @ex:

+ *

+ * Sign the part @content, and attach it as the first part

+ * (CAMEL_MULTIPART_SIGNED_CONTENT) of the multipart @mps. A

+ * signature object will be created and setup as the second part

+ * (CAMEL_MULTIPART_SIGNED_SIGNATURE) of the object. Once a part has

+ * been successfully signed the mutlipart is ready for transmission.

+ *

+ * This method should be used to create multipart/signed objects

+ * which are properly canoncalised before signing, etc.

+ *

+ * Return value: -1 on error, setting @ex appropriately. On error

+ * neither the content or signature parts will be setup.

+ **/

+int

+camel_multipart_signed_sign(CamelMultipartSigned *mps, CamelCipherContext *context, CamelMimePart *content, const char *userid, CamelCipherHash hash, CamelException *ex)

+{

+ abort();

+#if 0

+ CamelMimeFilter *canon_filter;

+ CamelStream *mem;

+ CamelStreamFilter *filter;

+ CamelContentType *mime_type;

+ CamelMimePart *sigpart;

+

+ /* this needs to be set */

+ g_return_val_if_fail(context->sign_protocol != NULL, -1);

+

+ prepare_sign(content);

+

+ mem = camel_stream_mem_new();

+ filter = camel_stream_filter_new_with_stream(mem);

+

+ /* Note: see rfc2015 or rfc3156, section 5 */

+ canon_filter = camel_mime_filter_canon_new(CAMEL_MIME_FILTER_CANON_STRIP|CAMEL_MIME_FILTER_CANON_CRLF|CAMEL_MIME_FILTER_CANON_FROM);

+ camel_stream_filter_add(filter, (CamelMimeFilter *)canon_filter);

+ camel_object_unref((CamelObject *)canon_filter);

+

+ camel_data_wrapper_write_to_stream((CamelDataWrapper *)content, (CamelStream *)filter);

+ camel_stream_flush((CamelStream *)filter);

+ camel_object_unref((CamelObject *)filter);

+ camel_stream_reset(mem);

+

+#if 0

+ printf("-- Signing:\n");

+ fwrite(((CamelStreamMem *)mem)->buffer->data, ((CamelStreamMem *)mem)->buffer->len, 1, stdout);

+ printf("-- end\n");

+#endif

+

+ sigpart = camel_mime_part_new();

+

+ if (camel_cipher_sign(context, userid, hash, mem, sigpart, ex) == -1) {

+ camel_object_unref(mem);

+ camel_object_unref(sigpart);

+ return -1;

+ }

+

+ /* setup our mime type and boundary */

+ mime_type = camel_content_type_new("multipart", "signed");

+ camel_content_type_set_param(mime_type, "micalg", camel_cipher_hash_to_id(context, hash));

+ camel_content_type_set_param(mime_type, "protocol", context->sign_protocol);

+ camel_data_wrapper_set_mime_type_field(CAMEL_DATA_WRAPPER (mps), mime_type);

+ camel_content_type_unref(mime_type);

+ camel_multipart_set_boundary((CamelMultipart *)mps, NULL);

+

+ /* just keep the whole raw content. We dont *really* need to do this because

+ we know how we just proccessed it, but, well, better to be safe than sorry */

+ mps->signature = sigpart;

+ mps->contentraw = mem;

+ camel_stream_reset(mem);

+

+ /* clear the data-wrapper stream - tells write_to_stream to use the right object */

+ if (((CamelDataWrapper *)mps)->stream) {

+ camel_object_unref((CamelObject *) ((CamelDataWrapper *)mps)->stream);

+ ((CamelDataWrapper *)mps)->stream = NULL;

+ }

+#endif

+ return 0;

+}

+

+

+/**

+ * camel_multipart_signed_verify:

+ * @mps:

+ * @context:

+ * @ex:

+ *

+ * Verify a signed object. This may be used to verify newly signed

+ * objects as well as those created from external streams or parsers.

+ *

+ * Return value: A validity value, or NULL on error, setting @ex

+ * appropriately.

+ **/

+CamelCipherValidity *

+camel_multipart_signed_verify(CamelMultipartSigned *mps, CamelCipherContext *context, CamelException *ex)

+{

+ abort();

+

+ return NULL;

+#if 0

+ CamelCipherValidity *valid;

+ CamelMimePart *sigpart;

+ CamelStream *constream;

+

+ /* we need to be able to verify stuff we just signed as well as stuff we loaded from a stream/parser */

+

+ if (mps->contentraw) {

+ constream = mps->contentraw;

+ camel_object_ref((CamelObject *)constream);

+ } else {

+ CamelStream *sub;

+ CamelMimeFilter *canon_filter;

+

+ if (mps->start1 == -1 && parse_content(mps) == -1) {

+ camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, _("parse error"));

+ return NULL;

+ }

+

+ /* first, prepare our parts */

+ sub = camel_seekable_substream_new((CamelSeekableStream *)((CamelDataWrapper *)mps)->stream, mps->start1, mps->end1);

+ constream = (CamelStream *)camel_stream_filter_new_with_stream(sub);

+ camel_object_unref((CamelObject *)sub);

+

+ /* Note: see rfc2015 or rfc3156, section 5 */

+ canon_filter = camel_mime_filter_canon_new (CAMEL_MIME_FILTER_CANON_CRLF);

+ camel_stream_filter_add((CamelStreamFilter *)constream, (CamelMimeFilter *)canon_filter);

+ camel_object_unref((CamelObject *)canon_filter);

+ }

+

+ /* we do this as a normal mime part so we can have it handle transfer encoding etc */

+ sigpart = camel_multipart_get_part((CamelMultipart *)mps, CAMEL_MULTIPART_SIGNED_SIGNATURE);

+

+ /* do the magic, the caller must supply the right context for this kind of object */

+ valid = camel_cipher_verify(context, camel_cipher_id_to_hash(context, mps->micalg), constream, sigpart, ex);

+

+#if 0

+ {

+ CamelStream *sout = camel_stream_fs_new_with_fd(dup(0));

+

+ camel_stream_printf(sout, "-- Verifying:\n");

+ camel_stream_reset(constream);

+ camel_stream_write_to_stream(constream, sout);

+ camel_stream_printf(sout, "-- end\n");

+ camel_object_unref((CamelObject *)sout);

+ }

+#endif

+

+ camel_object_unref(constream);

+

+ return valid;

+#endif

+}

+

+

+#include "e-util/e-msgport.h"

+

+#include <e-util/md5-utils.h>

+#include <gal/util/e-iconv.h>

+ struct hostent *h;

+#include <netdb.h>

+#include "e-util/e-msgport.h"

+

+#include "e-util/e-host-utils.h"

+

+/* ********************************************************************** */

+struct _addrinfo_msg {

+ EMsg msg;

+ unsigned int cancelled:1;

+

+ /* for host lookup */

+ const char *name;

+ const char *service;

+ int result;

+ const struct addrinfo *hints;

+ struct addrinfo **res;

+

+ /* for host lookup emulation */

+#ifdef NEED_ADDRINFO

+ struct hostent hostbuf;

+ int hostbuflen;

+ char *hostbufmem;

+#endif

+

+ /* for name lookup */

+ const struct sockaddr *addr;

+ socklen_t addrlen;

+ char *host;

+ int hostlen;

+ char *serv;

+ int servlen;

+ int flags;

+};

+

+static void

+cs_freeinfo(struct _addrinfo_msg *msg)

+{

+ g_free(msg->host);

+ g_free(msg->serv);

+#ifdef NEED_ADDRINFO

+ g_free(msg->hostbufmem);

+#endif

+ g_free(msg);

+}

+

+/* returns -1 if cancelled */

+static int

+cs_waitinfo(void *(worker)(void *), struct _addrinfo_msg *msg, const char *error, CamelException *ex)

+{

+ EMsgPort *reply_port;

+ pthread_t id;

+ int err, cancel_fd, cancel = 0, fd;

+

+ cancel_fd = camel_operation_cancel_fd(NULL);

+ if (cancel_fd == -1) {

+ worker(msg);

+ return 0;

+ }

+

+ reply_port = msg->msg.reply_port = e_msgport_new();

+ fd = e_msgport_fd(msg->msg.reply_port);

+ if ((err = pthread_create(&id, NULL, worker, msg)) == 0) {

+ struct pollfd polls[2];

+ int status;

+

+ polls[0].fd = fd;

+ polls[0].events = POLLIN;

+ polls[1].fd = cancel_fd;

+ polls[1].events = POLLIN;

+

+ d(printf("waiting for name return/cancellation in main process\n"));

+ do {

+ polls[0].revents = 0;

+ polls[1].revents = 0;

+ status = poll(polls, 2, -1);

+ } while (status == -1 && errno == EINTR);

+

+ if (status == -1 || (polls[1].revents & POLLIN)) {

+ if (status == -1)

+ camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, "%s: %s", error, g_strerror(errno));

+ else

+ camel_exception_setv(ex, CAMEL_EXCEPTION_USER_CANCEL, _("Cancelled"));

+

+ /* We cancel so if the thread impl is decent it causes immediate exit.

+ We detach so we dont need to wait for it to exit if it isn't.

+ We check the reply port incase we had a reply in the mean time, which we free later */

+ d(printf("Cancelling lookup thread and leaving it\n"));

+ msg->cancelled = 1;

+ pthread_detach(id);

+ pthread_cancel(id);

+ cancel = 1;

+ } else {

+ struct _addrinfo_msg *reply = (struct _addrinfo_msg *)e_msgport_get(reply_port);

+

+ g_assert(reply == msg);

+ d(printf("waiting for child to exit\n"));

+ pthread_join(id, NULL);

+ d(printf("child done\n"));

+ }

+ } else {

+ camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, "%s: %s: %s", error, _("cannot create thread"), g_strerror(err));

+ }

+ e_msgport_destroy(reply_port);

+

+ return cancel;

+}

+

+#ifdef NEED_ADDRINFO

+static void *

+cs_getaddrinfo(void *data)

+{

+ struct _addrinfo_msg *msg = data;

+ int herr;

+ struct hostent h;

+ struct addrinfo *res, *last = NULL;

+ struct sockaddr_in *sin;

+ in_port_t port = 0;

+ int i;

+

+ /* This is a pretty simplistic emulation of getaddrinfo */

+

+ while ((msg->result = e_gethostbyname_r(msg->name, &h, msg->hostbufmem, msg->hostbuflen, &herr)) == ERANGE) {

+ pthread_testcancel();

+ msg->hostbuflen *= 2;

+ msg->hostbufmem = g_realloc(msg->hostbufmem, msg->hostbuflen);

+ }

+

+ /* If we got cancelled, dont reply, just free it */

+ if (msg->cancelled)

+ goto cancel;

+

+ /* FIXME: map error numbers across */

+ if (msg->result != 0)

+ goto reply;

+

+ /* check hints matched */

+ if (msg->hints && msg->hints->ai_family && msg->hints->ai_family != h.h_addrtype) {

+ msg->result = EAI_FAMILY;

+ goto reply;

+ }

+

+ /* we only support ipv4 for this interface, even if it could supply ipv6 */

+ if (h.h_addrtype != AF_INET) {

+ msg->result = EAI_FAMILY;

+ goto reply;

+ }

+

+ /* check service mapping */

+ if (msg->service) {

+ const char *p = msg->service;

+

+ while (*p) {

+ if (*p < '0' || *p > '9')

+ break;

+ p++;

+ }

+

+ if (*p) {

+ const char *socktype = NULL;

+ struct servent *serv;

+

+ if (msg->hints && msg->hints->ai_socktype) {

+ if (msg->hints->ai_socktype == SOCK_STREAM)

+ socktype = "tcp";

+ else if (msg->hints->ai_socktype == SOCK_DGRAM)

+ socktype = "udp";

+ }

+

+ serv = getservbyname(msg->service, socktype);

+ if (serv == NULL) {

+ msg->result = EAI_NONAME;

+ goto reply;

+ }

+ port = serv->s_port;

+ } else {

+ port = htons(strtoul(msg->service, NULL, 10));

+ }

+ }

+

+ for (i=0;h.h_addr_list[i];i++) {

+ res = g_malloc0(sizeof(*res));

+ if (msg->hints) {

+ res->ai_flags = msg->hints->ai_flags;

+ if (msg->hints->ai_flags & AI_CANONNAME)

+ res->ai_canonname = g_strdup(h.h_name);

+ res->ai_socktype = msg->hints->ai_socktype;

+ res->ai_protocol = msg->hints->ai_protocol;

+ } else {

+ res->ai_flags = 0;

+ res->ai_socktype = SOCK_STREAM; /* fudge */

+ res->ai_protocol = 0; /* fudge */

+ }

+ res->ai_family = AF_INET;

+ res->ai_addrlen = sizeof(*sin);

+ res->ai_addr = g_malloc(sizeof(*sin));

+ sin = (struct sockaddr_in *)res->ai_addr;

+ sin->sin_family = AF_INET;

+ sin->sin_port = port;

+ memcpy(&sin->sin_addr, h.h_addr_list[i], sizeof(sin->sin_addr));

+

+ if (last == NULL) {

+ *msg->res = last = res;

+ } else {

+ last->ai_next = res;

+ last = res;

+ }

+ }

+reply:

+ e_msgport_reply((EMsg *)msg);

+ return NULL;

+cancel:

+ cs_freeinfo(msg);

+ return NULL;

+}

+#else

+static void *

+cs_getaddrinfo(void *data)

+{

+ struct _addrinfo_msg *info = data;

+

+ info->result = getaddrinfo(info->name, info->service, info->hints, info->res);

+

+ if (info->cancelled) {

+ g_free(info);

+ } else {

+ e_msgport_reply((EMsg *)info);

+ }

+

+ return NULL;

+}

+#endif /* NEED_ADDRINFO */

+

+struct addrinfo *

+camel_getaddrinfo(const char *name, const char *service, const struct addrinfo *hints, CamelException *ex)

+{

+ struct _addrinfo_msg *msg;

+ struct addrinfo *res = NULL;

+#ifndef ENABLE_IPv6

+ struct addrinfo myhints;

+#endif

+ g_return_val_if_fail(name != NULL, NULL);

+

+ if (camel_operation_cancel_check(NULL)) {

+ camel_exception_set(ex, CAMEL_EXCEPTION_USER_CANCEL, _("Cancelled"));

+ return NULL;

+ }

+

+ camel_operation_start_transient(NULL, _("Resolving: %s"), name);

+

+ /* force ipv4 addresses only */

+#ifndef ENABLE_IPv6

+ if (hints == NULL)

+ memset(&myhints, 0, sizeof(myhints));

+ else

+ memcpy (&myhints, hints, sizeof (myhints));

+

+ myhints.ai_family = AF_INET;

+ hints = &myhints;

+#endif

+

+ msg = g_malloc0(sizeof(*msg));

+ msg->name = name;

+ msg->service = service;

+ msg->hints = hints;

+ msg->res = &res;

+#ifdef NEED_ADDRINFO

+ msg->hostbuflen = 1024;

+ msg->hostbufmem = g_malloc(msg->hostbuflen);

+#endif

+ if (cs_waitinfo(cs_getaddrinfo, msg, _("Host lookup failed"), ex) == 0) {

+ if (msg->result != 0)

+ camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, _("Host lookup failed: %s: %s"),

+ name, gai_strerror (msg->result));

+

+ cs_freeinfo(msg);

+ } else

+ res = NULL;

+

+ camel_operation_end(NULL);

+

+ return res;

+}

+

+void

+camel_freeaddrinfo(struct addrinfo *host)

+{

+#ifdef NEED_ADDRINFO

+ while (host) {

+ struct addrinfo *next = host->ai_next;

+

+ g_free(host->ai_canonname);

+ g_free(host->ai_addr);

+ g_free(host);

+ host = next;

+ }

+#else

+ freeaddrinfo(host);

+#endif

+}

+

+#ifdef NEED_ADDRINFO

+static void *

+cs_getnameinfo(void *data)

+{

+ struct _addrinfo_msg *msg = data;

+ int herr;

+ struct hostent h;

+ struct sockaddr_in *sin = (struct sockaddr_in *)msg->addr;

+

+ /* FIXME: error code */

+ if (msg->addr->sa_family != AF_INET) {

+ msg->result = -1;

+ return NULL;

+ }

+

+ /* FIXME: honour getnameinfo flags: do we care, not really */

+

+ while ((msg->result = e_gethostbyaddr_r((const char *)&sin->sin_addr, sizeof(sin->sin_addr), AF_INET, &h,

+ msg->hostbufmem, msg->hostbuflen, &herr)) == ERANGE) {

+ pthread_testcancel ();

+ msg->hostbuflen *= 2;

+ msg->hostbufmem = g_realloc(msg->hostbufmem, msg->hostbuflen);

+ }

+

+ if (msg->cancelled)

+ goto cancel;

+

+ if (msg->host) {

+ g_free(msg->host);

+ if (msg->result == 0 && h.h_name && h.h_name[0]) {

+ msg->host = g_strdup(h.h_name);

+ } else {

+ unsigned char *in = (unsigned char *)&sin->sin_addr;

+

+ /* sin_addr is always network order which is big-endian */

+ msg->host = g_strdup_printf("%u.%u.%u.%u", in[0], in[1], in[2], in[3]);

+ }

+ }

+

+ /* we never actually use this anyway */

+ if (msg->serv)

+ sprintf(msg->serv, "%d", sin->sin_port);

+

+ e_msgport_reply((EMsg *)msg);

+ return NULL;

+cancel:

+ cs_freeinfo(msg);

+ return NULL;

+}

+#else

+static void *

+cs_getnameinfo(void *data)

+{

+ struct _addrinfo_msg *msg = data;

+

+ /* there doens't appear to be a return code which says host or serv buffers are too short, lengthen them */

+ msg->result = getnameinfo(msg->addr, msg->addrlen, msg->host, msg->hostlen, msg->serv, msg->servlen, msg->flags);

+

+ if (msg->cancelled)

+ cs_freeinfo(msg);

+ else

+ e_msgport_reply((EMsg *)msg);

+

+ return NULL;

+}

+#endif

+

+int

+camel_getnameinfo(const struct sockaddr *sa, socklen_t salen, char **host, char **serv, int flags, CamelException *ex)

+{

+ struct _addrinfo_msg *msg;

+ int result;

+

+ if (camel_operation_cancel_check(NULL)) {

+ camel_exception_set (ex, CAMEL_EXCEPTION_USER_CANCEL, _("Cancelled"));

+ return -1;

+ }

+

+ camel_operation_start_transient(NULL, _("Resolving address"));

+

+ msg = g_malloc0(sizeof(*msg));

+ msg->addr = sa;

+ msg->addrlen = salen;

+ if (host) {

+ msg->hostlen = NI_MAXHOST;

+ msg->host = g_malloc(msg->hostlen);

+ msg->host[0] = 0;

+ }

+ if (serv) {

+ msg->servlen = NI_MAXSERV;

+ msg->serv = g_malloc(msg->servlen);

+ msg->serv[0] = 0;

+ }

+ msg->flags = flags;

+#ifdef NEED_ADDRINFO

+ msg->hostbuflen = 1024;

+ msg->hostbufmem = g_malloc(msg->hostbuflen);

+#endif

+ cs_waitinfo(cs_getnameinfo, msg, _("Name lookup failed"), ex);

+

+ if ((result = msg->result) != 0)

+ camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, _("Name lookup failed: %s"),

+ gai_strerror (result));

+

+ if (host)

+ *host = g_strdup(msg->host);

+ if (serv)

+ *serv = g_strdup(msg->serv);

+

+ g_free(msg->host);

+ g_free(msg->serv);

+ g_free(msg);

+

+ camel_operation_end(NULL);

+

+ return result;

+}

+

+

+ * Author :

+ * Bertrand Guiheneuf <bertrand@helixcode.com>

+

+#include <netdb.h>

+

+

+

+#ifdef NEED_ADDRINFO

+/* Some of this is copied from GNU's netdb.h

+

+ Copyright (C) 1996-2002, 2003, 2004 Free Software Foundation, Inc.

+ This file is part of the GNU C Library.

+

+ The GNU C Library is free software; you can redistribute it and/or

+ modify it under the terms of the GNU Lesser General Public

+ License as published by the Free Software Foundation; either

+ version 2.1 of the License, or (at your option) any later version.

+*/

+struct addrinfo {

+ int ai_flags;

+ int ai_family;

+ int ai_socktype;

+ int ai_protocol;

+ size_t ai_addrlen;

+ struct sockaddr *ai_addr;

+ char *ai_canonname;

+ struct addrinfo *ai_next;

+};

+

+#define AI_CANONNAME 0x0002 /* Request for canonical name. */

+#define AI_NUMERICHOST 0x0004 /* Don't use name resolution. */

+

+/* Error values for `getaddrinfo' function. */

+#define EAI_BADFLAGS -1 /* Invalid value for `ai_flags' field. */

+#define EAI_NONAME -2 /* NAME or SERVICE is unknown. */

+#define EAI_AGAIN -3 /* Temporary failure in name resolution. */

+#define EAI_FAIL -4 /* Non-recoverable failure in name res. */

+#define EAI_NODATA -5 /* No address associated with NAME. */

+#define EAI_FAMILY -6 /* `ai_family' not supported. */

+#define EAI_SOCKTYPE -7 /* `ai_socktype' not supported. */

+#define EAI_SERVICE -8 /* SERVICE not supported for `ai_socktype'. */

+#define EAI_ADDRFAMILY -9 /* Address family for NAME not supported. */

+#define EAI_MEMORY -10 /* Memory allocation failure. */

+#define EAI_SYSTEM -11 /* System error returned in `errno'. */

+#define EAI_OVERFLOW -12 /* Argument buffer overflow. */

+

+#define NI_MAXHOST 1025

+#define NI_MAXSERV 32

+

+#define NI_NUMERICHOST 1 /* Don't try to look up hostname. */

+#define NI_NUMERICSERV 2 /* Don't convert port number to name. */

+#define NI_NOFQDN 4 /* Only return nodename portion. */

+#define NI_NAMEREQD 8 /* Don't return numeric addresses. */

+#define NI_DGRAM 16 /* Look up UDP service rather than TCP. */

+#endif

+

+/* new hostname interfaces */

+struct addrinfo *camel_getaddrinfo(const char *name, const char *service,

+ const struct addrinfo *hints, CamelException *ex);

+void camel_freeaddrinfo(struct addrinfo *host);

+int camel_getnameinfo(const struct sockaddr *sa, socklen_t salen, char **host, char **serv,

+ int flags, CamelException *ex);

+

+ camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot create CMS signedData"));

+ camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot attach CMS signedData"));

+ camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot create CMS SignerInfo"));

+ camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot find cert chain"));

+ camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot add CMS SigningTime"));

+ camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, _("Encryption cert for '%s' does not exist"), p->encrypt_key);

+ camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, _("Encryption cert for '%s' does not exist"), nick);

+ camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot add CMS SignerInfo"));

+ camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("No signedData in signature"));

+ g_string_printf(description, _("Certificate only message, cannot verify certificates"));

+ g_string_printf(description, _("Certificate only message, certificates imported and verified"));

+ camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot create CMS EnvelopedData"));

+ camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot attach CMS EnvelopedData"));

+ camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot create CMS RecipientInfo"));

+ camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, _("Cannot add CMS RecipientInfo"));

+/*#include <e-util/md5-utils.h>*/

+#include "camel-folder-summary.h"

+#include "e-util/md5-utils.h"

+#include "e-util/e-memory.h"

+static gboolean vee_set_message_flags (CamelFolder *folder, const char *uid, guint32 flags, guint32 set);

+static void vee_set_message_user_flag (CamelFolder *folder, const char *uid, const char *name, gboolean value);

+static void vee_set_message_user_tag(CamelFolder *folder, const char *uid, const char *name, const char *value);

+static int vee_folder_build_folder(CamelVeeFolder *vf, CamelFolder *source, CamelException *ex);

+static void vee_folder_remove_folder(CamelVeeFolder *vf, CamelFolder *source, int killun);

+static void subfolder_renamed(CamelFolder *f, void *event_data, CamelVeeFolder *vf);

+static void

+camel_vee_folder_class_init (CamelVeeFolderClass *klass)

+{

+ CamelFolderClass *folder_class = (CamelFolderClass *) klass;

+

+ camel_vee_folder_parent = CAMEL_FOLDER_CLASS(camel_type_get_global_classfuncs (camel_folder_get_type ()));

+

+ folder_class->refresh_info = vee_refresh_info;

+ folder_class->sync = vee_sync;

+ folder_class->expunge = vee_expunge;

+

+ folder_class->get_message = vee_get_message;

+ folder_class->append_message = vee_append_message;

+ folder_class->transfer_messages_to = vee_transfer_messages_to;

+

+ folder_class->search_by_expression = vee_search_by_expression;

+ folder_class->search_by_uids = vee_search_by_uids;

+

+ folder_class->set_message_flags = vee_set_message_flags;

+ folder_class->set_message_user_flag = vee_set_message_user_flag;

+ folder_class->set_message_user_tag = vee_set_message_user_tag;

+

+ folder_class->rename = vee_rename;

+

+ folder_class->freeze = vee_freeze;

+ folder_class->thaw = vee_thaw;

+}

+

+static void

+camel_vee_folder_init (CamelVeeFolder *obj)

+{

+ struct _CamelVeeFolderPrivate *p;

+ CamelFolder *folder = (CamelFolder *)obj;

+

+ p = _PRIVATE(obj) = g_malloc0(sizeof(*p));

+

+ folder->folder_flags |= (CAMEL_FOLDER_HAS_SUMMARY_CAPABILITY |

+ CAMEL_FOLDER_HAS_SEARCH_CAPABILITY);

+

+ /* FIXME: what to do about user flags if the subfolder doesn't support them? */

+ folder->permanent_flags = CAMEL_MESSAGE_ANSWERED |

+ CAMEL_MESSAGE_DELETED |

+ CAMEL_MESSAGE_DRAFT |

+ CAMEL_MESSAGE_FLAGGED |

+ CAMEL_MESSAGE_SEEN;

+

+ obj->changes = camel_folder_change_info_new();

+ obj->search = camel_folder_search_new();

+

+ p->summary_lock = g_mutex_new();

+ p->subfolder_lock = g_mutex_new();

+ p->changed_lock = g_mutex_new();

+}

+

+static void

+camel_vee_folder_finalise (CamelObject *obj)

+{

+ CamelVeeFolder *vf = (CamelVeeFolder *)obj;

+ struct _CamelVeeFolderPrivate *p = _PRIVATE(vf);

+ GList *node;

+ CamelVeeFolder *folder_unmatched = vf->parent_vee_store ? vf->parent_vee_store->folder_unmatched : NULL;

+

+ /* FIXME: check leaks */

+ node = p->folders;

+ while (node) {

+ CamelFolder *f = node->data;

+

+ if (vf != folder_unmatched) {

+ camel_object_unhook_event((CamelObject *)f, "folder_changed", (CamelObjectEventHookFunc) folder_changed, vf);

+ camel_object_unhook_event((CamelObject *)f, "deleted", (CamelObjectEventHookFunc) subfolder_deleted, vf);

+ camel_object_unhook_event((CamelObject *)f, "renamed", (CamelObjectEventHookFunc) subfolder_renamed, vf);

+ /* this updates the vfolder */

+ if ((vf->flags & CAMEL_STORE_FOLDER_PRIVATE) == 0)

+ vee_folder_remove_folder(vf, f, FALSE);

+ }

+ camel_object_unref((CamelObject *)f);

+

+ node = g_list_next(node);

+ }

+

+ g_free(vf->expression);

+ g_free(vf->vname);

+

+ g_list_free(p->folders);

+ g_list_free(p->folders_changed);

+

+ camel_folder_change_info_free(vf->changes);

+ camel_object_unref((CamelObject *)vf->search);

+

+ g_mutex_free(p->summary_lock);

+ g_mutex_free(p->subfolder_lock);

+ g_mutex_free(p->changed_lock);

+

+ g_free(p);

+}

+

+ char *tmp;

+ vf->vname = g_strdup(name);

+ tmp = strrchr(vf->vname, '/');

+ tmp = vf->vname;

+ camel_folder_construct(folder, parent_store, vf->vname, tmp);

+ /* should CamelVeeMessageInfo be subclassable ..? */

+ folder->summary = camel_folder_summary_new();

+ folder->summary->message_info_size = sizeof(CamelVeeMessageInfo);

+ struct _CamelVeeFolderPrivate *p = _PRIVATE(vf);

+ GList *node;

+

+ CAMEL_VEE_FOLDER_LOCK(vf, subfolder_lock);

+

+ /* no change, do nothing */

+ if ((vf->expression && query && strcmp(vf->expression, query) == 0)

+ || (vf->expression == NULL && query == NULL)) {

+ CAMEL_VEE_FOLDER_UNLOCK(vf, subfolder_lock);

+ return;

+ }

+

+ g_free(vf->expression);

+ if (query)

+ vf->expression = g_strdup(query);

+

+ node = p->folders;

+ while (node) {

+ CamelFolder *f = node->data;

+

+ if (vee_folder_build_folder(vf, f, NULL) == -1)

+ break;

+

+ node = node->next;

+ }

+

+ CAMEL_VEE_FOLDER_LOCK(vf, changed_lock);

+ g_list_free(p->folders_changed);

+ p->folders_changed = NULL;

+ CAMEL_VEE_FOLDER_UNLOCK(vf, changed_lock);

+

+ CAMEL_VEE_FOLDER_UNLOCK(vf, subfolder_lock);

+ camel_object_hook_event((CamelObject *)sub, "renamed", (CamelObjectEventHookFunc)subfolder_renamed, vf);

+ vee_folder_build_folder(vf, sub, NULL);

+ int killun = FALSE;

+ camel_object_unhook_event((CamelObject *)sub, "renamed", (CamelObjectEventHookFunc) subfolder_renamed, vf);

+ killun = TRUE;

+ if (g_list_find(up->folders, sub) == NULL) {

+ killun = TRUE;

+ }

+ vee_folder_remove_folder(vf, sub, killun);

+ int changed;

+

+ /* if this was a changed folder, re-update it while we're here */

+ CAMEL_VEE_FOLDER_LOCK(vf, changed_lock);

+ changed = g_list_find(p->folders_changed, folder) != NULL;

+ if (changed)

+ p->folders_changed = g_list_remove(p->folders_changed, folder);

+ CAMEL_VEE_FOLDER_UNLOCK(vf, changed_lock);

+ if (changed)

+ vee_folder_build_folder(vf, folder, NULL);

+ if (CAMEL_IS_VEE_FOLDER(vinfo->folder)) {

+ CamelFolder *folder;

+ vfinfo = (CamelVeeMessageInfo *)camel_folder_get_message_info(vinfo->folder, camel_message_info_uid(vinfo)+8);

+ folder = camel_vee_folder_get_location((CamelVeeFolder *)vinfo->folder, vfinfo, realuid);

+ camel_folder_free_message_info(vinfo->folder, (CamelMessageInfo *)vfinfo);

+ return folder;

+ return vinfo->folder;

+ if (vee_folder_build_folder(vf, f, ex) == -1)

+ && vee_folder_build_folder(vf, f, ex) == -1)

+ msg = camel_folder_get_message(mi->folder, camel_message_info_uid(mi)+8, ex);

+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);

+ g_ptr_array_free(folder_uids, 0);

+static gboolean

+vee_set_message_flags(CamelFolder *folder, const char *uid, guint32 flags, guint32 set)

+{

+ CamelVeeMessageInfo *mi;

+ int res = FALSE;

+

+ mi = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, uid);

+ if (mi) {

+ res = camel_folder_set_message_flags(mi->folder, camel_message_info_uid(mi) + 8, flags, set);

+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);

+ res = res || ((CamelFolderClass *)camel_vee_folder_parent)->set_message_flags(folder, uid, flags, set);

+ }

+

+ return res;

+}

+

+static void

+vee_set_message_user_flag(CamelFolder *folder, const char *uid, const char *name, gboolean value)

+{

+ CamelVeeMessageInfo *mi;

+

+ mi = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, uid);

+ if (mi) {

+ camel_folder_set_message_user_flag(mi->folder, camel_message_info_uid(mi) + 8, name, value);

+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);

+ ((CamelFolderClass *)camel_vee_folder_parent)->set_message_user_flag(folder, uid, name, value);

+ }

+}

+

+static void

+vee_set_message_user_tag(CamelFolder *folder, const char *uid, const char *name, const char *value)

+{

+ CamelVeeMessageInfo *mi;

+

+ mi = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, uid);

+ if (mi) {

+ camel_folder_set_message_user_tag(mi->folder, camel_message_info_uid(mi) + 8, name, value);

+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);

+ ((CamelFolderClass *)camel_vee_folder_parent)->set_message_user_tag(folder, uid, name, value);

+ }

+}

+

+ CamelVeeFolder *vf = (CamelVeeFolder *)folder;

+

+ g_free(vf->vname);

+ vf->vname = g_strdup(new);

+/* ********************************************************************** *

+ utility functions */

+/* must be called with summary_lock held */

+static CamelVeeMessageInfo *

+vee_folder_add_info(CamelVeeFolder *vf, CamelFolder *f, CamelMessageInfo *info, const char hash[8])

+{

+ CamelVeeMessageInfo *mi;

+ char *vuid;

+ const char *uid;

+ CamelFolder *folder = (CamelFolder *)vf;

+ CamelMessageInfo *dinfo;

+ uid = camel_message_info_uid(info);

+ vuid = alloca(strlen(uid)+9);

+ memcpy(vuid, hash, 8);

+ strcpy(vuid+8, uid);

+ dinfo = camel_folder_summary_uid(folder->summary, vuid);

+ if (dinfo) {

+ d(printf("w:clash, we already have '%s' in summary\n", vuid));

+ camel_folder_summary_info_free(folder->summary, dinfo);

+ return NULL;

+ d(printf("adding vuid %s to %s\n", vuid, vf->vname));

+

+ mi = (CamelVeeMessageInfo *)camel_folder_summary_info_new(folder->summary);

+ camel_message_info_dup_to(info, (CamelMessageInfo *)mi);

+#ifdef DOEPOOLV

+ mi->info.strings = e_poolv_set(mi->info.strings, CAMEL_MESSAGE_INFO_UID, vuid, FALSE);

+#elif defined (DOESTRV)

+ mi->info.strings = e_strv_set_ref(mi->info.strings, CAMEL_MESSAGE_INFO_UID, vuid);

+ mi->info.strings = e_strv_pack(mi->info.strings);

+#else

+ g_free(mi->info.uid);

+ mi->info.uid = g_strdup(vuid);

+#endif

+ mi->folder = f;

+ camel_folder_summary_add(folder->summary, (CamelMessageInfo *)mi);

+ return mi;

+}

+ mi = vee_folder_add_info(vf, f, info, hash);

+vee_folder_remove_folder(CamelVeeFolder *vf, CamelFolder *source, int killun)

+

+ if (mi->folder == source) {

+ camel_folder_summary_info_free(((CamelFolder *)folder_unmatched)->summary, (CamelMessageInfo *)mi);

+ if (mi->folder == source) {

+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);

+ camel_folder_summary_info_free(((CamelFolder *)u->folder_unmatched)->summary, (CamelMessageInfo *)mi);

+vee_folder_build_folder(CamelVeeFolder *vf, CamelFolder *source, CamelException *ex)

+ if (mi->folder == source) {

+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);

+ if (mi->folder == source) {

+ camel_folder_summary_info_free(((CamelFolder *)folder_unmatched)->summary, (CamelMessageInfo *)mi);

+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)vinfo);

+ int changed = FALSE;

+

+ if (vinfo->info.flags != info->flags){

+ vinfo->info.flags = info->flags;

+ changed = TRUE;

+ }

+

+ changed |= camel_flag_list_copy(&vinfo->info.user_flags, &info->user_flags);

+ changed |= camel_tag_list_copy(&vinfo->info.user_tags, &info->user_tags);

+ if (changed)

+ camel_folder_change_info_change_uid(vf->changes, vuid);

+

+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)vinfo);

+ int changed = FALSE;

+

+ if (uinfo->info.flags != info->flags){

+ uinfo->info.flags = info->flags;

+ changed = TRUE;

+ }

+

+ changed |= camel_flag_list_copy(&uinfo->info.user_flags, &info->user_flags);

+ changed |= camel_tag_list_copy(&uinfo->info.user_tags, &info->user_tags);

+ if (changed)

+ camel_folder_change_info_change_uid(folder_unmatched->changes, vuid);

+

+ camel_folder_summary_info_free(((CamelFolder *)folder_unmatched)->summary, (CamelMessageInfo *)uinfo);

+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)vinfo);

+ camel_folder_summary_info_free(((CamelFolder *)folder_unmatched)->summary, (CamelMessageInfo *)uinfo);

+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)vinfo);

+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)vinfo);

+folder_changed(CamelFolder *sub, CamelFolderChangeInfo *changes, CamelVeeFolder *vf)

+ if (mi->folder == sub) {

+ camel_folder_summary_info_free(((CamelFolder *)vf)->summary, (CamelMessageInfo *)mi);

+subfolder_renamed(CamelFolder *f, void *event_data, CamelVeeFolder *vf)

+ * Copyright (C) 2000 Ximian Inc.

+ * Authors: Michael Zucchi <notzed@ximian.com>

+/* our message info includes the parent folder */

+typedef struct _CamelVeeMessageInfo {

+ CamelMessageInfo info;

+ CamelFolder *folder;

+} CamelVeeMessageInfo;

+

+ char *vname; /* local name */

+CamelFolder *camel_vee_folder_get_location(CamelVeeFolder *vf, const CamelVeeMessageInfo *vinfo, char **realuid);

+ name = alloca(strlen(vf->vname)+1);

+ strcpy(name, vf->vname);

+ change_folder(store, vf->vname, CHANGE_ADD, camel_folder_get_message_count((CamelFolder *)vf));

+add_esource (const char *conf_key, const char *group_name, const char* source_name, const char *username, const char* relative_uri, const char *soap_port, const char *use_ssl)

+ if ( !e_source_list_add_group (source_list, group, -1))

+

+ e_source_set_property (source, "username", username);

+ e_source_set_property (source, "port", soap_port);

+ e_source_set_property (source, "use_ssl", use_ssl);

+modify_esource (const char* conf_key, GwAccountInfo *old_account_info, const char* new_group_name, const char *username, const char* new_relative_uri, const char *soap_port, const char *use_ssl)

+

+ e_source_set_property (source, "username", username);

+ e_source_set_property (source, "port", soap_port);

+ e_source_set_property (source, "use_ssl", use_ssl);

+ add_esource ("/apps/evolution/calendar/sources", info->name, _("Calendar"), url->user, relative_uri, soap_port, use_ssl);

+ add_esource ("/apps/evolution/tasks/sources", info->name, _("Tasks"), url->user, relative_uri, soap_port, use_ssl);

+

+ char *relative_uri;

+ relative_uri = g_strdup_printf ("%s@%s/", new_url->user, new_poa_address);

+ modify_esource ("/apps/evolution/calendar/sources", existing_account_info, account->name, new_url->user, relative_uri, new_soap_port, new_use_ssl);

+ modify_esource ("/apps/evolution/tasks/sources", existing_account_info, account->name, new_url->user, relative_uri, new_soap_port, new_use_ssl);

+ g_free (relative_uri);

+

+

+ do {

+ if (camel_imap_store_readline (store, &line, ex) < 0)

+ goto lose;

+

+ /* MAJOR HACK ALERT, gropuwise sometimes sends an extra blank line after literals, check that here */

+ if (line[0] == 0)

+ g_warning("Server sent empty line after a literal, assuming in error");

+ } while (line[0] == 0);

+

+#include "e-util/e-path.h"

+#include "e-util/e-time-utils.h"

+ folder->summary = camel_imap_summary_new (summary_file);

+ camel_folder_summary_info_free (folder->summary, info);

+ folder_dir = e_path_to_physical (folders, new);

+ camel_folder_summary_info_free (folder->summary, info);

+ camel_folder_summary_info_free(folder->summary, info);

+

+ info->flags = (info->flags | server_set) & ~server_cleared;

+ camel_folder_summary_info_free (folder->summary, info);

+ CamelMessageInfo *info;

+ info = camel_folder_summary_index (folder->summary, i);

+ if ((info->flags & mask) != flags) {

+ camel_folder_summary_info_free (folder->summary, info);

+ CamelMessageInfo *info;

+ if (!(info = camel_folder_summary_index (folder->summary, i)))

+ if (!(info->flags & CAMEL_MESSAGE_FOLDER_FLAGGED)) {

+ camel_folder_summary_info_free (folder->summary, info);

+ unset = !(info->flags & folder->permanent_flags);

+ matches = get_matching (folder, info->flags & (folder->permanent_flags | CAMEL_MESSAGE_FOLDER_FLAGGED),

+ camel_folder_summary_info_free (folder->summary, info);

+ flaglist = imap_create_flag_list (unset ? folder->permanent_flags : info->flags & folder->permanent_flags);

+ info->flags &= ~CAMEL_MESSAGE_FOLDER_FLAGGED;

+ ((CamelImapMessageInfo *) info)->server_flags =

+ info->flags & CAMEL_IMAP_SERVER_FLAGS;

+ camel_folder_summary_info_free (folder->summary, info);

+

+ /* create flag string param */

+ if (info && info->flags)

+ flagstr = imap_create_flag_list (info->flags);

+ camel_folder_summary_info_free (source->summary, mi);

+ CamelMessageInfo *mi;

+ mi = camel_folder_summary_uid (folder->summary, uid);

+ || mi->size < IMAP_SMALL_BODY_SIZE

+ || (!content_info_incomplete(mi->content) && !mi->content->childs)) {

+ if (content_info_incomplete (mi->content)) {

+ imap_parse_body ((const char **) &body, folder, mi->content);

+ camel_message_info_dump(mi);

+ if (content_info_incomplete (mi->content))

+ msg = get_message (imap_folder, uid, mi->content, ex);

+ camel_folder_summary_info_free (folder->summary, mi);

+ CamelMessageInfo *mi;

+ mi = camel_folder_summary_info_new_from_message (folder->summary, msg);

+ mi->date_received = decode_internaldate (idate);

+ if (mi->date_received == -1)

+ mi->date_received = mi->date_sent;

+ CamelMessageInfo *mi, *info;

+ mi = camel_folder_summary_index (folder->summary, seq - 1);

+ camel_folder_summary_info_free (folder->summary, mi);

+ mi = camel_message_info_new ();

+ camel_message_info_dup_to (pmi, mi);

+ camel_message_info_set_uid (mi, g_strdup (uid));

+ mi->flags |= flags;

+ mi->size = size;

+ info = camel_folder_summary_uid(folder->summary, uid);

+ camel_folder_summary_info_free(folder->summary, info);

+ camel_folder_summary_add (folder->summary, mi);

+ if ((mi->flags & CAMEL_IMAP_MESSAGE_RECENT))

+ camel_folder_summary_info_free(folder->summary, mi);

+ camel_folder_summary_info_free (folder->summary, messages->pdata[i]);

+ camel_folder_summary_info_free(folder->summary, info);

+

+#include "e-util/e-path.h"

+

+

+

+ USE_SSL_NEVER,

+ USE_SSL_ALWAYS,

+ USE_SSL_WHEN_POSSIBLE

+connect_to_server (CamelService *service, int ssl_mode, int try_starttls, CamelException *ex)

+ int clean_quit;

+ int ret;

+ struct addrinfo *ai, hints = { 0 };

+ char *serv;

+ const char *port = NULL;

+

+ /* FIXME: this connect stuff is duplicated everywhere */

+

+ if (service->url->port) {

+ serv = g_alloca(16);

+ sprintf(serv, "%d", service->url->port);

+ } else {

+ serv = "imap";

+ port = IMAP_PORT;

+ }

+ if (ssl_mode != USE_SSL_NEVER) {

+ if (try_starttls) {

+ if (service->url->port == 0) {

+ serv = "imaps";

+ port = IMAPS_PORT;

+ }

+ if (!try_starttls && service->url->port == 0) {

+ serv = "imaps";

+ port = IMAPS_PORT;

+ }

+ camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,

+ _("Could not connect to %s (port %s): %s"),

+ service->url->host, serv,

+ _("SSL unavailable"));

+

+ hints.ai_socktype = SOCK_STREAM;

+ ai = camel_getaddrinfo(service->url->host, serv, &hints, ex);

+ if (ai == NULL && port != NULL && camel_exception_get_id(ex) != CAMEL_EXCEPTION_USER_CANCEL) {

+ camel_exception_clear(ex);

+ ai = camel_getaddrinfo(service->url->host, port, &hints, ex);

+ }

+ if (ai == NULL) {

+ camel_object_unref(tcp_stream);

+ return FALSE;

+ }

+ ret = camel_tcp_stream_connect(CAMEL_TCP_STREAM(tcp_stream), ai);

+ camel_freeaddrinfo(ai);

+ if (ret == -1) {

+ _("Could not connect to %s (port %s): %s"),

+ service->url->host, serv, g_strerror (errno));

+ if (strstr (buf, "Courier-IMAP") || getenv("CAMEL_IMAP_BRAINDAMAGED")) {

+#ifdef HAVE_SSL

+ if (ssl_mode == USE_SSL_WHEN_POSSIBLE) {

+ if (store->capabilities & IMAP_CAPABILITY_STARTTLS)

+ goto starttls;

+ } else if (ssl_mode == USE_SSL_ALWAYS) {

+ if (try_starttls) {

+ if (store->capabilities & IMAP_CAPABILITY_STARTTLS) {

+ /* attempt to toggle STARTTLS mode */

+ goto starttls;

+ } else {

+ /* server doesn't support STARTTLS, abort */

+ camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,

+ _("Failed to connect to IMAP server %s in secure mode: %s"),

+ service->url->host, _("SSL/TLS extension not supported."));

+ /* we have the possibility of quitting cleanly here */

+ clean_quit = TRUE;

+ goto exception;

+ }

+ }

+#endif /* HAVE_SSL */

+ return TRUE;

+

+#ifdef HAVE_SSL

+ starttls:

+#endif /* HAVE_SSL */

+ { "", USE_SSL_ALWAYS },

+ { "always", USE_SSL_ALWAYS },

+ { "when-possible", USE_SSL_WHEN_POSSIBLE },

+ { "never", USE_SSL_NEVER },

+ { NULL, USE_SSL_NEVER },

+ const char *command;

+#ifdef HAVE_SSL

+ const char *use_ssl;

+ int i, ssl_mode;

+#endif

+ command = camel_url_get_param (service->url, "command");

+ if (command)

+

+#ifdef HAVE_SSL

+ use_ssl = camel_url_get_param (service->url, "use_ssl");

+ if (use_ssl) {

+ if (!strcmp (ssl_options[i].value, use_ssl))

+ ssl_mode = ssl_options[i].mode;

+ } else

+ ssl_mode = USE_SSL_NEVER;

+

+ if (ssl_mode == USE_SSL_ALWAYS) {

+ /* First try the ssl port */

+ if (!connect_to_server (service, ssl_mode, FALSE, ex)) {

+ if (camel_exception_get_id (ex) == CAMEL_EXCEPTION_SERVICE_UNAVAILABLE) {

+ /* The ssl port seems to be unavailable, lets try STARTTLS */

+ camel_exception_clear (ex);

+ return connect_to_server (service, ssl_mode, TRUE, ex);

+ } else {

+ return FALSE;

+ }

+ }

+

+ return TRUE;

+ } else if (ssl_mode == USE_SSL_WHEN_POSSIBLE) {

+ /* If the server supports STARTTLS, use it */

+ return connect_to_server (service, ssl_mode, TRUE, ex);

+ /* User doesn't care about SSL */

+ return connect_to_server (service, ssl_mode, FALSE, ex);

+#else

+ return connect_to_server (service, USE_SSL_NEVER, FALSE, ex);

+#endif

+ folder_dir = e_path_to_physical (storage_path, folder_name);

+ summary = camel_imap_summary_new (summary_file);

+ CamelMessageInfo *info;

+

+ for (i = 0; i < max; i++) {

+ info = camel_folder_summary_index (summary, i);

+ if (info && (info->flags & CAMEL_MESSAGE_FOLDER_FLAGGED))

+ return TRUE;

+ folder_dir = e_path_to_physical (storage_path, folder_name);

+ folder_dir = e_path_to_physical (storage_path, folder_name);

+ oldpath = e_path_to_physical (storage_path, old_name);

+ newpath = e_path_to_physical (storage_path, new_name_in);

+ folder_dir = e_path_to_physical(storage_path, fi->full_name);

+ if (!e_path_find_folders (storage_path, get_one_folder_offline, folders)) {

+imap4_namespace_clear (CamelIMAP4Namespace **namespace)

+{

+ CamelIMAP4Namespace *node, *next;

+

+ node = *namespace;

+ while (node != NULL) {

+ next = node->next;

+ g_free (node->path);

+ g_free (node);

+ node = next;

+ }

+

+ *namespace = NULL;

+}

+

+static void

+ imap4_namespace_clear (&engine->namespaces.personal);

+ imap4_namespace_clear (&engine->namespaces.other);

+ imap4_namespace_clear (&engine->namespaces.shared);

+ { "NAMESPACE", CAMEL_IMAP4_CAPABILITY_NAMESPACE },

+ { "UIDPLUS", CAMEL_IMAP4_CAPABILITY_UIDPLUS },

+ { "LITERAL+", CAMEL_IMAP4_CAPABILITY_LITERALPLUS },

+ if (!strncasecmp ("AUTH=", token.v.atom, 5)) {

+ imap4_namespace_clear (&engine->namespaces.personal);

+ imap4_namespace_clear (&engine->namespaces.other);

+ imap4_namespace_clear (&engine->namespaces.shared);

+ if (token.token != CAMEL_IMAP4_TOKEN_QSTRING || strlen (token.v.qstring) > 1) {

+ d(fprintf (stderr, "Expected to find a qstring token as second element in NAMESPACE pair\n"));

+ node->sep = *token.v.qstring;

+ imap4_namespace_clear (&namespaces[i]);

+ if (token.token != CAMEL_IMAP4_TOKEN_ATOM) {

+ d(fprintf (stderr, "Expected an atom token as the second argument to the COPYUID RESP-CODE\n"));

+ if (resp != NULL)

+ resp->v.copyuid.srcset = g_strdup (token.v.atom);

+ if (token.token != CAMEL_IMAP4_TOKEN_ATOM) {

+ d(fprintf (stderr, "Expected an atom token as the third argument to the APPENDUID RESP-CODE\n"));

+ if (resp != NULL)

+ resp->v.copyuid.destset = g_strdup (token.v.atom);

+

+/* returns -1 on error, or one of CAMEL_IMAP4_UNTAGGED_[OK,NO,BAD,PREAUTH,HANDLED] on success */

+ tcp_stream = camel_tcp_stream_ssl_new (service->session, service->url->host, STARTTLS_FLAGS);

+ const char *port;

+

+ ret = connect_to_server (engine, ai, mode, ex);

+ fprintf (stderr, "sending : %s\r\n", challenge);

+ sasl = camel_sasl_new ("imap4", mech->authproto, service);

+ retval = imap4_reconnect (((CamelIMAP4Store *) service)->engine, ex);

+ if (clean && !store->engine->istream->disconnected) {

+

+static char

+imap4_get_path_delim (CamelIMAP4Engine *engine, const char *full_name)

+{

+ /* FIXME: move this to utils so imap4-folder.c can share */

+ CamelIMAP4Namespace *namespace;

+ const char *slash;

+ size_t len;

+ char *top;

+

+ if ((slash = strchr (full_name, '/')))

+ len = (slash - full_name);

+ else

+ len = strlen (full_name);

+

+ top = g_alloca (len + 1);

+ memcpy (top, full_name, len);

+ top[len] = '\0';

+

+ if (!g_ascii_strcasecmp (top, "INBOX"))

+ top = "INBOX";

+

+ retry:

+ namespace = engine->namespaces.personal;

+ while (namespace != NULL) {

+ if (!strcmp (namespace->path, top))

+ return namespace->sep;

+ namespace = namespace->next;

+ }

+

+ namespace = engine->namespaces.other;

+ while (namespace != NULL) {

+ if (!strcmp (namespace->path, top))

+ return namespace->sep;

+ namespace = namespace->next;

+ }

+

+ namespace = engine->namespaces.shared;

+ while (namespace != NULL) {

+ if (!strcmp (namespace->path, top))

+ return namespace->sep;

+ namespace = namespace->next;

+ }

+

+ if (top[0] != '\0') {

+ /* look for a default namespace? */

+ top[0] = '\0';

+ goto retry;

+ }

+

+ return '/';

+}

+

+ char sep;

+ sep = imap4_get_path_delim (((CamelIMAP4Store *) store)->engine, folder_name);

+

+ if (sep != '/') {

+ p = real_name = g_alloca (strlen (folder_name) + 1);

+ strcpy (real_name, folder_name);

+ while (*p != '\0') {

+ if (*p == '/')

+ *p = sep;

+ p++;

+ folder_name = real_name;

+ }

+

+ if (*folder_name)

+ else

+ sep = imap4_get_path_delim (engine, parent_name);

+

+ if (!(flags & CAMEL_STORE_FOLDER_INFO_FAST)) {

+ if (folder && !strcmp (folder->full_name, fi->full_name)) {

+ /* can't STATUS this folder since it is SELECTED, besides - it would be wasteful */

+ CamelMessageInfo *info;

+ int index;

+

+ fi->total = camel_folder_summary_count (folder->summary);

+

+ fi->unread = 0;

+ for (index = 0; index < fi->total; index++) {

+ if (!(info = camel_folder_summary_index (folder->summary, index)))

+ continue;

+

+ if ((info->flags & CAMEL_MESSAGE_SEEN) == 0)

+ fi->unread++;

+

+ camel_folder_summary_info_free (folder->summary, info);

+ }

+ } else {

+ imap4_status (store, fi);

+ }

+ if (engine->state == CAMEL_IMAP4_ENGINE_DISCONNECTED) {

+ if (!camel_service_connect ((CamelService *) store, ex))

+ return NULL;

+

+ engine = ((CamelIMAP4Store *) store)->engine;

+ if (top == NULL)

+ top = "";

+

+ camel_folder_summary_info_free(((CamelFolder *)istore->selected)->summary, info);

+ camel_folder_summary_info_free(((CamelFolder *)istore->selected)->summary, info);

+ camel_folder_summary_info_free(((CamelFolder *)istore->selected)->summary, pending->info);

+ camel_folder_summary_info_free(((CamelFolder *)istore->selected)->summary, info);

+ camel_folder_summary_info_free(((CamelFolder *)istore->selected)->summary, info);

+

+ return (CamelLocalSummary *)camel_maildir_summary_new(path, folder, index);

+ camel_folder_summary_info_free(folder->summary, info);

+#ifdef STATUS_PINE

+static gboolean mbox_set_message_flags(CamelFolder *folder, const char *uid, guint32 flags, guint32 set);

+#endif

+

+static void mbox_set_message_user_flag(CamelFolder *folder, const char *uid, const char *name, gboolean value);

+static void mbox_set_message_user_tag(CamelFolder *folder, const char *uid, const char *name, const char *value);

+

+#ifdef STATUS_PINE

+ camel_folder_class->set_message_flags = mbox_set_message_flags;

+#endif

+ camel_folder_class->set_message_user_flag = mbox_set_message_user_flag;

+ camel_folder_class->set_message_user_tag = mbox_set_message_user_tag;

+

+ return (CamelLocalSummary *)camel_mbox_summary_new(path, folder, index);

+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)info);

+

+#ifdef STATUS_PINE

+static gboolean

+mbox_set_message_flags(CamelFolder *folder, const char *uid, guint32 flags, guint32 set)

+{

+ /* Basically, if anything could change the Status line, presume it does */

+ if (((CamelMboxSummary *)folder->summary)->xstatus

+ && (flags & (CAMEL_MESSAGE_SEEN|CAMEL_MESSAGE_FLAGGED|CAMEL_MESSAGE_ANSWERED|CAMEL_MESSAGE_DELETED))) {

+ flags |= CAMEL_MESSAGE_FOLDER_XEVCHANGE|CAMEL_MESSAGE_FOLDER_FLAGGED;

+ set |= CAMEL_MESSAGE_FOLDER_XEVCHANGE|CAMEL_MESSAGE_FOLDER_FLAGGED;

+ }

+

+ return ((CamelFolderClass *)parent_class)->set_message_flags(folder, uid, flags, set);

+}

+#endif

+

+static void

+mbox_set_message_user_flag(CamelFolder *folder, const char *uid, const char *name, gboolean value)

+{

+ CamelMessageInfo *info;

+

+ g_return_if_fail(folder->summary != NULL);

+

+ info = camel_folder_summary_uid(folder->summary, uid);

+ if (info == NULL)

+ return;

+

+ if (camel_flag_set(&info->user_flags, name, value)) {

+ CamelFolderChangeInfo *changes = camel_folder_change_info_new();

+

+ info->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED|CAMEL_MESSAGE_FOLDER_XEVCHANGE;

+ camel_folder_summary_touch(folder->summary);

+

+ camel_folder_change_info_change_uid(changes, uid);

+ camel_object_trigger_event(folder, "folder_changed", changes);

+ camel_folder_change_info_free(changes);

+ }

+ camel_folder_summary_info_free(folder->summary, info);

+}

+

+static void

+mbox_set_message_user_tag(CamelFolder *folder, const char *uid, const char *name, const char *value)

+{

+ CamelMessageInfo *info;

+

+ g_return_if_fail(folder->summary != NULL);

+

+ info = camel_folder_summary_uid(folder->summary, uid);

+ if (info == NULL)

+ return;

+

+ if (camel_tag_set(&info->user_tags, name, value)) {

+ CamelFolderChangeInfo *changes = camel_folder_change_info_new();

+

+ info->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED|CAMEL_MESSAGE_FOLDER_XEVCHANGE;

+ camel_folder_summary_touch(folder->summary);

+

+ camel_folder_change_info_change_uid(changes, uid);

+ camel_object_trigger_event (folder, "folder_changed", changes);

+ camel_folder_change_info_free(changes);

+ }

+ camel_folder_summary_info_free(folder->summary, info);

+}

+ mbs = (CamelMboxSummary *)camel_mbox_summary_new(path, folderpath, NULL);

+ return (CamelLocalSummary *)camel_mh_summary_new(path, folder, index);

+ camel_folder_summary_info_free(folder->summary, info);

+

+ return (CamelLocalSummary *)camel_spool_summary_new(folder);

+ folder->summary = (CamelFolderSummary *) camel_nntp_summary_new (root);

+#include "e-util/e-msgport.h"

+enum {

+ USE_SSL_NEVER,

+ USE_SSL_ALWAYS,

+ USE_SSL_WHEN_POSSIBLE

+};

+

+connect_to_server (CamelService *service, int ssl_mode, CamelException *ex)

+ struct addrinfo *ai, hints = { 0 };

+ char *serv;

+ const char *port = NULL;

+

+ if (service->url->port) {

+ serv = g_alloca(16);

+ sprintf(serv, "%d", service->url->port);

+ } else {

+ serv = "nntp";

+ port = NNTP_PORT;

+ }

+ if (ssl_mode != USE_SSL_NEVER) {

+ if (service->url->port == 0) {

+ serv = "nntps";

+ port = NNTPS_PORT;

+ tcp_stream = camel_tcp_stream_ssl_new (service->session, service->url->host, CAMEL_TCP_STREAM_SSL_ENABLE_SSL2 | CAMEL_TCP_STREAM_SSL_ENABLE_SSL3);

+#else

+ tcp_stream = camel_tcp_stream_raw_new ();

+#endif /* HAVE_SSL */

+

+ hints.ai_socktype = SOCK_STREAM;

+ ai = camel_getaddrinfo(service->url->host, serv, &hints, ex);

+ if (ai == NULL && port != NULL && camel_exception_get_id(ex) != CAMEL_EXCEPTION_USER_CANCEL) {

+ camel_exception_clear(ex);

+ ai = camel_getaddrinfo(service->url->host, port, &hints, ex);

+ }

+ if (ai == NULL) {

+ camel_object_unref(tcp_stream);

+ goto fail;

+ }

+ ret = camel_tcp_stream_connect(CAMEL_TCP_STREAM(tcp_stream), ai);

+ camel_freeaddrinfo(ai);

+ if (ret == -1) {

+ _("Could not connect to %s (port %s): %s"),

+ service->url->host, serv, g_strerror (errno));

+

+ /* set 'reader' mode & ignore return code, also ping the server, inn goes offline very quickly otherwise */

+ goto fail;

+ { "", USE_SSL_ALWAYS },

+ { "always", USE_SSL_ALWAYS },

+ { "when-possible", USE_SSL_WHEN_POSSIBLE },

+ { "never", USE_SSL_NEVER },

+ { NULL, USE_SSL_NEVER },

+#ifdef HAVE_SSL

+ const char *use_ssl;

+ int i, ssl_mode;

+ use_ssl = camel_url_get_param (service->url, "use_ssl");

+ if (use_ssl) {

+ if (!strcmp (ssl_options[i].value, use_ssl))

+ ssl_mode = ssl_options[i].mode;

+ } else

+ ssl_mode = USE_SSL_NEVER;

+

+ if (ssl_mode == USE_SSL_ALWAYS) {

+ /* Connect via SSL */

+ return connect_to_server (service, ssl_mode, ex);

+ } else if (ssl_mode == USE_SSL_WHEN_POSSIBLE) {

+ /* If the server supports SSL, use it */

+ if (!connect_to_server (service, ssl_mode, ex)) {

+ if (camel_exception_get_id (ex) == CAMEL_EXCEPTION_SERVICE_UNAVAILABLE) {

+ /* The ssl port seems to be unavailable, fall back to plain NNTP */

+ camel_exception_clear (ex);

+ return connect_to_server (service, USE_SSL_NEVER, ex);

+ } else {

+ return FALSE;

+ }

+ }

+

+ return TRUE;

+ /* User doesn't care about SSL */

+ return connect_to_server (service, ssl_mode, ex);

+#else

+ return connect_to_server (service, USE_SSL_NEVER, ex);

+#endif

+static CamelMessageInfo * message_info_new (CamelFolderSummary *, struct _camel_header_raw *);

+ sklass->message_info_new = message_info_new;

+ s->message_info_size = sizeof(CamelMessageInfo);

+camel_nntp_summary_new(const char *path)

+message_info_new(CamelFolderSummary *s, struct _camel_header_raw *h)

+ CamelMessageInfo *mi;

+ mi = ((CamelFolderSummaryClass *)camel_nntp_summary_parent)->message_info_new(s, h);

+ camel_message_info_set_uid(mi, cns->priv->uid);

+ return mi;

+ CamelMessageInfo *mi;

+ mi = camel_folder_summary_uid(s, cns->priv->uid);

+ mi = camel_folder_summary_add_from_header(s, headers);

+ camel_folder_summary_info_free(s, mi);

+ camel_folder_summary_info_free(s, mi);

+ camel_folder_summary_info_free(s, mi);

+ CamelMessageInfo *mi = camel_folder_summary_index(s, i);

+ camel_folder_summary_info_free(s, mi);

+#include "e-util/md5-utils.h"

+#define POP3_PORT 110

+ USE_SSL_NEVER,

+ USE_SSL_ALWAYS,

+ USE_SSL_WHEN_POSSIBLE

+connect_to_server (CamelService *service, int ssl_mode, int try_starttls, CamelException *ex)

+ struct addrinfo *ai, hints = { 0 };

+ char *serv;

+ const char *port = NULL;

+

+ if (service->url->port) {

+ serv = g_alloca(16);

+ sprintf(serv, "%d", service->url->port);

+ } else {

+ serv = "pop3";

+ port = "110";

+ }

+

+ if (ssl_mode != USE_SSL_NEVER) {

+ if (try_starttls) {

+ if (service->url->port == 0) {

+ serv = "pop3s";

+ port = "995";

+ }

+ if (!try_starttls && service->url->port == 0) {

+ serv = "pop3s";

+ port = "995";

+ }

+

+ _("Could not connect to %s (port %s): %s"),

+ service->url->host, serv,

+ _("SSL unavailable"));