Mailbox quota support in imap4d: initial implementation.

* imap4d/quota.c: New file.
* imap4d/Makefile.am (imap4d_SOURCES): Add quota.c
* imap4d/append.c (imap4d_append0): Refuse to append if
the quota is exceeded or would be exceeded after completing
the operation.
* imap4d/copy.c (imap4d_copy0): Refuse to copy messages if
the quota is exceeded or would be exceeded after completing
the operation.
Return a meaningful textual description.
Attempt to restore mailbox to its original size if the operation failed.
* imap4d/imap4d.c (imap4d_session_setup0): Call quota_setup.
* imap4d/imap4d.h (quota_setup, quota_check, quota_update): New functions.

* include/mailutils/folder.h (mu_list_response) <format>: New member.
* include/mailutils/mailbox.h (mu_mailbox_create_from_record): New
function.
* include/mailutils/types.hin (MU_FOLDER_ATTRIBUTE_LINK): New flag.
* libproto/mbox/folder.c (list_helper): Do not return symbolic links
unless MU_FOLDER_ATTRIBUTE_LINK is set.
Fill in the resp->format member.
* mailbox/mailbox.c (_mailbox_create_from_record): New static function.
(_create_mailbox0): Rewrite as a wrapper over _mailbox_create_from_record.
(mu_mailbox_create_from_record): New function.

@@ -50,6 +50,7 @@ imap4d_SOURCES = \
  noop.c\
  parsebuf.c\
  preauth.c\
+ quota.c\
  rename.c\
  search.c\
  select.c\

@@ -71,6 +71,7 @@ imap4d_append0 (mu_mailbox_t mbox, int flags, char *date_time, char *text,
   struct tm *tm;
   time_t t;
   mu_envelope_t env;
+  size_t size;
   
   if (mu_message_create (&msg, &tm))
     return 1;
@@ -94,9 +95,9 @@ imap4d_append0 (mu_mailbox_t mbox, int flags, char *date_time, char *text,
 	}
     }
   else
-    time(&t);
+    time (&t);
   
-  tm = gmtime(&t);
+  tm = gmtime (&t);
 
   while (*text && mu_isblank (*text))
     text++;
