summaryrefslogtreecommitdiffstats
path: root/imap/smap.c
diff options
context:
space:
mode:
Diffstat (limited to 'imap/smap.c')
-rw-r--r--imap/smap.c4557
1 files changed, 4557 insertions, 0 deletions
diff --git a/imap/smap.c b/imap/smap.c
new file mode 100644
index 0000000..20a7c2c
--- /dev/null
+++ b/imap/smap.c
@@ -0,0 +1,4557 @@
+/*
+** Copyright 2003-2011 Double Precision, Inc.
+** See COPYING for distribution information.
+*/
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <ctype.h>
+#include <signal.h>
+#include <fcntl.h>
+#if HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#if HAVE_UTIME_H
+#include <utime.h>
+#endif
+#if TIME_WITH_SYS_TIME
+#include <sys/time.h>
+#include <time.h>
+#else
+#if HAVE_SYS_TIME_H
+#include <sys/time.h>
+#else
+#include <time.h>
+#endif
+#endif
+#if HAVE_LOCALE_H
+#include <locale.h>
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "mysignal.h"
+#include "imapd.h"
+#include "fetchinfo.h"
+#include "searchinfo.h"
+#include "storeinfo.h"
+#include "mailboxlist.h"
+#include "thread.h"
+#include "outbox.h"
+
+#include "imapwrite.h"
+#include "imaptoken.h"
+#include "imapscanclient.h"
+#include "searchinfo.h"
+#include "maildir/config.h"
+#include "maildir/maildircreate.h"
+#include "maildir/maildirrequota.h"
+#include "maildir/maildirgetquota.h"
+#include "maildir/maildirquota.h"
+#include "maildir/maildirmisc.h"
+#include "maildir/maildirwatch.h"
+#include "maildir/maildiraclt.h"
+#include "maildir/maildirnewshared.h"
+#include "maildir/maildirinfo.h"
+#include "unicode/unicode.h"
+
+#include "rfc2045/rfc2045.h"
+#include "rfc822/rfc822.h"
+
+#define SMAP_BUFSIZ 8192
+
+#define SHARED "shared"
+
+#define LIST_FOLDER 1
+#define LIST_DIRECTORY 2
+
+#define FETCH_UID 1
+#define FETCH_SIZE 2
+#define FETCH_FLAGS 4
+#define FETCH_KEYWORDS 8
+#define FETCH_INTERNALDATE 16
+
+extern dev_t homedir_dev;
+extern ino_t homedir_ino;
+
+int mdcreate(const char *mailbox);
+int mddelete(const char *s);
+
+extern int folder_rename(struct maildir_info *mi1,
+ struct maildir_info *mi2,
+ const char **errmsg);
+extern int current_temp_fd;
+extern const char *current_temp_fn;
+
+extern int snapshot_init(const char *, const char *);
+extern int keywords();
+
+extern unsigned long header_count, body_count;
+
+extern char *compute_myrights(maildir_aclt_list *l,
+ const char *l_owner);
+
+extern int addRemoveKeywords(int (*callback_func)(void *, void *),
+ void *callback_func_arg,
+ struct storeinfo *storeinfo_s);
+extern int doAddRemoveKeywords(unsigned long n, int uid, void *vp);
+
+
+extern void snapshot_select(int);
+extern void doflags(FILE *fp, struct fetchinfo *fi,
+ struct imapscaninfo *i, unsigned long msgnum,
+ struct rfc2045 *mimep);
+extern void set_time(const char *tmpname, time_t timestamp);
+extern int imapenhancedidle(void);
+extern void imapidle(void);
+
+extern void expunge();
+extern void doNoop(int);
+extern int do_store(unsigned long, int, void *);
+extern int reflag_filename(struct imapscanmessageinfo *mi,
+ struct imapflags *flags, int fd);
+
+extern void do_expunge(unsigned long expunge_start,
+ unsigned long expunge_end,
+ int force);
+
+extern char *current_mailbox, *current_mailbox_acl;
+static int current_mailbox_shared;
+
+extern struct imapscaninfo current_maildir_info;
+extern void get_message_flags(struct imapscanmessageinfo *,
+ char *, struct imapflags *);
+extern void fetchflags(unsigned long);
+extern int acl_lock(const char *homedir,
+ int (*func)(void *),
+ void *void_arg);
+extern void aclminimum(const char *);
+
+struct rfc2045 *fetch_alloc_rfc2045(unsigned long, FILE *);
+FILE *open_cached_fp(unsigned long);
+void fetch_free_cache();
+
+extern FILE *maildir_mkfilename(const char *mailbox, struct imapflags *flags,
+ unsigned long s, char **tmpname,
+ char **newname);
+
+/*
+** Parse a word from the current SMAP command.
+*/
+
+static char *getword(char **ptr)
+{
+ char *p= *ptr, *q, *r;
+
+ while (*p && isspace((int)(unsigned char)*p))
+ p++;
+
+ if (*p != '"')
+ {
+ for (q=p; *q; q++)
+ {
+ if (isspace((int)(unsigned char)*q))
+ {
+ *q++=0;
+ break;
+ }
+ }
+
+ *ptr=q;
+ return p;
+ }
+
+ ++p;
+ r=q=p;
+
+ while (*r)
+ {
+ if (*r == '"')
+ {
+ if (r[1] == '"')
+ {
+ r += 2;
+ *q++='"';
+ continue;
+ }
+ ++r;
+ break;
+ }
+
+ *q++ = *r++;
+ }
+
+ *q=0;
+ *ptr=r;
+ return p;
+}
+
+#define UC(c) if ( (c) >= 'a' && (c) <= 'z') (c) += 'A' - 'a'
+
+static void up(char *p)
+{
+ while (*p)
+ {
+ UC(*p);
+ p++;
+ }
+}
+
+/*
+** Write a WORD reply.
+*/
+static void smapword_s(const char *w);
+
+void smapword(const char *w)
+{
+ writes("\"");
+ smapword_s(w);
+ writes("\"");
+}
+
+static void smapword_s(const char *w)
+{
+ while (w && *w)
+ {
+ size_t i;
+
+ for (i=0; w[i]; i++)
+ if (w[i] == '"')
+ break;
+ if (i)
+ writemem(w, i);
+
+ w += i;
+
+ if (*w)
+ {
+ writes("\"\"");
+ ++w;
+ }
+ }
+}
+
+struct fn_word_list {
+ struct fn_word_list *next;
+ char *w;
+};
+
+/*
+** Create a folder word array by reading words from the SMAP command.
+*/
+
+static char **fn_fromwords(char **ptr)
+{
+ struct fn_word_list *h=NULL, *n, **t=&h;
+ size_t cnt=0;
+ char *p;
+ char **fn;
+
+ while (*(p=getword(ptr)))
+ {
+ n=malloc(sizeof(struct fn_word_list));
+
+ if (!n || !(n->w=strdup(p)))
+ {
+ if (n)
+ free(n);
+
+ while ((n=h) != NULL)
+ {
+ h=n->next;
+ free(n->w);
+ free(n);
+ }
+ return NULL;
+ }
+
+ n->next=NULL;
+ *t=n;
+ t= &n->next;
+ cnt++;
+ }
+
+ if (!h)
+ {
+ errno=EINVAL;
+ return NULL;
+ }
+
+ fn=malloc((cnt+1)*sizeof(char *));
+ cnt=0;
+
+ while ((n=h) != NULL)
+ {
+ h=n->next;
+
+ if (fn)
+ fn[cnt]=n->w;
+ else
+ free(n->w);
+ free(n);
+ cnt++;
+ }
+ if (fn)
+ fn[cnt]=0;
+ return fn;
+}
+
+/*
+** LIST-related functions.
+*/
+
+struct list_hier {
+ struct list_hier *next;
+ char *hier;
+ int flags;
+};
+
+struct list_callback_info {
+
+ struct list_hier *hier; /* Hierarchy being listed */
+
+ struct list_hier *found;
+};
+
+static void list(char *folder, const char *descr, int type)
+{
+ writes("* LIST ");
+
+ smapword(folder);
+
+ writes(" ");
+
+ smapword(descr);
+
+ if (type & LIST_FOLDER)
+ writes(" FOLDER");
+ if (type & LIST_DIRECTORY)
+ writes(" DIRECTORY");
+ writes("\n");
+}
+
+/*
+** Callback from maildir_list. f="INBOX.folder.name"
+**
+*/
+
+struct list_callback_utf8 {
+
+ void (*callback_func)(const char *, char **, void *);
+ void *callback_arg;
+ const char *homedir;
+ const char *owner;
+};
+
+static void list_callback(const char *f, void *vp)
+{
+ struct list_callback_utf8 *utf8=(struct list_callback_utf8 *)vp;
+ maildir_aclt_list l;
+
+ char **fn=maildir_smapfn_fromutf7(f);
+
+ if (!fn)
+ {
+ perror(f);
+ return;
+ }
+
+ if (maildir_acl_read(&l, utf8->homedir, strchr(f, '.')) == 0)
+ {
+ char *myrights;
+ char *owner=malloc(sizeof("user=")+strlen(utf8->owner));
+
+ if (!owner)
+ write_error_exit(0);
+
+ strcat(strcpy(owner, "user="), utf8->owner);
+ myrights=compute_myrights(&l, owner);
+ free(owner);
+
+ if (myrights && strchr(myrights, ACL_LOOKUP[0]) != NULL)
+ (*utf8->callback_func)(f, fn, utf8->callback_arg);
+ if (myrights)
+ free(myrights);
+
+ maildir_aclt_list_destroy(&l);
+ }
+ maildir_smapfn_free(fn);
+}
+
+/*
+** list_callback callback that accumulates existing folders beneath a
+** certain hierarchy.
+*/
+
+static void list_utf8_callback(const char *n, char **f, void *vp)
+{
+ struct list_callback_info *lci=(struct list_callback_info *)vp;
+ struct list_hier *h=lci->hier;
+
+ for (;;)
+ {
+ if (!*f)
+ return;
+
+ if (h)
+ {
+ if (strcmp(h->hier, *f))
+ break;
+
+ h=h->next;
+ f++;
+ continue;
+ }
+
+ for (h=lci->found; h; h=h->next)
+ {
+ if (strcmp(h->hier, *f) == 0)
+ break;
+ }
+
+ if (!h)
+ {
+ if ((h=malloc(sizeof(struct list_hier))) == NULL ||
+ (h->hier=strdup(*f)) == NULL)
+ {
+ if (h)
+ free(h);
+ perror("malloc");
+ break;
+ }
+
+ h->next=lci->found;
+ lci->found=h;
+ h->flags=0;
+ }
+
+ if (f[1])
+ h->flags |= LIST_DIRECTORY;
+ else
+ h->flags |= LIST_FOLDER;
+ break;
+ }
+}
+
+/*
+** SMAP1 list command goes here. Dirty hack: build the hierarchy list on
+** the stack.
+*/
+
+static void do_listcmd(struct list_hier **head,
+ struct list_hier **tail,
+ char **ptr);
+
+static void listcmd(struct list_hier **head,
+ struct list_hier **tail,
+ char **ptr)
+{
+ char *p;
+
+ if (*(p=getword(ptr)))
+ {
+ struct list_hier node;
+ node.next=NULL;
+ node.hier=p;
+
+ *tail= &node;
+ listcmd(head, &node.next, ptr);
+ return;
+ }
+ do_listcmd(head, tail, ptr);
+}
+
+struct smap_find_info {
+ char *homedir;
+ char *maildir;
+};
+
+static int smap_find_cb(struct maildir_newshared_enum_cb *cb);
+static int smap_list_cb(struct maildir_newshared_enum_cb *cb);
+static int read_acls(maildir_aclt_list *aclt_list,
+ struct maildir_info *minfo);
+
+static void do_listcmd(struct list_hier **head,
+ struct list_hier **tail,
+ char **ptr)
+{
+ struct list_hier *p;
+ size_t cnt;
+ char **vecs;
+ int hierlist=0;
+
+ if (!*head) /* No arguments to LIST */
+ {
+ list(INBOX, "New Mail", LIST_FOLDER);
+ list(INBOX, "Folders", LIST_DIRECTORY);
+ list(PUBLIC, "Public Folders", LIST_DIRECTORY);
+ }
+ else
+ {
+ struct list_callback_info lci;
+ struct list_callback_utf8 list_utf8_info;
+
+ list_utf8_info.callback_func= &list_utf8_callback;
+ list_utf8_info.callback_arg= &lci;
+
+ lci.hier= *head;
+ lci.found=NULL;
+
+ if (strcmp(lci.hier->hier, PUBLIC) == 0)
+ {
+ struct maildir_shindex_cache *curcache;
+ struct list_hier *p=lci.hier->next;
+ struct smap_find_info sfi;
+ int eof;
+ char *d;
+
+ curcache=maildir_shared_cache_read(NULL, NULL, NULL);
+
+ while (curcache && p)
+ {
+ size_t i;
+ int rc;
+ struct list_hier inbox;
+
+ for (i=0; i<curcache->nrecords; i++)
+ if (strcmp(curcache->records[i].name,
+ p->hier) == 0)
+ break;
+ if (i >= curcache->nrecords)
+ {
+ curcache=NULL;
+ break;
+ }
+
+ sfi.homedir=NULL;
+ sfi.maildir=NULL;
+ curcache->indexfile.startingpos=
+ curcache->records[i].offset;
+ rc=maildir_newshared_nextAt(&curcache
+ ->indexfile,
+ &eof,
+ smap_find_cb,
+ &sfi);
+
+ if (rc || eof)
+ {
+ fprintf(stderr, "ERR: Internal error -"
+ " maildir_newshared_nextAt: %s\n",
+ strerror(errno));
+ curcache=NULL;
+ break;
+ }
+
+ if (!sfi.homedir)
+ {
+ curcache=
+ maildir_shared_cache_read(curcache,
+ sfi.maildir,
+ p->hier);
+ p=p->next;
+ free(sfi.maildir);
+ continue;
+ }
+
+ inbox.next=p->next;
+ inbox.hier=INBOX;
+
+ d=maildir_location(sfi.homedir, sfi.maildir);
+ free(sfi.homedir);
+ free(sfi.maildir);
+
+ lci.hier= &inbox;
+ list_utf8_info.homedir=d;
+ list_utf8_info.owner=p->hier;
+
+ maildir_list(d, &list_callback,
+ &list_utf8_info);
+ free(d);
+ curcache=NULL;
+ break;
+ }
+
+ if (curcache) /* List a shared hierarchy */
+ {
+ int rc;
+
+ curcache->indexfile.startingpos=0;
+ eof=0;
+
+ do
+ {
+ rc=(curcache->indexfile.startingpos
+ ? maildir_newshared_next:
+ maildir_newshared_nextAt)
+ (&curcache->indexfile, &eof,
+ &smap_list_cb,
+ &list_utf8_info);
+
+ if (rc)
+ fprintf(stderr,
+ "ERR: Internal error -"
+ " maildir_newshared_next: %s\n",
+ strerror(errno));
+ } while (rc == 0 && !eof);
+
+ hierlist=1;
+ }
+ }
+ else
+ {
+ list_utf8_info.homedir=".";
+ list_utf8_info.owner=getenv("AUTHENTICATED");
+ maildir_list(".", &list_callback,
+ &list_utf8_info);
+ }
+
+ for (cnt=0, p= *head; p; p=p->next)
+ ++cnt;
+
+ vecs=malloc(sizeof(char *)*(cnt+2));
+
+ if (!vecs)
+ {
+ while (lci.found)
+ {
+ struct list_hier *h=lci.found;
+
+ lci.found=h->next;
+
+ free(h->hier);
+ free(h);
+ }
+ write_error_exit(0);
+ }
+
+
+ for (cnt=0, p= *head; p; p=p->next)
+ {
+ vecs[cnt]=p->hier;
+ ++cnt;
+ }
+
+ while (lci.found)
+ {
+ struct list_hier *h=lci.found;
+ struct maildir_info minfo;
+ maildir_aclt_list aclt_list;
+
+ lci.found=h->next;
+
+ vecs[cnt]=h->hier;
+ vecs[cnt+1]=0;
+
+ if (maildir_info_smap_find(&minfo, vecs,
+ getenv("AUTHENTICATED")) == 0)
+ {
+ if (read_acls(&aclt_list, &minfo) == 0)
+ {
+ char *acl;
+
+ acl=compute_myrights(&aclt_list,
+ minfo.owner);
+
+ if (acl)
+ {
+ if (strchr(acl, ACL_LOOKUP[0])
+ == NULL)
+ {
+ h->flags=LIST_DIRECTORY;
+
+ if (hierlist)
+ list(h->hier,
+ h->hier,
+ h->flags);
+
+ }
+ else
+ list(h->hier, h->hier,
+ h->flags);
+ free(acl);
+ }
+ else
+ {
+ fprintf(stderr,
+ "ERR: Cannot compute"
+ " my access rights"
+ " for %s: %s\n",
+ h->hier,
+ strerror(errno));
+ }
+
+ maildir_aclt_list_destroy(&aclt_list);
+ }
+ else
+ {
+ fprintf(stderr,
+ "ERR: Cannot read ACLs"
+ " for %s(%s): %s\n",
+ minfo.homedir ? minfo.homedir
+ : ".",
+ minfo.maildir ? minfo.maildir
+ : "unknown",
+ strerror(errno));
+ }
+ }
+ else
+ {
+ fprintf(stderr,
+ "ERR: Internal error in list():"
+ " cannot find folder %s: %s\n",
+ h->hier,
+ strerror(errno));
+ }
+
+ free(h->hier);
+ free(h);
+ }
+ free(vecs);
+ }
+ writes("+OK LIST completed\n");
+}
+
+static int smap_find_cb(struct maildir_newshared_enum_cb *cb)
+{
+ struct smap_find_info *ifs=(struct smap_find_info *)cb->cb_arg;
+
+ if (cb->homedir)
+ ifs->homedir=my_strdup(cb->homedir);
+ if (cb->maildir)
+ ifs->maildir=my_strdup(cb->maildir);
+ return 0;
+}
+
+static int smap_list_cb(struct maildir_newshared_enum_cb *cb)
+{
+ struct list_callback_utf8 *list_utf8_info=
+ (struct list_callback_utf8 *)cb->cb_arg;
+ struct list_callback_info *lci=
+ (struct list_callback_info *)list_utf8_info->callback_arg;
+ char *d;
+
+ struct list_hier *h;
+ struct stat stat_buf;
+
+ if (cb->homedir == NULL)
+ {
+ if ((h=malloc(sizeof(struct list_hier))) == NULL ||
+ (h->hier
+ =strdup(cb->name)) == NULL)
+ {
+ if (h)
+ free(h);
+ perror("ERR: malloc");
+ return 0;
+ }
+
+ h->next= lci->found;
+ lci->found=h;
+ h->flags = LIST_DIRECTORY;
+ return 0;
+ }
+
+ d=maildir_location(cb->homedir, cb->maildir);
+
+ if (!d)
+ {
+ perror("ERR: get_topmaildir");
+ return 0;
+ }
+
+ if (stat(d, &stat_buf) < 0 ||
+ (stat_buf.st_dev == homedir_dev &&
+ stat_buf.st_ino == homedir_ino))
+ {
+ free(d);
+ return 0;
+ }
+
+ list_utf8_info->homedir=d;
+ list_utf8_info->owner=cb->name;
+ lci->hier=NULL;
+ h=lci->found;
+ lci->found=NULL;
+ maildir_list(d, &list_callback, list_utf8_info);
+ free(d);
+
+ if (!lci->found)
+ lci->found=h;
+ else
+ {
+ char *p;
+
+ while (lci->found->next) /* SHOULDN'T HAPPEN!!! */
+ {
+ struct list_hier *p=lci->found->next;
+
+ lci->found->next=p->next;
+ free(p->hier);
+ free(p);
+ fprintf(stderr, "ERR: Unexpected folder list"
+ " in smap_list_cb()\n");
+ }
+ lci->found->next=h;
+
+ p=my_strdup(cb->name);
+ free(lci->found->hier);
+ lci->found->hier=p;
+ }
+
+ return (0);
+}
+
+/*
+** Read the name of a new folder. Returns the pathname to the folder, suitable
+** for immediate creation.
+*/
+
+static char *getCreateFolder_int(char **ptr, char *need_perms)
+{
+ char **fn;
+ char *n;
+ struct maildir_info minfo;
+ size_t i;
+ char *save;
+ maildir_aclt_list aclt_list;
+
+ fn=fn_fromwords(ptr);
+ if (!fn)
+ return NULL;
+
+
+ if (need_perms)
+ {
+ for (i=0; fn[i]; i++)
+ ;
+
+ if (i == 0)
+ {
+ *need_perms=0;
+ maildir_smapfn_free(fn);
+ errno=EINVAL;
+ return NULL;
+ }
+
+ save=fn[--i];
+ fn[i]=NULL;
+ if (maildir_info_smap_find(&minfo, fn,
+ getenv("AUTHENTICATED")) < 0)
+ {
+ fn[i]=save;
+ maildir_smapfn_free(fn);
+ return NULL;
+ }
+
+ fn[i]=save;
+
+ if (read_acls(&aclt_list, &minfo))
+ {
+ maildir_smapfn_free(fn);
+ maildir_info_destroy(&minfo);
+ return NULL;
+ }
+
+ save=compute_myrights(&aclt_list, minfo.owner);
+ maildir_aclt_list_destroy(&aclt_list);
+
+ for (i=0; need_perms[i]; i++)
+ if (save == NULL || strchr(save, need_perms[i])==NULL)
+ {
+ if (save)
+ free(save);
+ maildir_smapfn_free(fn);
+ maildir_info_destroy(&minfo);
+ *need_perms=0;
+ errno=EPERM;
+ return NULL;
+ }
+
+ if (save)
+ free(save);
+
+ maildir_info_destroy(&minfo);
+ }
+
+
+ if (maildir_info_smap_find(&minfo, fn, getenv("AUTHENTICATED")) < 0)
+ {
+ maildir_smapfn_free(fn);
+ return NULL;
+ }
+
+ maildir_smapfn_free(fn);
+
+ if (minfo.homedir == NULL || minfo.maildir == NULL)
+ {
+ maildir_info_destroy(&minfo);
+ errno=ENOENT;
+ return NULL;
+ }
+
+ n=maildir_name2dir(minfo.homedir, minfo.maildir);
+
+ if (need_perms && strchr(need_perms, ACL_CREATE[0]))
+ {
+ /* Initialize the ACL structures */
+
+ if (read_acls(&aclt_list, &minfo) == 0)
+ maildir_aclt_list_destroy(&aclt_list);
+ }
+
+ maildir_info_destroy(&minfo);
+
+ return n;
+}
+
+static char *getCreateFolder(char **ptr, char *perms)
+{
+ char *p=getCreateFolder_int(ptr, perms);
+
+ if (p && strncmp(p, "./", 2) == 0)
+ {
+ char *q=p+2;
+
+ while ((q[-2]=*q) != 0)
+ q++;
+ }
+ return p;
+}
+
+
+static int read_acls(maildir_aclt_list *aclt_list,
+ struct maildir_info *minfo)
+{
+ char *q;
+ int rc;
+
+ if (minfo->homedir == NULL || minfo->maildir == NULL)
+ {
+ if (minfo->mailbox_type == MAILBOXTYPE_NEWSHARED)
+ {
+ /* Intermediate node in public hier */
+
+ maildir_aclt_list_init(aclt_list);
+
+ if (maildir_aclt_list_add(aclt_list,
+ "anyone",
+ ACL_LOOKUP,
+ NULL) < 0)
+ {
+ maildir_aclt_list_destroy(aclt_list);
+ return -1;
+ }
+ return 0;
+ }
+
+ return -1;
+ }
+
+ q=maildir_name2dir(".", minfo->maildir);
+ if (!q)
+ {
+ fprintf(stderr, "ERR: Internal error"
+ " in read_acls(%s)\n", minfo->maildir);
+ return -1;
+ }
+
+ rc=maildir_acl_read(aclt_list, minfo->homedir,
+ q[0] == '.' &&
+ q[1] == '/' ? q+2:q);
+ free(q);
+
+ if (current_mailbox)
+ {
+ q=maildir_name2dir(minfo->homedir, minfo->maildir);
+
+ if (q)
+ {
+ if (strcmp(q, current_mailbox) == 0)
+ {
+ char *r=compute_myrights(aclt_list,
+ minfo->owner);
+
+ if (r && strcmp(current_mailbox_acl, r))
+ {
+ free(current_mailbox_acl);
+ current_mailbox_acl=r;
+ r=NULL;
+ }
+ if (r) free(r);
+ }
+ free(q);
+ }
+ }
+ return rc;
+}
+
+static char *getExistingFolder_int(char **ptr,
+ char *rightsWanted)
+{
+ char **fn;
+ char *n;
+ struct maildir_info minfo;
+
+ fn=fn_fromwords(ptr);
+ if (!fn)
+ return NULL;
+
+ if (maildir_info_smap_find(&minfo, fn, getenv("AUTHENTICATED")) < 0)
+ {
+ maildir_smapfn_free(fn);
+ return NULL;
+ }
+ maildir_smapfn_free(fn);
+
+ if (minfo.homedir == NULL || minfo.maildir == NULL)
+ {
+ maildir_info_destroy(&minfo);
+ errno=ENOENT;
+ return NULL;
+ }
+
+ n=maildir_name2dir(minfo.homedir, minfo.maildir);
+
+ if (n && rightsWanted)
+ {
+ maildir_aclt_list aclt_list;
+ char *q, *r, *s;
+
+ if (read_acls(&aclt_list, &minfo) < 0)
+ {
+ free(n);
+ maildir_info_destroy(&minfo);
+ return NULL;
+
+ }
+
+ q=compute_myrights(&aclt_list, minfo.owner);
+
+ maildir_aclt_list_destroy(&aclt_list);
+
+ if (q == NULL)
+ {
+ free(n);
+ maildir_info_destroy(&minfo);
+ return NULL;
+ }
+
+ for (r=s=rightsWanted; *r; r++)
+ if (strchr(q, *r))
+ *s++ = *r;
+ *s=0;
+ free(q);
+ }
+
+ maildir_info_destroy(&minfo);
+ return n;
+}
+
+static char *getAccessToFolder(char **ptr, char *rightsWanted)
+{
+ char *p=getExistingFolder_int(ptr, rightsWanted);
+
+ if (p && strncmp(p, "./", 2) == 0)
+ {
+ char *q=p+2;
+
+ while ((q[-2]=*q) != 0)
+ q++;
+ }
+
+ return p;
+}
+
+static void smap1_noop(int real_noop)
+{
+ if (current_mailbox)
+ doNoop(real_noop);
+ writes("+OK Folder updated\n");
+}
+
+/* Parse a message set. Return the next word following the message set */
+
+struct smapmsgset {
+ struct smapmsgset *next;
+ unsigned nranges;
+ unsigned long range[2][2];
+};
+
+static struct smapmsgset msgset;
+static const char digit[]="0123456789";
+
+static char *markmsgset(char **ptr, int *hasmsgset)
+{
+ unsigned long n;
+ char *w;
+
+ struct smapmsgset *msgsetp;
+
+ while ((msgsetp=msgset.next) != NULL)
+ {
+ msgset.next=msgsetp->next;
+ free(msgsetp);
+ }
+
+ msgsetp= &msgset;
+
+ msgsetp->nranges=0;
+
+ *hasmsgset=0;
+
+ n=0;
+
+ while (*(w=getword(ptr)))
+ {
+ unsigned long a=0, b=0;
+ const char *d;
+
+ if (!*w || (d=strchr(digit, *w)) == NULL)
+ break;
+
+ *hasmsgset=1;
+
+ while ( *w && (d=strchr(digit, *w)) != NULL)
+ {
+ a=a * 10 + d-digit;
+ w++;
+ }
+
+ b=a;
+
+ if (*w == '-')
+ {
+ ++w;
+ b=0;
+ while ( *w && (d=strchr(digit, *w)) != NULL)
+ {
+ b=b * 10 + d-digit;
+ w++;
+ }
+ }
+
+ if (a <= n || b < a)
+ {
+ errno=EINVAL;
+ return NULL;
+ }
+
+ n=b;
+
+ if (msgsetp->nranges >=
+ sizeof(msgsetp->range)/sizeof(msgsetp->range[0]))
+ {
+ if ((msgsetp->next=malloc(sizeof(struct smapmsgset)))
+ == NULL)
+ {
+ write_error_exit(0);
+ }
+
+ msgsetp=msgsetp->next;
+ msgsetp->next=NULL;
+ msgsetp->nranges=0;
+ }
+
+ msgsetp->range[msgsetp->nranges][0]=a;
+ msgsetp->range[msgsetp->nranges][1]=b;
+ ++msgsetp->nranges;
+ }
+
+ return w;
+}
+
+static void parseflags(char *q, struct imapflags *flags)
+{
+ char *p;
+
+ if ((q=strchr(q, '=')) == NULL)
+ return;
+ ++q;
+
+ while (*q)
+ {
+ p=q;
+
+ while (*q)
+ {
+ if (*q == ',')
+ {
+ *q++=0;
+ break;
+ }
+ q++;
+ }
+
+ if (strcmp(p, "SEEN") == 0)
+ flags->seen=1;
+ else if (strcmp(p, "REPLIED") == 0)
+ flags->answered=1;
+ else if (strcmp(p, "DRAFT") == 0)
+ flags->drafts=1;
+ else if (strcmp(p, "DELETED") == 0)
+ flags->deleted=1;
+ else if (strcmp(p, "MARKED") == 0)
+ flags->flagged=1;
+
+ }
+}
+
+extern int get_keyword(struct libmail_kwMessage **kwPtr, const char *kw);
+extern int valid_keyword(const char *kw);
+
+static void parsekeywords(char *q, struct libmail_kwMessage **msgp)
+{
+ char *p;
+
+ if ((q=strchr(q, '=')) == NULL)
+ return;
+ ++q;
+
+ while (*q)
+ {
+ p=q;
+
+ while (*q)
+ {
+ if (*q == ',')
+ {
+ *q++=0;
+ break;
+ }
+ q++;
+ }
+
+ get_keyword(msgp, p);
+ }
+}
+
+static int applymsgset( int (*callback_func)(unsigned long, void *),
+ void *callback_arg)
+{
+ struct smapmsgset *msgsetp= &msgset;
+ unsigned long n;
+ int rc;
+
+ while (msgsetp)
+ {
+ unsigned i;
+
+ for (i=0; i<msgsetp->nranges; i++)
+ {
+ for (n=msgsetp->range[i][0];
+ n <= msgsetp->range[i][1]; n++)
+ {
+ if (current_mailbox == NULL ||
+ n > current_maildir_info.nmessages)
+ break;
+ rc=(*callback_func)(n-1, callback_arg);
+ if (rc)
+ return rc;
+ }
+ }
+
+ msgsetp=msgsetp->next;
+ }
+ return 0;
+}
+
+static int do_attrfetch(unsigned long n, void *vp);
+
+static int applyflags(unsigned long n, void *vp)
+{
+ struct storeinfo *si=(struct storeinfo *)vp;
+ int attrs;
+ struct libmail_kwMessage *newKw;
+
+ if (n >= current_maildir_info.nmessages)
+ return 0;
+
+ attrs= si->keywords ? FETCH_KEYWORDS:FETCH_FLAGS;
+
+ if (!si->plusminus)
+ {
+ if (si->keywords == NULL) /* STORE FLAGS= */
+ si->keywords=current_maildir_info.msgs[n].keywordMsg;
+ else /* STORE KEYWORDS= */
+ get_message_flags(current_maildir_info.msgs+n, 0,
+ &si->flags);
+ }
+
+ /* do_store may clobber si->keywords. Punt */
+
+ newKw=si->keywords;
+ if (do_store(n+1, 0, si))
+ {
+ si->keywords=newKw;
+ return -1;
+ }
+ si->keywords=newKw;
+
+ do_attrfetch(n, &attrs);
+ return 0;
+}
+
+struct smapAddRemoveKeywordInfo {
+ struct storeinfo *si;
+ void *storeVoidArg;
+};
+
+static int addRemoveSmapKeywordsCallback(void *myVoidArg, void *storeVoidArg);
+
+static int addRemoveSmapKeywords(struct storeinfo *si)
+{
+ struct smapAddRemoveKeywordInfo ar;
+
+ ar.si=si;
+
+ return addRemoveKeywords(addRemoveSmapKeywordsCallback, &ar, si);
+}
+
+static int doAddRemoveSmapKeywords(unsigned long n, void *voidArg);
+
+static int addRemoveSmapKeywordsCallback(void *myVoidArg, void *storeVoidArg)
+{
+ struct smapAddRemoveKeywordInfo *info=
+ (struct smapAddRemoveKeywordInfo *)myVoidArg;
+
+ info->storeVoidArg=storeVoidArg;
+ return applymsgset(doAddRemoveSmapKeywords, info);
+}
+
+static int doAddRemoveSmapKeywords(unsigned long n, void *voidArg)
+{
+ struct smapAddRemoveKeywordInfo *info=
+ (struct smapAddRemoveKeywordInfo *)voidArg;
+
+ return doAddRemoveKeywords(n+1, 0, info->storeVoidArg);
+}
+
+static int setdate(unsigned long n, void *vp)
+{
+ time_t datestamp=*(time_t *)vp;
+ char *filename=maildir_filename(current_mailbox, 0,
+ current_maildir_info.msgs[n]
+ .filename);
+
+ if (filename)
+ {
+ set_time(filename, datestamp);
+ free(filename);
+ }
+ return 0;
+}
+
+static int msg_expunge(unsigned long n, void *vp)
+{
+ do_expunge(n, n+1, 1);
+ return 0;
+}
+
+struct smapfetchinfo {
+ int peek;
+ char *entity;
+ char *hdrs;
+ char *mimeid;
+};
+
+static int hashdr(const char *hdrList, const char *hdr)
+{
+ if (!hdrList || !*hdrList)
+ return 1;
+
+ while (*hdrList)
+ {
+ size_t n;
+ int is_envelope=0;
+ int is_mime=0;
+
+ if (*hdrList == ',')
+ {
+ ++hdrList;
+ continue;
+ }
+
+ if (strncmp(hdrList, ":ENVELOPE", 9) == 0)
+ {
+ switch (hdrList[9]) {
+ case 0:
+ case ',':
+ is_envelope=1;
+ break;
+ }
+ }
+
+ if (strncmp(hdrList, ":MIME", 5) == 0)
+ {
+ switch (hdrList[5]) {
+ case 0:
+ case ',':
+ is_mime=1;
+ break;
+ }
+ }
+
+
+ if (is_envelope || is_mime)
+ {
+ char hbuf[30];
+
+ hbuf[0]=0;
+ strncat(hbuf, hdr, 29);
+ up(hbuf);
+
+ if (strcmp(hbuf, "DATE") == 0)
+ return 1;
+ if (strcmp(hbuf, "SUBJECT") == 0)
+ return 1;
+ if (strcmp(hbuf, "FROM") == 0)
+ return 1;
+ if (strcmp(hbuf, "SENDER") == 0)
+ return 1;
+ if (strcmp(hbuf, "REPLY-TO") == 0)
+ return 1;
+ if (strcmp(hbuf, "TO") == 0)
+ return 1;
+ if (strcmp(hbuf, "CC") == 0)
+ return 1;
+ if (strcmp(hbuf, "BCC") == 0)
+ return 1;
+ if (strcmp(hbuf, "IN-REPLY-TO") == 0)
+ return 1;
+ if (strcmp(hbuf, "MESSAGE-ID") == 0)
+ return 1;
+ if (strcmp(hbuf, "REFERENCES") == 0)
+ return 1;
+
+ if (is_mime)
+ {
+ if (strcmp(hbuf, "MIME-VERSION") == 0)
+ return 1;
+
+ if (strncmp(hbuf, "CONTENT-", 8) == 0)
+ return 1;
+ }
+ }
+
+ for (n=0; hdrList[n] && hdrList[n] != ',' && hdr[n]; n++)
+ {
+ char a=hdrList[n];
+ char b=hdr[n];
+
+ UC(b);
+ if (a != b)
+ break;
+ }
+
+ if ((hdrList[n] == 0 || hdrList[n] == ',') && hdr[n] == 0)
+ return 1;
+
+ hdrList += n;
+ while (*hdrList && *hdrList != ',')
+ ++hdrList;
+ }
+ return 0;
+}
+
+static void writemimeid(struct rfc2045 *rfcp)
+{
+ if (rfcp->parent)
+ {
+ writemimeid(rfcp->parent);
+ writes(".");
+ }
+ writen(rfcp->pindex);
+}
+
+static int dump_hdrs(int fd, unsigned long n,
+ struct rfc2045 *rfcp, const char *hdrs,
+ const char *type)
+{
+ struct rfc2045src *src;
+ struct rfc2045headerinfo *h;
+ char *header;
+ char *value;
+ int rc;
+ off_t start_pos, end_pos, dummy, start_body;
+ off_t nbodylines;
+ int get_flags=RFC2045H_NOLC;
+
+ rc=0;
+
+ if (type && strcmp(type, "RAWHEADERS") == 0)
+ get_flags |= RFC2045H_KEEPNL;
+
+ if (!rfcp)
+ {
+ struct stat stat_buf;
+
+ if (fstat(fd, &stat_buf))
+ end_pos=8000; /* Heh */
+ else
+ end_pos=stat_buf.st_size;
+ start_pos=0;
+ start_body=0;
+ }
+ else rfc2045_mimepos(rfcp, &start_pos, &end_pos, &start_body, &dummy,
+ &nbodylines);
+
+ writes("{.");
+ writen(start_body - start_pos);
+ writes("} FETCH ");
+ writen(n+1);
+ if (type)
+ {
+ writes(" ");
+ writes(type);
+ writes("\n");
+ }
+ else /* MIME */
+ {
+ writes(" LINES=");
+ writen(nbodylines);
+ writes(" SIZE=");
+ writen(end_pos-start_body);
+ writes(" \"MIME.ID=");
+
+ if (rfcp->parent)
+ {
+ writemimeid(rfcp);
+ writes("\" \"MIME.PARENT=");
+ if (rfcp->parent->parent)
+ writemimeid(rfcp->parent);
+ }
+ writes("\"\n");
+ }
+
+ src=rfc2045src_init_fd(fd);
+ h=src ? rfc2045header_start(src, rfcp):NULL;
+
+ while (h &&
+ (rc=rfc2045header_get(h, &header, &value, get_flags)) == 0
+ && header)
+ {
+ if (hashdr(hdrs, header))
+ {
+ if (*header == '.')
+ writes(".");
+ writes(header);
+ writes(": ");
+ writes(value);
+ writes("\n");
+
+ header_count += strlen(header)+strlen(value)+3;
+ }
+ }
+ writes(".\n");
+
+ if (h)
+ rfc2045header_end(h);
+ else
+ rc= -1;
+ if (src)
+ rfc2045src_deinit(src);
+ return rc;
+}
+
+static int dump_body(FILE *fp, unsigned long msgNum,
+ struct rfc2045 *rfcp, int dump_all)
+{
+ char buffer[SMAP_BUFSIZ];
+ off_t start_pos, end_pos, dummy, start_body;
+ int i;
+ int first;
+
+ if (!rfcp)
+ {
+ struct stat stat_buf;
+
+ if (fstat(fileno(fp), &stat_buf) < 0)
+ return -1;
+
+ if (dump_all)
+ {
+ start_pos=start_body=0;
+ }
+ else
+ {
+ if (fseek(fp, 0L, SEEK_SET) < 0)
+ return -1;
+
+ if (!(rfcp=rfc2045_alloc()))
+ return -1;
+
+ do
+ {
+ i=fread(buffer, 1, sizeof(buffer), fp);
+
+ if (i < 0)
+ {
+ rfc2045_free(rfcp);
+ return -1;
+ }
+
+ if (i == 0)
+ break;
+ rfc2045_parse(rfcp, buffer, i);
+ } while (rfcp->workinheader);
+
+ rfc2045_mimepos(rfcp, &start_pos, &end_pos,
+ &start_body, &dummy,
+ &dummy);
+ rfc2045_free(rfcp);
+
+ start_pos=0;
+ }
+ end_pos=stat_buf.st_size;
+ }
+ else rfc2045_mimepos(rfcp, &start_pos, &end_pos, &start_body, &dummy,
+ &dummy);
+
+ if (dump_all)
+ start_body=start_pos;
+
+ if (fseek(fp, start_body, SEEK_SET) < 0)
+ return -1;
+
+ first=1;
+ do
+ {
+ int n=sizeof(buffer);
+
+ if (n > end_pos - start_body)
+ n=end_pos - start_body;
+
+ for (i=0; i<n; i++)
+ {
+ int ch=getc(fp);
+
+ if (ch == EOF)
+ {
+ errno=EIO;
+ return -1;
+ }
+ buffer[i]=ch;
+ }
+
+ if (first)
+ {
+ if (start_body == end_pos)
+ {
+ writes("{.0} FETCH ");
+ writen(msgNum+1);
+ writes(" CONTENTS\n.");
+ }
+ else
+ {
+ writes("{");
+ writen(i);
+ writes("/");
+ writen(end_pos - start_body);
+ writes("} FETCH ");
+ writen(msgNum+1);
+ writes(" CONTENTS\n");
+ }
+ }
+ else
+ {
+ writen(i);
+ writes("\n");
+ }
+
+ first=0;
+ writemem(buffer, i);
+
+ start_body += i;
+ body_count += i;
+ } while (start_body < end_pos);
+ writes("\n");
+ return 0;
+}
+
+struct decodeinfo {
+ char buffer[SMAP_BUFSIZ];
+ size_t bufptr;
+
+ int first;
+ unsigned long msgNum;
+ off_t estSize;
+};
+
+static void do_dump_decoded_flush(struct decodeinfo *);
+
+static struct rfc2045 *decodeCreateRfc(FILE *fp);
+static int do_dump_decoded(const char *, size_t, void *);
+
+static int dump_decoded(FILE *fp, unsigned long msgNum,
+ struct rfc2045 *rfcp)
+{
+ struct decodeinfo myDecodeInfo;
+ const char *content_type;
+ const char *content_transfer_encoding;
+ const char *charset;
+ off_t start_pos, end_pos, dummy, start_body;
+
+ struct rfc2045src *src;
+ struct rfc2045 *myrfcp=NULL;
+ int fd;
+ int i;
+
+ if (!rfcp)
+ {
+ rfcp=myrfcp=decodeCreateRfc(fp);
+ if (!rfcp)
+ return -1;
+ }
+
+ if ((fd=dup(fileno(fp))) < 0)
+ {
+ if (myrfcp)
+ rfc2045_free(myrfcp);
+ return -1;
+ }
+
+ myDecodeInfo.first=1;
+ myDecodeInfo.msgNum=msgNum;
+ myDecodeInfo.bufptr=0;
+
+ rfc2045_mimeinfo(rfcp, &content_type, &content_transfer_encoding,
+ &charset);
+ rfc2045_mimepos(rfcp, &start_pos, &end_pos, &start_body, &dummy,
+ &dummy);
+ myDecodeInfo.estSize=end_pos - start_body;
+
+ if (content_transfer_encoding
+ && strlen(content_transfer_encoding) == 6)
+ {
+ char buf[7];
+
+ strcpy(buf, content_transfer_encoding);
+ up(buf);
+
+ if (strcmp(buf, "BASE64") == 0)
+ myDecodeInfo.estSize = myDecodeInfo.estSize / 4 * 3;
+
+ /* Better estimate of base64 content */
+ }
+
+ src=rfc2045src_init_fd(fd);
+
+ i=src ? rfc2045_decodemimesection(src, rfcp, &do_dump_decoded,
+ &myDecodeInfo):-1;
+
+ do_dump_decoded_flush(&myDecodeInfo);
+
+ if (src)
+ rfc2045src_deinit(src);
+
+ close(fd);
+
+ if (i == 0 && myDecodeInfo.first) /* Empty body, punt */
+ {
+ writes("{.0} FETCH ");
+ writen(msgNum+1);
+ writes(" CONTENTS\n.");
+ }
+ writes("\n");
+ if (myrfcp)
+ rfc2045_free(myrfcp);
+ return i;
+}
+
+/* Dummy up a rfc2045 structure for retrieving the entire msg body */
+
+static struct rfc2045 *decodeCreateRfc(FILE *fp)
+{
+ char buffer[SMAP_BUFSIZ];
+ struct stat stat_buf;
+ int i;
+ struct rfc2045 *myrfcp;
+
+ if (fstat(fileno(fp), &stat_buf) < 0)
+ return NULL;
+
+ if (fseek(fp, 0L, SEEK_SET) < 0)
+ return NULL;
+
+ if (!(myrfcp=rfc2045_alloc()))
+ return NULL;
+
+ do
+ {
+ i=fread(buffer, 1, sizeof(buffer), fp);
+
+ if (i < 0)
+ {
+ rfc2045_free(myrfcp);
+ return NULL;
+ }
+
+ if (i == 0)
+ break;
+ rfc2045_parse(myrfcp, buffer, i);
+ } while (myrfcp->workinheader);
+
+ myrfcp->endpos=stat_buf.st_size;
+ return myrfcp;
+}
+
+static int do_dump_decoded(const char *chunk, size_t chunkSize,
+ void *vp)
+{
+ struct decodeinfo *myDecodeInfo=(struct decodeinfo *) vp;
+
+ while (chunkSize)
+ {
+ size_t n;
+
+ if (myDecodeInfo->bufptr >= sizeof(myDecodeInfo->buffer))
+ do_dump_decoded_flush(myDecodeInfo);
+
+ n=sizeof(myDecodeInfo->buffer)-myDecodeInfo->bufptr;
+
+ if (n > chunkSize)
+ n=chunkSize;
+ memcpy(myDecodeInfo->buffer + myDecodeInfo->bufptr, chunk, n);
+ myDecodeInfo->bufptr += n;
+ chunk += n;
+ chunkSize -= n;
+ }
+ return 0;
+}
+
+static void do_dump_decoded_flush(struct decodeinfo *myDecodeInfo)
+{
+ size_t chunkSize= myDecodeInfo->bufptr;
+
+ myDecodeInfo->bufptr=0;
+
+ if (chunkSize == 0)
+ return;
+
+ if (myDecodeInfo->first)
+ {
+ myDecodeInfo->first=0;
+ writes("{");
+ writen(chunkSize);
+ writes("/");
+ writen(myDecodeInfo->estSize);
+ writes("} FETCH ");
+ writen(myDecodeInfo->msgNum+1);
+ writes(" CONTENTS\n");
+ }
+ else
+ {
+ writen(chunkSize);
+ writes("\n");
+ }
+ writemem(myDecodeInfo->buffer, chunkSize);
+ body_count += chunkSize;
+}
+
+static int mime(int fd, unsigned long n,
+ struct rfc2045 *rfcp, const char *hdrs)
+{
+ int rc=dump_hdrs(fd, n, rfcp, hdrs, NULL);
+
+ if (rc)
+ return rc;
+
+ for (rfcp=rfcp->firstpart; rfcp; rfcp=rfcp->next)
+ if (!rfcp->isdummy)
+ {
+ rc=mime(fd, n, rfcp, hdrs);
+ if (rc)
+ return rc;
+ }
+
+ return 0;
+}
+
+/*
+** Find the specified MIME id.
+*/
+
+static struct rfc2045 *findmimeid(struct rfc2045 *rfcp,
+ const char *mimeid)
+{
+ unsigned long n;
+
+ while (mimeid && *mimeid)
+ {
+ const char *d;
+
+ n=0;
+
+ if (strchr(digit, *mimeid) == NULL)
+ return NULL;
+
+ while (*mimeid && (d=strchr(digit, *mimeid)) != NULL)
+ {
+ n=n * 10 + d-digit;
+ mimeid++;
+ }
+
+ while (rfcp)
+ {
+ if (!rfcp->isdummy && rfcp->pindex == n)
+ break;
+ rfcp=rfcp->next;
+ }
+
+ if (!rfcp)
+ return NULL;
+
+ if (*mimeid == '.')
+ {
+ ++mimeid;
+ rfcp=rfcp->firstpart;
+ }
+ }
+ return rfcp;
+}
+
+static int do_fetch(unsigned long n, void *vp)
+{
+ struct smapfetchinfo *fi=(struct smapfetchinfo *)vp;
+ FILE *fp=open_cached_fp(n);
+ int rc=0;
+
+ if (!fp)
+ return -1;
+
+ if (strcmp(fi->entity, "MIME") == 0)
+ {
+ struct rfc2045 *rfcp=fetch_alloc_rfc2045(n, fp);
+ int fd;
+
+ if (!rfcp)
+ return -1;
+
+ fd=dup(fileno(fp));
+ if (fd < 0)
+ return -1;
+
+ rc=mime(fd, n, rfcp, fi->hdrs);
+ close(fd);
+ }
+ else if (strcmp(fi->entity, "HEADERS") == 0 ||
+ strcmp(fi->entity, "RAWHEADERS") == 0)
+ {
+ int fd;
+ struct rfc2045 *rfcp;
+
+ fd=dup(fileno(fp));
+ if (fd < 0)
+ return -1;
+
+ if (!fi->mimeid || !*fi->mimeid)
+ rfcp=NULL;
+ else
+ {
+ rfcp=fetch_alloc_rfc2045(n, fp);
+
+ rfcp=findmimeid(rfcp, fi->mimeid);
+
+ if (!rfcp)
+ {
+ close(fd);
+ errno=EINVAL;
+ return -1;
+ }
+ }
+
+ rc=dump_hdrs(fd, n, rfcp, fi->hdrs, fi->entity);
+ close(fd);
+ }
+ else if (strcmp(fi->entity, "BODY") == 0
+ || strcmp(fi->entity, "ALL") == 0)
+ {
+ struct rfc2045 *rfcp;
+
+ if (!fi->mimeid || !*fi->mimeid)
+ rfcp=NULL;
+ else
+ {
+ rfcp=fetch_alloc_rfc2045(n, fp);
+
+ rfcp=findmimeid(rfcp, fi->mimeid);
+
+ if (!rfcp)
+ {
+ errno=EINVAL;
+ return -1;
+ }
+ }
+
+ rc=dump_body(fp, n, rfcp, fi->entity[0] == 'A');
+ }
+ else if (strcmp(fi->entity, "BODY.DECODED") == 0)
+ {
+ struct rfc2045 *rfcp;
+
+ if (!fi->mimeid || !*fi->mimeid)
+ rfcp=NULL;
+ else
+ {
+ rfcp=fetch_alloc_rfc2045(n, fp);
+
+ rfcp=findmimeid(rfcp, fi->mimeid);
+
+ if (!rfcp)
+ {
+ errno=EINVAL;
+ return -1;
+ }
+ }
+
+ rc=dump_decoded(fp, n, rfcp);
+ }
+ else
+ {
+ rc=0;
+ }
+
+ if (rc == 0 && !fi->peek)
+ {
+ struct imapflags flags;
+
+ get_message_flags(current_maildir_info.msgs+n,
+ 0, &flags);
+ if (!flags.seen)
+ {
+ flags.seen=1;
+ reflag_filename(&current_maildir_info.msgs[n],
+ &flags, fileno(fp));
+ current_maildir_info.msgs[n].changedflags=1;
+ }
+ }
+
+ if (current_maildir_info.msgs[n].changedflags)
+ fetchflags(n);
+
+ return rc;
+}
+
+void smap_fetchflags(unsigned long n)
+{
+ int items=FETCH_FLAGS | FETCH_KEYWORDS;
+
+ do_attrfetch(n, &items);
+}
+
+static int do_attrfetch(unsigned long n, void *vp)
+{
+ int items=*(int *)vp;
+
+ if (n >= current_maildir_info.nmessages)
+ return 0;
+
+ writes("* FETCH ");
+ writen(n+1);
+
+ if (items & FETCH_FLAGS)
+ {
+ char buf[256];
+
+ get_message_flags(current_maildir_info.msgs+n, buf, 0);
+
+ writes(" FLAGS=");
+ writes(buf);
+
+ current_maildir_info.msgs[n].changedflags=0;
+ }
+
+ if ((items & FETCH_KEYWORDS) && keywords())
+ {
+ struct libmail_kwMessageEntry *kme;
+
+ writes(" \"KEYWORDS=");
+
+ if (current_maildir_info.msgs[n].keywordMsg &&
+ current_maildir_info.msgs[n].keywordMsg->firstEntry)
+ {
+ const char *p="";
+
+ for (kme=current_maildir_info.msgs[n]
+ .keywordMsg->firstEntry;
+ kme; kme=kme->next)
+ {
+ writes(p);
+ p=",";
+ writes(keywordName(kme->libmail_keywordEntryPtr));
+ }
+ }
+ writes("\"");
+ }
+
+ if (items & FETCH_UID)
+ {
+ char *p, *q;
+
+ writes(" \"UID=");
+
+ p=current_maildir_info.msgs[n].filename;
+
+ q=strrchr(p, MDIRSEP[0]);
+ if (q)
+ *q=0;
+ smapword_s(p);
+ if (q)
+ *q=MDIRSEP[0];
+ writes("\"");
+ }
+
+ if (items & FETCH_SIZE)
+ {
+ char *p=current_maildir_info.msgs[n].filename;
+ unsigned long cnt;
+
+ if (maildir_parsequota(p, &cnt))
+ {
+ FILE *fp=open_cached_fp(n);
+ struct stat stat_buf;
+
+ if (fp && fstat(fileno(fp), &stat_buf) == 0)
+ cnt=stat_buf.st_size;
+ else
+ cnt=0;
+ }
+
+ writes(" SIZE=");
+ writen(cnt);
+ }
+
+ if (items & FETCH_INTERNALDATE)
+ {
+ struct stat stat_buf;
+ FILE *fp=open_cached_fp(n);
+
+ if (fp && fstat(fileno(fp), &stat_buf) == 0)
+ {
+ char buf[256];
+
+ rfc822_mkdate_buf(stat_buf.st_mtime, buf);
+ writes(" \"INTERNALDATE=");
+ smapword_s(buf);
+ writes("\"");
+ }
+ }
+ writes("\n");
+ return 0;
+}
+
+struct add_rcptlist {
+ struct add_rcptlist *next;
+ char *rcptto;
+};
+
+static unsigned long add_msg(FILE *fp, const char *format,
+ char *buffer,
+ size_t bufsize)
+{
+ unsigned long n=0;
+
+ writes("> Go ahead\n");
+ writeflush();
+
+ if (*format == '.')
+ {
+ int last_eol=1;
+ int dot_stuffed=0;
+ int counter=-1;
+
+ for (;;)
+ {
+ char c;
+
+ if ( ((counter=counter + 1 ) % 8192) == 0)
+ read_timeout(60);
+
+ c=READ();
+
+ if (c == '\r')
+ continue;
+
+ if (dot_stuffed && c == '\n')
+ break;
+ dot_stuffed=0;
+
+ if (c == '.')
+ {
+ if (last_eol)
+ {
+ dot_stuffed=1;
+ continue;
+ }
+ }
+ last_eol= c == '\n';
+ putc( (int)(unsigned char)c, fp);
+ n++;
+ }
+
+ if (!last_eol)
+ {
+ putc('\n', fp);
+ n++;
+ }
+ }
+ else
+ {
+ unsigned long chunkSize;
+ char last_char='\n';
+
+ while (sscanf(format, "%lu", &chunkSize) == 1)
+ {
+ while (chunkSize)
+ {
+ size_t nn=bufsize;
+ size_t i;
+
+ if (nn > chunkSize)
+ nn=(size_t)chunkSize;
+
+ read_timeout(60);
+ nn=doread(buffer, nn);
+
+ chunkSize -= nn;
+ n += nn;
+
+ for (i=0; i<nn; i++)
+ {
+ last_char=buffer[i];
+
+ if (last_char == '\r')
+ continue;
+ putc((int)(unsigned char)last_char,
+ fp);
+ }
+ }
+
+ read_timeout(60);
+ smap_readline(buffer, bufsize);
+ format=buffer;
+ }
+
+ if (last_char != '\n')
+ {
+ putc('\n', fp);
+ n++;
+ }
+ }
+
+ if (n == 0)
+ {
+ ++n;
+ putc('\n', fp);
+ }
+
+ if (fflush(fp) < 0 || ferror(fp))
+ return 0;
+ return n;
+}
+
+static void adduid(char *n)
+{
+ char *q;
+
+ q=strrchr(n, '/');
+ if (q)
+ n=q+1;
+
+ q=strrchr(n, MDIRSEP[0]);
+ if (q)
+ *q=0;
+ writes("* ADD \"UID=");
+ smapword_s(n);
+ writes("\"\n");
+ if (q)
+ *q=MDIRSEP[0];
+}
+
+static void senderr(char *errmsg)
+{
+ writes("-ERR ");
+ writes(errmsg);
+ writes("\n");
+}
+
+static int calc_quota(unsigned long n, void *voidptr)
+{
+ return do_copy_quota_calc(n+1, 0, voidptr);
+}
+
+/* Copy msg to another folder */
+
+static void copieduid(unsigned long n, char *newname)
+{
+ char *p, *q;
+
+ writes("* COPY ");
+ writen(n);
+ writes(" \"NEWUID=");
+
+ p=strrchr(newname, '/')+1;
+
+ if ((q=strrchr(p, MDIRSEP[0])) != NULL)
+ *q=0;
+
+ smapword_s(p);
+ writes("\"\n");
+}
+
+static int do_copyKeywords(struct libmail_kwMessage *msg,
+ const char *destmailbox,
+ const char *newname)
+{
+ char *tmpkname, *newkname;
+
+ if (!msg || !msg->firstEntry)
+ return 0;
+
+ if (maildir_kwSave(destmailbox, newname,
+ msg, &tmpkname, &newkname, 0))
+ {
+ perror("maildir_kwSave");
+ return -1;
+ }
+
+ rename(tmpkname, newkname);
+ free(tmpkname);
+ free(newkname);
+ return 0;
+}
+
+static void fixnewfilename(char *p)
+{
+ char *q;
+
+ /* Nice hack: */
+
+ q=strrchr(strrchr(p, '/'), MDIRSEP[0]);
+
+ if (strcmp(q, MDIRSEP "2,") == 0)
+ {
+ *q=0;
+ memcpy(strrchr(p, '/')-3, "new", 3);
+ }
+}
+
+static int do_copymsg(unsigned long n, void *voidptr)
+{
+ char buf[SMAP_BUFSIZ];
+ struct copyquotainfo *cqinfo=(struct copyquotainfo *)voidptr;
+ struct imapflags new_flags;
+ int fd;
+ struct stat stat_buf;
+ FILE *fp;
+ char *tmpname, *newname;
+
+ fd=imapscan_openfile(current_mailbox, &current_maildir_info, n);
+ if (fd < 0) return (0);
+
+ if (fstat(fd, &stat_buf) < 0)
+ {
+ close(fd);
+ return (0);
+ }
+
+ get_message_flags(current_maildir_info.msgs+n, 0, &new_flags);
+
+ fp=maildir_mkfilename(cqinfo->destmailbox,
+ &new_flags, stat_buf.st_size,
+ &tmpname, &newname);
+
+ fixnewfilename(newname);
+
+ if (!fp)
+ {
+ close(fd);
+ return (-1);
+ }
+
+ while (stat_buf.st_size)
+ {
+ int n=sizeof(buf);
+
+ if (n > stat_buf.st_size)
+ n=stat_buf.st_size;
+
+ n=read(fd, buf, n);
+
+ if (n <= 0 || fwrite(buf, 1, n, fp) != n)
+ {
+ close(fd);
+ fclose(fp);
+ unlink(tmpname);
+ free(tmpname);
+ free(newname);
+ fprintf(stderr,
+ "ERR: error copying a message, user=%s, errno=%d\n",
+ getenv("AUTHENTICATED"), errno);
+
+ return (-1);
+ }
+ stat_buf.st_size -= n;
+ }
+ close(fd);
+
+ if (fflush(fp) || ferror(fp))
+ {
+ fclose(fp);
+ unlink(tmpname);
+ free(tmpname);
+ free(newname);
+ fprintf(stderr,
+ "ERR: error copying a message, user=%s, errno=%d\n",
+ getenv("AUTHENTICATED"), errno);
+ return (-1);
+ }
+ fclose(fp);
+
+ if (do_copyKeywords(current_maildir_info.msgs[n].keywordMsg,
+ cqinfo->destmailbox,
+ strrchr(newname, '/')+1))
+ {
+ unlink(tmpname);
+ free(tmpname);
+ free(newname);
+ fprintf(stderr,
+ "ERR: error copying keywords, "
+ "user=%s, errno=%d\n",
+ getenv("AUTHENTICATED"), errno);
+ return (-1);
+ }
+
+ current_maildir_info.msgs[n].copiedflag=1;
+
+ maildir_movetmpnew(tmpname, newname);
+ set_time(newname, stat_buf.st_mtime);
+ free(tmpname);
+
+ copieduid(n+1, newname);
+ free(newname);
+ return 0;
+}
+
+static int do_movemsg(unsigned long n, void *voidptr)
+{
+ char *filename;
+ struct copyquotainfo *cqinfo=(struct copyquotainfo *)voidptr;
+ char *newfilename;
+
+ if (n >= current_maildir_info.nmessages)
+ return 0;
+
+ filename=maildir_filename(current_mailbox, 0,
+ current_maildir_info.msgs[n].filename);
+
+ if (!filename)
+ return 0;
+
+ newfilename=malloc(strlen(cqinfo->destmailbox) + sizeof("/cur")
+ + strlen(strrchr(filename, '/')));
+
+ if (!newfilename)
+ {
+ free(filename);
+ write_error_exit(0);
+ }
+
+ strcat(strcat(strcpy(newfilename, cqinfo->destmailbox),
+ "/cur"), strrchr(filename, '/'));
+
+ if (do_copyKeywords(current_maildir_info.msgs[n].keywordMsg,
+ cqinfo->destmailbox,
+ strrchr(newfilename, '/')+1))
+ {
+ fprintf(stderr,
+ "ERR: error copying keywords, "
+ "user=%s, errno=%d\n",
+ getenv("AUTHENTICATED"), errno);
+
+ free(filename);
+ free(newfilename);
+ return -1;
+ }
+
+
+ if (maildir_movetmpnew(filename, newfilename) == 0)
+ {
+ copieduid(n+1, newfilename);
+ free(filename);
+ free(newfilename);
+ return 0;
+ }
+
+ if (do_copymsg(n, voidptr))
+ return -1;
+
+ unlink(filename);
+ free(filename);
+ free(newfilename);
+ return 0;
+}
+
+static struct searchinfo *createSearch2(char *w,
+ struct searchinfo **head, char **ptr);
+
+static struct searchinfo *createSearch(struct searchinfo **head, char **ptr)
+{
+ char *w=getword(ptr);
+ struct searchinfo *siAnd, *n;
+
+ up(w);
+
+ if (strcmp(w, "MARKED") == 0)
+ {
+ w=getword(ptr);
+ up(w);
+
+ n=createSearch2(w, head, ptr);
+
+ if (!n)
+ return NULL;
+
+ siAnd=alloc_search(head);
+ siAnd->type=search_and;
+
+ siAnd->b=n;
+
+ siAnd->a=n=alloc_search(head);
+
+ n->type=search_msgflag;
+ if (!(n->as=strdup("\\FLAGGED")))
+ write_error_exit(0);
+
+ return siAnd;
+ }
+
+ if (strcmp(w, "UNMARKED") == 0)
+ {
+ w=getword(ptr);
+ up(w);
+
+ n=createSearch2(w, head, ptr);
+
+ if (!n)
+ return NULL;
+
+ siAnd=alloc_search(head);
+ siAnd->type=search_and;
+
+ siAnd->b=n;
+
+ siAnd->a=n=alloc_search(head);
+
+ n->type=search_not;
+
+ n=n->a=alloc_search(head);
+
+ n->type=search_msgflag;
+ if (!(n->as=strdup("\\FLAGGED")))
+ write_error_exit(0);
+
+ return siAnd;
+ }
+
+ if (strcmp(w, "ALL") == 0)
+ {
+ w=getword(ptr);
+ up(w);
+ return createSearch2(w, head, ptr);
+ }
+
+ {
+ char *ww=getword(ptr);
+ up(ww);
+ n=createSearch2(ww, head, ptr);
+
+ if (!n)
+ return NULL;
+
+ siAnd=alloc_search(head);
+ siAnd->type=search_and;
+
+ siAnd->b=n;
+
+ siAnd->a=n=alloc_search(head);
+
+ n->type=search_messageset;
+ if (!(n->as=strdup(w)))
+ write_error_exit(0);
+
+ for (ww=n->as; *ww; ww++)
+ if (*ww == '-')
+ *ww=':';
+
+ if (!ismsgset_str(n->as))
+ {
+ errno=EINVAL;
+ return NULL;
+ }
+ }
+ return siAnd;
+}
+
+static struct searchinfo *createSearch2(char *w,
+ struct searchinfo **head, char **ptr)
+{
+ int notflag=0;
+ struct searchinfo *n;
+
+ if (strcmp(w, "NOT") == 0)
+ {
+ notflag=1;
+ w=getword(ptr);
+ up(w);
+ }
+
+ if (strcmp(w, "REPLIED") == 0)
+ {
+ n=alloc_search(head);
+ n->type=search_msgflag;
+ if (!(n->as=strdup("\\ANSWERED")))
+ write_error_exit(0);
+ }
+ else if (strcmp(w, "DELETED") == 0)
+ {
+ n=alloc_search(head);
+ n->type=search_msgflag;
+ if (!(n->as=strdup("\\DELETED")))
+ write_error_exit(0);
+ }
+ else if (strcmp(w, "DRAFT") == 0)
+ {
+ n=alloc_search(head);
+ n->type=search_msgflag;
+ if (!(n->as=strdup("\\DRAFT")))
+ write_error_exit(0);
+ }
+ else if (strcmp(w, "SEEN") == 0)
+ {
+ n=alloc_search(head);
+ n->type=search_msgflag;
+ if (!(n->as=strdup("\\SEEN")))
+ write_error_exit(0);
+ }
+ else if (strcmp(w, "KEYWORD") == 0)
+ {
+ n=alloc_search(head);
+ n->type=search_msgkeyword;
+ if (!(n->as=strdup(getword(ptr))))
+ write_error_exit(0);
+ }
+ else if (strcmp(w, "FROM") == 0 ||
+ strcmp(w, "TO") == 0 ||
+ strcmp(w, "CC") == 0 ||
+ strcmp(w, "BCC") == 0 ||
+ strcmp(w, "SUBJECT") == 0)
+ {
+ n=alloc_search(head);
+ n->type=search_header;
+ if (!(n->cs=strdup(w)))
+ write_error_exit(0);
+ n->as=strdup(getword(ptr));
+ if (!n->as)
+ write_error_exit(0);
+ }
+ else if (strcmp(w, "HEADER") == 0)
+ {
+ n=alloc_search(head);
+ n->type=search_header;
+ if (!(n->cs=strdup(getword(ptr))))
+ write_error_exit(0);
+ up(n->cs);
+ n->as=strdup(getword(ptr));
+ if (!n->as)
+ write_error_exit(0);
+ }
+ else if (strcmp(w, "BODY") == 0)
+ {
+ n=alloc_search(head);
+ n->type=search_body;
+ n->as=strdup(getword(ptr));
+ if (!n->as)
+ write_error_exit(0);
+ }
+ else if (strcmp(w, "TEXT") == 0)
+ {
+ n=alloc_search(head);
+ n->type=search_text;
+ n->as=strdup(getword(ptr));
+ if (!n->as)
+ write_error_exit(0);
+ }
+ else if (strcmp(w, "BEFORE") == 0)
+ {
+ n=alloc_search(head);
+ n->type=search_before;
+ n->as=strdup(getword(ptr));
+ if (!n->as)
+ write_error_exit(0);
+ }
+ else if (strcmp(w, "ON") == 0)
+ {
+ n=alloc_search(head);
+ n->type=search_on;
+ n->as=strdup(getword(ptr));
+ if (!n->as)
+ write_error_exit(0);
+ }
+ else if (strcmp(w, "SINCE") == 0)
+ {
+ n=alloc_search(head);
+ n->type=search_since;
+ n->as=strdup(getword(ptr));
+ if (!n->as)
+ write_error_exit(0);
+ }
+ else if (strcmp(w, "SENTBEFORE") == 0)
+ {
+ n=alloc_search(head);
+ n->type=search_sentbefore;
+ n->as=strdup(getword(ptr));
+ if (!n->as)
+ write_error_exit(0);
+ }
+ else if (strcmp(w, "SENTON") == 0)
+ {
+ n=alloc_search(head);
+ n->type=search_senton;
+ n->as=strdup(getword(ptr));
+ if (!n->as)
+ write_error_exit(0);
+ }
+ else if (strcmp(w, "SINCE") == 0)
+ {
+ n=alloc_search(head);
+ n->type=search_sentsince;
+ n->as=strdup(getword(ptr));
+ if (!n->as)
+ write_error_exit(0);
+ }
+ else if (strcmp(w, "SMALLER") == 0)
+ {
+ n=alloc_search(head);
+ n->type=search_smaller;
+ n->as=strdup(getword(ptr));
+ if (!n->as)
+ write_error_exit(0);
+ }
+ else if (strcmp(w, "LARGER") == 0)
+ {
+ n=alloc_search(head);
+ n->type=search_larger;
+ n->as=strdup(getword(ptr));
+ if (!n->as)
+ write_error_exit(0);
+ }
+ else
+ {
+ errno=EINVAL;
+ return NULL;
+ }
+
+ if (notflag)
+ {
+ struct searchinfo *p=alloc_search(head);
+
+ p->type=search_not;
+ p->a=n;
+ n=p;
+ }
+ return n;
+}
+
+static int do_copyto(char *toFolder,
+ int (*do_func)(unsigned long, void *),
+ const char *acls)
+{
+ int has_quota=0;
+ struct copyquotainfo cqinfo;
+ struct maildirsize quotainfo;
+
+ cqinfo.destmailbox=toFolder;
+ cqinfo.nbytes=0;
+ cqinfo.nfiles=0;
+ cqinfo.acls=acls;
+
+ if (maildirquota_countfolder(toFolder))
+ {
+ if (maildir_openquotafile(&quotainfo, ".") == 0)
+ {
+ if (quotainfo.fd >= 0)
+ has_quota=1;
+ maildir_closequotafile(&quotainfo);
+ }
+
+ if (has_quota > 0 && applymsgset( &calc_quota, &cqinfo ))
+ has_quota= -1;
+ }
+
+ if (has_quota > 0 && cqinfo.nfiles > 0)
+ {
+ if (maildir_quota_add_start(".", &quotainfo,
+ cqinfo.nbytes,
+ cqinfo.nfiles,
+ getenv("MAILDIRQUOTA")))
+ {
+ errno=ENOSPC;
+ return (-1);
+ }
+
+ maildir_quota_add_end(&quotainfo,
+ cqinfo.nbytes,
+ cqinfo.nfiles);
+ }
+
+ return applymsgset(do_func, &cqinfo);
+}
+
+static int copyto(char *toFolder, int do_move, const char *acls)
+{
+ if (!do_move)
+ return do_copyto(toFolder, &do_copymsg, acls);
+
+ if (!current_mailbox_shared &&
+ maildirquota_countfolder(current_mailbox) ==
+ maildirquota_countfolder(toFolder))
+ {
+ if (do_copyto(toFolder, do_movemsg, acls))
+ return -1;
+
+ doNoop(0);
+ return(0);
+ }
+
+ if (do_copyto(toFolder, &do_copymsg, acls))
+ return -1;
+
+ applymsgset(&msg_expunge, NULL);
+ doNoop(0);
+ return 0;
+}
+
+struct smap1_search_results {
+
+ unsigned prev_runs;
+
+ unsigned long prev_search_hit;
+ unsigned long prev_search_hit_start;
+};
+
+static void smap1_search_cb_range(struct smap1_search_results *searchResults)
+{
+ if (searchResults->prev_runs > 100)
+ {
+ writes("\n");
+ searchResults->prev_runs=0;
+ }
+
+ if (searchResults->prev_runs == 0)
+ writes("* SEARCH");
+
+ writes(" ");
+ writen(searchResults->prev_search_hit_start);
+ if (searchResults->prev_search_hit_start !=
+ searchResults->prev_search_hit)
+ {
+ writes("-");
+ writen(searchResults->prev_search_hit);
+ }
+ ++searchResults->prev_runs;
+}
+
+static void smap1_search_cb(struct searchinfo *si,
+ struct searchinfo *sihead,
+ int isuid, unsigned long i, void *dummy)
+{
+ struct smap1_search_results *searchResults=
+ (struct smap1_search_results *)dummy;
+
+ ++i;
+
+ if (searchResults->prev_search_hit == 0)
+ {
+ searchResults->prev_search_hit=
+ searchResults->prev_search_hit_start=i;
+ return;
+ }
+
+ if (i != searchResults->prev_search_hit+1)
+ {
+ smap1_search_cb_range(searchResults);
+ searchResults->prev_search_hit_start=i;
+ }
+
+ searchResults->prev_search_hit=i;
+}
+
+static void accessdenied(const char *acl_required)
+{
+ writes("-ERR Access denied: ACL \"");
+ writes(acl_required);
+ writes("\" is required\n");
+}
+
+static int getacl(const char *ident,
+ const maildir_aclt *acl,
+ void *cb_arg)
+{
+ int *n=(int *)cb_arg;
+
+ if (*n > 5)
+ {
+ writes("\n");
+ *n=0;
+ }
+
+ if (*n == 0)
+ writes("* GETACL");
+
+ writes(" ");
+ smapword(ident);
+ writes(" ");
+ smapword(maildir_aclt_ascstr(acl));
+ ++*n;
+ return 0;
+}
+
+struct setacl_info {
+ struct maildir_info minfo;
+ char **ptr;
+};
+
+static int dosetdeleteacl(void *cb_arg, int);
+
+static int setacl(void *cb_arg)
+{
+ return dosetdeleteacl(cb_arg, 0);
+}
+
+static int deleteacl(void *cb_arg)
+{
+ return dosetdeleteacl(cb_arg, 1);
+}
+
+static int dosetdeleteacl(void *cb_arg, int dodelete)
+{
+ struct setacl_info *sainfo=(struct setacl_info *)cb_arg;
+ char *q;
+ int cnt;
+ const char *identifier;
+ const char *action;
+ const char *err_failedrights;
+ char *path;
+
+ maildir_aclt_list aclt_list;
+
+ if (read_acls(&aclt_list, &sainfo->minfo) < 0)
+ {
+ writes("-ERR Unable to read existing ACLS: ");
+ writes(strerror(errno));
+ writes("\n");
+ return 0;
+ }
+
+ q=compute_myrights(&aclt_list,
+ sainfo->minfo.owner);
+
+ if (!q || !strchr(q, ACL_ADMINISTER[0]))
+ {
+ if (q) free(q);
+ maildir_aclt_list_destroy(&aclt_list);
+ accessdenied(ACL_ADMINISTER);
+ return 0;
+ }
+
+ free(q);
+
+ while (*(identifier=getword(sainfo->ptr)))
+ {
+ if (dodelete)
+ {
+ if (maildir_aclt_list_del(&aclt_list,
+ identifier) < 0)
+ {
+ maildir_aclt_list_destroy(&aclt_list);
+ writes("-ERR Error: ");
+ writes(strerror(errno));
+ writes("\n");
+ return 0;
+ }
+ continue;
+ }
+
+ action=getword(sainfo->ptr);
+
+ if (*action == '+')
+ {
+ maildir_aclt newacl;
+ const maildir_aclt *oldacl;
+
+ if (maildir_aclt_init(&newacl,
+ action+1,
+ NULL) < 0)
+ {
+ maildir_aclt_list_destroy(&aclt_list);
+ writes("-ERR Error: ");
+ writes(strerror(errno));
+ writes("\n");
+ return 0;
+ }
+
+
+ oldacl=maildir_aclt_list_find(&aclt_list,
+ identifier
+ );
+ if (oldacl)
+ {
+ if (maildir_aclt_add(&newacl,
+ NULL,
+ oldacl)
+ < 0)
+ {
+ maildir_aclt_destroy(&newacl);
+ maildir_aclt_list_destroy(&aclt_list);
+ writes("-ERR Error: ");
+ writes(strerror(errno));
+ writes("\n");
+ return 0;
+ }
+ }
+
+ if (maildir_aclt_list_add(&aclt_list,
+ identifier,
+ NULL,
+ &newacl) < 0)
+ {
+ maildir_aclt_destroy(&newacl);
+ maildir_aclt_list_destroy(&aclt_list);
+ writes("-ERR Error: ");
+ writes(strerror(errno));
+ writes("\n");
+ return 0;
+
+ }
+ maildir_aclt_destroy(&newacl);
+ continue;
+ }
+
+ if (*action == '-')
+ {
+ maildir_aclt newacl;
+ const maildir_aclt *oldacl;
+
+ oldacl=maildir_aclt_list_find(&aclt_list,
+ identifier
+ );
+
+ if (!oldacl)
+ continue;
+
+ if (maildir_aclt_init(&newacl,
+ NULL,
+ oldacl) < 0)
+ {
+ maildir_aclt_list_destroy(&aclt_list);
+ writes("-ERR Error: ");
+ writes(strerror(errno));
+ writes("\n");
+ return 0;
+ }
+
+
+ if (maildir_aclt_del(&newacl,
+ action+1, NULL)
+ < 0)
+ {
+ maildir_aclt_destroy(&newacl);
+ maildir_aclt_list_destroy(&aclt_list);
+ writes("-ERR Error: ");
+ writes(strerror(errno));
+ writes("\n");
+ return 0;
+ }
+
+ if (strlen(maildir_aclt_ascstr(&newacl))
+ == 0 ?
+ maildir_aclt_list_del(&aclt_list,
+ identifier)
+ :maildir_aclt_list_add(&aclt_list,
+ identifier,
+ NULL,
+ &newacl) < 0)
+ {
+ maildir_aclt_destroy(&newacl);
+ maildir_aclt_list_destroy(&aclt_list);
+ writes("-ERR Error: ");
+ writes(strerror(errno));
+ writes("\n");
+ return 0;
+
+ }
+ maildir_aclt_destroy(&newacl);
+ continue;
+ }
+
+ if (strlen(action) == 0 ?
+ maildir_aclt_list_del(&aclt_list,
+ identifier):
+ maildir_aclt_list_add(&aclt_list,
+ identifier,
+ action, NULL) < 0)
+ {
+ maildir_aclt_list_destroy(&aclt_list);
+ writes("-ERR Error: ");
+ writes(strerror(errno));
+ writes("\n");
+ return 0;
+ }
+ }
+
+ path=maildir_name2dir(".", sainfo->minfo.maildir);
+
+ err_failedrights=NULL;
+ if (!path ||
+ maildir_acl_write(&aclt_list, sainfo->minfo.homedir,
+ path[0] == '.' && path[1] == '/'
+ ? path+2:path,
+ sainfo->minfo.owner,
+ &err_failedrights))
+ {
+ if (path)
+ free(path);
+
+ if (err_failedrights)
+ {
+ writes("* ACLMINIMUM ");
+ writes(err_failedrights);
+ writes(" ");
+ aclminimum(err_failedrights);
+ writes("\n");
+ }
+ writes("-ERR ACL update failed\n");
+ maildir_aclt_list_destroy(&aclt_list);
+ return 0;
+ }
+
+ cnt=0;
+ maildir_aclt_list_enum(&aclt_list,
+ getacl, &cnt);
+ if (cnt)
+ writes("\n");
+ maildir_aclt_list_destroy(&aclt_list);
+
+ /* Reread ACLs if the current mailbox's ACLs have changed */
+
+ if (read_acls(&aclt_list, &sainfo->minfo) < 0)
+ {
+ writes("-ERR Unable to re-read ACLS: ");
+ writes(strerror(errno));
+ writes("\n");
+ return 0;
+ }
+
+ maildir_aclt_list_destroy(&aclt_list);
+ writes("+OK Updated ACLs\n");
+ return 0;
+}
+
+static int checkacl(char **folder, struct maildir_info *minfo,
+ const char *acls)
+{
+ char *q;
+
+ maildir_aclt_list aclt_list;
+
+ if (maildir_info_smap_find(minfo, folder, getenv("AUTHENTICATED")) < 0)
+ return -1;
+
+ if (read_acls(&aclt_list, minfo) < 0)
+ {
+ maildir_info_destroy(minfo);
+ return -1;
+ }
+
+ q=compute_myrights(&aclt_list, minfo->owner);
+ maildir_aclt_list_destroy(&aclt_list);
+
+ while (*acls)
+ {
+ if (q == NULL || strchr(q, *acls) == NULL)
+ {
+ if (q) free(q);
+ maildir_info_destroy(minfo);
+ return -1;
+ }
+ ++acls;
+ }
+ if (q)
+ free(q);
+ return 0;
+}
+
+void smap()
+{
+ char buffer[8192];
+ char *ptr;
+ struct imapflags add_flags;
+ int in_add=0;
+ char *add_from=NULL;
+ char *add_folder=NULL;
+ time_t add_internaldate=0;
+ char *add_notify=NULL;
+ unsigned add_rcpt_count=0;
+ struct libmail_kwMessage *addKeywords=NULL;
+
+ struct add_rcptlist *add_rcpt_list=NULL;
+
+ char rights_buf[40];
+
+ imapscan_init(&current_maildir_info);
+ memset(&add_flags, 0, sizeof(add_flags));
+
+#define GETFOLDER(acl) ( strcpy(rights_buf, (acl)), \
+ getAccessToFolder(&ptr, rights_buf))
+
+ for (;;)
+ {
+ char *p;
+
+ writeflush();
+ read_timeout(30 * 60);
+ smap_readline(buffer, sizeof(buffer));
+
+ ptr=buffer;
+
+ p=getword(&ptr);
+ up(p);
+
+ if (strcmp(p, "ADD") == 0)
+ {
+ char **argvec;
+ const char *okmsg="So far, so good...";
+ int err_sent=0;
+
+ in_add=1;
+ while (*(p=getword(&ptr)))
+ {
+ char *q=strchr(p, '=');
+
+ if (q)
+ *q++=0;
+ up(p);
+
+ if (strcmp(p, "FOLDER") == 0)
+ {
+ if (add_folder)
+ free(add_folder);
+
+ add_folder=
+ GETFOLDER(ACL_INSERT
+ ACL_DELETEMSGS
+ ACL_SEEN
+ ACL_WRITE);
+ if (!add_folder)
+ {
+ writes("-ERR Invalid folder: ");
+ writes(strerror(errno));
+ writes("\n");
+ break;
+ }
+
+ if (strchr(rights_buf,
+ ACL_INSERT[0])
+ == NULL)
+ {
+ accessdenied(ACL_INSERT);
+ free(add_folder);
+ add_folder=NULL;
+ break;
+ }
+
+ okmsg="Will add to this folder";
+ }
+
+ if (strcmp(p, "MAILFROM") == 0 && q)
+ {
+ if (add_from)
+ free(add_from);
+ if ((add_from=strdup(q)) == NULL)
+ {
+ writes("-ERR ");
+ writes(strerror(errno));
+ writes("\n");
+ break;
+ }
+ okmsg="MAIL FROM set";
+ }
+
+ if (strcmp(p, "NOTIFY") == 0 && q)
+ {
+ if (add_notify)
+ free(add_notify);
+ if ((add_notify=strdup(q)) == NULL)
+ {
+ writes("-ERR ");
+ writes(strerror(errno));
+ writes("\n");
+ break;
+ }
+ okmsg="NOTIFY set";
+ }
+
+ if (strcmp(p, "RCPTTO") == 0 && q)
+ {
+ struct add_rcptlist *rcpt=
+ malloc(sizeof(struct
+ add_rcptlist));
+
+ if (rcpt == NULL ||
+ (rcpt->rcptto=strdup(q)) == NULL)
+ {
+ if (rcpt)
+ free(rcpt);
+ writes("-ERR ");
+ writes(strerror(errno));
+ writes("\n");
+ break;
+ }
+ rcpt->next=add_rcpt_list;
+ add_rcpt_list=rcpt;
+ ++add_rcpt_count;
+ okmsg="RCPT TO set";
+ }
+
+ if (strcmp(p, "FLAGS") == 0 && q)
+ {
+ memset(&add_flags, 0,
+ sizeof(add_flags));
+ *--q='=';
+ parseflags(q, &add_flags);
+
+ if (strchr(rights_buf,
+ ACL_SEEN[0])
+ == NULL)
+ add_flags.seen=0;
+ if (strchr(rights_buf,
+ ACL_DELETEMSGS[0])
+ == NULL)
+ add_flags.deleted=0;
+ if (strchr(rights_buf,
+ ACL_WRITE[0])
+ == NULL)
+ add_flags.answered=
+ add_flags.flagged=
+ add_flags.drafts=0;
+
+ okmsg="FLAGS set";
+ }
+
+ if (strcmp(p, "KEYWORDS") == 0 && q &&
+ keywords() && strchr(rights_buf,
+ ACL_WRITE[0]))
+ {
+ if (addKeywords)
+ libmail_kwmDestroy(addKeywords);
+
+ addKeywords=libmail_kwmCreate();
+
+ if (addKeywords == NULL)
+ {
+ write_error_exit(0);
+ }
+
+ *--q='=';
+ parsekeywords(q, &addKeywords);
+ okmsg="KEYWORDS set";
+ }
+
+ if (strcmp(p, "INTERNALDATE") == 0 && q)
+ {
+ add_internaldate=rfc822_parsedt(q);
+
+ if (add_internaldate)
+ okmsg="INTERNALDATE set";
+ }
+
+ if (p[0] == '{')
+ {
+ char *tmpname, *newname;
+ char *s;
+ char *tmpKeywords=NULL;
+ char *newKeywords=NULL;
+ FILE *fp;
+ unsigned long n;
+
+ fp=maildir_mkfilename(add_folder
+ ?add_folder
+ :".",
+ &add_flags,
+ 0,
+ &tmpname,
+ &newname);
+
+ if (!fp)
+ {
+ writes("-ERR ");
+ writes(strerror(errno));
+ writes("\n");
+ break;
+ }
+
+ fixnewfilename(newname);
+
+ current_temp_fd=fileno(fp);
+ current_temp_fn=tmpname;
+
+ n=add_msg(fp, p+1, buffer,
+ sizeof(buffer));
+
+ if (n)
+ {
+ s=maildir_requota(newname, n);
+
+ if (!s)
+ n=0;
+ else
+ {
+ free(newname);
+ newname=s;
+ }
+ }
+
+ current_temp_fd= -1;
+ current_temp_fn= NULL;
+
+ if (n > 0 && add_folder &&
+ maildirquota_countfolder(add_folder)
+ && maildirquota_countfile(newname))
+ {
+ struct maildirsize quotainfo;
+
+ if (maildir_quota_add_start(add_folder, &quotainfo, n, 1,
+ getenv("MAILDIRQUOTA")))
+ {
+ errno=ENOSPC;
+ n=0;
+ }
+ else
+ maildir_quota_add_end(&quotainfo, n, 1);
+ }
+
+ fclose(fp);
+
+ chmod(tmpname, 0600);
+
+ if (add_folder && n && addKeywords)
+ {
+ if (maildir_kwSave(add_folder,
+ strrchr(newname, '/')+1,
+ addKeywords,
+ &tmpKeywords,
+ &newKeywords,
+ 0))
+ {
+ tmpKeywords=NULL;
+ newKeywords=NULL;
+ n=0;
+ perror("maildir_kwSave");
+ }
+ }
+
+ argvec=NULL;
+
+ if (add_rcpt_count > 0 && n)
+ {
+ argvec=malloc(sizeof(char *)
+ * (add_rcpt_count
+ +10));
+
+ if (!argvec)
+ n=0;
+ }
+
+ if (argvec)
+ {
+ int i=1;
+ struct add_rcptlist *l;
+
+ argvec[i++]="-oi";
+
+ argvec[i++]="-f";
+ argvec[i++]=add_from
+ ? add_from:
+ (char *)
+ defaultSendFrom();
+
+ if (add_notify)
+ {
+ argvec[i++]="-N";
+ argvec[i++]=add_notify;
+ }
+
+ for (l=add_rcpt_list; l;
+ l=l->next)
+ {
+ argvec[i++]=l->rcptto;
+ }
+ argvec[i]=0;
+
+ i=imapd_sendmsg(tmpname, argvec,
+ &senderr);
+ free(argvec);
+ if (i)
+ {
+ n=0;
+ err_sent=1;
+ }
+ }
+
+ if (tmpKeywords)
+ {
+ rename(tmpKeywords,
+ newKeywords);
+ free(tmpKeywords);
+ free(newKeywords);
+ }
+
+ if (add_folder && n)
+ {
+ if (maildir_movetmpnew(tmpname,
+ newname)
+ )
+ n=0;
+ else
+ {
+ if (add_internaldate)
+ set_time(newname,
+ add_internaldate);
+ adduid(newname);
+ }
+ }
+
+ if (n == 0)
+ {
+ unlink(tmpname);
+ free(tmpname);
+ free(newname);
+ if (!err_sent)
+ {
+ writes("-ERR ");
+ writes(strerror(errno));
+ writes("\n");
+ }
+ break;
+ }
+
+ unlink(tmpname);
+
+ free(tmpname);
+ free(newname);
+ okmsg="Message saved";
+ p=NULL;
+ break;
+ }
+ }
+
+ if (p && *p)
+ continue; /* Error inside the loop */
+
+ writes("+OK ");
+ writes(okmsg);
+ writes("\n");
+
+ if (p)
+ continue;
+ }
+
+ if (in_add)
+ {
+ struct add_rcptlist *l;
+
+ while ((l=add_rcpt_list) != NULL)
+ {
+ add_rcpt_list=l->next;
+ free(l->rcptto);
+ free(l);
+ }
+ memset(&add_flags, 0, sizeof(add_flags));
+ if (add_from)
+ free(add_from);
+ if (add_folder)
+ free(add_folder);
+ if (add_notify)
+ free(add_notify);
+
+ if (addKeywords)
+ libmail_kwmDestroy(addKeywords);
+
+ in_add=0;
+ add_from=NULL;
+ add_folder=NULL;
+ add_internaldate=0;
+ add_notify=NULL;
+ addKeywords=NULL;
+ add_rcpt_count=0;
+ if (!p)
+ continue; /* Just added a message */
+ }
+
+ if (strcmp(p, "LOGOUT") == 0)
+ break;
+
+ if (strcmp(p, "RSET") == 0)
+ {
+ writes("+OK Reset\n");
+ continue;
+ }
+
+ if (strcmp(p, "GETACL") == 0 ||
+ strcmp(p, "ACL") == 0)
+ {
+ char **fn=fn_fromwords(&ptr);
+ struct maildir_info minfo;
+ maildir_aclt_list aclt_list;
+ char *q;
+ int cnt;
+
+ if (!fn)
+ {
+ writes("-ERR Invalid folder: ");
+ writes(strerror(errno));
+ writes("\n");
+ continue;
+ }
+
+ if (maildir_info_smap_find(&minfo, fn,
+ getenv("AUTHENTICATED"))
+ < 0)
+ {
+ maildir_smapfn_free(fn);
+ writes("-ERR Invalid folder: ");
+ writes(strerror(errno));
+ writes("\n");
+ continue;
+ }
+
+ if (read_acls(&aclt_list, &minfo) < 0)
+ {
+ maildir_info_destroy(&minfo);
+ maildir_smapfn_free(fn);
+ writes("-ERR Unable to read"
+ " existing ACLS: ");
+ writes(strerror(errno));
+ writes("\n");
+ continue;
+ }
+
+ q=compute_myrights(&aclt_list,
+ minfo.owner);
+
+ if (!q ||
+ strcmp(p, "ACL") ?
+ !strchr(q, ACL_ADMINISTER[0])
+ :
+ !maildir_acl_canlistrights(q)
+ )
+ {
+ if (q) free(q);
+ maildir_aclt_list_destroy(&aclt_list);
+ maildir_info_destroy(&minfo);
+ maildir_smapfn_free(fn);
+ accessdenied(ACL_ADMINISTER);
+ continue;
+ }
+ if (strcmp(p, "ACL") == 0)
+ {
+ writes("* ACL ");
+ smapword(q);
+ writes("\n");
+ free(q);
+ }
+ else
+ {
+ free(q);
+ cnt=0;
+ maildir_aclt_list_enum(&aclt_list,
+ getacl, &cnt);
+ if (cnt)
+ writes("\n");
+ }
+ maildir_aclt_list_destroy(&aclt_list);
+ maildir_info_destroy(&minfo);
+ maildir_smapfn_free(fn);
+ writes("+OK ACLs retrieved\n");
+ continue;
+ }
+
+ if (strcmp(p, "SETACL") == 0 ||
+ strcmp(p, "DELETEACL") == 0)
+ {
+ char **fn=fn_fromwords(&ptr);
+ struct setacl_info sainfo;
+
+ if (!fn)
+ {
+ writes("-ERR Invalid folder: ");
+ writes(strerror(errno));
+ writes("\n");
+ continue;
+ }
+
+ if (maildir_info_smap_find(&sainfo.minfo,
+ fn, getenv("AUTHENTICATED"))
+ < 0)
+ {
+ maildir_smapfn_free(fn);
+ writes("-ERR Invalid folder: ");
+ writes(strerror(errno));
+ writes("\n");
+ continue;
+ }
+
+
+ sainfo.ptr= &ptr;
+
+ acl_lock(sainfo.minfo.homedir,
+ *p == 'S' ? setacl:deleteacl,
+ &sainfo);
+
+ maildir_smapfn_free(fn);
+ maildir_info_destroy(&sainfo.minfo);
+ continue;
+ }
+
+ if (strcmp(p, "LIST") == 0)
+ {
+ struct list_hier *hier=NULL;
+
+ listcmd(&hier, &hier, &ptr);
+ continue;
+ }
+
+ if (strcmp(p, "STATUS") == 0)
+ {
+ char *t;
+ struct imapscaninfo other_info, *loaded_infoptr,
+ *infoptr;
+ unsigned long n, i;
+
+ getword(&ptr);
+
+ t=GETFOLDER(ACL_LOOKUP);
+
+ if (!t)
+ {
+ writes("-ERR Cannot read folder status: ");
+ writes(strerror(errno));
+ writes("\n");
+ continue;
+ }
+
+ if (strchr(rights_buf, ACL_LOOKUP[0]) == NULL)
+ {
+ accessdenied(ACL_LOOKUP);
+ continue;
+ }
+
+ if (current_mailbox &&
+ strcmp(current_mailbox, t) == 0)
+ {
+ loaded_infoptr=0;
+ infoptr= &current_maildir_info;
+ }
+ else
+ {
+ loaded_infoptr= &other_info;
+ infoptr=loaded_infoptr;
+
+ imapscan_init(loaded_infoptr);
+
+ if (imapscan_maildir(infoptr, t, 1, 1, NULL))
+ {
+ writes("-ERR Cannot read"
+ " folder status: ");
+ writes(strerror(errno));
+ writes("\n");
+ continue;
+ }
+ }
+
+ writes("* STATUS EXISTS=");
+ writen(infoptr->nmessages+infoptr->left_unseen);
+
+ n=infoptr->left_unseen, i;
+
+ for (i=0; i<infoptr->nmessages; i++)
+ {
+ const char *p=infoptr->msgs[i].filename;
+
+ p=strrchr(p, MDIRSEP[0]);
+ if (p && strncmp(p, MDIRSEP "2,", 3) == 0 &&
+ strchr(p, 'S')) continue;
+ ++n;
+ }
+ writes(" UNSEEN=");
+ writen(n);
+ writes("\n+OK Folder status retrieved\n");
+ if (loaded_infoptr)
+ imapscan_free(loaded_infoptr);
+ continue;
+ }
+
+ if (strcmp(p, "CREATE") == 0)
+ {
+ char *t;
+
+ strcpy(rights_buf, ACL_CREATE);
+ t=getCreateFolder(&ptr, rights_buf);
+
+ if (t)
+ {
+ if (mdcreate(t))
+ {
+ writes("-ERR Cannot create folder: ");
+ writes(strerror(errno));
+ writes("\n");
+ }
+ else
+ {
+ writes("+OK Folder created\n");
+ }
+ free(t);
+ }
+ else
+ {
+ if (rights_buf[0] == 0)
+ accessdenied(ACL_CREATE);
+ else
+ {
+ writes("-ERR Cannot create folder: ");
+ writes(strerror(errno));
+ writes("\n");
+ }
+ }
+ continue;
+ }
+
+ if (strcmp(p, "MKDIR") == 0)
+ {
+ char *t;
+
+ strcpy(rights_buf, ACL_CREATE);
+ t=getCreateFolder(&ptr, rights_buf);
+
+ if (t)
+ {
+ writes("+OK Folder created\n");
+ free(t);
+ }
+ else if (rights_buf[0] == 0)
+ accessdenied(ACL_CREATE);
+ else
+ {
+ writes("-ERR Cannot create folder: ");
+ writes(strerror(errno));
+ writes("\n");
+ }
+ continue;
+ }
+
+ if (strcmp(p, "RMDIR") == 0)
+ {
+ char *t;
+
+ strcpy(rights_buf, ACL_DELETEFOLDER);
+ t=getCreateFolder(&ptr, rights_buf);
+
+ if (t)
+ {
+ writes("+OK Folder deleted\n");
+ free(t);
+ }
+ else if (rights_buf[0] == 0)
+ accessdenied(ACL_DELETEFOLDER);
+ else
+ {
+ writes("-ERR Cannot create folder: ");
+ writes(strerror(errno));
+ writes("\n");
+ }
+ continue;
+ }
+
+ if (strcmp(p, "DELETE") == 0)
+ {
+ char **fn;
+ char *t=NULL;
+
+ fn=fn_fromwords(&ptr);
+
+ if (fn)
+ {
+ struct maildir_info minfo;
+
+ if (maildir_info_smap_find(&minfo, fn,
+ getenv("AUTHENTICATED")) == 0)
+ {
+ if (minfo.homedir && minfo.maildir)
+ {
+ maildir_aclt_list list;
+ char *q;
+
+ if (strcmp(minfo.maildir,
+ INBOX) == 0)
+ {
+ writes("-ERR INBOX may"
+ " not be deleted\n");
+ maildir_info_destroy(&minfo);
+ continue;
+ }
+
+ if (read_acls(&list, &minfo)
+ < 0)
+ {
+ maildir_info_destroy(&minfo);
+ accessdenied(ACL_DELETEFOLDER);
+ continue;
+ }
+
+ q=compute_myrights(&list,
+ minfo.owner
+ );
+
+ if (!q ||
+ strchr(q,
+ ACL_DELETEFOLDER[0])
+ == NULL)
+ {
+ if (q)
+ free(q);
+ maildir_info_destroy(&minfo);
+ accessdenied(ACL_DELETEFOLDER);
+ continue;
+ }
+ free(q);
+ maildir_aclt_list_destroy(&list);
+ t=maildir_name2dir(minfo.homedir,
+ minfo.maildir);
+ }
+ maildir_info_destroy(&minfo);
+ }
+ }
+
+ if (t && current_mailbox &&
+ strcmp(t, current_mailbox) == 0)
+ {
+ writes("-ERR Cannot DELETE currently open folder.\n");
+ free(t);
+ continue;
+ }
+
+
+ if (t)
+ {
+ if (mddelete(t) == 0)
+ {
+ maildir_quota_recalculate(".");
+ writes("+OK Folder deleted");
+ }
+ else
+ {
+ writes("-ERR Cannot delete folder: ");
+ writes(strerror(errno));
+ }
+ writes("\n");
+ free(t);
+
+ }
+ else
+ {
+ if (t)
+ {
+ free(t);
+ errno=EINVAL;
+ }
+
+ writes("-ERR Unable to delete folder: ");
+ writes(strerror(errno));
+ writes("\n");
+ }
+ continue;
+ }
+
+ if (strcmp(p, "RENAME") == 0)
+ {
+ struct maildir_info msrc, mdst;
+ char **fnsrc, **fndst;
+ size_t i;
+ char *save;
+ const char *errmsg;
+
+ if ((fnsrc=fn_fromwords(&ptr)) == NULL)
+ {
+ writes("-ERR ");
+ writes(strerror(errno));
+ writes("\n");
+ continue;
+ }
+
+ if ((fndst=fn_fromwords(&ptr)) == NULL)
+ {
+ maildir_smapfn_free(fnsrc);
+ writes("-ERR ");
+ writes(strerror(errno));
+ writes("\n");
+ continue;
+ }
+
+ for (i=0; fndst[i]; i++)
+ ;
+
+ if (i == 0)
+ {
+ maildir_smapfn_free(fnsrc);
+ maildir_smapfn_free(fndst);
+ writes("-ERR Invalid destination folder name\n");
+ continue;
+ }
+
+ if (checkacl(fnsrc, &msrc, ACL_DELETEFOLDER))
+ {
+ maildir_smapfn_free(fnsrc);
+ maildir_smapfn_free(fndst);
+ accessdenied(ACL_DELETEFOLDER);
+ continue;
+ }
+ save=fndst[--i];
+ fndst[i]=NULL;
+
+ if (checkacl(fndst, &mdst, ACL_CREATE))
+ {
+ fndst[i]=save;
+ maildir_smapfn_free(fnsrc);
+ maildir_smapfn_free(fndst);
+ maildir_info_destroy(&msrc);
+ accessdenied(ACL_CREATE);
+ continue;
+ }
+
+ fndst[i]=save;
+
+ maildir_info_destroy(&mdst);
+
+ if (maildir_info_smap_find(&mdst, fndst,
+ getenv("AUTHENTICATED")) < 0)
+ {
+ maildir_smapfn_free(fnsrc);
+ maildir_smapfn_free(fndst);
+ maildir_info_destroy(&msrc);
+ writes("-ERR Internal error in RENAME: ");
+ writes(strerror(errno));
+ writes("\n");
+ continue;
+ }
+
+ if (folder_rename(&msrc, &mdst, &errmsg))
+ {
+ writes("-ERR ");
+ writes(*errmsg == '@' ? errmsg+1:errmsg);
+ if (*errmsg == '@')
+ writes(strerror(errno));
+ writes("\n");
+ }
+ else
+ {
+ writes("+OK Folder renamed.\n");
+ }
+ maildir_info_destroy(&msrc);
+ maildir_info_destroy(&mdst);
+ continue;
+ }
+
+ if (strcmp(p, "OPEN") == 0 ||
+ strcmp(p, "SOPEN") == 0)
+ {
+ char **fn;
+ char *q;
+ const char *snapshot=0;
+ struct maildir_info minfo;
+ maildir_aclt_list aclt_list;
+
+ if (current_mailbox)
+ {
+ free(current_mailbox);
+ imapscan_free(&current_maildir_info);
+ imapscan_init(&current_maildir_info);
+ current_mailbox=0;
+ }
+ if (current_mailbox_acl)
+ free(current_mailbox_acl);
+ current_mailbox_acl=NULL;
+ current_mailbox_shared=0;
+
+ fetch_free_cache();
+
+ if (p[0] == 'S')
+ snapshot=getword(&ptr);
+
+ fn=fn_fromwords(&ptr);
+
+ if (!fn)
+ {
+ writes("-ERR Invalid folder: ");
+ writes(strerror(errno));
+ writes("\n");
+ continue;
+ }
+
+ if (maildir_info_smap_find(&minfo, fn,
+ getenv("AUTHENTICATED"))
+ < 0)
+ {
+ maildir_smapfn_free(fn);
+ writes("-ERR Invalid folder: ");
+ writes(strerror(errno));
+ writes("\n");
+ continue;
+ }
+
+ if (read_acls(&aclt_list, &minfo) < 0)
+ {
+ maildir_info_destroy(&minfo);
+ maildir_smapfn_free(fn);
+ writes("-ERR Unable to read"
+ " existing ACLS: ");
+ writes(strerror(errno));
+ writes("\n");
+ continue;
+ }
+
+ q=compute_myrights(&aclt_list, minfo.owner);
+ maildir_aclt_list_destroy(&aclt_list);
+ maildir_smapfn_free(fn);
+
+ if (!q || strchr(q, ACL_READ[0]) == NULL)
+ {
+ if (q) free(q);
+ maildir_info_destroy(&minfo);
+ accessdenied(ACL_READ);
+ maildir_info_destroy(&minfo);
+ continue;
+ }
+ current_mailbox_acl=q;
+ current_mailbox=maildir_name2dir(minfo.homedir,
+ minfo.maildir);
+
+ if (current_mailbox == NULL)
+ {
+ fprintf(stderr, "ERR: Internal error"
+ " in maildir_name2dir(%s,%s)\n",
+ minfo.homedir,
+ minfo.maildir);
+ maildir_info_destroy(&minfo);
+ continue;
+ }
+ maildir_info_destroy(&minfo);
+
+ snapshot_select(snapshot != NULL);
+
+ if (snapshot_init(current_mailbox, snapshot))
+ {
+ writes("* SNAPSHOTEXISTS ");
+ smapword(snapshot);
+ writes("\n");
+ smap1_noop(0);
+ continue;
+ }
+
+ if (imapscan_maildir(&current_maildir_info,
+ current_mailbox, 0, 0, NULL) == 0)
+ {
+ snapshot_init(current_mailbox, NULL);
+ writes("* EXISTS ");
+ writen(current_maildir_info.nmessages);
+ writes("\n+OK Folder opened\n");
+ continue;
+ }
+
+ writes("-ERR Cannot open the folder: ");
+ writes(strerror(errno));
+ writes("\n");
+
+ free(current_mailbox);
+ current_mailbox=NULL;
+ continue;
+ }
+
+ if (strcmp(p, "CLOSE") == 0)
+ {
+ if (current_mailbox)
+ {
+ free(current_mailbox);
+ imapscan_free(&current_maildir_info);
+ imapscan_init(&current_maildir_info);
+ current_mailbox=0;
+ }
+ writes("+OK Folder closed\n");
+ continue;
+ }
+
+ if (strcmp(p, "NOOP") == 0)
+ {
+ smap1_noop(1);
+ continue;
+ }
+
+ if (strcmp(p, "IDLE") == 0)
+ {
+ if ((p=getenv("IMAP_ENHANCEDIDLE")) == NULL
+ || !atoi(p)
+ || imapenhancedidle())
+ imapidle();
+
+ read_timeout(60);
+ smap_readline(buffer, sizeof(buffer));
+ ptr=buffer;
+ p=getword(&ptr);
+ up(p);
+ if (strcmp(p, "RESUME"))
+ {
+ writes("-ERR RESUME is required to follow IDLE\n");
+ }
+ else
+ writes("+OK Resumed...\n");
+ continue;
+ }
+
+ if (!current_mailbox)
+ p=""; /* FALLTHROUGH */
+
+ if (strcmp(p, "EXPUNGE") == 0)
+ {
+ int hasSet;
+
+ p=markmsgset(&ptr, &hasSet);
+
+ if (p)
+ {
+ if (strchr(current_mailbox_acl,
+ ACL_EXPUNGE[0]) == NULL)
+ {
+ accessdenied(ACL_EXPUNGE);
+ continue;
+ }
+
+ if (hasSet)
+ {
+ if (strchr(current_mailbox_acl,
+ ACL_DELETEMSGS[0]) == NULL)
+ {
+ accessdenied(ACL_DELETEMSGS);
+ continue;
+ }
+
+ applymsgset( &msg_expunge, NULL);
+ }
+ else
+ expunge();
+ smap1_noop(0);
+ continue;
+ }
+ }
+
+ if (strcmp(p, "STORE") == 0)
+ {
+ struct storeinfo si;
+ int dummy;
+
+ p=markmsgset(&ptr, &dummy);
+
+ dummy=0;
+
+ if (!p)
+ dummy=1;
+
+ while (p && *p)
+ {
+ char *q=strchr(p, '=');
+
+ if (q)
+ *q=0;
+ up(p);
+ /* Uppercase only the keyword, for now */
+ if (q)
+ *q='=';
+
+ if (strncmp(p, "FLAGS=", 6) == 0)
+ {
+ memset(&si, 0, sizeof(si));
+ up(p);
+ parseflags(p, &si.flags);
+ if ((dummy=applymsgset(&applyflags,
+ &si)) != 0)
+ break;
+ }
+ else if (strncmp(p, "+FLAGS=", 7) == 0 ||
+ strncmp(p, "-FLAGS=", 7) == 0)
+ {
+ memset(&si, 0, sizeof(si));
+ up(p);
+ si.plusminus=p[0];
+ parseflags(p, &si.flags);
+ if ((dummy=applymsgset(&applyflags,
+ &si)) != 0)
+ break;
+ }
+ else if (strncmp(p, "KEYWORDS=", 9) == 0 &&
+ keywords())
+ {
+ struct libmail_kwMessage *kwm;
+
+ memset(&si, 0, sizeof(si));
+ kwm=si.keywords=libmail_kwmCreate();
+
+ if (!kwm)
+ write_error_exit(0);
+
+ parsekeywords(p, &si.keywords);
+ dummy=applymsgset(&applyflags,
+ &si);
+
+ libmail_kwmDestroy(kwm);
+
+ if (dummy != 0)
+ break;
+ }
+ else if ((strncmp(p, "+KEYWORDS=", 10) == 0 ||
+ strncmp(p, "-KEYWORDS=", 10) == 0) &&
+ keywords())
+ {
+ memset(&si, 0, sizeof(si));
+ si.keywords=libmail_kwmCreate();
+
+ if (!si.keywords)
+ write_error_exit(0);
+ si.plusminus=p[0];
+ parsekeywords(p, &si.keywords);
+ dummy=applymsgset(&applyflags,
+ &si);
+
+ if (dummy == 0)
+ dummy=addRemoveSmapKeywords(&si);
+ libmail_kwmDestroy(si.keywords);
+
+ if (dummy != 0)
+ break;
+ }
+ else if (strncmp(p, "INTERNALDATE=", 13) == 0)
+ {
+ time_t t;
+
+ up(p);
+
+ t=rfc822_parsedt(p+13);
+
+ if (t &&
+ (dummy=applymsgset(&setdate, &t))
+ != 0)
+ break;
+ }
+
+ p=getword(&ptr);
+ }
+ if (dummy)
+ {
+ writes("-ERR Cannot update folder status: ");
+ writes(strerror(errno));
+ writes("\n");
+ }
+ else
+ writes("+OK Folder status updated\n");
+ continue;
+ }
+
+ if (strcmp(p, "FETCH") == 0)
+ {
+ int dummy;
+ struct smapfetchinfo fi;
+ int fetch_items=0;
+
+ for (p=markmsgset(&ptr, &dummy);
+ p && *p; p=getword(&ptr))
+ {
+ if ((fi.entity=strchr(p, '=')) == NULL)
+ {
+ up(p);
+
+ if (strcmp(p, "UID") == 0)
+ fetch_items |= FETCH_UID;
+ if (strcmp(p, "SIZE") == 0)
+ fetch_items |= FETCH_SIZE;
+ if (strcmp(p, "FLAGS") == 0)
+ fetch_items |= FETCH_FLAGS;
+ if (strcmp(p, "KEYWORDS") == 0)
+ fetch_items |= FETCH_KEYWORDS;
+ if (strcmp(p, "INTERNALDATE") == 0)
+ fetch_items
+ |= FETCH_INTERNALDATE;
+ continue;
+ }
+
+ *fi.entity++=0;
+
+ fi.hdrs=strrchr(fi.entity, '(');
+ if (fi.hdrs)
+ {
+ char *q;
+
+ *fi.hdrs++=0;
+
+ q=strrchr(fi.hdrs, ')');
+ if (q)
+ *q=0;
+ up(fi.hdrs);
+ }
+
+ fi.mimeid=strrchr(fi.entity, '[');
+ if (fi.mimeid)
+ {
+ char *q;
+
+ *fi.mimeid++=0;
+ q=strrchr(fi.mimeid, ']');
+ if (q)
+ *q=0;
+ }
+
+ up(p);
+
+ if (strcmp(p, "CONTENTS") == 0 ||
+ strcmp(p, "CONTENTS.PEEK") == 0)
+ {
+ fi.peek=strchr(p, '.') != NULL;
+ if (applymsgset(&do_fetch, &fi) == 0)
+ {
+ continue;
+ }
+ }
+ else
+ {
+ continue;
+ }
+
+ writes("-ERR Cannot retrieve message: ");
+ writes(strerror(errno));
+ writes("\n");
+ break;
+ }
+
+ if (!p || !*p)
+ {
+ if (fetch_items &&
+ applymsgset(&do_attrfetch, &fetch_items))
+ {
+ writes("-ERR Cannot retrieve message: ");
+ writes(strerror(errno));
+ writes("\n");
+ }
+ else
+ writes("+OK Message retrieved.\n");
+ }
+ continue;
+ }
+
+ if (strcmp(p, "COPY") == 0
+ || strcmp(p, "MOVE") == 0)
+ {
+ int dummy;
+ int domove= *p == 'M';
+
+ p=markmsgset(&ptr, &dummy);
+
+ if (dummy && *p == 0)
+ {
+ p=GETFOLDER(ACL_INSERT
+ ACL_DELETEMSGS
+ ACL_SEEN
+ ACL_WRITE);
+
+ if (p)
+ {
+ if (strchr(rights_buf, ACL_INSERT[0])
+ == NULL)
+ {
+ free(p);
+ accessdenied(ACL_INSERT);
+ continue;
+ }
+
+ if (copyto(p, domove, rights_buf) == 0)
+ {
+ free(p);
+ writes("+OK Messages copied.\n"
+ );
+ continue;
+ }
+ free(p);
+ }
+
+ writes("-ERR Cannot copy messages: ");
+ writes(strerror(errno));
+ writes("\n");
+ continue;
+ }
+ writes("-ERR Syntax error.\n");
+ continue;
+ }
+
+ if (strcmp(p, "SEARCH") == 0)
+ {
+ struct searchinfo *searchInfo=NULL;
+ struct searchinfo *si;
+ struct smap1_search_results searchResults;
+
+ if ((si=createSearch(&searchInfo, &ptr)) == NULL)
+ {
+ writes("-ERR SEARCH failed: ");
+ writes(strerror(errno));
+ writes("\n");
+ free_search(searchInfo);
+ continue;
+ }
+
+ searchResults.prev_runs=0;
+ searchResults.prev_search_hit=0;
+ searchResults.prev_search_hit_start=0;
+
+ search_internal(si, searchInfo, "utf-8", 0,
+ smap1_search_cb, &searchResults);
+
+ if (searchResults.prev_search_hit)
+ smap1_search_cb_range(&searchResults);
+
+ if (searchResults.prev_runs)
+ writes("\n");
+
+ writes("+OK Search completed.\n");
+ free_search(searchInfo);
+ continue;
+ }
+
+
+ writes("-ERR Syntax error.\n");
+ }
+
+ writes("* BYE Courier-SMAP server shutting down\n"
+ "+OK LOGOUT completed\n");
+ writeflush();
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-31 07:17:01 +0000