@@ -109,8 +110,30 @@ imap4d_append0 (mu_mailbox_t mbox, int flags, char *date_time, char *text,
   mu_envelope_set_date (env, _append_date, msg);
   mu_envelope_set_sender (env, _append_sender, msg);
   mu_message_set_envelope (msg, env, &tm);
+
+  rc = _append_size (msg, &size);
+  if (rc)
+    {
+      mu_diag_output (MU_DIAG_NOTICE,
+		      _("cannot compute size of the message being appended; "
+			"using estimated value: %s"),
+		      mu_strerror (rc));
+      /* raw estimate */
+      size = strlen (text);
+    }
+  rc = quota_check (size);
+  if (rc != RESP_OK)
+    {
+      *err_text = rc == RESP_NO ?
+	                   "Mailbox quota exceeded" : "Operation failed";
+      mu_message_destroy (&msg, &tm);
+      return 1;
+    }
+  
   rc = mu_mailbox_append_message (mbox, msg);
-  if (rc == 0 && flags)
+  if (rc == 0)
+    {
+      if (flags)
 	{
 	  size_t num = 0;
 	  mu_attribute_t attr = NULL;
@@ -119,6 +142,9 @@ imap4d_append0 (mu_mailbox_t mbox, int flags, char *date_time, char *text,
 	  mu_message_get_attribute (msg, &attr);
 	  mu_attribute_set_flags (attr, flags);
 	}
+      /* FIXME: If not INBOX */
+      quota_update (size);
+    }
 
   mu_message_destroy (&msg, &tm);
   return rc;

@@ -57,6 +57,153 @@ imap4d_copy (struct imap4d_command *command, imap4d_tokbuf_t tok)
   return io_completion_response (command, rc, "%s", text);
 }
 
+static int
+copy_check_size (mu_mailbox_t mbox, size_t n, size_t *set, mu_off_t *size)
+{
+  int status;
+  size_t i;
+  mu_off_t total = 0;
+  
+  for (i = 0; i < n; i++)
+    {
+      mu_message_t msg = NULL;
+      size_t msgno = set[i];
+      if (msgno)
+	{
+	  status = mu_mailbox_get_message (mbox, msgno, &msg);
+	  if (status)
+	    {
+	      mu_diag_funcall (MU_DIAG_ERROR, "mu_mailbox_get_message", NULL,
+			       status);
+	      return RESP_BAD;
+	    }
+	  else 
+	    {
+	      size_t size;
+	      status = mu_message_size (msg, &size);
+	      if (status)
+		{
+		  mu_diag_funcall (MU_DIAG_ERROR, "mu_message_size", NULL,
+				   status);
+		  return RESP_BAD;
+		}
+	      total += size;
+	    }
+	}
+    }
+  *size = total;
+  return quota_check (total);
+}
+
+static int
+try_copy (mu_mailbox_t dst, mu_mailbox_t src, size_t n, size_t *set)
+{
+  int result;
+  size_t i;
+  mu_off_t total;
+  
+  result = copy_check_size (src, n, set, &total);
+  if (result)
+    return result;
+  
+  for (i = 0; i < n; i++)
+    {
+      mu_message_t msg = NULL;
+      size_t msgno = set[i];
+
+      if (msgno)
+	{
+	  int status = mu_mailbox_get_message (src, msgno, &msg);
+	  if (status)
+	    {
+	      mu_diag_funcall (MU_DIAG_ERROR, "mu_mailbox_get_message", NULL,
+			       status);
+	      return RESP_BAD;
+	    }
+
+	  status = mu_mailbox_append_message (dst, msg);
+	  if (status)
+	    {
+	      mu_diag_funcall (MU_DIAG_ERROR, "mu_mailbox_append_message",
+			       NULL,
+			       status);
+	      return RESP_BAD;
+	    }
+	}
+    }
+  quota_update (total);
+  return RESP_OK;
+}
+
+static int
+safe_copy (mu_mailbox_t dst, mu_mailbox_t src, size_t n, size_t *set,
+	   char **err_text)
+{
+  size_t nmesg;
+  int status;
+  
+  status = mu_mailbox_messages_count (dst, &nmesg);
+  if (status)
+    {
+      mu_diag_funcall (MU_DIAG_ERROR, "mu_mailbox_messages_count",
+		       NULL, status);
+      *err_text = "Operation failed";
+      return RESP_NO;
+    }
+
+  status = try_copy (dst, src, n, set);
+  if (status)
+    {
+      size_t maxmesg;
+
+      if (status == RESP_NO)
+	*err_text = "Mailbox quota exceeded";
+      else
+	*err_text = "Operation failed";
+      
+      /* If the COPY command is unsuccessful for any reason, server
+	 implementations MUST restore the destination mailbox to its state
+	 before the COPY attempt. */
+
+      status = mu_mailbox_messages_count (dst, &maxmesg);
+      if (status)
+	{
+	  mu_url_t url = NULL;
+
+	  mu_mailbox_get_url (dst, &url);
+	  mu_error (_("cannot count messages in mailbox %s: %s"),
+		    mu_url_to_string (url), mu_strerror (status));
+	  imap4d_bye (ERR_MAILBOX_CORRUPTED);
+	}
+      
+      for (nmesg++; nmesg <= maxmesg; nmesg++)
+	{
+	  mu_message_t msg;
+	  
+	  if (mu_mailbox_get_message (dst, nmesg, &msg) == 0)
+	    {
+	      mu_attribute_t attr;
+	      mu_message_get_attribute (msg, &attr);
+	      mu_attribute_set_userflag (attr, MU_ATTRIBUTE_DELETED);
+	    }
+	}
+      
+      status = mu_mailbox_flush (dst, 1);
+      if (status)
+	{
+	  mu_url_t url = NULL;
+
+	  mu_mailbox_get_url (dst, &url);
+	  mu_error (_("cannot flush mailbox %s: %s"),
+		    mu_url_to_string (url), mu_strerror (status));
+	  imap4d_bye (ERR_MAILBOX_CORRUPTED);
+	}
+      return RESP_NO;
+    }
+  
+  return RESP_OK;
+}
+
 int
 imap4d_copy0 (imap4d_tokbuf_t tok, int isuid, char **err_text)
 {
@@ -71,6 +218,7 @@ imap4d_copy0 (imap4d_tokbuf_t tok, int isuid, char **err_text)
   int arg = IMAP4_ARG_1 + !!isuid;
   int ns;
 
+  *err_text = NULL;
   if (imap4d_tokbuf_argc (tok) != arg + 2)
     {
       *err_text = "Invalid arguments";
@@ -89,11 +237,19 @@ imap4d_copy0 (imap4d_tokbuf_t tok, int isuid, char **err_text)
       return RESP_OK;
     }
 
+  if (isuid)
+    {
+      int i;
+      /* Fixup the message set. Perhaps util_msgset should do it itself? */
+      for (i = 0; i < n; i++)
+	set[i] = uid_to_msgno (set[i]);
+    }
+  
   mailbox_name = namespace_getfullpath (name, delim, &ns);
 
   if (!mailbox_name)
     {
-      *err_text = "NO Copy failed.";
+      *err_text = "Copy failed";
       return RESP_NO;
     }
 
@@ -106,14 +262,7 @@ imap4d_copy0 (imap4d_tokbuf_t tok, int isuid, char **err_text)
       status = mu_mailbox_open (cmbox, MU_STREAM_RDWR | mailbox_mode[ns]);
       if (status == 0)
 	{
-	  size_t i;
-	  for (i = 0; i < n; i++)
-	    {
-	      mu_message_t msg = NULL;
-	      size_t msgno = (isuid) ? uid_to_msgno (set[i]) : set[i];
-	      if (msgno && mu_mailbox_get_message (mbox, msgno, &msg) == 0)
-		mu_mailbox_append_message (cmbox, msg);
-	    }
+	  status = safe_copy (cmbox, mbox, n, set, err_text);
 	  mu_mailbox_close (cmbox);
 	}
       mu_mailbox_destroy (&cmbox);
@@ -132,6 +281,7 @@ imap4d_copy0 (imap4d_tokbuf_t tok, int isuid, char **err_text)
      of the text of the tagged NO response.  This gives a hint to the
      client that it can attempt a CREATE command and retry the copy if
      the CREATE is successful.  */
+  if (!*err_text)
     *err_text = "[TRYCREATE] failed";
   return RESP_NO;
 }

@@ -352,9 +352,14 @@ imap4d_session_setup0 ()
 
   util_chdir (imap4d_homedir);
   namespace_init_session (imap4d_homedir);
+  
   mu_diag_output (MU_DIAG_INFO,
 		  _("user `%s' logged in (source: %s)"), auth_data->name,
 		  auth_data->source);
+
+  if (auth_data->quota)
+    quota_setup ();
+  
   return 0;
 }
 

@@ -424,6 +424,11 @@ extern void auth_gsasl_init (void);
 # define auth_gsasl_init()
 #endif
 
+/* Quota support */
+void quota_setup (void);
+int quota_check (mu_off_t size);
+void quota_update (mu_off_t size);
+
 #ifdef __cplusplus
 }
 #endif

+/* GNU Mailutils -- a suite of utilities for electronic mail
+   Copyright (C) 1999, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+   2009, 2010 Free Software Foundation, Inc.
+
+   GNU Mailutils is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3, or (at your option)
+   any later version.
+
+   GNU Mailutils is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GNU Mailutils.  If not, see <http://www.gnu.org/licenses/>. */
+
+#include "imap4d.h"
+
+struct imap4d_sizeinfo
+{
+  mu_off_t size;
+  mu_off_t nfiles;
+  mu_off_t ndirs;
+  mu_off_t nerrs;
+};
+  
+static int
+addsize (mu_folder_t folder, struct mu_list_response *resp, void *data)
+{
+  struct imap4d_sizeinfo *si = data;
+
+  if (resp->type & MU_FOLDER_ATTRIBUTE_DIRECTORY)
+    si->ndirs++;
+  
+  if (resp->type & MU_FOLDER_ATTRIBUTE_FILE)
+    {
+      mu_off_t size;
+      mu_mailbox_t mbox;
+      int rc;
+      
+      si->nfiles++;
+
+      rc = mu_mailbox_create_from_record (&mbox, resp->format, resp->name);
+
+      if (rc)
+	{
+	  mu_diag_funcall (MU_DIAG_ERROR, "mu_mailbox_create_from_record",
+			   resp->name, rc);
+	  si->nerrs++;
+	  return 0;
+	}
+
+      rc = mu_mailbox_open (mbox, MU_STREAM_READ);
+      if (rc)
+	{
+	  mu_diag_funcall (MU_DIAG_ERROR, "mu_mailbox_open",
+			   resp->name, rc);
+	  si->nerrs++;
+	  mu_mailbox_destroy (&mbox);
+	  return 0;
+	}
+
+      rc = mu_mailbox_get_size (mbox, &size);
+      mu_mailbox_destroy (&mbox);
+
+      if (rc)
+	{
+	  mu_diag_funcall (MU_DIAG_ERROR, "mu_mailbox_open",
+			   resp->name, rc);
+	  si->nerrs++;
+	  return 0;
+	}
+      si->size += size;
+    }
+  return 0;
+}
+  
+void
+directory_size (const char *dirname, mu_off_t *size)
+{
+  mu_folder_t folder;
+  struct imap4d_sizeinfo sizeinfo;
+  int status;
+  
+  status = mu_folder_create (&folder, dirname);
+  if (status)
+    {
+      mu_diag_funcall (MU_DIAG_ERROR, "mu_folder_create", dirname, status);
+      return;
+    }
+
+  status = mu_folder_open (folder, MU_STREAM_READ);
+  if (status)
+    {
+      mu_diag_funcall (MU_DIAG_ERROR, "mu_folder_open", dirname, status);
+      mu_folder_destroy (&folder);
+      return;
+    }
+
+  memset (&sizeinfo, 0, sizeof (sizeinfo));
+  status = mu_folder_enumerate (folder, NULL, "*", 0, 0, NULL,
+				addsize, &sizeinfo);
+  if (status)
+    mu_diag_funcall (MU_DIAG_ERROR, "mu_folder_enumerate", dirname, status);
+  else
+    {
+      mu_diag_output (MU_DIAG_INFO,
+		      _("%s statistics: size=%lu, ndirs=%lu, nfiles=%lu, nerrs=%lu"),
+		      dirname,
+		      (unsigned long)sizeinfo.size,
+		      (unsigned long)sizeinfo.ndirs,
+		      (unsigned long)sizeinfo.nfiles,
+		      (unsigned long)sizeinfo.nerrs);
+    }
+  *size = sizeinfo.size;
+}
+
+
+mu_off_t used_size;
+
+void
+quota_setup ()
+{
+  directory_size (imap4d_homedir, &used_size);
+}
+
+int
+quota_check (mu_off_t size)
+{
+  char *mailbox_name;
+  mu_mailbox_t mbox;
+  mu_off_t total;
+  int rc;
+  
+  if (auth_data->quota == 0)
+    return RESP_OK;
+
+  total = used_size;
+
+  mailbox_name = namespace_getfullpath ("INBOX", "/", NULL);
+  rc = mu_mailbox_create (&mbox, mailbox_name);
+  if (rc)
+    {
+      mu_diag_funcall (MU_DIAG_ERROR, "mu_mailbox_create", mailbox_name, rc);
+      free (mailbox_name);
+    }
+  else
+    {
+      do
+	{
+	  mu_off_t mbsize;
+	  
+	  rc = mu_mailbox_open (mbox, MU_STREAM_READ);
+	  if (rc)
+	    {
+	      if (rc != ENOENT)
+		mu_diag_funcall (MU_DIAG_ERROR, "mu_mailbox_open",
+				 mailbox_name, rc);
+	      break;
+	    }
+	  
+	  rc = mu_mailbox_get_size (mbox, &mbsize);
+	  if (rc)
+	    {
+	      mu_diag_funcall (MU_DIAG_ERROR, "mu_mailbox_get_size",
+			       mailbox_name, rc);
+	      mu_mailbox_close (mbox);
+	      break;
+	    }
+	  total += mbsize;
+	  mu_mailbox_close (mbox);
+	}
+      while (0);
+      mu_mailbox_destroy (&mbox);
+    }
+  free (mailbox_name);
+
+  if (rc)
+    return RESP_BAD;
+  
+  if (total > auth_data->quota)
+    {
+      mu_diag_output (MU_DIAG_NOTICE,
+		      _("user %s is out of mailbox quota"),
+		      auth_data->name);
+      return RESP_NO;
+    }
+  else if (total + size > auth_data->quota)
+    {
+      mu_diag_output (MU_DIAG_NOTICE,
+		      _("user %s: adding %lu bytes would exceed mailbox quota"),
+		      auth_data->name, (unsigned long) size);
+      return RESP_NO;
+    }
+  return RESP_OK;
+}
+
+void
+quota_update (mu_off_t size)
+{
+  used_size += size;
+}

@@ -32,6 +32,7 @@ struct mu_list_response
   int level;
   int separator;
   char *name;
+  mu_record_t format;   /* Associated mailbox format record */
 };
 
 typedef int (*mu_folder_match_fp) (const char *, void *, int);

@@ -40,9 +40,12 @@ int mu_construct_user_mailbox_url (char **pout, const char *name);
 /* Constructor/destructor and possible types.  */
 extern int  mu_mailbox_create          (mu_mailbox_t *, const char *);
 extern int  mu_mailbox_create_from_url (mu_mailbox_t *, mu_url_t);
+extern int  mu_mailbox_create_from_record (mu_mailbox_t *pmbox,
+					   mu_record_t record,
+					   const char *name);
+extern int  mu_mailbox_create_default  (mu_mailbox_t *, const char *);
 
 extern void mu_mailbox_destroy         (mu_mailbox_t *);
-extern int  mu_mailbox_create_default  (mu_mailbox_t *, const char *);
 
 extern int  mu_mailbox_open            (mu_mailbox_t, int flag);
 extern int  mu_mailbox_close           (mu_mailbox_t);

@@ -120,6 +120,7 @@ typedef struct _mu_mime_io_buffer *mu_mime_io_buffer_t;
   
 #define MU_FOLDER_ATTRIBUTE_DIRECTORY  0x001
 #define MU_FOLDER_ATTRIBUTE_FILE       0x002
+#define MU_FOLDER_ATTRIBUTE_LINK       0x004
 
 #define MU_FOLDER_ATTRIBUTE_ALL \
           (MU_FOLDER_ATTRIBUTE_DIRECTORY|MU_FOLDER_ATTRIBUTE_FILE)

@@ -345,13 +345,15 @@ list_helper (struct search_data *data, mu_record_t record,
       if (ename[ename[0] != '.' ? 0 : ename[1] != '.' ? 1 : 2] == 0)
 	continue;
       fname = get_pathname (dirname, ename);
-      if (stat (fname, &st) == 0)
+      if (lstat (fname, &st) == 0)
 	{
 	  int f;
 	  if (S_ISDIR (st.st_mode))
 	    f = MU_FOLDER_ATTRIBUTE_DIRECTORY;
 	  else if (S_ISREG (st.st_mode))
 	    f = MU_FOLDER_ATTRIBUTE_FILE;
+	  else if (S_ISLNK (st.st_mode))
+	    f = MU_FOLDER_ATTRIBUTE_LINK;
 	  else
 	    f = 0;
 	  if (mu_record_list_p (record, ename, f))
@@ -386,6 +388,7 @@ list_helper (struct search_data *data, mu_record_t record,
 		  resp->level = level;
 		  resp->separator = '/';
 		  resp->type = type;
+		  resp->format = rec;
 		  
 		  if (resp->type == 0)
 		    {

@@ -69,21 +69,19 @@ mailbox_folder_create (mu_mailbox_t mbox, const char *name,
   return rc;
 }
 
-static int
-_create_mailbox0 (mu_mailbox_t *pmbox, mu_url_t url, const char *name)
+int
+_mailbox_create_from_record (mu_mailbox_t *pmbox,
+			     mu_record_t record,
+			     mu_url_t url, 
+			     const char *name)
 {
-  int status;
-  mu_record_t record = NULL;
-
-  if (mu_registrar_lookup_url (url, MU_FOLDER_ATTRIBUTE_FILE, &record, NULL)
-      == 0)
-    {
   mu_log_level_t level;
   int (*m_init) (mu_mailbox_t) = NULL;
       
   mu_record_get_mailbox (record, &m_init);
   if (m_init)
     {
+      int status;
       int (*u_init) (mu_url_t) = NULL;
       mu_mailbox_t mbox;
       
@@ -160,7 +158,17 @@ _create_mailbox0 (mu_mailbox_t *pmbox, mu_url_t url, const char *name)
       
       return status;
     }
-    }
+  return MU_ERR_NO_HANDLER;
+}
+
+static int
+_create_mailbox0 (mu_mailbox_t *pmbox, mu_url_t url, const char *name)
+{
+  mu_record_t record = NULL;
+
+  if (mu_registrar_lookup_url (url, MU_FOLDER_ATTRIBUTE_FILE, &record, NULL)
+      == 0)
+    return _mailbox_create_from_record (pmbox, record, url, name);
   return MU_ERR_NO_HANDLER;
 }
 
@@ -202,6 +210,24 @@ mu_mailbox_create_from_url (mu_mailbox_t *pmbox, mu_url_t url)
   return _create_mailbox0 (pmbox, url, mu_url_to_string (url));
 }
 
+int
+mu_mailbox_create_from_record (mu_mailbox_t *pmbox, mu_record_t record,
+			       const char *name)
+{
+  mu_url_t url;
+  int rc;
+  
+  rc = mu_url_create (&url, name);
+  if (rc)
+    return rc;
+  rc = mu_url_parse (url);
+  if (rc == 0)
+    rc = _mailbox_create_from_record (pmbox, record, url, name);
+  if (rc)
+    mu_url_destroy (&url);
+  return rc;
+}
+
 void
 mu_mailbox_destroy (mu_mailbox_t *pmbox)
 {