Fix input operations and RFC-compliance in imap4d.

* imap4d/util.c (util_getword, util_getitem, util_token)
(util_unquote): Remove.
(imap4d_readline): Rewrite to reduce memory reallocation.  Add
support for non-synchronizing literals (RFC 2088).
(imap4d_readline_ex): Remove.
(util_do_command): Rewrite using new imap4d_readline.
(util_parse_internal_date0): Remove.
(imap4d_tokbuf_init, imap4d_tokbuf_destroy, imap4d_tokbuf_argc)
(imap4d_tokbuf_getarg, util_isdelim)
(imap4d_tokbuf_from_string): New functions.
* imap4d/append.c, imap4d/auth_gss.c, imap4d/authenticate.c,
imap4d/check.c, imap4d/close.c, imap4d/commands.c, imap4d/copy.c,
imap4d/create.c, imap4d/delete.c, imap4d/examine.c,
imap4d/imap4d.h, imap4d/list.c, imap4d/login.c, imap4d/logout.c,
imap4d/lsub.c, imap4d/expunge.c, imap4d/idle.c, imap4d/noop.c,
imap4d/rename.c, imap4d/search.c, imap4d/select.c,
imap4d/starttls.c, imap4d/status.c, imap4d/store.c,
imap4d/subscribe.c, imap4d/uid.c, imap4d/unsubscribe.c,
imap4d/version.c: Rewrite using new imap4d_readline.
* imap4d/namespace.c: Use new imap4d_readline.  Ensure that
each reported prefix ends with a hierarchy delimiter.
* imap4d/imap4d.c (imap4d_mainloop): Use new imap4d_readline.
* imap4d/fetch.c: Rewrite parser from scratch.
* imap4d/capability.c (imap4d_capability_init): Report LITERAL+
capability.

* imap4d/testsuite/imap4d/anystate.exp: Account for the LITERAL+
capability.
* imap4d/testsuite/imap4d/append.exp: Fix APPEND arguments (imap4d
requires exactly three arguments, as per RFC3501.
Fix octet count in literals returned by fetch (previous versions
failed to include the trailing CRLF).
* imap4d/testsuite/imap4d/create.exp: Likewise.
* imap4d/testsuite/imap4d/fetch.exp: Fix FETCH arguments (previous
versions incorrectly accepted header-list without parentheses.
Fix result of FETCH 4 BODY[2.2.1]: it returns entire part, in the
contrast to previous versions, which treated it as
BODY[2.2.1.TEXT].

* maidag/mailtmp.c (mail_tmp_finish): Ensure /dev/null is treated
as mailbox.

+2008-08-11  Sergey Poznyakoff  <gray@gnu.org.ua>
+
+	Fix input operations and RFC-compliance in imap4d.
+	
+	* imap4d/util.c (util_getword, util_getitem, util_token)
+	(util_unquote): Remove.
+	(imap4d_readline): Rewrite to reduce memory reallocation.  Add 
+	support for non-synchronizing literals (RFC 2088).
+	(imap4d_readline_ex): Remove.
+	(util_do_command): Rewrite using new imap4d_readline.
+	(util_parse_internal_date0): Remove.
+	(imap4d_tokbuf_init, imap4d_tokbuf_destroy, imap4d_tokbuf_argc)
+	(imap4d_tokbuf_getarg, util_isdelim)
+	(imap4d_tokbuf_from_string): New functions.
+	* imap4d/append.c, imap4d/auth_gss.c, imap4d/authenticate.c,
+	imap4d/check.c, imap4d/close.c, imap4d/commands.c, imap4d/copy.c,
+	imap4d/create.c, imap4d/delete.c, imap4d/examine.c,
+	imap4d/imap4d.h, imap4d/list.c, imap4d/login.c, imap4d/logout.c,
+	imap4d/lsub.c, imap4d/expunge.c, imap4d/idle.c, imap4d/noop.c,
+	imap4d/rename.c, imap4d/search.c, imap4d/select.c,
+	imap4d/starttls.c, imap4d/status.c, imap4d/store.c,
+	imap4d/subscribe.c, imap4d/uid.c, imap4d/unsubscribe.c,
+	imap4d/version.c: Rewrite using new imap4d_readline.
+	* imap4d/namespace.c: Use new imap4d_readline.  Ensure that
+	each reported prefix ends with a hierarchy delimiter.
+	* imap4d/imap4d.c (imap4d_mainloop): Use new imap4d_readline.
+	* imap4d/fetch.c: Rewrite parser from scratch.
+	* imap4d/capability.c (imap4d_capability_init): Report LITERAL+
+	capability.
+
+	* imap4d/testsuite/imap4d/anystate.exp: Account for the LITERAL+
+	capability.
+	* imap4d/testsuite/imap4d/append.exp: Fix APPEND arguments (imap4d
+	requires exactly three arguments, as per RFC3501.
+	Fix octet count in literals returned by fetch (previous versions
+	failed to include the trailing CRLF).
+	* imap4d/testsuite/imap4d/create.exp: Likewise.
+	* imap4d/testsuite/imap4d/fetch.exp: Fix FETCH arguments (previous
+	versions incorrectly accepted header-list without parentheses.
+	Fix result of FETCH 4 BODY[2.2.1]: it returns entire part, in the
+	contrast to previous versions, which treated it as
+	BODY[2.2.1.TEXT].
+
+	* maidag/mailtmp.c (mail_tmp_finish): Ensure /dev/null is treated
+	as mailbox.
+
 2008-08-08  Sergey Poznyakoff  <gray@gnu.org.ua>
 2008-08-08  Sergey Poznyakoff  <gray@gnu.org.ua>
 
 
 	Fix imap appends for AMD mailboxes.
 	Fix imap appends for AMD mailboxes.

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2005, 2006, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2005, 2006, 2007,
+   2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -18,49 +19,6 @@
 
 
 #include "imap4d.h"
 #include "imap4d.h"
 
 
-/* APPEND mbox [(flags)] [date_time] message_literal */
-int
-imap4d_append (struct imap4d_command *command, char *arg)
-{
-  char *sp;
-  char *mboxname;
-  int flags = 0;
-  mu_mailbox_t dest_mbox = NULL;
-  int status;
-
-  mboxname = util_getword (arg, &sp);
-  if (!mboxname)
-    return util_finish (command, RESP_BAD, "Too few arguments");
-
-  util_unquote (&mboxname);
-  
-  if (*sp == '(' && util_parse_attributes (sp+1, &sp, &flags))
-    return util_finish (command, RESP_BAD, "Missing closing parenthesis");
-  
-  mboxname = namespace_getfullpath (mboxname, "/");
-  if (!mboxname)
-    return util_finish (command, RESP_NO, "Couldn't open mailbox"); 
-
-  status = mu_mailbox_create_default (&dest_mbox, mboxname);
-  if (status == 0)
-    {
-      /* It SHOULD NOT automatifcllly create the mailbox. */
-      status = mu_mailbox_open (dest_mbox, MU_STREAM_RDWR);
-      if (status == 0)
-	{
-	  status = imap4d_append0 (dest_mbox, flags, sp);
-	  mu_mailbox_close (dest_mbox);
-	}
-      mu_mailbox_destroy (&dest_mbox);
-    }
-  
-  free (mboxname);
-  if (status == 0)
-    return util_finish (command, RESP_OK, "Completed");
-
-  return util_finish (command, RESP_NO, "[TRYCREATE] failed");
-}
-
 static int
 static int
 _append_date (mu_envelope_t envelope, char *buf, size_t len, size_t *pnwrite)
 _append_date (mu_envelope_t envelope, char *buf, size_t len, size_t *pnwrite)
 {
 {
@@ -93,12 +51,18 @@ _append_size (mu_message_t msg, size_t *psize)
   mu_stream_t str;
   mu_stream_t str;
   int status = mu_message_get_stream (msg, &str);
   int status = mu_message_get_stream (msg, &str);
   if (status == 0)
   if (status == 0)
-    status = mu_stream_size (str, psize);
+    {
+      mu_off_t size;
+      status = mu_stream_size (str, &size);
+      if (status == 0 && psize)
+	*psize = size;
+    }
   return status;
   return status;
 }
 }
 
 
 int
 int
-imap4d_append0 (mu_mailbox_t mbox, int flags, char *text)
+imap4d_append0 (mu_mailbox_t mbox, int flags, char *date_time, char *text,
+		char **err_text)
 {
 {
   mu_stream_t stream;
   mu_stream_t stream;
   int rc = 0;
   int rc = 0;
@@ -118,23 +82,25 @@ imap4d_append0 (mu_mailbox_t mbox, int flags, char *text)
       return 1;
       return 1;
     }
     }
 
 
-  while (*text && isspace (*text))
-    text++;
-
   /* If a date_time is specified, the internal date SHOULD be set in the
   /* If a date_time is specified, the internal date SHOULD be set in the
      resulting message; otherwise, the internal date of the resulting
      resulting message; otherwise, the internal date of the resulting
      message is set to the current date and time by default. */
      message is set to the current date and time by default. */
-  if (util_parse_internal_date0 (text, &t, &text) == 0)
+  if (date_time)
     {
     {
-      while (*text && isspace(*text))
-	text++;
+      if (util_parse_internal_date (date_time, &t))
+	{
+	  *err_text = "Invalid date/time format";
+	  return 1;
+	}
     }
     }
   else
   else
-    {
     time(&t);
     time(&t);
-    }
+  
   tm = gmtime(&t);
   tm = gmtime(&t);
 
 
+  while (*text && isspace (*text))
+    text++;
+
   mu_stream_write (stream, text, strlen (text), len, &len);
   mu_stream_write (stream, text, strlen (text), len, &len);
   mu_message_set_stream (msg, stream, &tm);
   mu_message_set_stream (msg, stream, &tm);
   mu_message_set_size (msg, _append_size, &tm);
   mu_message_set_size (msg, _append_size, &tm);
@@ -159,3 +125,86 @@ imap4d_append0 (mu_mailbox_t mbox, int flags, char *text)
 }
 }
 
 
 
 
+/* APPEND mbox [(flags)] [date_time] message_literal */
+int
+imap4d_append (struct imap4d_command *command, imap4d_tokbuf_t tok)
+{
+  int i;
+  char *mboxname;
+  int flags = 0;
+  mu_mailbox_t dest_mbox = NULL;
+  int status;
+  int argc = imap4d_tokbuf_argc (tok);
+  char *date_time;
+  char *msg_text;
+  char *err_text = "[TRYCREATE] failed";
+  
+  if (argc < 4)
+    return util_finish (command, RESP_BAD, "Too few arguments");
+      
+  mboxname = imap4d_tokbuf_getarg (tok, IMAP4_ARG_1);
+  if (!mboxname)
+    return util_finish (command, RESP_BAD, "Too few arguments");
+
+  i = IMAP4_ARG_2;
+  if (imap4d_tokbuf_getarg (tok, i)[0] == '(')
+    {
+      while (++i < argc)
+	{
+	  int type;
+	  char *arg = imap4d_tokbuf_getarg (tok, i);
+	  
+	  if (!util_attribute_to_type (arg, &type))
+	    flags |= type;
+	  else if (arg[0] == ')')
+	    break;
+	}
+      if (i == argc)
+	return util_finish (command, RESP_BAD, "Missing closing parenthesis");
+      i++;
+    }
+
+  switch (argc - i)
+    {
+    case 2:
+      /* Date/time is present */
+      date_time = imap4d_tokbuf_getarg (tok, i);
+      i++;
+      break;
+
+    case 1:
+      date_time = NULL;
+      break;
+
+    default:
+      return util_finish (command, RESP_BAD, "Too many arguments");
+    }
+
+  msg_text = imap4d_tokbuf_getarg (tok, i);
+  
+  mboxname = namespace_getfullpath (mboxname, "/");
+  if (!mboxname)
+    return util_finish (command, RESP_NO, "Couldn't open mailbox"); 
+
+  status = mu_mailbox_create_default (&dest_mbox, mboxname);
+  if (status == 0)
+    {
+      /* It SHOULD NOT automatically create the mailbox. */
+      status = mu_mailbox_open (dest_mbox, MU_STREAM_RDWR);
+      if (status == 0)
+	{
+	  status = imap4d_append0 (dest_mbox, flags, date_time, msg_text,
+				   &err_text);
+	  mu_mailbox_close (dest_mbox);
+	}
+      mu_mailbox_destroy (&dest_mbox);
+    }
+  
+  free (mboxname);
+  if (status == 0)
+    return util_finish (command, RESP_OK, "Completed");
+
+  return util_finish (command, RESP_NO, err_text);
+}
+
+

@@ -119,7 +119,9 @@ auth_gssapi (struct imap4d_command *command,
   gss_ctx_id_t context;
   gss_ctx_id_t context;
   gss_cred_id_t cred_handle, server_creds;
   gss_cred_id_t cred_handle, server_creds;
   gss_OID mech_type;
   gss_OID mech_type;
-  char *token_str;
+  char *token_str = NULL;
+  size_t token_size = 0;
+  size_t token_len;
   unsigned char *tmp = NULL;
   unsigned char *tmp = NULL;
   size_t size;
   size_t size;
   gss_name_t server_name;
   gss_name_t server_name;
@@ -168,11 +170,10 @@ auth_gssapi (struct imap4d_command *command,
 
 
   for (;;)
   for (;;)
     {
     {
-      token_str = imap4d_readline_ex ();
-      util_base64_decode (token_str, strlen (token_str), &tmp, &size);
+      imap4d_getline (&token_str, &token_size, &token_len);
+      util_base64_decode (token_str, token_len, &tmp, &size);
       tokbuf.value = tmp;
       tokbuf.value = tmp;
       tokbuf.length = size;
       tokbuf.length = size;
-      free (token_str);
 
 
       maj_stat = gss_accept_sec_context (&min_stat,
       maj_stat = gss_accept_sec_context (&min_stat,
 					 &context,
 					 &context,
@@ -202,6 +203,7 @@ auth_gssapi (struct imap4d_command *command,
       display_status ("accept context", maj_stat, min_stat);
       display_status ("accept context", maj_stat, min_stat);
       maj_stat = gss_delete_sec_context (&min_stat, &context, &outbuf);
       maj_stat = gss_delete_sec_context (&min_stat, &context, &outbuf);
       gss_release_buffer (&min_stat, &outbuf);
       gss_release_buffer (&min_stat, &outbuf);
+      free (token_str);
       return RESP_NO;
       return RESP_NO;
     }
     }
 
 
@@ -211,8 +213,7 @@ auth_gssapi (struct imap4d_command *command,
       util_send ("+ %*.*s\r\n", size, size, tmp);
       util_send ("+ %*.*s\r\n", size, size, tmp);
       free (tmp);
       free (tmp);
       gss_release_buffer (&min_stat, &outbuf);
       gss_release_buffer (&min_stat, &outbuf);
-      token_str = imap4d_readline_ex ();
-      free (token_str);
+      imap4d_getline (&token_str, &token_size, &token_len);
     }
     }
 
 
   /* Construct security-level data */
   /* Construct security-level data */
@@ -224,6 +225,7 @@ auth_gssapi (struct imap4d_command *command,
   if (maj_stat != GSS_S_COMPLETE)
   if (maj_stat != GSS_S_COMPLETE)
     {
     {
       display_status ("wrap", maj_stat, min_stat);
       display_status ("wrap", maj_stat, min_stat);
+      free (token_str);
       return RESP_NO;
       return RESP_NO;
     }
     }
   
   
@@ -231,8 +233,8 @@ auth_gssapi (struct imap4d_command *command,
   util_send ("+ %*.*s\r\n", size, size, tmp);
   util_send ("+ %*.*s\r\n", size, size, tmp);
   free (tmp);
   free (tmp);
 
 
-  token_str = imap4d_readline_ex ();
-  util_base64_decode (token_str, strlen (token_str),
+  imap4d_getline (&token_str, &token_size, &token_len);
+  util_base64_decode (token_str, token_len,
 		      (unsigned char **) &tokbuf.value, &tokbuf.length);
 		      (unsigned char **) &tokbuf.value, &tokbuf.length);
   free (token_str);
   free (token_str);
 
 

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2005, 2006, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2005, 2006, 2007,
+   2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -93,24 +94,30 @@ imap4d_auth_capability ()
   mu_list_do (imap_auth_list, _auth_capa, NULL);
   mu_list_do (imap_auth_list, _auth_capa, NULL);
 }
 }
 
 
+/*
+6.2.1.  AUTHENTICATE Command
+
+   Arguments:  authentication mechanism name
+*/
+
 int
 int
-imap4d_authenticate (struct imap4d_command *command, char *arg)
+imap4d_authenticate (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
-  char *sp = NULL;
   char *auth_type;
   char *auth_type;
   struct auth_data adata;
   struct auth_data adata;
 
 
-  auth_type = util_getword (arg, &sp);
-  util_unquote (&auth_type);
-  if (!auth_type)
-    return util_finish (command, RESP_BAD, "Too few arguments");
+  if (imap4d_tokbuf_argc (tok) != 3)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
+  
+  auth_type = imap4d_tokbuf_getarg (tok, IMAP4_ARG_1);
 
 
   if (tls_required)
   if (tls_required)
-    return util_finish (command, RESP_NO, "Command disabled: Use STARTTLS first");
+    return util_finish (command, RESP_NO,
+			"Command disabled: Use STARTTLS first");
   
   
   adata.command = command;
   adata.command = command;
   adata.auth_type = auth_type;
   adata.auth_type = auth_type;
-  adata.arg = sp;
+  adata.arg = NULL;
   adata.username = NULL;
   adata.username = NULL;
 
 
   if (mu_list_do (imap_auth_list, _auth_try, &adata) == 0)
   if (mu_list_do (imap_auth_list, _auth_try, &adata) == 0)

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2003, 2005, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2003, 2005, 2007,
+   2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -50,6 +51,7 @@ imap4d_capability_init ()
     "IMAP4rev1",
     "IMAP4rev1",
     "NAMESPACE",
     "NAMESPACE",
     "IDLE",
     "IDLE",
+    "LITERAL+",
     "X-VERSION",
     "X-VERSION",
     NULL
     NULL
   };
   };
@@ -67,8 +69,11 @@ print_capa (void *item, void *data)
 }
 }
 
 
 int
 int
-imap4d_capability (struct imap4d_command *command, char *arg MU_ARG_UNUSED)
+imap4d_capability (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
+  if (imap4d_tokbuf_argc (tok) != 2)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
+  
   util_send ("* CAPABILITY");
   util_send ("* CAPABILITY");
 
 
   mu_list_do (capa_list, print_capa, NULL);
   mu_list_do (capa_list, print_capa, NULL);

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -19,13 +19,20 @@
 #include "imap4d.h"
 #include "imap4d.h"
 
 
 /*
 /*
- * Do we need to do anything here?
- * FIXME: This is like noop we need to notify the client of
- *        new mails etc ... and do housekeeping.
- */
+6.4.1.  CHECK Command
+
+   Arguments:  none
+
+   Responses:  no specific responses for this command
+
+   Result:     OK - check completed
+               BAD - command unknown or arguments invalid
+*/
 
 
 int
 int
-imap4d_check (struct imap4d_command *command, char *arg MU_ARG_UNUSED)
+imap4d_check (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
+  if (imap4d_tokbuf_argc (tok) != 2)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
   return util_finish (command, RESP_OK, "Completed");
   return util_finish (command, RESP_OK, "Completed");
 }
 }

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2004, 2005, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2004, 2005, 2007,
+   2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -19,17 +20,28 @@
 #include "imap4d.h"
 #include "imap4d.h"
 
 
 /*
 /*
- */
+6.4.2.  CLOSE Command
 
 
-/* The CLOSE command permanently removes from the currently selected
+   Arguments:  none
+
+   Responses:  no specific responses for this command
+
+   Result:     OK - close completed, now in authenticated state
+               NO - close failure: no mailbox selected
+               BAD - command unknown or arguments invalid
+
+   The CLOSE command permanently removes from the currently selected
    mailbox all messages that have the \\Deleted flag set, and returns
    mailbox all messages that have the \\Deleted flag set, and returns
    to authenticated state from selected state.  */
    to authenticated state from selected state.  */
 int
 int
-imap4d_close (struct imap4d_command *command, char *arg MU_ARG_UNUSED)
+imap4d_close (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
   const char *msg = NULL;
   const char *msg = NULL;
   int status, flags;
   int status, flags;
 
 
+  if (imap4d_tokbuf_argc (tok) != 2)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
+  
   mu_mailbox_get_flags (mbox, &flags);
   mu_mailbox_get_flags (mbox, &flags);
   if ((flags & MU_STREAM_READ) == 0)
   if ((flags & MU_STREAM_READ) == 0)
     {
     {

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2003, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2003, 2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2005, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2005, 2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -19,55 +19,69 @@
 #include "imap4d.h"
 #include "imap4d.h"
 
 
 /*
 /*
- * copy messages in argv[2] to mailbox in argv[3]
+6.4.7.  COPY Command
+
+   Arguments:  message set
+               mailbox name
+
+   Responses:  no specific responses for this command
+
+   Result:     OK - copy completed
+               NO - copy error: can't copy those messages or to that
+                    name
+               BAD - command unknown or arguments invalid
+
+  copy messages in argv[2] to mailbox in argv[3]
  */
  */
 
 
 int
 int
-imap4d_copy (struct imap4d_command *command, char *arg)
+imap4d_copy (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
   int rc;
   int rc;
-  char buffer[64];
+  char *text;
+
+  if (imap4d_tokbuf_argc (tok) != 4)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
+  
+  rc = imap4d_copy0 (tok, 0, &text);
   
   
-  rc = imap4d_copy0 (arg, 0, buffer, sizeof buffer);
   if (rc == RESP_NONE)
   if (rc == RESP_NONE)
     {
     {
       /* Reset the state ourself.  */
       /* Reset the state ourself.  */
       int new_state = (rc == RESP_OK) ? command->success : command->failure;
       int new_state = (rc == RESP_OK) ? command->success : command->failure;
       if (new_state != STATE_NONE)
       if (new_state != STATE_NONE)
 	state = new_state;
 	state = new_state;
-      return util_send ("%s %s\r\n", command->tag, buffer);
+      return util_send ("%s %s\r\n", command->tag, text);
     }
     }
-  return util_finish (command, rc, "%s", buffer);
+  return util_finish (command, rc, "%s", text);
 }
 }
 
 
 int
 int
-imap4d_copy0 (char *arg, int isuid, char *resp, size_t resplen)
+imap4d_copy0 (imap4d_tokbuf_t tok, int isuid, char **err_text)
 {
 {
   int status;
   int status;
   char *msgset;
   char *msgset;
   char *name;
   char *name;
   char *mailbox_name;
   char *mailbox_name;
   const char *delim = "/";
   const char *delim = "/";
-  char *sp = NULL;
   size_t *set = NULL;
   size_t *set = NULL;
   int n = 0;
   int n = 0;
   mu_mailbox_t cmbox = NULL;
   mu_mailbox_t cmbox = NULL;
+  int arg = IMAP4_ARG_1 + !!isuid;
 
 
-  msgset = util_getword (arg, &sp);
-  name = util_getword (NULL, &sp);
-
-  util_unquote (&name);
-  if (!msgset || !name || *name == '\0')
+  if (imap4d_tokbuf_argc (tok) != arg + 2)
     {
     {
-      snprintf (resp, resplen, "Too few args");
-      return RESP_BAD;
+      *err_text = "Invalid arguments";
+      return 1;
     }
     }
   
   
+  msgset = imap4d_tokbuf_getarg (tok, arg);
+  name = imap4d_tokbuf_getarg (tok, arg + 1);
   /* Get the message numbers in set[].  */
   /* Get the message numbers in set[].  */
   status = util_msgset (msgset, &set, &n, isuid);
   status = util_msgset (msgset, &set, &n, isuid);
   if (status != 0)
   if (status != 0)
     {
     {
-      snprintf (resp, resplen, "Bogus number set");
+      *err_text = "Bogus number set";
       return RESP_BAD;
       return RESP_BAD;
     }
     }
 
 
@@ -75,7 +89,7 @@ imap4d_copy0 (char *arg, int isuid, char *resp, size_t resplen)
 
 
   if (!mailbox_name)
   if (!mailbox_name)
     {
     {
-      snprintf (resp, resplen, "NO Create failed.");
+      *err_text = "NO Create failed.";
       return RESP_NO;
       return RESP_NO;
     }
     }
 
 
@@ -105,7 +119,7 @@ imap4d_copy0 (char *arg, int isuid, char *resp, size_t resplen)
 
 
   if (status == 0)
   if (status == 0)
     {
     {
-      snprintf (resp, resplen, "Completed");
+      *err_text = "Completed";
       return RESP_OK;
       return RESP_OK;
     }
     }
 
 
@@ -114,6 +128,6 @@ imap4d_copy0 (char *arg, int isuid, char *resp, size_t resplen)
      of the text of the tagged NO response.  This gives a hint to the
      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
      client that it can attempt a CREATE command and retry the copy if
      the CREATE is successful.  */
      the CREATE is successful.  */
-  snprintf (resp, resplen, "NO [TRYCREATE] failed");
+  *err_text = "NO [TRYCREATE] failed";
   return RESP_NONE;
   return RESP_NONE;
 }
 }

@@ -63,25 +63,34 @@ mkdir_p (char *name, int delim)
   return 0;
   return 0;
 }
 }
 
 
+/*
+6.3.3.  CREATE Command
+
+   Arguments:  mailbox name
+
+   Responses:  no specific responses for this command
+
+   Result:     OK - create completed
+               NO - create failure: can't create mailbox with that name
+               BAD - command unknown or arguments invalid
+*/  
 /* FIXME: How do we do this ??????:
 /* FIXME: How do we do this ??????:
    IF a new mailbox is created with the same name as a mailbox which was
    IF a new mailbox is created with the same name as a mailbox which was
    deleted, its unique identifiers MUST be greater than any unique identifiers
    deleted, its unique identifiers MUST be greater than any unique identifiers
    used in the previous incarnation of the mailbox.  */
    used in the previous incarnation of the mailbox.  */
 int
 int
-imap4d_create (struct imap4d_command *command, char *arg)
+imap4d_create (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
   char *name;
   char *name;
-  char *sp = NULL;
   const char *delim = "/";
   const char *delim = "/";
   int isdir = 0;
   int isdir = 0;
   int rc = RESP_OK;
   int rc = RESP_OK;
   const char *msg = "Completed";
   const char *msg = "Completed";
 
 
-  name = util_getword (arg, &sp);
-  if (!name)
-    return util_finish (command, RESP_BAD, "Too few arguments");
+  if (imap4d_tokbuf_argc (tok) != 3)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
 
 
-  util_unquote (&name);
+  name = imap4d_tokbuf_getarg (tok, IMAP4_ARG_1);
 
 
   if (*name == '\0')
   if (*name == '\0')
     return util_finish (command, RESP_BAD, "Too few arguments");
     return util_finish (command, RESP_BAD, "Too few arguments");
@@ -152,6 +161,5 @@ imap4d_create (struct imap4d_command *command, char *arg)
       msg = "already exists";
       msg = "already exists";
     }
     }
 
 
-  free (name);
   return util_finish (command, rc, msg);
   return util_finish (command, rc, msg);
 }
 }

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -19,20 +19,27 @@
 #include "imap4d.h"
 #include "imap4d.h"
 
 
 /*
 /*
- *  
- */
+6.3.4.  DELETE Command
 
 
+   Arguments:  mailbox name
+
+   Responses:  no specific responses for this command
+
+   Result:     OK - delete completed
+               NO - delete failure: can't delete mailbox with that name
+               BAD - command unknown or arguments invalid
+*/  
 int
 int
-imap4d_delete (struct imap4d_command *command, char *arg)
+imap4d_delete (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
-  char *sp = NULL;
   int rc = RESP_OK;
   int rc = RESP_OK;
   const char *msg = "Completed";
   const char *msg = "Completed";
   const char *delim = "/";
   const char *delim = "/";
   char *name;
   char *name;
 
 
-  name = util_getword (arg, &sp);
-  util_unquote (&name);
+  if (imap4d_tokbuf_argc (tok) != 3)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
+  name = imap4d_tokbuf_getarg (tok, IMAP4_ARG_1);
   if (!name || *name == '\0')
   if (!name || *name == '\0')
     return util_finish (command, RESP_BAD, "Too few arguments");
     return util_finish (command, RESP_BAD, "Too few arguments");
 
 
@@ -51,6 +58,5 @@ imap4d_delete (struct imap4d_command *command, char *arg)
       rc = RESP_NO;
       rc = RESP_NO;
       msg = "Cannot remove";
       msg = "Cannot remove";
     }
     }
-  free (name);
   return util_finish (command, rc, msg);
   return util_finish (command, rc, msg);
 }
 }

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -19,11 +19,23 @@
 #include "imap4d.h"
 #include "imap4d.h"
 
 
 /*
 /*
- * copy things from select.c
- */
+6.3.2.  EXAMINE Command
 
 
+   Arguments:  mailbox name
+
+   Responses:  REQUIRED untagged responses: FLAGS, EXISTS, RECENT
+               OPTIONAL OK untagged responses: UNSEEN, PERMANENTFLAGS
+
+   Result:     OK - examine completed, now in selected state
+               NO - examine failure, now in authenticated state: no
+                    such mailbox, can't access mailbox
+               BAD - command unknown or arguments invalid
+*/
 int
 int
-imap4d_examine (struct imap4d_command *command, char *arg)
+imap4d_examine (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
-  return imap4d_select0 (command, arg, MU_STREAM_READ);
+  if (imap4d_tokbuf_argc (tok) != 3)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
+  return imap4d_select0 (command, imap4d_tokbuf_getarg (tok, IMAP4_ARG_1),
+			 MU_STREAM_READ);
 }
 }

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2005, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2005, 2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -19,16 +19,23 @@
 #include "imap4d.h"
 #include "imap4d.h"
 
 
 /*
 /*
- *  
- */
+6.4.3.  EXPUNGE Command
+
+   Arguments:  none
+
+   Responses:  untagged responses: EXPUNGE
+
+   Result:     OK - expunge completed
+               NO - expunge failure: can't expunge (e.g. permission
+                    denied)
+               BAD - command unknown or arguments invalid
+*/
 
 
 int
 int
-imap4d_expunge (struct imap4d_command *command, char *arg)
+imap4d_expunge (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
-  char *sp = NULL;
-
-  if (util_getword (arg, &sp))
-    return util_finish (command, RESP_NO, "Too many args");
+  if (imap4d_tokbuf_argc (tok) != 2)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
 
 
   /* FIXME: check for errors.  */
   /* FIXME: check for errors.  */
   mu_mailbox_expunge (mbox);
   mu_mailbox_expunge (mbox);

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2005, 2006, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2005, 2006, 2007,
+   2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -20,9 +21,6 @@
 #include <ctype.h>
 #include <ctype.h>
 #include <mailutils/argcv.h>
 #include <mailutils/argcv.h>
 
 
-/* This will suck, too.
-   Alain: Yes it does.  */
-
 /*  Taken from RFC2060
 /*  Taken from RFC2060
     fetch           ::= "FETCH" SPACE set SPACE ("ALL" / "FULL" /
     fetch           ::= "FETCH" SPACE set SPACE ("ALL" / "FULL" /
     "FAST" / fetch_att / "(" 1#fetch_att ")")
     "FAST" / fetch_att / "(" 1#fetch_att ")")
@@ -34,495 +32,93 @@
     ["<" number "." nz_number ">"]
     ["<" number "." nz_number ">"]
 */
 */
 
 
-struct fetch_command;
-
-static int fetch_all               (struct fetch_command *, char**);
-static int fetch_full              (struct fetch_command *, char**);
-static int fetch_fast              (struct fetch_command *, char**);
-static int fetch_envelope          (struct fetch_command *, char**);
-static int fetch_flags             (struct fetch_command *, char**);
-static int fetch_internaldate      (struct fetch_command *, char**);
-static int fetch_rfc822_header     (struct fetch_command *, char**);
-static int fetch_rfc822_size       (struct fetch_command *, char**);
-static int fetch_rfc822_text       (struct fetch_command *, char**);
-static int fetch_rfc822            (struct fetch_command *, char**);
-static int fetch_bodystructure     (struct fetch_command *, char**);
-static int fetch_body              (struct fetch_command *, char**);
-static int fetch_uid               (struct fetch_command *, char**);
-
-/* Helper functions.  */
-static int fetch_envelope0         (mu_message_t);
-static int fetch_bodystructure0    (mu_message_t, int);
-static int bodystructure           (mu_message_t, int);
-static void send_parameter_list    (const char *);
-static int fetch_operation         (mu_message_t, char **, int);
-static int fetch_message           (mu_message_t, unsigned long, unsigned long);
-static int fetch_header            (mu_message_t, unsigned long, unsigned long);
-static int fetch_body_content      (mu_message_t, unsigned long, unsigned long);
-static int fetch_io                (mu_stream_t, unsigned long, unsigned long, unsigned long);
-static int fetch_header_fields     (mu_message_t, char **, unsigned long, unsigned long);
-static int fetch_header_fields_not (mu_message_t, char **, unsigned long, unsigned long);
-static int fetch_send_address      (const char *);
-
-static struct fetch_command* fetch_getcommand (char *, struct fetch_command*);
-
-struct fetch_command
+struct fetch_runtime_closure
 {
 {
-  const char *name;
-  int (*func) (struct fetch_command *, char **);
+  int eltno;
+  size_t msgno;
   mu_message_t msg;
   mu_message_t msg;
-} fetch_command_table [] =
-{
-#define F_ALL 0
-  {"ALL", fetch_all, 0},
-#define F_FULL 1
-  {"FULL", fetch_full, 0},
-#define F_FAST 2
-  {"FAST", fetch_fast, 0},
-#define F_ENVELOPE 3
-  {"ENVELOPE", fetch_envelope, 0},
-#define F_FLAGS 4
-  {"FLAGS", fetch_flags, 0},
-#define F_INTERNALDATE 5
-  {"INTERNALDATE", fetch_internaldate, 0},
-#define F_RFC822_HEADER 6
-   {"RFC822.HEADER", fetch_rfc822_header, 0},
-#define F_RFC822_SIZE 7
-  {"RFC822.SIZE", fetch_rfc822_size, 0},
-#define F_RFC822_TEXT 8
-  {"RFC822.TEXT", fetch_rfc822_text, 0},
-#define F_RFC822 9
-  {"RFC822", fetch_rfc822, 0},
-#define F_BODYSTRUCTURE 10
-  {"BODYSTRUCTURE", fetch_bodystructure, 0},
-#define F_BODY 11
-  {"BODY", fetch_body, 0},
-#define F_UID 12
-  {"UID", fetch_uid, 0},
-  { NULL, 0, 0}
+  char *err_text;
 };
 };
 
 
-/* Go through the fetch array sub command and returns the the structure.  */
-
-static struct fetch_command *
-fetch_getcommand (char *cmd, struct fetch_command *command_table)
-{
-  size_t i, len = strlen (cmd);
+struct fetch_function_closure;
 
 
-  for (i = 0; command_table[i].name != 0; i++)
-    {
-      if (strlen (command_table[i].name) == len &&
-          !strcasecmp (command_table[i].name, cmd))
-        return &command_table[i];
-    }
-  return NULL;
-}
+typedef int (*fetch_function_t) (struct fetch_function_closure *,
+				 struct fetch_runtime_closure *);
 
 
-/* The FETCH command retrieves data associated with a message in the
-   mailbox.  The data items to be fetched can be either a single atom
-   or a parenthesized list.  */
-int
-imap4d_fetch (struct imap4d_command *command, char *arg)
+struct fetch_function_closure
 {
 {
-  int rc;
-  char buffer[64];
+  fetch_function_t fun;            /* Handler function */
+  const char *name;                /* Response tag */
+  size_t *section_part;            /* Section-part */
+  size_t nset;                     /* Number of elements in section_part */
+  int peek;
+  int not;                         /* Negate header set */  
+  mu_list_t headers;               /* Headers */
+  size_t start;                    /* Substring start */ 
+  size_t size;                     /* Substring length */
+};
 
 
-  rc = imap4d_fetch0 (arg, 0, buffer, sizeof buffer);
-  return util_finish (command, rc, "%s", buffer);
-}
 
 
-/* Where the real implementation is.  It is here since UID command also
-   calls FETCH.  */
-int
-imap4d_fetch0 (char *arg, int isuid, char *resp, size_t resplen)
+static int
+fetch_send_address (const char *addr)
 {
 {
-  struct fetch_command *fcmd = NULL;
-  int rc = RESP_OK;
-  char *sp = NULL;
-  char *msgset;
-  size_t *set = NULL;
-  int n = 0;
-  int i;
-  int status;
-
-  msgset = util_getword (arg, &sp);
-  if (!msgset || !sp || *sp == '\0')
-    {
-      snprintf (resp, resplen, "Too few args");
-      return RESP_BAD;
-    }
+  mu_address_t address;
+  size_t i, count = 0;
 
 
-  /* Get the message numbers in set[].  */
-  status = util_msgset (msgset, &set, &n, isuid);
-  if (status != 0)
+  /* Short circuit.  */
+  if (addr == NULL || *addr == '\0')
     {
     {
-      snprintf (resp, resplen, "Bogus number set");
-      return RESP_BAD;
+      util_send ("NIL");
+      return RESP_OK;
     }
     }
 
 
-  /* Prepare status code. It will be replaced if an error occurs in the
-     loop below */
-  snprintf (resp, resplen, "Completed");
-  
-  for (i = 0; i < n && rc == RESP_OK; i++)
-    {
-      size_t msgno = (isuid) ? uid_to_msgno (set[i]) : set[i];
-      mu_message_t msg = NULL;
-
-      if (msgno && mu_mailbox_get_message (mbox, msgno, &msg) == 0)
-	{
-	  char item[32];
-	  char *items = strdup (sp);
-	  char *p = items;
-	  int space = 0;
+  mu_address_create (&address, addr);
+  mu_address_get_count (address, &count);
 
 
-	  fcmd = NULL;
-	  util_send ("* %s FETCH (", mu_umaxtostr (0, msgno));
-	  item[0] = '\0';
-	  /* Server implementations MUST implicitly
-	     include the UID message data item as part of any FETCH
-	     response caused by a UID command, regardless of whether
-	     a UID was specified as a message data item to the FETCH. */
-	  if (isuid)
-	    {
-	      fcmd = &fetch_command_table[F_UID];
-	      fcmd->msg = msg;
-	      rc = fetch_uid (fcmd, &items);
-	    }
-	  /* Get the fetch command names.  */
-	  while (*items && *items != ')')
-	    {
-	      util_token (item, sizeof (item), &items);
-	      /* Do not send the UID again.  */
-	      if (isuid && strcasecmp (item, "UID") == 0)
-		continue;
-	      if (fcmd)
-		space = 1;
-	      /* Search in the table.  */
-	      fcmd = fetch_getcommand (item, fetch_command_table);
-	      if (fcmd)
-		{
-		  if (space)
-		    {
-		      util_send (" ");
-		      space = 0;
-		    }
-		  fcmd->msg = msg;
-		  rc = fcmd->func (fcmd, &items);
-		}
-	    }
-	  util_send (")\r\n");
-	  free (p);
-	}
-      else if (!isuid)
-	/* According to RFC 3501, "A non-existent unique identifier is
-	   ignored without any error message generated." */
+  /* We failed: can't parse.  */
+  if (count == 0)
     {
     {
-	  snprintf (resp, resplen,
-		    "Bogus message set: message number out of range");
-	  rc = RESP_BAD;
-	  break;
-	}
+      util_send ("NIL");
+      return RESP_OK;
     }
     }
-  free (set);
-  return rc;
-}
 
 
-/* ALL:
-   Macro equivalent to: (FLAGS INTERNALDATE RFC822.SIZE ENVELOPE)
-   Combination of FAST and ENVELOPE.  */
-static int
-fetch_all (struct fetch_command *command, char **arg)
-{
-  struct fetch_command c_env = fetch_command_table[F_ENVELOPE];
-  fetch_fast (command, arg);
-  util_send (" ");
-  c_env.msg = command->msg;
-  fetch_envelope (&c_env, arg);
-  return RESP_OK;
-}
+  util_send ("(");
+  for (i = 1; i <= count; i++)
+    {
+      const char *str;
+      int is_group = 0;
 
 
-/* FULL:
-   Macro equivalent to: (FLAGS INTERNALDATE
-   RFC822.SIZE ENVELOPE BODY).
-   Combination of (ALL BODY).  */
-static int
-fetch_full (struct fetch_command *command, char **arg)
-{
-  struct fetch_command c_body = fetch_command_table[F_BODY];
-  fetch_all (command, arg);
-  util_send (" ");
-  c_body.msg = command->msg;
-  return fetch_body (&c_body, arg);
-}
+      util_send ("(");
 
 
-/* FAST:
-   Macro equivalent to: (FLAGS INTERNALDATE RFC822.SIZE)
-   Combination of (FLAGS INTERNALDATE RFC822.SIZE).  */
-static int
-fetch_fast (struct fetch_command *command, char **arg)
-{
-  struct fetch_command c_idate = fetch_command_table[F_INTERNALDATE];
-  struct fetch_command c_rfc = fetch_command_table[F_RFC822_SIZE];
-  struct fetch_command c_flags = fetch_command_table[F_FLAGS];
-  c_flags.msg = command->msg;
-  fetch_flags (&c_flags, arg);
-  util_send (" ");
-  c_idate.msg = command->msg;
-  fetch_internaldate (&c_idate, arg);
+      mu_address_sget_personal (address, i, &str);
+      util_send_qstring (str);
       util_send (" ");
       util_send (" ");
-  c_rfc.msg = command->msg;
-  fetch_rfc822_size (&c_rfc, arg);
-  return RESP_OK;
-}
-
-/* ENVELOPE:
-   Header: Date, Subject, From, Sender, Reply-To, To, Cc, Bcc, In-Reply-To,
-   and Message-Id.  */
-static int
-fetch_envelope (struct fetch_command *command, char **arg MU_ARG_UNUSED)
-{
-  int status;
-  util_send ("%s (", command->name);
-  status = fetch_envelope0 (command->msg);
-  util_send (")");
-  return status;
-}
 
 
-/* FLAGS: The flags that are set for this message.  */
-/* FIXME: User flags not done. If enable change the PERMANENTFLAGS in SELECT */
-void
-fetch_flags0 (const char *prefix, mu_message_t msg, int isuid)
-{
-  mu_attribute_t attr = NULL;
+      mu_address_sget_route (address, i, &str);
+      util_send_qstring (str);
 
 
-  mu_message_get_attribute (msg, &attr);
-  if (isuid)
-    {
-      struct fetch_command *fcmd = &fetch_command_table[F_UID];
-      fcmd->msg = msg;
-      fetch_uid (fcmd, NULL);
       util_send (" ");
       util_send (" ");
-    }
-  util_send ("%s (", prefix);
-  util_print_flags(attr);
-  util_send (")");
-}
-
-static int
-fetch_flags (struct fetch_command *command, char **arg)
-{
-  fetch_flags0 (command->name, command->msg, 0);
-  return RESP_OK;
-}
-
-
-/* INTERNALDATE   The internal date of the message.
-   Format:
-
-   date_time       ::= <"> date_day_fixed "-" date_month "-" date_year
-   SPACE time SPACE zone <">
-
-   date_day        ::= 1*2digit
-   ;; Day of month
-
-   date_day_fixed  ::= (SPACE digit) / 2digit
-   ;; Fixed-format version of date_day
-
-   date_month      ::= "Jan" / "Feb" / "Mar" / "Apr" / "May" / "Jun" /
-   "Jul" / "Aug" / "Sep" / "Oct" / "Nov" / "Dec"
-
-   date_text       ::= date_day "-" date_month "-" date_year
-
-   date_year       ::= 4digit
-
-   time            ::= 2digit ":" 2digit ":" 2digit
-   ;; Hours minutes seconds
-
-   zone            ::= ("+" / "-") 4digit
-   ;; Signed four-digit value of hhmm representing
-   ;; hours and minutes west of Greenwich (that is,
-   ;; (the amount that the given time differs from
-   ;; Universal Time).  Subtracting the timezone
-   ;; from the given time will give the UT form.
-   ;; The Universal Time zone is "+0000".  */
-static int
-fetch_internaldate (struct fetch_command *command, char **arg MU_ARG_UNUSED)
-{
-  const char *date;
-  mu_envelope_t env = NULL;
-  struct tm tm, *tmp = NULL;
-  mu_timezone tz;
-  char datebuf[sizeof ("13-Jul-2002 00:00:00")];
 
 
-  mu_message_get_envelope (command->msg, &env);
-  if (mu_envelope_sget_date (env, &date) == 0
-      && mu_parse_ctime_date_time (&date, &tm, &tz) == 0)
-    tmp = &tm;
+      mu_address_is_group (address, i, &is_group);
+      str = NULL;
+      if (is_group)
+	mu_address_sget_personal (address, i, &str);
       else
       else
-    {
-      time_t t = time (NULL);
-      tmp = localtime (&t);
-    }
-  mu_strftime (datebuf, sizeof (datebuf), "%d-%b-%Y %H:%M:%S", tmp);
-  util_send ("%s", command->name);
-  util_send (" \"%s +0000\"", datebuf);
-  return RESP_OK;
-}
-
-/*
-  RFC822.HEADER:
-  Functionally equivalent to BODY.PEEK[HEADER], differing in the syntax of
-  the resulting untagged FETCH data (RFC822.HEADER is returned). */
-static int
-fetch_rfc822_header (struct fetch_command *command, char **arg MU_ARG_UNUSED)
-{
-  char buffer[32];
-  char *p = buffer;
-
-  strcpy (buffer, ".PEEK[HEADER]");
-  return fetch_body (command, &p);
-}
-
-/* RFC822.TEXT:
-   Functionally equivalent to BODY[TEXT], differing in the syntax of the
-   resulting untagged FETCH data (RFC822.TEXT is returned). */
-static int
-fetch_rfc822_text (struct fetch_command *command, char **arg MU_ARG_UNUSED)
-{
-  char buffer[16];
-  char *p = buffer;
-
-  strcpy (buffer, "[TEXT]");
-  return fetch_body (command, &p);
-}
-
-/* The [RFC-822] size of the message.  */
-static int
-fetch_rfc822_size (struct fetch_command *command, char **arg MU_ARG_UNUSED)
-{
-  size_t size = 0;
-  size_t lines = 0;
-  
-  mu_message_size (command->msg, &size);
-  mu_message_lines (command->msg, &lines);
-  util_send ("%s %u", command->name, size + lines);
-  return RESP_OK;
-}
+	mu_address_sget_local_part (address, i, &str);
 
 
-/* RFC822:
-   Functionally equivalent to BODY[], differing in the syntax of the
-   resulting untagged FETCH data (RFC822 is returned). */
-static int
-fetch_rfc822 (struct fetch_command *command, char **arg)
-{
-  if (**arg == '.')
-    {
-      /* We have to catch the other RFC822.XXX commands here.  This is because
-	 util_token() in imap4d_fetch0 will return the RFC822 token only.  */
-      if (strncasecmp (*arg, ".SIZE", 5) == 0)
-	{
-	  struct fetch_command c_rfc= fetch_command_table[F_RFC822_SIZE];
-	  c_rfc.msg = command->msg;
-	  (*arg) += 5;
-	  fetch_rfc822_size (&c_rfc, arg);
-	}
-      else if (strncasecmp (*arg, ".TEXT", 5) == 0)
-	{
-	  struct fetch_command c_rfc = fetch_command_table[F_RFC822_TEXT];
-	  c_rfc.msg = command->msg;
-	  (*arg) += 5;
-	  fetch_rfc822_text (&c_rfc, arg);
-	}
-      else if (strncasecmp (*arg, ".HEADER", 7) == 0)
-	{
-	  struct fetch_command c_rfc = fetch_command_table[F_RFC822_HEADER];
-	  c_rfc.msg = command->msg;
-	  (*arg) += 7;
-	  fetch_rfc822_header (&c_rfc, arg);
-	}
-    }
-  else
-    {
-      char buffer[16];
-      char *p = buffer;
-      strcpy (buffer, "[]");
-      fetch_body (command, &p);
-    }
-  return RESP_OK;
-}
+      util_send_qstring (str);
 
 
-/* UID: The unique identifier for the message.  */
-static int
-fetch_uid (struct fetch_command *command, char **arg MU_ARG_UNUSED)
-{
-  size_t uid = 0;
+      util_send (" ");
 
 
-  mu_message_get_uid (command->msg, &uid);
-  util_send ("%s %s", command->name, mu_umaxtostr (0, uid));
-  return RESP_OK;
-}
+      mu_address_sget_domain (address, i, &str);
+      util_send_qstring (str);
 
 
-/* BODYSTRUCTURE:
-   The [MIME-IMB] body structure of the message.  This is computed by the
-   server by parsing the [MIME-IMB] header fields in the [RFC-822] header and
-   [MIME-IMB] headers.  */
-static int
-fetch_bodystructure (struct fetch_command *command, char **arg MU_ARG_UNUSED)
-{
-  util_send ("%s (", command->name);
-  fetch_bodystructure0 (command->msg, 1); /* 1 means with extension data.  */
       util_send (")");
       util_send (")");
-  return RESP_OK;
-}
-
-/* BODY:          Non-extensible form of BODYSTRUCTURE.
-   BODY[<section>]<<partial>> :
-   The text of a particular body section.  The section specification is a set
-   of zero or more part specifiers delimited by periods.  A part specifier
-   is either a part number or one of the following: HEADER, HEADER.FIELDS,
-   HEADER.FIELDS.NOT, MIME, and TEXT.  An empty section specification refers
-   to the entire message, including the header.
-
-   Note: for body section, the \Seen flag is implicitly set;
-         if this causes the flags to change they SHOULD be
-	 included as part of the FETCH responses. */
-static int
-fetch_body (struct fetch_command *command, char **arg)
-{
-  /* It's body section, set the message as seen  */
-  if (**arg == '[')
-    {
-      mu_attribute_t attr = NULL;
-      mu_message_get_attribute (command->msg, &attr);
-      if (!mu_attribute_is_read (attr))
-	{
-	  util_send ("FLAGS (\\Seen) ");
-	  mu_attribute_set_read (attr);
-	}
-    }
-  else if (strncasecmp (*arg,".PEEK", 5) == 0)
-    {
-      /* Move pass the .peek  */
-      (*arg) += 5;
-      while (isspace ((unsigned)**arg))
-	(*arg)++;
     }
     }
-  else if (**arg != '[' && **arg != '.')
-    {
-      /* Call body structure without the extension.  */
-      util_send ("%s (", command->name);
-      fetch_bodystructure0 (command->msg, 0);
   util_send (")");
   util_send (")");
   return RESP_OK;
   return RESP_OK;
-    }
-  util_send ("%s", command->name);
-  return fetch_operation (command->msg, arg,
-			  strcasecmp (command->name, "BODY"));
 }
 }
 
 
-/* Helper Functions: Where the Beef is.  */
-
 static void
 static void
 fetch_send_header_value (mu_header_t header, const char *name,
 fetch_send_header_value (mu_header_t header, const char *name,
 			 const char *defval, int space)
 			 const char *defval, int space)
@@ -543,7 +139,7 @@ fetch_send_header_value (mu_header_t header, const char *name,
 }
 }
 
 
 static void
 static void
-fetch_send_header_list (mu_header_t header, const char *name,
+fetch_send_header_address (mu_header_t header, const char *name,
 			   const char *defval, int space)
 			   const char *defval, int space)
 {
 {
   char *buffer;
   char *buffer;
@@ -552,146 +148,47 @@ fetch_send_header_list (mu_header_t header, const char *name,
     util_send (" ");
     util_send (" ");
   if (mu_header_aget_value (header, name, &buffer) == 0)
   if (mu_header_aget_value (header, name, &buffer) == 0)
     {
     {
-      send_parameter_list (buffer);
+      fetch_send_address (buffer);
       free (buffer);
       free (buffer);
     }
     }
-  else if (defval)
-    send_parameter_list (defval);
   else
   else
-    util_send ("NIL");
+    fetch_send_address (defval);
 }
 }
 
 
+/* Send parameter list for the bodystructure.  */
 static void
 static void
-fetch_send_header_address (mu_header_t header, const char *name,
-			   const char *defval, int space)
+send_parameter_list (const char *buffer)
 {
 {
-  char *buffer;
+  int argc = 0;
+  char **argv;
   
   
-  if (space)
-    util_send (" ");
-  if (mu_header_aget_value (header, name, &buffer) == 0)
+  if (!buffer)
     {
     {
-      fetch_send_address (buffer);
-      free (buffer);
+      util_send ("NIL");
+      return;
     }
     }
-  else
-    fetch_send_address (defval);
-}
-
-/* ENVELOPE:
-   The envelope structure of the message.  This is computed by the server by
-   parsing the [RFC-822] header into the component parts, defaulting various
-   fields as necessary.  The fields are presented in the order:
-   Date, Subject, From, Sender, Reply-To, To, Cc, Bcc, In-Reply-To, Message-ID.
-   Any field of an envelope or address structure that is not applicable is
-   presented as NIL.  Note that the server MUST default the reply-to and sender
-   fields from the from field.  The date, subject, in-reply-to, and message-id
-   fields are strings.  The from, sender, reply-to, to, cc, and bcc fields
-   are parenthesized lists of address structures.  */
-static int
-fetch_envelope0 (mu_message_t msg)
-{
-  char *from = NULL;
-  mu_header_t header = NULL;
-
-  mu_message_get_header (msg, &header);
-
-  fetch_send_header_value (header, "Date", NULL, 0);
-  fetch_send_header_value (header, "Subject", NULL, 1);
-
-  /* From:  */
-  mu_header_aget_value (header, "From", &from);
-  util_send (" ");
-  fetch_send_address (from);
-
-  fetch_send_header_address (header, "Sender", from, 1);
-  fetch_send_header_address (header, "Reply-to", from, 1);
-  fetch_send_header_address (header, "To", NULL, 1);
-  fetch_send_header_address (header, "Cc", NULL, 1);
-  fetch_send_header_address (header, "Bcc", NULL, 1);
-  fetch_send_header_value (header, "In-Reply-To", NULL, 1);
-  fetch_send_header_value (header, "Message-ID", NULL, 1);
-
-  free (from);
-  return RESP_OK;
-}
-
-/* The beef BODYSTRUCTURE.
-   A parenthesized list that describes the [MIME-IMB] body structure of a
-   message. Multiple parts are indicated by parenthesis nesting.  Instead of
-   a body type as the first element of the parenthesized list there is a nested
-   body.  The second element of the parenthesized list is the multipart
-   subtype (mixed, digest, parallel, alternative, etc.).
-
-   The extension data of a multipart body part are in the following order:
-   body parameter parenthesized list:
-   A parenthesized list of attribute/value pairs [e.g. ("foo" "bar" "baz"
-   "rag") where "bar" is the value of "foo" and "rag" is the value of
-   "baz"] as defined in [MIME-IMB].
-
-   body disposition:
-   A parenthesized list, consisting of a disposition type string followed by a
-   parenthesized list of disposition attribute/value pairs.  The disposition
-   type and attribute names will be defined in a future standards-track
-   revision to [DISPOSITION].
 
 
-   body language:
-   A string or parenthesized list giving the body language value as defined
-   in [LANGUAGE-TAGS].  */
-static int
-fetch_bodystructure0 (mu_message_t message, int extension)
-{
-  size_t nparts = 1;
-  size_t i;
-  int is_multipart = 0;
+  mu_argcv_get (buffer, " \t\r\n;=", NULL, &argc, &argv);
   
   
-  mu_message_is_multipart (message, &is_multipart);
-  if (is_multipart)
+  if (argc == 0)
+    util_send ("NIL");
+  else
     {
     {
-      char *buffer = NULL;
-      mu_header_t header = NULL;
-
-      mu_message_get_num_parts (message, &nparts);
+      char *p;
       
       
-      /* Get all the sub messages.  */
-      for (i = 1; i <= nparts; i++)
-        {
-          mu_message_t msg = NULL;
-          mu_message_get_part (message, i, &msg);
       util_send ("(");
       util_send ("(");
-          fetch_bodystructure0 (msg, extension);
-          util_send (")");
-        } /* for () */
-
-      mu_message_get_header (message, &header);
         
         
+      p = argv[0];
+      util_send_qstring (p);
 
 
-      /* The subtype.  */
-      if (mu_header_aget_value (header, MU_HEADER_CONTENT_TYPE, &buffer) == 0)
-	{
-	  int argc = 0;
-	  char **argv;
-	  char *s;
-	  
-	  mu_argcv_get (buffer, " \t\r\n;=", NULL, &argc, &argv);
-
-	  s = strchr (argv[0], '/');
-	  if (s)
-	    s++;
-	  util_send (" ");
-	  util_send_qstring (s);
-
-	  /* The extension data for multipart. */
-	  if (extension)
+      if (argc > 1)
 	{
 	{
-	      int space = 0;
+	  int i, space = 0;
 	  char *lvalue = NULL;
 	  char *lvalue = NULL;
 
 
-	      util_send (" (");
+	  util_send ("(");
 	  for (i = 1; i < argc; i++)
 	  for (i = 1; i < argc; i++)
 	    {
 	    {
-		  /* body parameter parenthesized list:
-		     Content-type parameter list. */
 	      if (lvalue)
 	      if (lvalue)
 		{
 		{
 		  if (space)
 		  if (space)
@@ -711,7 +208,6 @@ fetch_bodystructure0 (mu_message_t message, int extension)
 		    {
 		    {
 		      char *p = argv[i];
 		      char *p = argv[i];
 		      util_send (" ");
 		      util_send (" ");
-			  util_unquote (&p);
 		      util_send_qstring (p);
 		      util_send_qstring (p);
 		    }
 		    }
 		  break;
 		  break;
@@ -730,22 +226,65 @@ fetch_bodystructure0 (mu_message_t message, int extension)
 	}
 	}
       else
       else
 	util_send (" NIL");
 	util_send (" NIL");
+      util_send (")");
+    }
   mu_argcv_free (argc, argv);
   mu_argcv_free (argc, argv);
+}
+
+static void
+fetch_send_header_list (mu_header_t header, const char *name,
+			const char *defval, int space)
+{
+  char *buffer;
+  
+  if (space)
+    util_send (" ");
+  if (mu_header_aget_value (header, name, &buffer) == 0)
+    {
+      send_parameter_list (buffer);
       free (buffer);
       free (buffer);
     }
     }
+  else if (defval)
+    send_parameter_list (defval);
   else
   else
-	/* No content-type header */
-	util_send (" NIL");
+    util_send ("NIL");
+}
 
 
-      /* body disposition: Content-Disposition.  */
-      fetch_send_header_list (header, MU_HEADER_CONTENT_DISPOSITION,
-			      NULL, 1);
-      /* body language: Content-Language.  */
-      fetch_send_header_list (header, MU_HEADER_CONTENT_LANGUAGE,
-			      NULL, 1);
-    }
-  else
-    bodystructure (message, extension);
+/* ENVELOPE:
+   The envelope structure of the message.  This is computed by the server by
+   parsing the [RFC-822] header into the component parts, defaulting various
+   fields as necessary.  The fields are presented in the order:
+   Date, Subject, From, Sender, Reply-To, To, Cc, Bcc, In-Reply-To, Message-ID.
+   Any field of an envelope or address structure that is not applicable is
+   presented as NIL.  Note that the server MUST default the reply-to and sender
+   fields from the from field.  The date, subject, in-reply-to, and message-id
+   fields are strings.  The from, sender, reply-to, to, cc, and bcc fields
+   are parenthesized lists of address structures.  */
+static int
+fetch_envelope0 (mu_message_t msg)
+{
+  char *from = NULL;
+  mu_header_t header = NULL;
+
+  mu_message_get_header (msg, &header);
+
+  fetch_send_header_value (header, "Date", NULL, 0);
+  fetch_send_header_value (header, "Subject", NULL, 1);
+
+  /* From:  */
+  mu_header_aget_value (header, "From", &from);
+  util_send (" ");
+  fetch_send_address (from);
+
+  fetch_send_header_address (header, "Sender", from, 1);
+  fetch_send_header_address (header, "Reply-to", from, 1);
+  fetch_send_header_address (header, "To", NULL, 1);
+  fetch_send_header_address (header, "Cc", NULL, 1);
+  fetch_send_header_address (header, "Bcc", NULL, 1);
+  fetch_send_header_value (header, "In-Reply-To", NULL, 1);
+  fetch_send_header_value (header, "Message-ID", NULL, 1);
+
+  free (from);
   return RESP_OK;
   return RESP_OK;
 }
 }
 
 
@@ -857,7 +396,6 @@ bodystructure (mu_message_t msg, int extension)
 		    {
 		    {
 		      char *p = argv[i];
 		      char *p = argv[i];
 		      util_send (" ");
 		      util_send (" ");
-		      util_unquote (&p);
 		      util_send_qstring (p);
 		      util_send_qstring (p);
 		    }
 		    }
 		  break;
 		  break;
@@ -955,195 +493,187 @@ bodystructure (mu_message_t msg, int extension)
   return RESP_OK;
   return RESP_OK;
 }
 }
 
 
+/* The beef BODYSTRUCTURE.
+   A parenthesized list that describes the [MIME-IMB] body structure of a
+   message. Multiple parts are indicated by parenthesis nesting.  Instead of
+   a body type as the first element of the parenthesized list there is a nested
+   body.  The second element of the parenthesized list is the multipart
+   subtype (mixed, digest, parallel, alternative, etc.).
+
+   The extension data of a multipart body part are in the following order:
+   body parameter parenthesized list:
+   A parenthesized list of attribute/value pairs [e.g. ("foo" "bar" "baz"
+   "rag") where "bar" is the value of "foo" and "rag" is the value of
+   "baz"] as defined in [MIME-IMB].
+
+   body disposition:
+   A parenthesized list, consisting of a disposition type string followed by a
+   parenthesized list of disposition attribute/value pairs.  The disposition
+   type and attribute names will be defined in a future standards-track
+   revision to [DISPOSITION].
+
+   body language:
+   A string or parenthesized list giving the body language value as defined
+   in [LANGUAGE-TAGS].  */
 static int
 static int
-fetch_operation (mu_message_t msg, char **arg, int silent)
+fetch_bodystructure0 (mu_message_t message, int extension)
 {
 {
-  unsigned long start = ULONG_MAX; /* No starting offset.  */
-  unsigned long end = ULONG_MAX; /* No limit. */
-  char *section; /* Hold the section number string.  */
-  char *partial = strchr (*arg, '<');
-  int rc;
+  size_t nparts = 1;
+  size_t i;
+  int is_multipart = 0;
 
 
-  /* Check for section specific offset.  */
-  if (partial)
-    {
-      /* NOTE: should this should be move in imap4d_fetch() and have a more
-	 draconian check?  */
-      *partial = '\0';
-      partial++;
-      start = strtoul (partial, &partial, 10);
-      if (*partial == '.')
+  mu_message_is_multipart (message, &is_multipart);
+  if (is_multipart)
     {
     {
-	  partial++;
-	  end = strtoul (partial, NULL, 10);
-	}
-    }
+      char *buffer = NULL;
+      mu_header_t header = NULL;
 
 
-  /* Pass the first bracket '['  */
-  (*arg)++;
-  section = *arg;
+      mu_message_get_num_parts (message, &nparts);
 
 
-  /* Retreive the section message.  */
-  while (isdigit ((unsigned)**arg))
+      /* Get all the sub messages.  */
+      for (i = 1; i <= nparts; i++)
         {
         {
-      unsigned long j = strtoul (*arg, arg, 10);
-      int status;
+          mu_message_t msg = NULL;
+          mu_message_get_part (message, i, &msg);
+          util_send ("(");
+          fetch_bodystructure0 (msg, extension);
+          util_send (")");
+        } /* for () */
 
 
-      /* Wrong section message number bail out.  */
-      if (j == 0 || j == ULONG_MAX) /* Technical: I should check errno too.  */
-	break;
+      mu_message_get_header (message, &header);
 
 
-      /* If the section message did not exist bail out here.  */
-      status = mu_message_get_part (msg, j, &msg);
-      if (status != 0)
-	{
-	  util_send (" \"\"");
-	  return RESP_OK;
-	}
-      if (**arg == '.')
-	(*arg)++;
-      else
-	break;
-    }
 
 
-  /* Did we have a section message?  */
-  if (((*arg) - section) > 0)
+      /* The subtype.  */
+      if (mu_header_aget_value (header, MU_HEADER_CONTENT_TYPE, &buffer) == 0)
 	{
 	{
-      char *p = section;
-      section = calloc ((*arg) - p + 1, 1);
-      if (section)
-	memcpy (section, p, (*arg) - p);
-    }
-  else
-    section = calloc (1, 1);
+	  int argc = 0;
+	  char **argv;
+	  char *s;
 	  
 	  
-  rc = RESP_OK;
+	  mu_argcv_get (buffer, " \t\r\n;=", NULL, &argc, &argv);
 
 
-  /* Choose the right fetch attribute.  */
-  if (*section == '\0' && **arg == ']')
-    {
-      if (!silent)
-	util_send ("[]");
-      (*arg)++;
-      rc = fetch_message (msg, start, end);
-    }
-  else if (strncasecmp (*arg, "HEADER]", 7) == 0)
-    {
-      if (!silent)
-	{
-	  /* NOTE: We violate the RFC here: Header cannot take a prefix for
-	     section messages it only referes to the RFC822 header .. ok
-	     see it as an extension. But according to IMAP4 we should
-	     have send an empty string: util_send (" \"\"");
-	  */
-	  util_send ("[%sHEADER]", section);
-	}
-      (*arg) += 7;
-      rc = fetch_header (msg, start, end);
-    }
-  else if (strncasecmp (*arg, "MIME]", 5) == 0)
-    {
-      if (!silent)
+	  s = strchr (argv[0], '/');
+	  if (s)
+	    s++;
+	  util_send (" ");
+	  util_send_qstring (s);
+
+	  /* The extension data for multipart. */
+	  if (extension)
 	    {
 	    {
-	  if (*section)
-	    util_send ("[%sMIME]", section);
-	  else
-	    util_send ("[%s", *arg);
-	}
-      (*arg) += 5;
-      rc = fetch_header (msg, start, end);
-    }
-  else if (strncasecmp (*arg, "HEADER.FIELDS.NOT", 17) == 0)
+	      int space = 0;
+	      char *lvalue = NULL;
+	      
+	      util_send (" (");
+	      for (i = 1; i < argc; i++)
 		{
 		{
-      /* NOTE: we should flag an error if section is not empty: accept
-	 as an extension for now.  */
-      if (*section)
-	util_send ("[%s", section);
-      else
-	util_send ("[");
-      (*arg) += 17;
-      rc = fetch_header_fields_not (msg, arg, start, end);
-    }
-  else if (strncasecmp (*arg, "HEADER.FIELDS", 13) == 0)
+		  /* body parameter parenthesized list:
+		     Content-type parameter list. */
+		  if (lvalue)
 		    {
 		    {
-      /* NOTE: we should flag an error if section is not empty: accept
-	 as an extension for now.  */
-      if (*section)
-	util_send ("[%s", section);
-      else
-	util_send ("[");
-      (*arg) += 13;
-      rc = fetch_header_fields (msg, arg, start, end);
+		      if (space)
+			util_send (" ");
+		      util_send_qstring (lvalue);
+		      lvalue = NULL;
+		      space = 1;
 		    }
 		    }
 
 
-  else if (strncasecmp (*arg, "TEXT]", 5) == 0)
+		  switch (argv[i][0])
 		    {
 		    {
-      if (!silent)
+		    case ';':
+		      continue;
+		      
+		    case '=':
+		      if (++i < argc)
 			{
 			{
-	  if (*section)
-	    util_send ("[%sTEXT]", section);
-	  else
-	    util_send ("[TEXT]");
+			  char *p = argv[i];
+			  util_send (" ");
+			  util_send_qstring (p);
+			}
+		      break;
+		      
+		    default:
+		      lvalue = argv[i];
 		    }
 		    }
-      (*arg) += 5;
-      rc = fetch_body_content (msg, start, end);
 		}
 		}
-  else if (**arg == ']')
+	      if (lvalue)
 		{
 		{
-      if (!silent)
-	util_send ("[%s]", section);
-      (*arg)++;
-      rc = fetch_body_content (msg, start, end);
+		  if (space)
+		    util_send (" ");
+		  util_send_qstring (lvalue);
+		}
+	      util_send (")");
 	    }
 	    }
 	  else
 	  else
-    {
-      util_send (" \"\"");/*FIXME: ERROR Message!*/
-      rc = RESP_BAD;
+	    util_send (" NIL");
+	  mu_argcv_free (argc, argv);
+          free (buffer);
 	}
 	}
-  free (section);
-  return rc;
+      else
+	/* No content-type header */
+	util_send (" NIL");
+
+      /* body disposition: Content-Disposition.  */
+      fetch_send_header_list (header, MU_HEADER_CONTENT_DISPOSITION,
+			      NULL, 1);
+      /* body language: Content-Language.  */
+      fetch_send_header_list (header, MU_HEADER_CONTENT_LANGUAGE,
+			      NULL, 1);
+    }
+  else
+    bodystructure (message, extension);
+  return RESP_OK;
 }
 }
 
 
-static int
-fetch_message (mu_message_t msg, unsigned long start, unsigned long end)
+static void
+set_seen (struct fetch_function_closure *ffc,
+	  struct fetch_runtime_closure *frt)
 {
 {
-  mu_stream_t stream = NULL;
-  size_t size = 0, lines = 0;
-  mu_message_get_stream (msg, &stream);
-  mu_message_size (msg, &size);
-  mu_message_lines (msg, &lines);
-  return fetch_io (stream, start, end, size + lines);
+  if (!ffc->peek)
+    {
+      mu_attribute_t attr = NULL;
+      mu_message_get_attribute (frt->msg, &attr);
+      if (!mu_attribute_is_read (attr))
+	{
+	  util_send ("FLAGS (\\Seen) ");
+	  mu_attribute_set_read (attr);
+	}
+    }
 }
 }
 
 
-static int
-fetch_header (mu_message_t msg, unsigned long start, unsigned long end)
+static mu_message_t 
+fetch_get_part (struct fetch_function_closure *ffc,
+		struct fetch_runtime_closure *frt)
 {
 {
-  mu_header_t header = NULL;
-  mu_stream_t stream = NULL;
-  size_t size = 0, lines = 0;
-  mu_message_get_header (msg, &header);
-  mu_header_size (header, &size);
-  mu_header_lines (header, &lines);
-  mu_header_get_stream (header, &stream);
-  return fetch_io (stream, start, end, size + lines);
+  mu_message_t msg = frt->msg;
+  size_t i;
+
+  for (i = 0; i < ffc->nset; i++)
+    if (mu_message_get_part (msg, ffc->section_part[i], &msg))
+      return NULL;
+  return msg;
 }
 }
 
 
-static int
-fetch_body_content (mu_message_t msg, unsigned long start, unsigned long end)
+static void
+fetch_send_section_part (struct fetch_function_closure *ffc,
+			 const char *prefix, const char *suffix)
 {
 {
-  mu_body_t body = NULL;
-  mu_stream_t stream = NULL;
-  size_t size = 0, lines = 0;
-  mu_message_get_body (msg, &body);
-  mu_body_size (body, &size);
-  mu_body_lines (body, &lines);
-  mu_body_get_stream (body, &stream);
-  return fetch_io (stream, start, end, size + lines);
+  int i;
+  
+  util_send ("%s", prefix);
+  for (i = 0; i < ffc->nset; i++)
+    {
+      if (i)
+	util_send (".");
+      util_send ("%lu",  (unsigned long) ffc->section_part[i]);
+    }
+  if (i && suffix[0] != ']')
+    util_send (".");
+  util_send ("%s", suffix);
 }
 }
 
 
 static int
 static int
-fetch_io (mu_stream_t stream, unsigned long start, unsigned long end,
-	  unsigned long max)
+fetch_io (mu_stream_t stream, size_t start, size_t size, size_t max)
 {
 {
   mu_stream_t rfc = NULL;
   mu_stream_t rfc = NULL;
   size_t n = 0;
   size_t n = 0;
@@ -1151,13 +681,13 @@ fetch_io (mu_stream_t stream, unsigned long start, unsigned long end,
 
 
   mu_filter_create (&rfc, stream, "rfc822", MU_FILTER_ENCODE, MU_STREAM_READ);
   mu_filter_create (&rfc, stream, "rfc822", MU_FILTER_ENCODE, MU_STREAM_READ);
 
 
-  if (start == ULONG_MAX || end == ULONG_MAX)
+  if (start == 0 && size == (size_t) -1)
     {
     {
       char buffer[512];
       char buffer[512];
       offset = 0;
       offset = 0;
       if (max)
       if (max)
 	{
 	{
-	  util_send (" {%lu}\r\n", max);
+	  util_send (" {%lu}\r\n", (unsigned long) max);
 	  while (mu_stream_read (rfc, buffer, sizeof (buffer) - 1, offset,
 	  while (mu_stream_read (rfc, buffer, sizeof (buffer) - 1, offset,
 				 &n) == 0 && n > 0)
 				 &n) == 0 && n > 0)
 	    {
 	    {
@@ -1165,11 +695,12 @@ fetch_io (mu_stream_t stream, unsigned long start, unsigned long end,
 	      util_send ("%s", buffer);
 	      util_send ("%s", buffer);
 	      offset += n;
 	      offset += n;
 	    }
 	    }
+	  /* FIXME: Make sure exactly max bytes were sent */
 	}
 	}
       else
       else
 	util_send (" \"\"");
 	util_send (" \"\"");
     }
     }
-  else if (end + 2 < end) /* Check for integer overflow */
+  else if (size + 2 < size) /* Check for integer overflow */
     {
     {
       return RESP_BAD;
       return RESP_BAD;
     }
     }
@@ -1178,393 +709,944 @@ fetch_io (mu_stream_t stream, unsigned long start, unsigned long end,
       char *buffer, *p;
       char *buffer, *p;
       size_t total = 0;
       size_t total = 0;
       offset = start;
       offset = start;
-      p = buffer = calloc (end + 2, 1);
-      while (end > 0
-	     && mu_stream_read (rfc, buffer, end + 1, offset, &n) == 0 && n > 0)
+      p = buffer = malloc (size + 1);
+      if (!p)
+	imap4d_bye (ERR_NO_MEM);
+      
+      while (total < size
+	     && mu_stream_read (rfc, p, size - total + 1, offset, &n) == 0
+	     && n > 0)
 	{
 	{
 	  offset += n;
 	  offset += n;
 	  total += n;
 	  total += n;
-	  end -= n;
-	  buffer += n;
+	  p += n;
 	}
 	}
-      /* Make sure we null terminate.  */
-      *buffer = '\0';
-      util_send ("<%lu>", start);
+      *p = 0;
+      util_send ("<%lu>", (unsigned long) start);
       if (total)
       if (total)
 	{
 	{
-	  util_send (" {%s}\r\n", mu_umaxtostr (0, total));
-	  util_send ("%s", p);
+	  util_send (" {%lu}\r\n", (unsigned long) total);
+	  util_send ("%s", buffer);
 	}
 	}
       else
       else
 	util_send (" \"\"");
 	util_send (" \"\"");
-      free (p);
+      free (buffer);
     }
     }
   return RESP_OK;
   return RESP_OK;
 }
 }
 
 
+
+/* Runtime functions */
 static int
 static int
-fetch_header_fields (mu_message_t msg, char **arg, unsigned long start,
-		     unsigned long end)
+_frt_uid (struct fetch_function_closure *ffc,
+	  struct fetch_runtime_closure *frt)
 {
 {
-  char *buffer = NULL;
-  char **array = NULL;
-  size_t array_len = 0;
-  size_t off = 0;
-  size_t lines = 0;
-  mu_stream_t stream = NULL;
-  int status;
-
-  status = mu_memory_stream_create (&stream, 0, 0);
-  if (status != 0)
-    imap4d_bye (ERR_NO_MEM);
-
-  /* Save the fields in an array.  */
-  {
-    char *field;
-    char *sp = NULL;
-    char *f = *arg;
-    /* Find the end of the header.field tag.  */
-    field = strchr (f, ']');
-    if (field)
-      {
-	*field++ = '\0';
-	*arg = field;
-      }
-    else
-      *arg += strlen (*arg);
-
-    for (;(field = util_getitem (f, " ()]\r\n", &sp)); f = NULL, array_len++)
-      {
-	array = realloc (array, (array_len + 1) * sizeof (*array));
-	if (!array)
-	  imap4d_bye (ERR_NO_MEM);
-	array[array_len] = field;
-      }
-  }
-
-  /* Get the header values.  */
-  {
-    size_t j;
-    mu_header_t header = NULL;
-    mu_message_get_header (msg, &header);
-    for (j = 0; j < array_len; j++)
-      {
-	char *value = NULL;
-	size_t n = 0;
-	if (mu_header_aget_value (header, array[j], &value))
-	    continue;
+  size_t uid = 0;
 
 
-	n = asprintf (&buffer, "%s: %s\n", array[j], value);
-	status = mu_stream_write (stream, buffer, n, off, &n);
-	off += n;
-	/* count the lines.  */
-	{
-	  char *nl = buffer;
-	  for (;(nl = strchr (nl, '\n')); nl++)
-	    lines++;
-	}
-	free (value);
-	free (buffer);
-	buffer = NULL;
-	if (status != 0)
-	  {
-	    free (array);
-	    imap4d_bye (ERR_NO_MEM);
-	  }
-      }
-  }
-  /* Headers are always sent with the NL separator.  */
-  mu_stream_write (stream, "\n", 1, off, NULL);
-  off++;
-  lines++;
+  mu_message_get_uid (frt->msg, &uid);
+  util_send ("%s %s", ffc->name, mu_umaxtostr (0, uid));
+  return RESP_OK;
+}
 
 
-  /* Send the command back. The first braket was already sent.  */
-  util_send ("HEADER.FIELDS");
-  {
-    size_t j;
-    util_send (" (");
-    for (j = 0; j < array_len; j++)
-      {
-	util_upper (array[j]);
-	if (j)
-	  util_send (" ");
-	util_send_qstring (array[j]);
-      }
+static int
+_frt_envelope (struct fetch_function_closure *ffc,
+	       struct fetch_runtime_closure *frt)
+{
+  util_send ("%s (", ffc->name);
+  fetch_envelope0 (frt->msg);
   util_send (")");
   util_send (")");
-    util_send ("]");
-  }
-
-  fetch_io (stream, start, end, off + lines);
-  if (array)
-    free (array);
   return RESP_OK;
   return RESP_OK;
 }
 }
 
 
 static int
 static int
-fetch_header_fields_not (mu_message_t msg, char **arg, unsigned long start,
-			 unsigned long end)
+_frt_flags (struct fetch_function_closure *ffc,
+	    struct fetch_runtime_closure *frt)
 {
 {
-  char **array = NULL;
-  size_t array_len = 0;
-  char *buffer = NULL;
-  size_t off = 0;
-  size_t lines = 0;
-  mu_stream_t stream = NULL;
-  int status;
+  mu_attribute_t attr = NULL;
 
 
-  status = mu_memory_stream_create (&stream, 0, 0);
-  if (status)
-    imap4d_bye (ERR_NO_MEM);
+  mu_message_get_attribute (frt->msg, &attr);
+  util_send ("%s (", ffc->name);
+  util_print_flags (attr);
+  util_send (")");
+  return 0;
+}
 
 
-  /* Save the field we want to ignore.  */
-  {
-    char *field;
-    char *sp = NULL;
-    char *f = *arg;
-    /* Find the end of the header.field.no tag.  */
-    field = strchr (f, ']');
-    if (field)
-      {
-	*field++ = '\0';
-	*arg = field;
-      }
-    else
-      *arg += strlen (*arg);
+/* INTERNALDATE   The internal date of the message.
+   Format:
 
 
-    for (;(field = strtok_r (f, " ()\r\n", &sp)); f = NULL, array_len++)
-      {
-	array = realloc (array, (array_len + 1) * sizeof (*array));
-	if (!array)
-	  imap4d_bye (ERR_NO_MEM);
-	array[array_len] = field;
-      }
-  }
+   date_time       ::= <"> date_day_fixed "-" date_month "-" date_year
+   SPACE time SPACE zone <">
 
 
-  /* Build the memory buffer.  */
-  {
-    size_t i;
-    mu_header_t header = NULL;
-    size_t count = 0;
-    mu_message_get_header (msg, &header);
-    mu_header_get_field_count (header, &count);
-    for (i = 1; i <= count; i++)
-      {
-	char *name = NULL;
-	char *value ;
-	size_t n = 0;
-	size_t ignore = 0;
+   date_day        ::= 1*2digit
+   ;; Day of month
 
 
-	/* Get the field name.  */
-	status = mu_header_aget_field_name (header, i, &name);
-	if (*name == '\0')
-	  {
-	    free (name);
-	    continue;
-	  }
+   date_day_fixed  ::= (SPACE digit) / 2digit
+   ;; Fixed-format version of date_day
 
 
-	/* Should we ignore the field?  */
-	{
-	  size_t j;
-	  for (j = 0; j < array_len; j++)
-	    {
-	      if (strcasecmp (array[j], name) == 0)
-		{
-		  ignore = 1;
-		  break;
-		}
-	    }
-	  if (ignore)
-	    {
-	      free (name);
-	      continue;
-	    }
-	}
+   date_month      ::= "Jan" / "Feb" / "Mar" / "Apr" / "May" / "Jun" /
+   "Jul" / "Aug" / "Sep" / "Oct" / "Nov" / "Dec"
 
 
-	if (mu_header_aget_field_value (header, i, &value) == 0)
-	  {
-	    char *nl;
+   date_text       ::= date_day "-" date_month "-" date_year
 
 
-	    /* Save the field.  */
-	    n = asprintf (&buffer, "%s: %s\n", name, value);
-	    status = mu_stream_write (stream, buffer, n, off, &n);
-	    off += n;
-	    /* count the lines.  */
-	    for (nl = buffer;(nl = strchr (nl, '\n')); nl++)
-	      lines++;
+   date_year       ::= 4digit
 
 
-	    free (value);
-	  }
-        free (name);
-        free (buffer);
-        buffer = NULL;
-        if (status != 0)
-	  {
-	    free (array);
-	    imap4d_bye (ERR_NO_MEM);
-	  }
-      }
-  }
-  /* Headers are always sent with a NL separator.  */
-  mu_stream_write (stream, "\n", 1, off, NULL);
-  off++;
-  lines++;
+   time            ::= 2digit ":" 2digit ":" 2digit
+   ;; Hours minutes seconds
 
 
-  util_send ("HEADER.FIELDS.NOT");
-  {
-    size_t j;
-    util_send (" (");
-    for (j = 0; j < array_len; j++)
+   zone            ::= ("+" / "-") 4digit
+   ;; Signed four-digit value of hhmm representing
+   ;; hours and minutes west of Greenwich (that is,
+   ;; (the amount that the given time differs from
+   ;; Universal Time).  Subtracting the timezone
+   ;; from the given time will give the UT form.
+   ;; The Universal Time zone is "+0000".  */
+static int
+_frt_internaldate (struct fetch_function_closure *ffc,
+		   struct fetch_runtime_closure *frt)
+{
+  const char *date;
+  mu_envelope_t env = NULL;
+  struct tm tm, *tmp = NULL;
+  mu_timezone tz;
+  char datebuf[sizeof ("13-Jul-2002 00:00:00")];
+
+  mu_message_get_envelope (frt->msg, &env);
+  if (mu_envelope_sget_date (env, &date) == 0
+      && mu_parse_ctime_date_time (&date, &tm, &tz) == 0)
+    tmp = &tm;
+  else
     {
     {
-	util_upper (array[j]);
-	if (j)
-	  util_send (" ");
-	util_send_qstring (array[j]);
-      }
-    util_send (")");
-    util_send ("]");
+      time_t t = time (NULL);
+      tmp = localtime (&t);
     }
     }
+  mu_strftime (datebuf, sizeof (datebuf), "%d-%b-%Y %H:%M:%S", tmp);
+  util_send ("%s", ffc->name);
+  util_send (" \"%s +0000\"", datebuf);
+  return 0;
+}
 
 
-  fetch_io (stream, start, end, off + lines);
-  if (array)
-    free (array);
+static int
+_frt_bodystructure (struct fetch_function_closure *ffc,
+		    struct fetch_runtime_closure *frt)
+{
+  util_send ("%s (", ffc->name);
+  fetch_bodystructure0 (frt->msg, 1); /* 1 means with extension data.  */
+  util_send (")");
   return RESP_OK;
   return RESP_OK;
 }
 }
 
 
 static int
 static int
-fetch_send_address (const char *addr)
+_frt_bodystructure0 (struct fetch_function_closure *ffc,
+		     struct fetch_runtime_closure *frt)
 {
 {
-  mu_address_t address;
-  size_t i, count = 0;
+  util_send ("%s (", ffc->name);
+  fetch_bodystructure0 (frt->msg, 0);
+  util_send (")");
+  return RESP_OK;
+}
 
 
-  /* Short circuit.  */
-  if (addr == NULL || *addr == '\0')
+/* BODY[] */
+static int
+_frt_body (struct fetch_function_closure *ffc,
+	   struct fetch_runtime_closure *frt)
+{
+  mu_message_t msg;
+  mu_stream_t stream = NULL;
+  size_t size = 0, lines = 0;
+
+  set_seen (ffc, frt);
+  if (ffc->name)
+    util_send ("%s", ffc->name);
+  else
+    fetch_send_section_part (ffc, "BODY[", "]");
+  msg = fetch_get_part (ffc, frt);
+  if (!msg)
     {
     {
-      util_send ("NIL");
+      util_send (" \"\"");
       return RESP_OK;
       return RESP_OK;
     }
     }
+  mu_message_get_stream (msg, &stream);
+  mu_message_size (msg, &size);
+  mu_message_lines (msg, &lines);
+  return fetch_io (stream, ffc->start, ffc->size, size + lines);
+}
 
 
-  mu_address_create (&address, addr);
-  mu_address_get_count (address, &count);
+static int
+_frt_body_text (struct fetch_function_closure *ffc,
+		struct fetch_runtime_closure *frt)
+{
+  mu_message_t msg;
+  mu_body_t body = NULL;
+  mu_stream_t stream = NULL;
+  size_t size = 0, lines = 0;
 
 
-  /* We failed: can't parse.  */
-  if (count == 0)
+  set_seen (ffc, frt);
+  if (ffc->name)
+    util_send ("%s",  ffc->name);
+  else
+    fetch_send_section_part (ffc, "BODY[", "TEXT]");
+  msg = fetch_get_part (ffc, frt);
+  if (!msg)
     {
     {
-      util_send ("NIL");
+      util_send (" \"\"");
       return RESP_OK;
       return RESP_OK;
     }
     }
 
 
-  util_send ("(");
-  for (i = 1; i <= count; i++)
-    {
-      const char *str;
-      int is_group = 0;
-
-      util_send ("(");
+  mu_message_get_body (msg, &body);
+  mu_body_size (body, &size);
+  mu_body_lines (body, &lines);
+  mu_body_get_stream (body, &stream);
+  return fetch_io (stream, ffc->start, ffc->size, size + lines);
+}
 
 
-      mu_address_sget_personal (address, i, &str);
-      util_send_qstring (str);
-      util_send (" ");
+static int
+_frt_size (struct fetch_function_closure *ffc,
+	   struct fetch_runtime_closure *frt)
+{
+  size_t size = 0;
+  size_t lines = 0;
   
   
-      mu_address_sget_route (address, i, &str);
-      util_send_qstring (str);
+  mu_message_size (frt->msg, &size);
+  mu_message_lines (frt->msg, &lines);
+  util_send ("%s %u", ffc->name, size + lines);
+  return RESP_OK;
+}
 
 
-      util_send (" ");
+static int
+_frt_header0 (struct fetch_function_closure *ffc,
+	      struct fetch_runtime_closure *frt,
+	      const char *suffix)
+{
+  mu_message_t msg;
+  mu_header_t header = NULL;
+  mu_stream_t stream = NULL;
+  size_t size = 0, lines = 0;
   
   
-      mu_address_is_group (address, i, &is_group);
-      str = NULL;
-      if (is_group)
-	mu_address_sget_personal (address, i, &str);
+  set_seen (ffc, frt);
+  if (ffc->name)
+    util_send ("%s",  ffc->name);
   else
   else
-	mu_address_sget_local_part (address, i, &str);
+    fetch_send_section_part (ffc, "BODY[", suffix);
 
 
-      util_send_qstring (str);
+  msg = fetch_get_part (ffc, frt);
+  if (!msg)
+    {
+      util_send (" \"\"");
+      return RESP_OK;
+    }
+  mu_message_get_header (msg, &header);
+  mu_header_size (header, &size);
+  mu_header_lines (header, &lines);
+  mu_header_get_stream (header, &stream);
+  return fetch_io (stream, ffc->start, ffc->size, size + lines);
+}
 
 
+static int
+_frt_header (struct fetch_function_closure *ffc,
+	     struct fetch_runtime_closure *frt)
+{
+  return _frt_header0 (ffc, frt, "HEADER]");
+}
+
+static int
+_frt_mime (struct fetch_function_closure *ffc,
+	   struct fetch_runtime_closure *frt)
+{
+  return _frt_header0 (ffc, frt, "MIME]");
+}
+
+static int
+_send_header_name (void *item, void *data)
+{
+  int *pf = data;
+  if (*pf)
     util_send (" ");
     util_send (" ");
+  else
+    *pf = 1;
+  util_send ("\"%s\"", (char*) item);
+  return 0;
+}
 
 
-      mu_address_sget_domain (address, i, &str);
-      util_send_qstring (str);
+static int
+count_nl (const char *str)
+{
+  int n = 0;
+  for (;(str = strchr (str, '\n')); str++)
+    n++;
+  return n;
+}
 
 
-      util_send (")");
+static int
+_frt_header_fields (struct fetch_function_closure *ffc,
+		    struct fetch_runtime_closure *frt)
+{
+  int status;
+  mu_message_t msg;
+  mu_off_t size = 0;
+  size_t lines = 0;
+  mu_stream_t stream;
+  mu_header_t header;
+  mu_iterator_t itr;
+  
+  set_seen (ffc, frt);
+
+  fetch_send_section_part (ffc, "BODY[", "HEADER.FIELDS");
+  if (ffc->not)
+    util_send (".NOT");
+  util_send (" (");
+  status = 0;
+  mu_list_do (ffc->headers, _send_header_name, &status);
+  util_send (")]");
+  
+  msg = fetch_get_part (ffc, frt);
+  if (!msg)
+    {
+      util_send (" \"\"");
+      return RESP_OK;
     }
     }
-  util_send (")");
+
+  /* Collect headers: */
+  if (mu_message_get_header (msg, &header)
+      || mu_header_get_iterator (header, &itr))
+    {
+      util_send (" \"\"");
       return RESP_OK;
       return RESP_OK;
+    }
+
+  status = mu_memory_stream_create (&stream, NULL, MU_STREAM_NO_CHECK);
+  if (status != 0)
+    imap4d_bye (ERR_NO_MEM);
+
+  for (mu_iterator_first (itr);
+       !mu_iterator_is_done (itr); mu_iterator_next (itr))
+    {
+      const char *hf;
+      char *hv;
+      const char *item;
+      
+      mu_iterator_current_kv (itr, (const void **)&hf, (void **)&hv);
+      status = mu_list_locate (ffc->headers, (void *)hf, (void**) &item) == 0;
+      if (ffc->not)
+	{
+	  status = !status;
+	  item = hf;
+	}
+      
+      if (status)
+	{
+	  mu_stream_sequential_printf (stream, "%s: %s\n", item, hv);
+	  lines += 1 + count_nl (hv);
+	}
+    }
+  mu_stream_sequential_write (stream, "\n", 1);
+  lines++;
+  
+  /* Output collected data */
+  mu_stream_size (stream, &size);
+  status = fetch_io (stream, ffc->start, ffc->size, size + lines);
+  mu_stream_destroy (&stream, NULL);
+  
+  return status;
 }
 }
 
 
-/* Send parameter list for the bodystructure.  */
+
 static void
 static void
-send_parameter_list (const char *buffer)
+ffc_init (struct fetch_function_closure *ffc)
 {
 {
-  int argc = 0;
-  char **argv;
+  memset(ffc, 0, sizeof *ffc);
+  ffc->start = 0;
+  ffc->size = (size_t) -1;
+}
 
 
-  if (!buffer)
+static void
+_free_ffc (void *item)
+{
+  struct fetch_function_closure *ffc = item;
+  mu_list_destroy (&ffc->headers);
+  free (ffc);
+}
+
+static int
+_do_fetch (void *item, void *data)
+{
+  struct fetch_function_closure *ffc = item;
+  struct fetch_runtime_closure *frt = data;
+  if (frt->eltno++)
+    util_send (" ");
+  return ffc->fun (ffc, frt);
+}
+    
+struct parsebuf
+{
+  imap4d_tokbuf_t tok;
+  int arg;
+  char *token;
+  int isuid;
+  mu_list_t fnlist;
+  jmp_buf errjmp;
+  char *err_text;
+};
+
+static void
+parsebuf_exit (struct parsebuf *p, char *text)
+{
+  p->err_text = text;
+  longjmp (p->errjmp, 1);
+}
+
+static char *
+parsebuf_peek (struct parsebuf *p)
+{
+  return imap4d_tokbuf_getarg (p->tok, p->arg);
+}
+
+static char *
+parsebuf_next (struct parsebuf *p, int req)
+{
+  p->token = imap4d_tokbuf_getarg (p->tok, p->arg++);
+  if (!p->token && req)
+    parsebuf_exit (p, "Too few arguments");
+  return p->token;
+}
+
+static void
+append_ffc (struct parsebuf *p, struct fetch_function_closure *ffc)
+{
+  struct fetch_function_closure *new_ffc = malloc (sizeof (*new_ffc));
+  if (!new_ffc)
+    imap4d_bye (ERR_NO_MEM);
+  *new_ffc = *ffc;
+  mu_list_append (p->fnlist, new_ffc);
+}
+
+static void
+append_simple_function (struct parsebuf *p, const char *name,
+			fetch_function_t fun)
+{
+  struct fetch_function_closure ffc;
+  ffc_init (&ffc);
+  ffc.fun = fun;
+  ffc.name = name;
+  append_ffc (p, &ffc);
+}
+
+
+static struct fetch_macro
+{
+  char *macro;
+  char *exp;
+} fetch_macro_tab[] = {
+  { "ALL",  "FLAGS INTERNALDATE RFC822.SIZE ENVELOPE" },
+  { "FULL", "FLAGS INTERNALDATE RFC822.SIZE ENVELOPE BODY" },
+  { "FAST", "FLAGS INTERNALDATE RFC822.SIZE" },
+  { NULL }
+};
+
+static char *
+find_macro (const char *name)
+{
+  int i;
+  for (i = 0; fetch_macro_tab[i].macro; i++)
+    if (strcasecmp (fetch_macro_tab[i].macro, name) == 0)
+      return fetch_macro_tab[i].exp;
+  return NULL;
+}
+
+
+struct fetch_att_tab
+{
+  char *name;
+  fetch_function_t fun;
+};
+
+static struct fetch_att_tab fetch_att_tab[] = {
+  { "ENVELOPE", _frt_envelope },
+  { "FLAGS", _frt_flags },
+  { "INTERNALDATE", _frt_internaldate },
+  { "UID", _frt_uid },
+  { NULL }
+};
+
+static struct fetch_att_tab *
+find_fetch_att_tab (char *name)
+{
+  struct fetch_att_tab *p;
+  for (p = fetch_att_tab; p->name; p++)
+    if (strcasecmp (p->name, name) == 0)
+      return p;
+  return NULL;
+}
+
+/*
+fetch-att       = "ENVELOPE" / "FLAGS" / "INTERNALDATE" /
+                  "RFC822" [".HEADER" / ".SIZE" / ".TEXT"] /
+                  "BODY" ["STRUCTURE"] / "UID" /
+                  "BODY" section ["<" number "." nz-number ">"] /
+                  "BODY.PEEK" section ["<" number "." nz-number ">"]
+
+*/
+
+/*  "RFC822" [".HEADER" / ".SIZE" / ".TEXT"]  */
+static void
+parse_fetch_rfc822 (struct parsebuf *p)
+{
+  struct fetch_function_closure ffc;
+  ffc_init (&ffc);
+  ffc.name = "RFC822";
+  parsebuf_next (p, 0);
+  if (p->token == NULL || p->token[0] == ')') 
     {
     {
-      util_send ("NIL");
-      return;
+      /* Equivalent to BODY[]. */
+      ffc.fun = _frt_body;
     }
     }
+  else if (p->token[0] == '.')
+    {
+      parsebuf_next (p, 1);
+      if (strcasecmp (p->token, "HEADER") == 0)
+	{
+	  /* RFC822.HEADER
+	     Equivalent to BODY[HEADER].  Note that this did not result in
+	     \Seen being set, because RFC822.HEADER response data occurs as
+	     a result of a FETCH of RFC822.HEADER.  BODY[HEADER] response
+	     data occurs as a result of a FETCH of BODY[HEADER] (which sets
+	     \Seen) or BODY.PEEK[HEADER] (which does not set \Seen). */
 
 
-  mu_argcv_get (buffer, " \t\r\n;=", NULL, &argc, &argv);
+	  ffc.name = "RFC822.HEADER";
+	  ffc.fun = _frt_header;
+	  ffc.peek = 1;
+	  parsebuf_next (p, 0);
+	}
+      else if (strcasecmp (p->token, "SIZE") == 0)
+	{
+	  /* A number expressing the [RFC-2822] size of the message. */
+	  ffc.name = "RFC822.SIZE";
+	  ffc.fun = _frt_size;
+	  parsebuf_next (p, 0);
+	}
+      else if (strcasecmp (p->token, "TEXT") == 0)
+	{
+	  /* RFC822.TEXT
+	     Equivalent to BODY[TEXT]. */
+	  ffc.name = "RFC822.TEXT";
+	  ffc.fun = _frt_body_text;
+	  parsebuf_next (p, 0);
+	}
+      else
+	parsebuf_exit (p, "Syntax error after RFC822.");
+    }
+  else
+    parsebuf_exit (p, "Syntax error after RFC822");
+  append_ffc (p, &ffc);
+}
 
 
-  if (argc == 0)
-    util_send ("NIL");
+static int
+_header_cmp (const void *a, const void *b)
+{
+  return strcasecmp ((char*)a, (char*)b);
+}
+
+/*
+header-fld-name = astring
+
+header-list     = "(" header-fld-name *(SP header-fld-name) ")"
+*/
+static void
+parse_header_list (struct parsebuf *p, struct fetch_function_closure *ffc)
+{
+  if (p->token[0] != '(')
+    parsebuf_exit (p, "Syntax error: expected (");
+  mu_list_create (&ffc->headers);
+  mu_list_set_comparator (ffc->headers, _header_cmp);
+  for (parsebuf_next (p, 1); p->token[0] != ')'; parsebuf_next (p, 1))
+    {
+      if (util_isdelim (p->token))
+	parsebuf_exit (p, "Syntax error: unexpected delimiter");
+      mu_list_append (ffc->headers, p->token);
+    }
+  parsebuf_next (p, 1);
+}
+
+/*
+section-msgtext = "HEADER" / "HEADER.FIELDS" [".NOT"] SP header-list /
+                  "TEXT"
+                    ; top-level or MESSAGE/RFC822 part
+section-text    = section-msgtext / "MIME"
+                    ; text other than actual body part (headers, etc.)
+*/  
+static int
+parse_section_text (struct parsebuf *p, struct fetch_function_closure *ffc,
+		    int allow_mime)
+{
+  if (strcasecmp (p->token, "HEADER") == 0)
+    {
+      /* "HEADER" / "HEADER.FIELDS" [".NOT"] SP header-list  */
+      parsebuf_next (p, 1);
+      if (p->token[0] == '.')
+	{
+	  parsebuf_next (p, 1);
+	  if (strcasecmp (p->token, "FIELDS"))
+	    parsebuf_exit (p, "Expected FIELDS");
+	  ffc->fun = _frt_header_fields;
+	  parsebuf_next (p, 1);
+	  if (p->token[0] == '.')
+	    {
+	      parsebuf_next (p, 1);
+	      if (strcasecmp (p->token, "NOT") == 0)
+		{
+		  ffc->not = 1;
+		  parsebuf_next (p, 1);
+		}
+	      else
+		parsebuf_exit (p, "Expected NOT");
+	    }
+	  parse_header_list (p, ffc);
+	}
       else
       else
+	ffc->fun = _frt_header;
+    }
+  else if (strcasecmp (p->token, "TEXT") == 0)
     {
     {
-      char *p;
+      parsebuf_next (p, 1);
+      ffc->fun = _frt_body_text;
+    }
+  else if (allow_mime && strcasecmp (p->token, "MIME") == 0)
+    {
+      parsebuf_next (p, 1);
+      ffc->fun = _frt_mime;
+    }
+  else
+    return 1;
+ return 0;
+}
 
 
-      util_send ("(");
+static size_t
+parsebuf_get_number (struct parsebuf *p)
+{
+  char *cp;
+  unsigned n = strtoul (p->token, &cp, 10);
 
 
-      p = argv[0];
-      util_send_qstring (p);
+  if (*cp)
+    parsebuf_exit (p, "Syntax error: expected number");
+  return n;
+}
     
     
-      if (argc > 1)
+/*
+section-part    = nz-number *("." nz-number)
+                    ; body part nesting
+*/  
+static void
+parse_section_part (struct parsebuf *p, struct fetch_function_closure *ffc)
+{
+  size_t *parts;
+  size_t nmax = 0;
+  size_t ncur = 0;
+
+  for (;;)
     {
     {
-	  int i, space = 0;
-	  char *lvalue = NULL;
+      char *cp;
+      size_t n = parsebuf_get_number (p);
+      if (ncur == nmax)
+	{
+	  if (nmax == 0)
+	    {
+	      nmax = 16;
+	      parts = calloc (nmax, sizeof (parts[0]));
+	    }
+	  else
+	    {
+	      nmax *= 2;
+	      parts = realloc (parts, nmax * sizeof (parts[0]));
+	    }
+	  if (!parts)
+	    imap4d_bye (ERR_NO_MEM);
+	}
+      parts[ncur++] = n;
 
 
-	  util_send ("(");
-	  for (i = 1; i < argc; i++)
+      parsebuf_next (p, 1);
+      if (p->token[0] == '.'
+	  && (cp = parsebuf_peek (p)) && isascii (*cp) && isdigit (cp[0]))
+	parsebuf_next (p, 1);
+      else
+	break;
+    }
+  ffc->section_part = parts;
+  ffc->nset = ncur;
+}
+  
+/*
+section         = "[" [section-spec] "]"
+section-spec    = section-msgtext / (section-part ["." section-text])
+*/  
+static int
+parse_section (struct parsebuf *p, struct fetch_function_closure *ffc)
+{
+  if (p->token[0] != '[')
+    return 1;
+  ffc_init (ffc);
+  ffc->name = NULL;
+  ffc->fun = _frt_body;
+  parsebuf_next (p, 1);
+  if (parse_section_text (p, ffc, 0))
     {
     {
-	      if (lvalue)
+      if (p->token[0] == ']')
+	/* OK */;
+      else if (isascii (p->token[0]) && isdigit (p->token[0]))
 	{
 	{
-		  if (space)
-		    util_send (" ");
-		  util_send_qstring (lvalue);
-		  lvalue = NULL;
-		  space = 1;
+	  parse_section_part (p, ffc);
+	  if (p->token[0] == '.')
+	    {
+	      parsebuf_next (p, 1);
+	      parse_section_text (p, ffc, 1);
+	    }
 	}
 	}
+      else
+	parsebuf_exit (p, "Syntax error");
+    }
+  if (p->token[0] != ']')
+    parsebuf_exit (p, "Syntax error: missing ]");
+  parsebuf_next (p, 0);
+  return 0;
+}
 
 
-	      switch (argv[i][0])
+static void
+parse_substring (struct parsebuf *p, struct fetch_function_closure *ffc)
+{
+  if (p->token && p->token[0] == '<')
+    {
+      parsebuf_next (p, 1);
+      ffc->start = parsebuf_get_number (p);
+      parsebuf_next (p, 1);
+      if (p->token[0] != '.')
+	parsebuf_exit (p, "Syntax error: expected .");
+      parsebuf_next (p, 1);
+      ffc->size = parsebuf_get_number (p);
+      parsebuf_next (p, 1);
+      if (p->token[0] != '>')
+	parsebuf_exit (p, "Syntax error: expected >");
+      parsebuf_next (p, 0);
+    }
+}
+	
+/* section ["<" number "." nz-number ">"]  */
+static int
+parse_body_args (struct parsebuf *p, int peek)
+{
+  struct fetch_function_closure ffc;
+  if (parse_section (p, &ffc) == 0)
     {
     {
-		case ';':
-		  continue;
+      parse_substring (p, &ffc);
+      ffc.peek = peek;
+      append_ffc (p, &ffc);
+      return 0;
+    }
+  return 1;
+}
 
 
-		case '=':
-		  if (++i < argc)
+static void
+parse_body_peek (struct parsebuf *p)
+{
+  parsebuf_next (p, 1);
+  if (strcasecmp (p->token, "PEEK") == 0)
     {
     {
-		      char *p = argv[i];
-		      util_send (" ");
-		      util_unquote (&p);
-		      util_send_qstring (p);
+      parsebuf_next (p, 1);
+      if (parse_body_args (p, 1))
+	parsebuf_exit (p, "Syntax error");
     }
     }
-		  break;
+  else
+    parsebuf_exit (p, "Syntax error: expected PEEK");
+}
 
 
-		default:
-		  lvalue = argv[i];
+/*  "BODY" ["STRUCTURE"] / 
+    "BODY" section ["<" number "." nz-number ">"] /
+    "BODY.PEEK" section ["<" number "." nz-number ">"] */
+static void
+parse_fetch_body (struct parsebuf *p)
+{
+  if (parsebuf_next (p, 0) == NULL || p->token[0] == ')')
+    append_simple_function (p, "BODY", _frt_bodystructure0);
+  else if (p->token[0] == '.')
+    parse_body_peek (p);
+  else if (strcasecmp (p->token, "STRUCTURE") == 0)
+    {
+      /* For compatibility with previous versions */
+      append_simple_function (p, "BODYSTRUCTURE", _frt_bodystructure);
+      parsebuf_next (p, 0);
+    }
+  else if (parse_body_args (p, 0))
+    parsebuf_exit (p, "Syntax error");
+}
+
+static int
+parse_fetch_att (struct parsebuf *p)
+{
+  struct fetch_att_tab *ent;
+
+  ent = find_fetch_att_tab (p->token);
+  if (ent)
+    {
+      if (!(ent->fun == _frt_uid && p->isuid))
+	append_simple_function (p, ent->name, ent->fun);
+      parsebuf_next (p, 0);
     }
     }
+  else if (strcasecmp (p->token, "RFC822") == 0)
+    parse_fetch_rfc822 (p);
+  else if (strcasecmp (p->token, "BODY") == 0)
+    parse_fetch_body (p);
+  else if (strcasecmp (p->token, "BODYSTRUCTURE") == 0)
+    {
+      append_simple_function (p, "BODYSTRUCTURE", _frt_bodystructure);
+      parsebuf_next (p, 0);
     }
     }
-	  if (lvalue)
+  else
+    return 1;
+  return 0;
+}
+
+/* fetch-att *(SP fetch-att) */
+static void
+parse_fetch_att_list (struct parsebuf *p)
+{
+  while (p->token && parse_fetch_att (p) == 0)
+    ;
+}
+
+/* "ALL" / "FULL" / "FAST" / fetch-att / "(" */
+static void
+parse_macro (struct parsebuf *p)
+{  
+  char *exp;
+  
+  parsebuf_next (p, 1);
+  if (p->token[0] == '(')
     {
     {
-	      if (space)
-		util_send (" ");
-	      util_send_qstring (lvalue);
+      parsebuf_next (p, 1);
+      parse_fetch_att_list (p);
+      if (p->token[0] != ')')
+	parsebuf_exit (p, "Missing closing parenthesis");
     }
     }
-	  util_send (")");
+  else if ((exp = find_macro (p->token))) 
+    {
+      imap4d_tokbuf_t save_tok = p->tok;
+      int save_arg = p->arg;
+      p->tok = imap4d_tokbuf_from_string (exp);
+      p->arg = 0;
+      parsebuf_next (p, 1);
+      parse_fetch_att_list (p);
+      imap4d_tokbuf_destroy (&p->tok);
+  
+      p->arg = save_arg;
+      p->tok = save_tok;
+
+      if (parsebuf_peek (p))
+	parsebuf_exit (p, "Too many arguments");
     }     
     }     
   else
   else
-	util_send (" NIL");
-      util_send (")");
+    {
+      parse_fetch_att (p);
+      if (p->token)
+	parsebuf_exit (p, "Too many arguments");
     }
     }
-  mu_argcv_free (argc, argv);
 }
 }
     
     
+/* Where the real implementation is.  It is here since UID command also
+   calls FETCH.  */
+int
+imap4d_fetch0 (imap4d_tokbuf_t tok, int isuid, char **err_text)
+{
+  int rc = RESP_OK;
+  char *msgset;
+  size_t *set = NULL;
+  int n = 0;
+  int i;
+  int status;
+  struct fetch_runtime_closure frc;
+  struct parsebuf pb;
+
+  if (imap4d_tokbuf_argc (tok) - (IMAP4_ARG_1 + isuid) < 2)
+    {
+      *err_text = "Invalid arguments";
+      return 1;
+    }
+  
+  pb.tok = tok;
+  pb.arg = IMAP4_ARG_1 + isuid;
+  pb.isuid = isuid;
+  pb.err_text = "Syntax error";
+  mu_list_create (&pb.fnlist);
+  mu_list_set_destroy_item (pb.fnlist, _free_ffc);
+  if (setjmp (pb.errjmp))
+    {
+      *err_text = pb.err_text;
+      mu_list_destroy (&pb.fnlist);
+      return RESP_BAD;
+    }
+  
+  msgset = parsebuf_next (&pb, 1);
+
+  /* Get the message numbers in set[].  */
+  status = util_msgset (msgset, &set, &n, isuid);
+  if (status != 0)
+    {
+      *err_text = "Bogus number set";
+      return RESP_BAD;
+    }
+
+  /* Compile the expression */
+
+  /* Server implementations MUST implicitly
+     include the UID message data item as part of any FETCH
+     response caused by a UID command, regardless of whether
+     a UID was specified as a message data item to the FETCH. */
+  if (isuid)
+    append_simple_function (&pb, "UID", _frt_uid);
+
+  parse_macro (&pb);
+  
+  /* Prepare status code. It will be replaced if an error occurs in the
+     loop below */
+  frc.err_text = "Completed";
+  
+  for (i = 0; i < n && rc == RESP_OK; i++)
+    {
+      frc.msgno = (isuid) ? uid_to_msgno (set[i]) : set[i];
+
+      if (frc.msgno && mu_mailbox_get_message (mbox, frc.msgno, &frc.msg) == 0)
+	{
+	  util_send ("* %lu FETCH (", (unsigned long) frc.msgno);
+	  frc.eltno = 0;
+	  rc = mu_list_do (pb.fnlist, _do_fetch, &frc);
+	  util_send (")\r\n");
+	}
+    }
+  
+  mu_list_destroy (&pb.fnlist);
+  free (set);
+  return rc;
+}
+
+/*
+6.4.5.  FETCH Command
+
+   Arguments:  message set
+               message data item names
+
+   Responses:  untagged responses: FETCH
+
+   Result:     OK - fetch completed
+               NO - fetch error: can't fetch that data
+               BAD - command unknown or arguments invalid
+*/
+
+/* The FETCH command retrieves data associated with a message in the
+   mailbox.  The data items to be fetched can be either a single atom
+   or a parenthesized list.  */
+int
+imap4d_fetch (struct imap4d_command *command, imap4d_tokbuf_t tok)
+{
+  int rc;
+  char *err_text = "Completed";
+
+  rc = imap4d_fetch0 (tok, 0, &err_text);
+  return util_finish (command, rc, "%s", err_text);
+}
 
 

@@ -19,13 +19,12 @@
 #include "imap4d.h"
 #include "imap4d.h"
 
 
 int
 int
-imap4d_idle (struct imap4d_command *command, char *arg)
+imap4d_idle (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
-  char *sp;
   time_t start;
   time_t start;
   
   
-  if (util_getword (arg, &sp))
-    return util_finish (command, RESP_BAD, "Too many args");
+  if (imap4d_tokbuf_argc (tok) != 2)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
 
 
   if (util_wait_input (0) == -1)
   if (util_wait_input (0) == -1)
     return util_finish (command, RESP_NO, "Cannot idle");
     return util_finish (command, RESP_NO, "Cannot idle");
@@ -38,15 +37,10 @@ imap4d_idle (struct imap4d_command *command, char *arg)
     {
     {
       if (util_wait_input (5))
       if (util_wait_input (5))
 	{
 	{
-	  int rc;
-	  char *p;
-	  char *cmd = imap4d_readline ();
-	  
-	  p = util_getword (cmd, &sp);
-	  rc = strcasecmp (p, "done") == 0;
-
-	  free (cmd);
-	  if (rc)
+	  imap4d_readline (tok);
+	  if (imap4d_tokbuf_argc (tok) == 1
+	      && strcasecmp (imap4d_tokbuf_getarg (tok, IMAP4_ARG_TAG),
+			     "done") == 0)
 	    break;
 	    break;
 	}
 	}
       else if (time (NULL) - start > idle_timeout)
       else if (time (NULL) - start > idle_timeout)

@@ -370,6 +370,7 @@ get_client_address (int fd, struct sockaddr_in *pcs)
 static int
 static int
 imap4d_mainloop (int fd, FILE *infile, FILE *outfile)
 imap4d_mainloop (int fd, FILE *infile, FILE *outfile)
 {
 {
+  imap4d_tokbuf_t tokp;
   char *text;
   char *text;
   int debug_mode = isatty (fd);
   int debug_mode = isatty (fd);
   static int sigtab[] = { SIGILL, SIGBUS, SIGFPE, SIGSEGV, SIGSTOP, SIGPIPE,
   static int sigtab[] = { SIGILL, SIGBUS, SIGFPE, SIGSEGV, SIGSTOP, SIGPIPE,
@@ -400,14 +401,14 @@ imap4d_mainloop (int fd, FILE *infile, FILE *outfile)
   util_out ((state == STATE_AUTH) ? RESP_PREAUTH : RESP_OK, "%s", text);
   util_out ((state == STATE_AUTH) ? RESP_PREAUTH : RESP_OK, "%s", text);
   util_flush_output ();
   util_flush_output ();
 
 
+  tokp = imap4d_tokbuf_init ();
   while (1)
   while (1)
     {
     {
-      char *cmd = imap4d_readline ();
+      imap4d_readline (tokp);
       /* check for updates */
       /* check for updates */
       imap4d_sync ();
       imap4d_sync ();
-      util_do_command (cmd);
+      util_do_command (tokp);
       imap4d_sync ();
       imap4d_sync ();
-      free (cmd);
       util_flush_output ();
       util_flush_output ();
     }
     }
 
 

@@ -41,6 +41,7 @@
 #include <stdlib.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <unistd.h>
 #include <string.h>
 #include <string.h>
+#include <setjmp.h>
 #include <sys/wait.h>
 #include <sys/wait.h>
 #include <sys/types.h>
 #include <sys/types.h>
 #include <syslog.h>
 #include <syslog.h>
@@ -108,10 +109,12 @@
 extern "C" {
 extern "C" {
 #endif
 #endif
 
 
+typedef struct imap4d_tokbuf *imap4d_tokbuf_t;
+
 struct imap4d_command
 struct imap4d_command
 {
 {
   const char *name;
   const char *name;
-  int (*func) (struct imap4d_command *, char *);
+  int (*func) (struct imap4d_command *, imap4d_tokbuf_t);
   int states;
   int states;
   int failure;
   int failure;
   int success;
   int success;
@@ -192,47 +195,62 @@ extern int imap4d_transcript;
 extern char *strtok_r (char *s, const char *delim, char **save_ptr);
 extern char *strtok_r (char *s, const char *delim, char **save_ptr);
 #endif
 #endif
 
 
-/* Imap4 commands */
-extern int  imap4d_append (struct imap4d_command *, char *);
-extern int  imap4d_append0 (mu_mailbox_t mbox, int flags, char *text);
-extern int  imap4d_authenticate (struct imap4d_command *, char *);
+/* Input functions */
+imap4d_tokbuf_t imap4d_tokbuf_init (void);
+void imap4d_tokbuf_destroy (imap4d_tokbuf_t *tok);
+int imap4d_tokbuf_argc (imap4d_tokbuf_t tok);
+char *imap4d_tokbuf_getarg (imap4d_tokbuf_t tok, int n);
+void imap4d_readline (imap4d_tokbuf_t tok);
+struct imap4d_tokbuf *imap4d_tokbuf_from_string (char *str);
+int imap4d_getline (char **pbuf, size_t *psize, size_t *pnbytes);
+
+#define IMAP4_ARG_TAG     0
+#define IMAP4_ARG_COMMAND 1
+#define IMAP4_ARG_1       2
+#define IMAP4_ARG_2       3
+#define IMAP4_ARG_3       4
+#define IMAP4_ARG_4       5
+  
+  /* Imap4 commands */
+extern int  imap4d_append (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_authenticate (struct imap4d_command *, imap4d_tokbuf_t);
 extern void imap4d_auth_capability (void);
 extern void imap4d_auth_capability (void);
-extern int  imap4d_capability (struct imap4d_command *, char *);
-extern int  imap4d_check (struct imap4d_command *, char *);
-extern int  imap4d_close (struct imap4d_command *, char *);
-extern int  imap4d_copy (struct imap4d_command *, char *);
-extern int  imap4d_copy0 (char *, int, char *, size_t);
-extern int  imap4d_create (struct imap4d_command *, char *);
-extern int  imap4d_delete (struct imap4d_command *, char *);
-extern int  imap4d_examine (struct imap4d_command *, char *);
-extern int  imap4d_expunge (struct imap4d_command *, char *);
-extern int  imap4d_fetch (struct imap4d_command *, char *);
-extern int  imap4d_fetch0 (char *, int, char *, size_t);
-extern int  imap4d_list (struct imap4d_command *, char *);
-extern int  imap4d_lsub (struct imap4d_command *, char *);
-extern int  imap4d_login (struct imap4d_command *, char *);
-extern int  imap4d_logout (struct imap4d_command *, char *);
-extern int  imap4d_noop (struct imap4d_command *, char *);
-extern int  imap4d_rename (struct imap4d_command *, char *);
+extern int  imap4d_capability (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_check (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_close (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_copy (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_copy0 (imap4d_tokbuf_t, int isuid, char **err_text);
+extern int  imap4d_create (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_delete (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_examine (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_expunge (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_fetch (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_fetch0 (imap4d_tokbuf_t tok, int isuid, char **err_text);
+extern int  imap4d_list (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_lsub (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_login (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_logout (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_noop (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_rename (struct imap4d_command *, imap4d_tokbuf_t);
 extern int  imap4d_preauth_setup (int fd);
 extern int  imap4d_preauth_setup (int fd);
-extern int  imap4d_search (struct imap4d_command *, char *);
-extern int  imap4d_search0 (char *arg, int isuid, char *replybuf, size_t replysize);
-extern int  imap4d_select (struct imap4d_command *, char *);
+extern int  imap4d_search (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_search0 (imap4d_tokbuf_t, int isuid, char **repyptr);
+extern int  imap4d_select (struct imap4d_command *, imap4d_tokbuf_t);
 extern int  imap4d_select0 (struct imap4d_command *, char *, int);
 extern int  imap4d_select0 (struct imap4d_command *, char *, int);
 extern int  imap4d_select_status (void);
 extern int  imap4d_select_status (void);
 #ifdef WITH_TLS
 #ifdef WITH_TLS
-extern int  imap4d_starttls (struct imap4d_command *, char *);
+extern int  imap4d_starttls (struct imap4d_command *, imap4d_tokbuf_t);
 extern void starttls_init (void);
 extern void starttls_init (void);
 #endif /* WITH_TLS */
 #endif /* WITH_TLS */
-extern int  imap4d_status (struct imap4d_command *, char *);
-extern int  imap4d_store (struct imap4d_command *, char *);
-extern int  imap4d_store0 (char *, int, char *, size_t);
-extern int  imap4d_subscribe (struct imap4d_command *, char *);
-extern int  imap4d_uid (struct imap4d_command *, char *);
-extern int  imap4d_unsubscribe (struct imap4d_command *, char *);
-extern int  imap4d_namespace (struct imap4d_command *, char *);
-extern int  imap4d_version (struct imap4d_command *, char *);
-extern int  imap4d_idle (struct imap4d_command *, char *);
+extern int  imap4d_status (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_store (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_store0 (imap4d_tokbuf_t, int, char **);
+extern int  imap4d_subscribe (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_uid (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_unsubscribe (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_namespace (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_version (struct imap4d_command *, imap4d_tokbuf_t);
+extern int  imap4d_idle (struct imap4d_command *, imap4d_tokbuf_t);
   
   
 extern int imap4d_check_home_dir (const char *dir, uid_t uid, gid_t gid);
 extern int imap4d_check_home_dir (const char *dir, uid_t uid, gid_t gid);
 
 
@@ -274,25 +292,17 @@ extern int  util_start (char *);
 extern int  util_finish (struct imap4d_command *, int, const char *, ...) 
 extern int  util_finish (struct imap4d_command *, int, const char *, ...) 
                          MU_PRINTFLIKE(3,4);
                          MU_PRINTFLIKE(3,4);
 extern int  util_getstate (void);
 extern int  util_getstate (void);
-extern int  util_do_command (char *);
-extern char *imap4d_readline (void);
-extern char *imap4d_readline_ex (void);
-extern char *util_getword (char *, char **);
-extern char *util_getitem (char *, const char *, char **);
-extern int  util_token (char *, size_t, char **);
-extern void util_unquote (char **);
+extern int  util_do_command (imap4d_tokbuf_t);
 extern char *util_tilde_expansion (const char *, const char *);
 extern char *util_tilde_expansion (const char *, const char *);
 extern char *util_getfullpath (char *, const char *);
 extern char *util_getfullpath (char *, const char *);
 extern int  util_msgset (char *, size_t **, int *, int);
 extern int  util_msgset (char *, size_t **, int *, int);
 extern int  util_upper (char *);
 extern int  util_upper (char *);
 extern struct imap4d_command *util_getcommand (char *, 
 extern struct imap4d_command *util_getcommand (char *, 
                                                struct imap4d_command []);
                                                struct imap4d_command []);
-extern int util_parse_internal_date0 (char *date, time_t *timep, char **endp);
 extern int util_parse_internal_date (char *date, time_t *timep);
 extern int util_parse_internal_date (char *date, time_t *timep);
 extern int util_parse_822_date (const char *date, time_t *timep);
 extern int util_parse_822_date (const char *date, time_t *timep);
 extern int util_parse_ctime_date (const char *date, time_t *timep);
 extern int util_parse_ctime_date (const char *date, time_t *timep);
 extern char *util_strcasestr (const char *haystack, const char *needle);
 extern char *util_strcasestr (const char *haystack, const char *needle);
-extern int util_parse_attributes (char *items, char **save, int *flags);
 
 
 extern int util_base64_encode (const unsigned char *input,
 extern int util_base64_encode (const unsigned char *input,
 			       size_t input_len,
 			       size_t input_len,
@@ -330,6 +340,7 @@ void util_bye (void);
 void util_atexit (void (*fp) (void));
 void util_atexit (void (*fp) (void));
 void util_chdir (const char *homedir);
 void util_chdir (const char *homedir);
 int is_atom (const char *s);
 int is_atom (const char *s);
+int util_isdelim (const char *str);
   
   
 #ifdef WITH_TLS
 #ifdef WITH_TLS
 int imap4d_init_tls_server (void);
 int imap4d_init_tls_server (void);

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
    Copyright (C) 1999, 2001, 2002, 2005, 2006,
    Copyright (C) 1999, 2001, 2002, 2005, 2006,
-   2007 Free Software Foundation, Inc.
+   2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -106,6 +106,19 @@ list_fun (mu_folder_t folder, struct mu_list_response *resp, void *data)
 }
 }
 
 
 /*
 /*
+6.3.8.  LIST Command
+
+   Arguments:  reference name
+               mailbox name with possible wildcards
+
+   Responses:  untagged responses: LIST
+
+   Result:     OK - list completed
+               NO - list failure: can't list that reference or name
+               BAD - command unknown or arguments invalid
+*/
+
+/*
   1- IMAP4 insists: the reference argument present in the
   1- IMAP4 insists: the reference argument present in the
   interpreted form SHOULD prefix the interpreted form.  It SHOULD
   interpreted form SHOULD prefix the interpreted form.  It SHOULD
   also be in the same form as the reference name argument.  This
   also be in the same form as the reference name argument.  This
@@ -126,21 +139,17 @@ list_fun (mu_folder_t folder, struct mu_list_response *resp, void *data)
   but it does not match the hierarchy delimiter.  */
   but it does not match the hierarchy delimiter.  */
 
 
 int
 int
-imap4d_list (struct imap4d_command *command, char *arg)
+imap4d_list (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
-  char *sp = NULL;
   char *ref;
   char *ref;
   char *wcard;
   char *wcard;
   const char *delim = "/";
   const char *delim = "/";
 
 
-  ref = util_getword (arg, &sp);
-  wcard = util_getword (NULL, &sp);
-  if (!ref || !wcard)
-    return util_finish (command, RESP_BAD, "Too few arguments");
+  if (imap4d_tokbuf_argc (tok) != 4)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
   
   
-  /* Remove the double quotes.  */
-  util_unquote (&ref);
-  util_unquote (&wcard);
+  ref = imap4d_tokbuf_getarg (tok, IMAP4_ARG_1);
+  wcard = imap4d_tokbuf_getarg (tok, IMAP4_ARG_2);
 
 
   /* If wildcard is empty, it is a special case: we have to
   /* If wildcard is empty, it is a special case: we have to
      return the hierarchy.  */
      return the hierarchy.  */

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
    Copyright (C) 1999, 2001, 2002, 2006,
    Copyright (C) 1999, 2001, 2002, 2006,
-   2007 Free Software Foundation, Inc.
+   2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -19,26 +19,32 @@
 
 
 #include "imap4d.h"
 #include "imap4d.h"
 
 
+/*
+6.2.2.  LOGIN Command
+
+   Arguments:  user name
+               password
+
+   Responses:  no specific responses for this command
+
+   Result:     OK - login completed, now in authenticated state
+               NO - login failure: user name or password rejected
+               BAD - command unknown or arguments invalid
+*/  
 int
 int
-imap4d_login (struct imap4d_command *command, char *arg)
+imap4d_login (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
-  char *sp = NULL, *username, *pass;
+  char *username, *pass;
   int rc;
   int rc;
 
 
   if (login_disabled || tls_required)    
   if (login_disabled || tls_required)    
     return util_finish (command, RESP_NO, "Command disabled");
     return util_finish (command, RESP_NO, "Command disabled");
 
 
-  username = util_getword (arg, &sp);
-  pass = util_getword (NULL, &sp);
-
-  /* Remove the double quotes.  */
-  util_unquote (&username);
-  util_unquote (&pass);
+  if (imap4d_tokbuf_argc (tok) != 4)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
   
   
-  if (username == NULL || *username == '\0' || pass == NULL)
-    return util_finish (command, RESP_NO, "Too few args");
-  else if (util_getword (NULL, &sp))
-    return util_finish (command, RESP_NO, "Too many args");
+  username = imap4d_tokbuf_getarg (tok, IMAP4_ARG_1);
+  pass = imap4d_tokbuf_getarg (tok, IMAP4_ARG_2);
 
 
   auth_data = mu_get_auth_by_name (username);
   auth_data = mu_get_auth_by_name (username);
 
 

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -19,15 +19,21 @@
 #include "imap4d.h"
 #include "imap4d.h"
 
 
 /*
 /*
- * This needs to properly close the mailbox
- */
+6.1.3.  LOGOUT Command
+
+   Arguments:  none
+
+   Responses:  REQUIRED untagged response: BYE
+
+   Result:     OK - logout completed
+               BAD - command unknown or arguments invalid
+*/
 
 
 int
 int
-imap4d_logout (struct imap4d_command *command, char *arg)
+imap4d_logout (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
-  char *sp = NULL;
-  if (util_getword (arg, &sp))
-    return util_finish (command, RESP_BAD, "Too many args");
+  if (imap4d_tokbuf_argc (tok) != 2)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
   imap4d_bye0 (OK, command);
   imap4d_bye0 (OK, command);
   return 0;
   return 0;
 }
 }

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -19,13 +19,20 @@
 #include "imap4d.h"
 #include "imap4d.h"
 
 
 /*
 /*
- *  
- */
+6.3.9.  LSUB Command
 
 
+   Arguments:  reference name
+               mailbox name with possible wildcards
+
+   Responses:  untagged responses: LSUB
+
+   Result:     OK - lsub completed
+               NO - lsub failure: can't list that reference or name
+               BAD - command unknown or arguments invalid
+*/
 int
 int
-imap4d_lsub (struct imap4d_command *command, char *arg)
+imap4d_lsub (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
-  char *sp;
   char *ref;
   char *ref;
   char *wcard;
   char *wcard;
   char *file = NULL;
   char *file = NULL;
@@ -33,14 +40,11 @@ imap4d_lsub (struct imap4d_command *command, char *arg)
   const char *delim = "/";
   const char *delim = "/";
   FILE *fp;
   FILE *fp;
   
   
-  ref = util_getword (arg, &sp);
-  wcard = util_getword (NULL, &sp);
-  if (!ref || !wcard)
-    return util_finish (command, RESP_BAD, "Too few arguments");
+  if (imap4d_tokbuf_argc (tok) != 4)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
   
   
-  /* Remove the double quotes.  */
-  util_unquote (&ref);
-  util_unquote (&wcard);
+  ref = imap4d_tokbuf_getarg (tok, IMAP4_ARG_1);
+  wcard = imap4d_tokbuf_getarg (tok, IMAP4_ARG_2);
 
 
   asprintf (&pattern, "%s%s", ref, wcard);
   asprintf (&pattern, "%s%s", ref, wcard);
   if (!pattern)
   if (!pattern)

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2005, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2005, 2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -89,8 +89,9 @@ print_namespace (int n)
   util_send ("(");
   util_send ("(");
   for (i = 0; i < namespace[n].subdir_c; i++)
   for (i = 0; i < namespace[n].subdir_c; i++)
     {
     {
-      util_send ("(\"%s\" \"/\")",
-		 printable_pathname (namespace[n].subdir_v[i]));
+      char *dir = printable_pathname (namespace[n].subdir_v[i]);
+      char *suf = (dir[0] && dir[strlen (dir) - 1] != '/') ? "/" : "";
+      util_send ("(\"%s%s\" \"/\")", dir, suf);
     }
     }
   util_send (")");
   util_send (")");
 }
 }
@@ -114,11 +115,27 @@ namespace_enumerate_all (nsfp_t f, void *closure)
     || namespace_enumerate (NS_SHARED, f, closure);
     || namespace_enumerate (NS_SHARED, f, closure);
 }
 }
 
 
+/*
+5. NAMESPACE Command
+
+   Arguments: none
+
+   Response:  an untagged NAMESPACE response that contains the prefix
+                 and hierarchy delimiter to the server's Personal
+                 Namespace(s), Other Users' Namespace(s), and Shared
+                 Namespace(s) that the server wishes to expose. The
+                 response will contain a NIL for any namespace class
+                 that is not available. Namespace_Response_Extensions
+                 MAY be included in the response.
+                 Namespace_Response_Extensions which are not on the IETF
+                 standards track, MUST be prefixed with an "X-".
+*/
+
 int
 int
-imap4d_namespace (struct imap4d_command *command, char *arg)
+imap4d_namespace (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
-  if (*arg)
-    return util_finish (command, RESP_BAD, "Too many arguments");
+  if (imap4d_tokbuf_argc (tok) != 2)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
 
 
   util_send ("* NAMESPACE ");
   util_send ("* NAMESPACE ");
 
 

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -19,13 +19,10 @@
 #include "imap4d.h"
 #include "imap4d.h"
 
 
 int
 int
-imap4d_noop (struct imap4d_command *command, char *arg)
+imap4d_noop (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
-  char *sp = NULL;
-
-  if (util_getword (arg, &sp))
-    return util_finish (command, RESP_BAD, "Too many args");
-
+  if (imap4d_tokbuf_argc (tok) != 2)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
   imap4d_sync ();
   imap4d_sync ();
   return util_finish (command, RESP_OK, "Completed");
   return util_finish (command, RESP_OK, "Completed");
 }
 }

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2005, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2005, 2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -19,30 +19,37 @@
 #include "imap4d.h"
 #include "imap4d.h"
 
 
 /*
 /*
+6.3.5.  RENAME Command
+
+   Arguments:  existing mailbox name
+               new mailbox name
+
+   Responses:  no specific responses for this command
+
+   Result:     OK - rename completed
+               NO - rename failure: can't rename mailbox with that name,
+                    can't rename to mailbox with that name
+               BAD - command unknown or arguments invalid
+*/  
+/*
   FIXME: Renaming a mailbox we must change the UIDVALIDITY
   FIXME: Renaming a mailbox we must change the UIDVALIDITY
   of the mailbox.  */
   of the mailbox.  */
 
 
 int
 int
-imap4d_rename (struct imap4d_command *command, char *arg)
+imap4d_rename (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
   char *oldname;
   char *oldname;
   char *newname;
   char *newname;
-  char *sp = NULL;
   int rc = RESP_OK;
   int rc = RESP_OK;
   const char *msg = "Completed";
   const char *msg = "Completed";
   struct stat newst;
   struct stat newst;
   const char *delim = "/";
   const char *delim = "/";
 
 
-  oldname = util_getword (arg, &sp);
-  newname = util_getword (NULL, &sp);
-  if (!newname || !oldname)
-    return util_finish (command, RESP_BAD, "Too few arguments");
-
-  util_unquote (&newname);
-  util_unquote (&oldname);
+  if (imap4d_tokbuf_argc (tok) != 4)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
   
   
-  if (*newname == '\0' || *oldname == '\0')
-    return util_finish (command, RESP_BAD, "Too few arguments");
+  oldname = imap4d_tokbuf_getarg (tok, IMAP4_ARG_1);
+  newname = imap4d_tokbuf_getarg (tok, IMAP4_ARG_2);
 
 
   if (strcasecmp (newname, "INBOX") == 0)
   if (strcasecmp (newname, "INBOX") == 0)
     return util_finish (command, RESP_NO, "Name Inbox is reservered");
     return util_finish (command, RESP_NO, "Name Inbox is reservered");

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2002, 2005, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2002, 2005, 2007,
+   2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -223,11 +224,9 @@ struct mem_chain
 /* Parse buffer structure */
 /* Parse buffer structure */
 struct parsebuf
 struct parsebuf
 {
 {
-  char *token;                  /* Current token. Either points to tokbuf
-				   or is allocated within `alloc' chain */
-  char tokbuf[MAXTOKEN+1];      /* Token buffer for short tokens */
-
-  char *arg;                    /* Rest of command line to be parsed */
+  imap4d_tokbuf_t tok;          /* Token buffer */   
+  int arg;                      /* Argument number */
+  char *token;                  /* Current token */
   int isuid;                    /* UIDs instead of msgnos are required */ 
   int isuid;                    /* UIDs instead of msgnos are required */ 
   char *err_mesg;               /* Error message if a parse error occured */
   char *err_mesg;               /* Error message if a parse error occured */
   struct mem_chain *alloc;      /* Chain of objects allocated during parsing */
   struct mem_chain *alloc;      /* Chain of objects allocated during parsing */
@@ -249,30 +248,45 @@ static int parse_gettoken (struct parsebuf *pb, int req);
 static int search_run (struct parsebuf *pb);
 static int search_run (struct parsebuf *pb);
 static void do_search (struct parsebuf *pb);
 static void do_search (struct parsebuf *pb);
 
 
+/*
+6.4.4.  SEARCH Command
+
+   Arguments:  OPTIONAL [CHARSET] specification
+               searching criteria (one or more)
+
+   Responses:  REQUIRED untagged response: SEARCH
+
+   Result:     OK - search completed
+               NO - search error: can't search that [CHARSET] or
+                    criteria
+               BAD - command unknown or arguments invalid
+*/
+
 int
 int
-imap4d_search (struct imap4d_command *command, char *arg)
+imap4d_search (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
   int rc;
   int rc;
-  char buffer[64];
+  char *err_text= "";
   
   
-  rc = imap4d_search0 (arg, 0, buffer, sizeof buffer);
-  return util_finish (command, rc, "%s", buffer);
+  rc = imap4d_search0 (tok, 0, &err_text);
+  return util_finish (command, rc, "%s", err_text);
 }
 }
   
   
 int
 int
-imap4d_search0 (char *arg, int isuid, char *replybuf, size_t replysize)
+imap4d_search0 (imap4d_tokbuf_t tok, int isuid, char **err_text)
 {
 {
   struct parsebuf parsebuf;
   struct parsebuf parsebuf;
   
   
   memset (&parsebuf, 0, sizeof(parsebuf));
   memset (&parsebuf, 0, sizeof(parsebuf));
-  parsebuf.arg = arg;
+  parsebuf.tok = tok;
+  parsebuf.arg = IMAP4_ARG_1 + !!isuid;
   parsebuf.err_mesg = NULL;
   parsebuf.err_mesg = NULL;
   parsebuf.alloc = NULL;
   parsebuf.alloc = NULL;
   parsebuf.isuid = isuid;
   parsebuf.isuid = isuid;
 
 
   if (!parse_gettoken (&parsebuf, 0))
   if (!parse_gettoken (&parsebuf, 0))
     {
     {
-      snprintf (replybuf, replysize, "Too few args");
+      *err_text = "Too few args";
       return RESP_BAD;
       return RESP_BAD;
     }
     }
   
   
@@ -280,20 +294,20 @@ imap4d_search0 (char *arg, int isuid, char *replybuf, size_t replysize)
     {
     {
       if (!parse_gettoken (&parsebuf, 0))
       if (!parse_gettoken (&parsebuf, 0))
 	{
 	{
-	  snprintf (replybuf, replysize, "Too few args");
+	  *err_text = "Too few args";
 	  return RESP_BAD;
 	  return RESP_BAD;
 	}
 	}
 
 
       /* Currently only ASCII is supported */
       /* Currently only ASCII is supported */
       if (strcasecmp (parsebuf.token, "US-ASCII"))
       if (strcasecmp (parsebuf.token, "US-ASCII"))
 	{
 	{
-	  snprintf (replybuf, replysize, "Charset not supported");
+	  *err_text = "Charset not supported";
 	  return RESP_NO;
 	  return RESP_NO;
 	}
 	}
 
 
       if (!parse_gettoken (&parsebuf, 0))
       if (!parse_gettoken (&parsebuf, 0))
 	{
 	{
-	  snprintf (replybuf, replysize, "Too few args");
+	  *err_text = "Too few args";
 	  return RESP_BAD;
 	  return RESP_BAD;
 	}
 	}
 
 
@@ -304,16 +318,14 @@ imap4d_search0 (char *arg, int isuid, char *replybuf, size_t replysize)
   if (!parsebuf.tree)
   if (!parsebuf.tree)
     {
     {
       parse_free_mem (&parsebuf);
       parse_free_mem (&parsebuf);
-      snprintf (replybuf, replysize, "%s (near %s)",
-			  parsebuf.err_mesg,
-			  *parsebuf.arg ? parsebuf.arg : "end");
+      *err_text = "Parse error";
       return RESP_BAD;
       return RESP_BAD;
     }
     }
 
 
-  if (parsebuf.token[0] != 0)
+  if (parsebuf.token)
     {
     {
       parse_free_mem (&parsebuf);
       parse_free_mem (&parsebuf);
-      snprintf (replybuf, replysize, "Junk at the end of statement");
+      *err_text = "Junk at the end of statement";
       return RESP_BAD;
       return RESP_BAD;
     }
     }
   
   
@@ -322,7 +334,7 @@ imap4d_search0 (char *arg, int isuid, char *replybuf, size_t replysize)
   
   
   parse_free_mem (&parsebuf);
   parse_free_mem (&parsebuf);
   
   
-  snprintf (replybuf, replysize, "Completed");
+  *err_text = "Completed";
   return RESP_OK;
   return RESP_OK;
 }
 }
 
 
@@ -359,41 +371,13 @@ do_search (struct parsebuf *pb)
 int
 int
 parse_gettoken (struct parsebuf *pb, int req)
 parse_gettoken (struct parsebuf *pb, int req)
 {
 {
-  int rc;
-  char *s;
-  
-  pb->token = pb->tokbuf;
-  while (*pb->arg && *pb->arg == ' ')
-    pb->arg++;
-  switch (*pb->arg)
+  if (req && pb->arg >= imap4d_tokbuf_argc (pb->tok))
     {
     {
-    case '(':
-    case ')':
-      pb->token[0] = *pb->arg++;
-      pb->token[1] = 0;
-      rc = 1;
-      break;
-    case '"':
-      s = ++pb->arg;
-      while (*pb->arg && *pb->arg != '"')
-	pb->arg++;
-      rc = pb->arg - s;
-      if (*pb->arg)
-	pb->arg++;
-
-      if (rc >= sizeof(pb->tokbuf))
-	pb->token = parse_alloc (pb, rc+1);
-      memcpy (pb->token, s, rc);
-      pb->token[rc] = 0;
-      break;
-      
-    default:
-      rc = util_token (pb->token, sizeof(pb->tokbuf), &pb->arg);
-      break;
-    }
-  if (req && rc == 0)
       pb->err_mesg = "Unexpected end of statement";
       pb->err_mesg = "Unexpected end of statement";
-  return rc;
+      return 0;
+    }
+  pb->token = imap4d_tokbuf_getarg (pb->tok, pb->arg++);
+  return 1;
 }
 }
 
 
 /* Memory handling */
 /* Memory handling */
@@ -468,7 +452,7 @@ parse_search_key_list (struct parsebuf *pb)
 {
 {
   struct search_node *leftarg = NULL;
   struct search_node *leftarg = NULL;
   
   
-  while (pb->token[0] && pb->token[0] != ')')
+  while (pb->token && pb->token[0] != ')')
     {
     {
       struct search_node *rightarg = parse_search_key (pb);
       struct search_node *rightarg = parse_search_key (pb);
       if (!rightarg)
       if (!rightarg)
@@ -563,8 +547,8 @@ parse_equiv_key (struct parsebuf *pb)
 {
 {
   struct search_node *node;
   struct search_node *node;
   struct cond_equiv *condp;
   struct cond_equiv *condp;
-  char *arg;
-  char *save_arg;
+  int save_arg;
+  imap4d_tokbuf_t save_tok;
   
   
   for (condp = equiv_list; condp->name && strcasecmp (condp->name, pb->token);
   for (condp = equiv_list; condp->name && strcasecmp (condp->name, pb->token);
        condp++)
        condp++)
@@ -574,8 +558,9 @@ parse_equiv_key (struct parsebuf *pb)
     return parse_simple_key (pb);
     return parse_simple_key (pb);
 
 
   save_arg = pb->arg;
   save_arg = pb->arg;
-  arg = parse_strdup (pb, condp->equiv);
-  pb->arg = arg;
+  save_tok = pb->tok;
+  pb->tok = imap4d_tokbuf_from_string (condp->equiv);
+  pb->arg = 0;
 
 
   parse_gettoken (pb, 0);
   parse_gettoken (pb, 0);
 
 
@@ -587,8 +572,10 @@ parse_equiv_key (struct parsebuf *pb)
 		      __FILE__, __LINE__);
 		      __FILE__, __LINE__);
       abort (); 
       abort (); 
     }
     }
+  imap4d_tokbuf_destroy (&pb->tok);
   
   
   pb->arg = save_arg;
   pb->arg = save_arg;
+  pb->tok = save_tok;
   parse_gettoken (pb, 0);
   parse_gettoken (pb, 0);
   return node;
   return node;
 }
 }
@@ -658,7 +645,7 @@ parse_simple_key (struct parsebuf *pb)
 	      return NULL;
 	      return NULL;
 	    }
 	    }
 	  
 	  
-	  if (!pb->token[0])
+	  if (!pb->token)
 	    {
 	    {
 	      pb->err_mesg = "Not enough arguments for criterion";
 	      pb->err_mesg = "Not enough arguments for criterion";
 	      return NULL;
 	      return NULL;

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
    Copyright (C) 1999, 2001, 2003, 2005, 2006,
    Copyright (C) 1999, 2001, 2003, 2005, 2006,
-   2007 Free Software Foundation, Inc.
+   2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -24,25 +24,22 @@ static int select_flags;
 /* select          ::= "SELECT" SPACE mailbox  */
 /* select          ::= "SELECT" SPACE mailbox  */
 
 
 int
 int
-imap4d_select (struct imap4d_command *command, char *arg)
+imap4d_select (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
-  return imap4d_select0 (command, arg, MU_STREAM_RDWR);
+  if (imap4d_tokbuf_argc (tok) != 3)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
+  return imap4d_select0 (command, imap4d_tokbuf_getarg (tok, IMAP4_ARG_1),
+			 MU_STREAM_RDWR);
 }
 }
 
 
 /* This code is share with EXAMINE.  */
 /* This code is share with EXAMINE.  */
 int
 int
-imap4d_select0 (struct imap4d_command *command, char *arg, int flags)
+imap4d_select0 (struct imap4d_command *command, char *mailbox_name, int flags)
 {
 {
-  char *mailbox_name, *sp = NULL;
   int status;
   int status;
 
 
   /* FIXME: Check state.  */
   /* FIXME: Check state.  */
 
 
-  mailbox_name = util_getword (arg, &sp);
-  util_unquote (&mailbox_name);
-  if (mailbox_name == NULL || *mailbox_name == '\0')
-    return util_finish (command, RESP_BAD, "Too few arguments");
-
   /* Even if a mailbox is selected, a SELECT EXAMINE or LOGOUT
   /* Even if a mailbox is selected, a SELECT EXAMINE or LOGOUT
      command MAY be issued without previously issuing a CLOSE command.
      command MAY be issued without previously issuing a CLOSE command.
      The SELECT, EXAMINE, and LOGUT commands implictly close the
      The SELECT, EXAMINE, and LOGUT commands implictly close the

@@ -23,17 +23,26 @@
 static int tls_available;
 static int tls_available;
 static int tls_done;
 static int tls_done;
 
 
+/*
+6.2.1.  STARTTLS Command
+
+   Arguments:  none
+
+   Responses:  no specific response for this command
+
+   Result:     OK - starttls completed, begin TLS negotiation
+               BAD - command unknown or arguments invalid
+*/
 int
 int
-imap4d_starttls (struct imap4d_command *command, char *arg)
+imap4d_starttls (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
   int status;
   int status;
-  char *sp = NULL;
 
 
   if (!tls_available || tls_done)
   if (!tls_available || tls_done)
     return util_finish (command, RESP_BAD, "Invalid command");
     return util_finish (command, RESP_BAD, "Invalid command");
 
 
-  if (util_getword (arg, &sp))
-    return util_finish (command, RESP_BAD, "Too many args");
+  if (imap4d_tokbuf_argc (tok) != 2)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
 
 
   util_atexit (mu_deinit_tls_libs);
   util_atexit (mu_deinit_tls_libs);
 
 

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2005, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2005, 2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -53,10 +53,21 @@ status_get_handler (const char *name)
   return NULL;
   return NULL;
 }
 }
 
 
+/*
+6.3.10. STATUS Command
+
+   Arguments:  mailbox name
+               status data item names
+
+   Responses:  untagged responses: STATUS
+
+   Result:     OK - status completed
+               NO - status failure: no status for that name
+               BAD - command unknown or arguments invalid
+*/
 int
 int
-imap4d_status (struct imap4d_command *command, char *arg)
+imap4d_status (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
-  char *sp = NULL;
   char *name;
   char *name;
   char *mailbox_name;
   char *mailbox_name;
   const char *delim = "/";
   const char *delim = "/";
@@ -64,11 +75,12 @@ imap4d_status (struct imap4d_command *command, char *arg)
   int status;
   int status;
   int count = 0;
   int count = 0;
   char *err_msg = NULL;
   char *err_msg = NULL;
+  int argc = imap4d_tokbuf_argc (tok);
+
+  if (argc < 4)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
   
   
-  name = util_getword (arg, &sp);
-  util_unquote (&name);
-  if (!name || *name == '\0' || !sp || *sp == '\0')
-    return util_finish (command, RESP_BAD, "Too few args");
+  name = imap4d_tokbuf_getarg (tok, IMAP4_ARG_1);
 
 
   mailbox_name = namespace_getfullpath (name, delim);
   mailbox_name = namespace_getfullpath (name, delim);
 
 
@@ -85,20 +97,22 @@ imap4d_status (struct imap4d_command *command, char *arg)
       status = mu_mailbox_open (smbox, MU_STREAM_READ);
       status = mu_mailbox_open (smbox, MU_STREAM_READ);
       if (status == 0)
       if (status == 0)
 	{
 	{
-	  char item[32];
-	  item[0] = '\0';
+	  int i = IMAP4_ARG_2;
+	  char *item = imap4d_tokbuf_getarg (tok, i);
 	  
 	  
-	  if (*sp == '(')
-	    sp++;
-	  else
-	    *sp = 0;
+	  if (item[0] == '(')
+	    {
+	      if (imap4d_tokbuf_getarg (tok, argc - 1)[0] != ')')
+		return util_finish (command, RESP_BAD, "Invalid arguments");
+	      argc--;
+	      i++;
+	    }
 	  
 	  
-	  /* Get the status item names.  */
-	  while (*sp && *sp != ')')
+	  for (; i < argc; i++)
 	    {
 	    {
 	      status_funcp fun;
 	      status_funcp fun;
 
 
-	      util_token (item, sizeof (item), &sp);
+	      item = imap4d_tokbuf_getarg (tok, i);
 	      fun = status_get_handler (item);
 	      fun = status_get_handler (item);
 	      if (!fun)
 	      if (!fun)
 		{
 		{
@@ -112,6 +126,8 @@ imap4d_status (struct imap4d_command *command, char *arg)
 	      if (!fun (smbox))
 	      if (!fun (smbox))
 		util_send (" ");
 		util_send (" ");
 	    }
 	    }
+
+	  
 	  if (count > 0)
 	  if (count > 0)
 	    util_send (")\r\n");
 	    util_send (")\r\n");
 	  mu_mailbox_close (smbox);
 	  mu_mailbox_close (smbox);
@@ -193,5 +209,4 @@ status_unseen (mu_mailbox_t smbox)
     }
     }
   util_send ("UNSEEN %d", unseen);
   util_send ("UNSEEN %d", unseen);
   return 0;
   return 0;
-
 }
 }

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2005, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2005, 2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -23,134 +23,155 @@
  */
  */
 
 
 int
 int
-imap4d_store (struct imap4d_command *command, char *arg)
+imap4d_store (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
   int rc;
   int rc;
-  char buffer[64];
+  char *err_text;
   
   
-  rc = imap4d_store0 (arg, 0, buffer, sizeof buffer);
-  return util_finish (command, rc, "%s", buffer);
+  rc = imap4d_store0 (tok, 0, &err_text);
+  return util_finish (command, rc, "%s", err_text);
+}
+
+struct parsebuf
+{
+  char *token;
+  imap4d_tokbuf_t tok;
+  int arg;
+  jmp_buf errjmp;
+  char *err_text;
+};
+
+static void
+parsebuf_exit (struct parsebuf *p, char *text)
+{
+  p->err_text = text;
+  longjmp (p->errjmp, 1);
+}
+
+static char *
+parsebuf_next (struct parsebuf *p, int req)
+{
+  p->token = imap4d_tokbuf_getarg (p->tok, p->arg++);
+  if (!p->token && req)
+    parsebuf_exit (p, "Too few arguments");
+  return p->token;
 }
 }
 
 
 int
 int
-imap4d_store0 (char *arg, int isuid, char *resp, size_t resplen)
+imap4d_store0 (imap4d_tokbuf_t tok, int isuid, char **ptext)
 {
 {
   char *msgset;
   char *msgset;
-  char *data;
-  char *sp = NULL;
   int status;
   int status;
-  int ack = 0;
+  int ack = 1;
   size_t i;
   size_t i;
   int n = 0;
   int n = 0;
   size_t *set = NULL;
   size_t *set = NULL;
   enum value_type { STORE_SET, STORE_ADD, STORE_UNSET } how;
   enum value_type { STORE_SET, STORE_ADD, STORE_UNSET } how;
+  struct parsebuf pb;
+  char *data;
+  int type = 0;
   
   
-  msgset = util_getword (arg, &sp);
-  data = util_getword (NULL, &sp);
-
-  if (!msgset || !data || !sp || *sp == '\0')
+  pb.tok = tok;
+  pb.arg = IMAP4_ARG_1;
+  pb.err_text = NULL;
+  if (setjmp (pb.errjmp))
     {
     {
-      snprintf (resp, resplen, "Too few args");
+      *ptext = pb.err_text;
+      free (set);
       return RESP_BAD;
       return RESP_BAD;
     }
     }
       
       
-  /* The parsing of the data-item is a little slugish.  */
-  if (strcasecmp (data, "FLAGS") == 0)
-    {
-      ack = 1;
-      how = STORE_SET;
-    }
-  else if (strcasecmp (data, "+FLAGS") == 0)
+  msgset = parsebuf_next (&pb, 1);
+  data = parsebuf_next (&pb, 1);
+
+  if (*data == '+')
     {
     {
-      ack = 1;
       how = STORE_ADD;
       how = STORE_ADD;
+      data++;
     }
     }
-  else if (strcasecmp (data, "-FLAGS") == 0)
+  else if (*data == '-')
     {
     {
-      ack = 1;
       how = STORE_UNSET;
       how = STORE_UNSET;
+      data++;
     }
     }
-  else if (strcasecmp (data, "FLAGS.SILENT") == 0)
-    {
-      ack = 0;
+  else
     how = STORE_SET;
     how = STORE_SET;
-    }
-  else if (strcasecmp (data, "+FLAGS.SILENT") == 0)
+  
+  if (strcasecmp (data, "FLAGS"))
+    parsebuf_exit (&pb, "Bogus data item");
+  data = parsebuf_next (&pb, 1);
+
+  if (*data == '.')
     {
     {
-      ack = 0;
-      how = STORE_ADD;
-    }
-  else if (strcasecmp (data, "-FLAGS.SILENT") == 0)
+      data = parsebuf_next (&pb, 1);
+      if (strcasecmp (data, "SILENT") == 0)
 	{
 	{
 	  ack = 0;
 	  ack = 0;
-      how = STORE_UNSET;
+	  parsebuf_next (&pb, 1);
 	}
 	}
       else
       else
-    {
-      snprintf (resp, resplen, "Bogus data item");
-      return RESP_BAD;
+	parsebuf_exit (&pb, "Bogus data suffix");
     }
     }
 
 
   /* Get the message numbers in set[].  */
   /* Get the message numbers in set[].  */
   status = util_msgset (msgset, &set, &n, isuid);
   status = util_msgset (msgset, &set, &n, isuid);
   if (status != 0)
   if (status != 0)
+    parsebuf_exit (&pb, "Bogus number set");
+
+  if (pb.token[0] != '(')
+    parsebuf_exit (&pb, "Syntax error");
+  parsebuf_next (&pb, 1);
+  
+  do
     {
     {
-      snprintf (resp, resplen, "Bogus number set");
-      return RESP_BAD;
+      int t;
+      if (!util_attribute_to_type (pb.token, &t))
+	type |= t;
     }
     }
+  while (parsebuf_next (&pb, 1) && pb.token[0] != ')');
 
 
   for (i = 0; i < n; i++)
   for (i = 0; i < n; i++)
     {
     {
       mu_message_t msg = NULL;
       mu_message_t msg = NULL;
       mu_attribute_t attr = NULL;
       mu_attribute_t attr = NULL;
-      char *items = strdup (sp); /* Don't use the orignal list.  */
-      int first = 1;
-      size_t msgno;
-      char *p = items;
+      size_t msgno = isuid ? uid_to_msgno (set[i]) : set[i];
       
       
-      msgno = (isuid) ? uid_to_msgno (set[i]) : set[i];
       if (msgno)
       if (msgno)
 	{
 	{
 	  mu_mailbox_get_message (mbox, msgno, &msg);
 	  mu_mailbox_get_message (mbox, msgno, &msg);
 	  mu_message_get_attribute (msg, &attr);
 	  mu_message_get_attribute (msg, &attr);
 
 
-	  /* Get the fetch command names.  */
-	  while (*items && *items != ')')
+	  switch (how)
 	    {
 	    {
-	      int type = 0;
-	      char item[64] = "";
-	      util_token (item, sizeof (item), &items);
-	      if (!util_attribute_to_type (item, &type))
-		{
-		  if (how == STORE_ADD )
+	    case STORE_ADD:
 	      mu_attribute_set_flags (attr, type);
 	      mu_attribute_set_flags (attr, type);
-		  else if (how == STORE_UNSET )
+	      break;
+      
+	    case STORE_UNSET:
 	      mu_attribute_unset_flags (attr, type);
 	      mu_attribute_unset_flags (attr, type);
-		  else if (how == STORE_SET )
-		    {
-		      if (first)
-			{
-			  mu_attribute_set_flags (attr, 0);
-			  first = 0;
-			}
+	      break;
+      
+	    case STORE_SET:
+	      mu_attribute_unset_flags (attr, 0xffffffff); /* FIXME */
 	      mu_attribute_set_flags (attr, type);
 	      mu_attribute_set_flags (attr, type);
 	    }
 	    }
-		  mu_attribute_set_flags (attr, MU_ATTRIBUTE_MODIFIED);
-		}
-	    }
 	}
 	}
+
       if (ack)
       if (ack)
 	{
 	{
 	  util_send ("* %d FETCH (", msgno);
 	  util_send ("* %d FETCH (", msgno);
-	  fetch_flags0 ("FLAGS", msg, isuid);
-	  util_send (")\r\n");
+
+	  if (isuid)
+	    util_send ("UID %lu ", (unsigned long) msgno);
+	  util_send ("FLAGS (");
+	  util_print_flags (attr);
+	  util_send ("))\r\n");
 	}
 	}
-      free (p);
       /* Update the flags of uid table.  */
       /* Update the flags of uid table.  */
       imap4d_sync_flags (set[i]);
       imap4d_sync_flags (set[i]);
     }
     }
   free (set);
   free (set);
-  snprintf (resp, resplen, "Completed");
+  *ptext = "Completed";
   return RESP_OK;
   return RESP_OK;
 }
 }
 
 

@@ -19,21 +19,27 @@
 #include "imap4d.h"
 #include "imap4d.h"
 
 
 /*
 /*
-  FIXME: We need to lock the file to prevent simultaneous access.
- */
+6.3.6.  SUBSCRIBE Command
 
 
+   Arguments:  mailbox
+
+   Responses:  no specific responses for this command
+
+   Result:     OK - subscribe completed
+               NO - subscribe failure: can't subscribe to that name
+               BAD - command unknown or arguments invalid
+*/
 int
 int
-imap4d_subscribe (struct imap4d_command *command, char *arg)
+imap4d_subscribe (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
-  char *sp = NULL;
   char *name;
   char *name;
   char *file;
   char *file;
   FILE *fp;
   FILE *fp;
 
 
-  name = util_getword (arg, &sp);
-  util_unquote (&name);
-  if (!name || *name == '\0')
-    return util_finish (command, RESP_BAD, "Too few arguments");
+  if (imap4d_tokbuf_argc (tok) != 3)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
+
+  name = imap4d_tokbuf_getarg (tok, IMAP4_ARG_1);
 
 
   asprintf (&file, "%s/.mailboxlist", homedir);
   asprintf (&file, "%s/.mailboxlist", homedir);
   fp = fopen (file, "a");
   fp = fopen (file, "a");

 # -*- tcl -*-
 # -*- tcl -*-
 # This file is part of Mailutils testsuite.
 # This file is part of Mailutils testsuite.
-# Copyright (C) 2002, 2007 Free Software Foundation
+# Copyright (C) 2002, 2007, 2008 Free Software Foundation
 #  
 #  
 # This program is free software; you can redistribute it and/or modify
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # it under the terms of the GNU General Public License as published by
@@ -20,7 +20,7 @@
 imap4d_start 
 imap4d_start 
 
 
 imap4d_test "CAPABILITY" \
 imap4d_test "CAPABILITY" \
-            "CAPABILITY IMAP4rev1 NAMESPACE IDLE X-VERSION" \
+            "CAPABILITY IMAP4rev1 NAMESPACE IDLE LITERAL+ X-VERSION" \
 	    "OK"
 	    "OK"
 imap4d_test "NOOP"
 imap4d_test "NOOP"
 
 

@@ -48,7 +48,7 @@ Hello Joe, do you think we can meet at 3:30 tomorrow?
 
 
 " 
 " 
 
 
-imap4d_test -long "APPEND mbox 25-Aug-2002 18:00:00 +0200"\
+imap4d_test -long "APPEND mbox \"25-Aug-2002 18:00:00 +0200\""\
 "Date: Mon, 7 Feb 1994 21:52:25 -0800 (PST)
 "Date: Mon, 7 Feb 1994 21:52:25 -0800 (PST)
 From: Fred Foobar <foobar@Blurdybloop.COM>
 From: Fred Foobar <foobar@Blurdybloop.COM>
 Subject: afternoon meeting again
 Subject: afternoon meeting again
@@ -72,7 +72,7 @@ imap4d_test "SELECT mbox"\
 "OK"
 "OK"
 
 
 imap4d_test "FETCH 2:3 BODY\[\]"\
 imap4d_test "FETCH 2:3 BODY\[\]"\
-"2 FETCH (FLAGS (\\Seen) BODY\[\] {310}"\
+"2 FETCH (FLAGS (\\Seen) BODY\[\] {312}"\
 -literal\
 -literal\
 "Date: Mon, 7 Feb 1994 21:52:25 -0800 (PST)"\
 "Date: Mon, 7 Feb 1994 21:52:25 -0800 (PST)"\
 "From: Fred Foobar <foobar@Blurdybloop.COM>"\
 "From: Fred Foobar <foobar@Blurdybloop.COM>"\
@@ -83,9 +83,10 @@ imap4d_test "FETCH 2:3 BODY\[\]"\
 "Content-Type: TEXT/PLAIN; CHARSET=US-ASCII"\
 "Content-Type: TEXT/PLAIN; CHARSET=US-ASCII"\
 ""\
 ""\
 "Hello Joe, do you think we can meet at 3:30 tomorrow?"\
 "Hello Joe, do you think we can meet at 3:30 tomorrow?"\
+""\
 ")"\
 ")"\
 -noliteral\
 -noliteral\
-"3 FETCH (FLAGS (\\Seen) BODY\[\] {283}"\
+"3 FETCH (FLAGS (\\Seen) BODY\[\] {285}"\
 -literal\
 -literal\
 "Date: Mon, 7 Feb 1994 21:52:25 -0800 (PST)"\
 "Date: Mon, 7 Feb 1994 21:52:25 -0800 (PST)"\
 "From: Fred Foobar <foobar@Blurdybloop.COM>"\
 "From: Fred Foobar <foobar@Blurdybloop.COM>"\

@@ -37,7 +37,7 @@ imap4d_test "CREATE flat"
 
 
 imap4d_test "CREATE en/to/tre"
 imap4d_test "CREATE en/to/tre"
 
 
-imap4d_test -long "APPEND en/to/tre 25-Aug-2002 18:00:00 +0200"\
+imap4d_test -long "APPEND en/to/tre \"25-Aug-2002 18:00:00 +0200\""\
 "Date: Mon, 7 Feb 1994 21:52:25 -0800 (PST)
 "Date: Mon, 7 Feb 1994 21:52:25 -0800 (PST)
 From: Fred Foobar <foobar@Blurdybloop.COM>
 From: Fred Foobar <foobar@Blurdybloop.COM>
 Subject: afternoon meeting again
 Subject: afternoon meeting again
@@ -65,7 +65,7 @@ imap4d_test "SELECT en/to/tre"\
 "OK \[READ-WRITE\] SELECT Completed"
 "OK \[READ-WRITE\] SELECT Completed"
 
 
 imap4d_test "FETCH 1 ALL"\
 imap4d_test "FETCH 1 ALL"\
-"1 FETCH (FLAGS (\\Recent) INTERNALDATE \"25-Aug-2002 16:00:00 +0000\" RFC822.SIZE 283 ENVELOPE (\"Mon, 7 Feb 1994 21:52:25 -0800 (PST)\" \"afternoon meeting again\" ((\"Fred Foobar\" NIL \"foobar\" \"Blurdybloop.COM\")) ((\"Fred Foobar\" NIL \"foobar\" \"Blurdybloop.COM\")) ((\"Fred Foobar\" NIL \"foobar\" \"Blurdybloop.COM\")) ((NIL NIL \"mooch\" \"owatagu.siam.edu\")) NIL NIL NIL \"<B27397-0200000@Blurdybloop.COM>\"))"\
+"1 FETCH (FLAGS (\\Recent) INTERNALDATE \"25-Aug-2002 16:00:00 +0000\" RFC822.SIZE 285 ENVELOPE (\"Mon, 7 Feb 1994 21:52:25 -0800 (PST)\" \"afternoon meeting again\" ((\"Fred Foobar\" NIL \"foobar\" \"Blurdybloop.COM\")) ((\"Fred Foobar\" NIL \"foobar\" \"Blurdybloop.COM\")) ((\"Fred Foobar\" NIL \"foobar\" \"Blurdybloop.COM\")) ((NIL NIL \"mooch\" \"owatagu.siam.edu\")) NIL NIL NIL \"<B27397-0200000@Blurdybloop.COM>\"))"\
 "OK"
 "OK"
 
 
 	
 	

@@ -165,7 +165,7 @@ imap4d_test "FETCH 1 BODY\[HEADER\]"\
 # The subset returned by HEADER.FIELDS contains only those header fields
 # The subset returned by HEADER.FIELDS contains only those header fields
 # with a field-name that matches one of the names in the list;
 # with a field-name that matches one of the names in the list;
 
 
-imap4d_test "FETCH 1 BODY\[HEADER.FIELDS FROM TO SUBJECT\]"\
+imap4d_test "FETCH 1 BODY\[HEADER.FIELDS (FROM TO SUBJECT)\]"\
 "1 FETCH (BODY\[HEADER.FIELDS (\"FROM\" \"TO\" \"SUBJECT\")\] {94}"\
 "1 FETCH (BODY\[HEADER.FIELDS (\"FROM\" \"TO\" \"SUBJECT\")\] {94}"\
 -literal\
 -literal\
 "FROM: Foo Bar <foobar@nonexistent.net>"\
 "FROM: Foo Bar <foobar@nonexistent.net>"\
@@ -178,7 +178,7 @@ imap4d_test "FETCH 1 BODY\[HEADER.FIELDS FROM TO SUBJECT\]"\
 # similarly, the subset returned by HEADER.FIELDS.NOT contains only
 # similarly, the subset returned by HEADER.FIELDS.NOT contains only
 # the header fields with a non-matching field-name. 
 # the header fields with a non-matching field-name. 
 
 
-imap4d_test "FETCH 1 BODY\[HEADER.FIELDS.NOT FROM TO SUBJECT\]"\
+imap4d_test "FETCH 1 BODY\[HEADER.FIELDS.NOT (FROM TO SUBJECT)\]"\
 "1 FETCH (BODY\[HEADER.FIELDS.NOT (\"FROM\" \"TO\" \"SUBJECT\")\] {235}"\
 "1 FETCH (BODY\[HEADER.FIELDS.NOT (\"FROM\" \"TO\" \"SUBJECT\")\] {235}"\
 -literal\
 -literal\
 "Received: (from foobar@nonexistent.net) "\
 "Received: (from foobar@nonexistent.net) "\
@@ -330,8 +330,13 @@ imap4d_test "FETCH 3 BODY\[1.MIME\]"\
 "OK"
 "OK"
 
 
 imap4d_test "FETCH 4 BODY\[2.2.1\]"\
 imap4d_test "FETCH 4 BODY\[2.2.1\]"\
-"4 FETCH (FLAGS (\\Seen) BODY\[2.2.1\] {490}"\
+"4 FETCH (FLAGS (\\Seen) BODY\[2.2.1\] {680}"\
 -literal\
 -literal\
+"Content-Type: application/octet-stream; name=\"msg.23\""\
+"Content-ID: <5122.1026510654.6@Mirddin.farlep.net>"\
+"Content-Description: Father William Part III"\
+"Content-Transfer-Encoding: base64"\
+""\
 "YFlvdSBhcmUgb2xkLCcgc2FpZCB0aGUgeW91dGgsIGBhbmQgeW91ciBqYXdzIGFyZSB0b28gd2Vh"\
 "YFlvdSBhcmUgb2xkLCcgc2FpZCB0aGUgeW91dGgsIGBhbmQgeW91ciBqYXdzIGFyZSB0b28gd2Vh"\
 "awpGb3IgYW55dGhpbmcgdG91Z2hlciB0aGFuIHN1ZXQ7CllldCB5b3UgZmluaXNoZWQgdGhlIGdv"\
 "awpGb3IgYW55dGhpbmcgdG91Z2hlciB0aGFuIHN1ZXQ7CllldCB5b3UgZmluaXNoZWQgdGhlIGdv"\
 "b3NlLCB3aXRoIHRoZSBib25lcyBhbmQgdGhlIGJlYWstLQpQcmF5IGhvdyBkaWQgeW91IG1hbmFn"\
 "b3NlLCB3aXRoIHRoZSBib25lcyBhbmQgdGhlIGJlYWstLQpQcmF5IGhvdyBkaWQgeW91IG1hbmFn"\

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -24,36 +24,29 @@
  */
  */
 
 
 int
 int
-imap4d_uid (struct imap4d_command *command, char *arg)
+imap4d_uid (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
   char *cmd;
   char *cmd;
-  char *sp = NULL;
   int rc = RESP_NO;
   int rc = RESP_NO;
-  char buffer[64];
+  char *err_text = "Completed";
+
+  if (imap4d_tokbuf_argc (tok) < 3)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
+
+  cmd = imap4d_tokbuf_getarg (tok, IMAP4_ARG_1);
   
   
-  cmd = util_getword (arg, &sp);
-  if (!cmd)
-    util_finish (command, RESP_BAD, "Too few args");
   if (strcasecmp (cmd, "FETCH") == 0)
   if (strcasecmp (cmd, "FETCH") == 0)
-    {
-      rc = imap4d_fetch0 (sp, 1, buffer, sizeof buffer);
-    }
+    rc = imap4d_fetch0 (tok, 1, &err_text);
   else if (strcasecmp (cmd, "COPY") == 0)
   else if (strcasecmp (cmd, "COPY") == 0)
-    {
-      rc = imap4d_copy0 (sp, 1, buffer, sizeof buffer);
-    }
+    rc = imap4d_copy0 (tok, 1, &err_text);
   else if (strcasecmp (cmd, "STORE") == 0)
   else if (strcasecmp (cmd, "STORE") == 0)
-    {
-      rc = imap4d_store0 (sp, 1, buffer, sizeof buffer);
-    }
+    rc = imap4d_store0 (tok, 1, &err_text);
   else if (strcasecmp (cmd, "SEARCH") == 0)
   else if (strcasecmp (cmd, "SEARCH") == 0)
-    {
-      rc = imap4d_search0 (sp, 1, buffer, sizeof buffer);
-    }
+    rc = imap4d_search0 (tok, 1, &err_text);
   else
   else
     {
     {
-      snprintf (buffer, sizeof buffer, "Error uknown uid command");
+      err_text = "Uknown uid command";
       rc = RESP_BAD;
       rc = RESP_BAD;
     }
     }
-  return util_finish (command, rc, "%s %s", cmd, buffer);
+  return util_finish (command, rc, "%s %s", cmd, err_text);
 }
 }

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -71,19 +71,34 @@ unsubscribe (struct scan_data *data, char *name)
   return 0;
   return 0;
 }
 }
 
 
+/*
+6.3.7.  UNSUBSCRIBE Command
+
+   Arguments:  mailbox name
+
+   Responses:  no specific responses for this command
+
+   Result:     OK - unsubscribe completed
+               NO - unsubscribe failure: can't unsubscribe that name
+               BAD - command unknown or arguments invalid
+
+      The UNSUBSCRIBE command removes the specified mailbox name from
+      the server's set of "active" or "subscribed" mailboxes as returned
+      by the LSUB command.  This command returns a tagged OK response
+      only if the unsubscription is successful.
+*/
 int
 int
-imap4d_unsubscribe (struct imap4d_command *command, char *arg)
+imap4d_unsubscribe (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
-  char *sp = NULL;
   char *name;
   char *name;
   char *file;
   char *file;
   struct scan_data sd;
   struct scan_data sd;
   int rc;
   int rc;
   
   
-  name = util_getword (arg, &sp);
-  util_unquote (&name);
-  if (!name || *name == '\0')
-    return util_finish (command, RESP_BAD, "Too few arguments");
+  if (imap4d_tokbuf_argc (tok) != 3)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
+
+  name = imap4d_tokbuf_getarg (tok, IMAP4_ARG_1);
 
 
   asprintf (&file, "%s/.mailboxlist", homedir);
   asprintf (&file, "%s/.mailboxlist", homedir);
   sd.result = 0;
   sd.result = 0;

@@ -25,92 +25,6 @@ static mu_stream_t ostream;
 static int add2set (size_t **, int *, unsigned long);
 static int add2set (size_t **, int *, unsigned long);
 static const char *sc2string (int);
 static const char *sc2string (int);
 
 
-/* Get the next space/CR/NL separated word, some words are between double
-   quotes, strtok() cannot handle it.  */
-char *
-util_getword (char *s, char **save)
-{
-  return util_getitem (s, " \r\n", save);
-}
-
-/* Take care of words between double quotes.  */
-char *
-util_getitem (char *s, const char *delim, char **save)
-{
-  {
-    char *p;
-    if ((p = s) || (p = *save))
-      {
-	while (isspace ((unsigned) *p))
-	  p++;
-	if (*p == '"')
-	  {
-	    s = p;
-	    p++;
-	    while (*p && *p != '"')
-	      p++;
-	    if (*p == '"')
-	      p++;
-	    *save = (*p) ? p + 1 : p;
-	    *p = '\0';
-	    return s;
-	  }
-      }
-  }
-  return strtok_r (s, delim, save);
-}
-
-/* Stop at the first char that represents an IMAP4 special character. */
-int
-util_token (char *buf, size_t len, char **ptr)
-{
-  char *start = *ptr;
-  size_t i;
-  /* Skip leading space.  */
-  while (**ptr && **ptr == ' ')
-    (*ptr)++;
-
-  /* Break the string by token, i.e when we reconize IMAP special
-     atoms we stop and send it.  */
-  for (i = 1; **ptr && i < len; (*ptr)++, buf++, i++)
-    {
-      if (**ptr == ' ' || **ptr == '.'
-	  || **ptr == '(' || **ptr == ')'
-	  || **ptr == '[' || **ptr == ']'
-	  || **ptr == '<' || **ptr == '>' || **ptr == '\r' || **ptr == '\n')
-	{
-	  /* Advance.  */
-	  if (start == (*ptr))
-	    (*ptr)++;
-	  break;
-	}
-      *buf = **ptr;
-    }
-  *buf = '\0';
-  /* Skip trailing space.  */
-  while (**ptr && **ptr == ' ')
-    (*ptr)++;
-  return *ptr - start;
-}
-
-/* Remove the surrounding double quotes.  */
-/* FIXME:  Check if the quote was escaped and ignore it.  */
-void
-util_unquote (char **ptr)
-{
-  char *s = *ptr;
-  size_t len;
-  if (s && *s == '"' && (len = strlen (s)) > 1 && s[len - 1] == '"')
-    {
-      char *p = ++s;
-      while (*p && *p != '"')
-	p++;
-      if (*p == '"')
-	*p = '\0';
-    }
-  *ptr = s;
-}
-
 /* NOTE: Allocates Memory.  */
 /* NOTE: Allocates Memory.  */
 /* Expand: ~ --> /home/user and to ~guest --> /home/guest.  */
 /* Expand: ~ --> /home/user and to ~guest --> /home/guest.  */
 char *
 char *
@@ -266,8 +180,8 @@ util_msgset (char *s, size_t ** set, int *n, int isuid)
 	  s++;
 	  s++;
 	  break;
 	  break;
 
 
-	  /* As a convenience. '*' is provided to refer to the highest message
-	     number int the mailbox:
+	  /* As a convenience. '*' is provided to refer to the highest
+	     message number int the mailbox:
 	     5:*  --> 5 6 7 8
 	     5:*  --> 5 6 7 8
 	   */
 	   */
 	case '*':
 	case '*':
@@ -479,143 +393,30 @@ util_finish (struct imap4d_command *command, int rc, const char *format, ...)
   return status;
   return status;
 }
 }
 
 
-/* Clients are allowed to send literal string to the servers.  this
-   means that it can occur everywhere where a string is allowed.
-   A literal is a sequence of zero or more octets (including CR and LF)
-   prefix-quoted with an octet count in the form of an open brace ("{"),
-   the number of octets, close brace ("}"), and CRLF.
- */
-char *
-imap4d_readline (void)
-{
-  char buffer[512];
-  size_t len;
-  long number = 0;
-  size_t total = 0;
-  char *line = malloc (1);
-
-  if (!line)
-    imap4d_bye (ERR_NO_MEM);
-
-  line[0] = '\0';		/* start with a empty string.  */
-  do
-    {
-      size_t sz;
-      int rc;
-      
-      alarm (idle_timeout);
-      rc = mu_stream_sequential_readline (istream, buffer, sizeof (buffer), &sz);
-      if (sz == 0)
-	{
-	  mu_diag_output (MU_DIAG_INFO, _("Unexpected eof on input"));
-	  imap4d_bye (ERR_NO_OFILE);
-	}
-      else if (rc)
-	{
-	  const char *p;
-	  if (mu_stream_strerror (istream, &p))
-	    p = strerror (errno);
-
-	  mu_diag_output (MU_DIAG_INFO, _("Error reading from input file: %s"), p);
-	  imap4d_bye (ERR_NO_OFILE);
-	}
-      alarm (0);
-
-      len = strlen (buffer);
-      /* If we were in a litteral substract. We have to do it here since the CR
-         is part of the count in a literal.  */
-      if (number)
-	number -= len;
-
-      /* Remove CR.  */
-      if (len > 1 && buffer[len - 1] == '\n')
-	{
-	  if (buffer[len - 2] == '\r')
-	    {
-	      buffer[len - 2] = '\n';
-	      buffer[len - 1] = '\0';
-	    }
-	}
-      line = realloc (line, total + len + 1);
-      if (!line)
-	imap4d_bye (ERR_NO_MEM);
-      strcat (line, buffer);
-
-      total = strlen (line);
-
-      /* I observe some client requesting long FETCH operations since, I did
-         not see any limit in the command length in the RFC, catch things
-         here.  */
-      /* Check that we do have a terminated NL line and we are not retrieving
-         a literal. If we don't continue the read.  */
-      if (number <= 0 && total && line[total - 1] != '\n')
-	continue;
-
-      /* Check if the client try to send a literal and make sure we are not
-         already retrieving a literal.  */
-      if (number <= 0 && len > 2)
-	{
-	  size_t n = total - 1;	/* C arrays are 0-based.  */
-	  /* A literal is this "{number}\n".  The CR is already strip.  */
-	  if (line[n] == '\n' && line[n - 1] == '}')
-	    {
-	      /* Search for the matching bracket.  */
-	      while (n && line[n] != '{')
-		n--;
-	      if (line[n] == '{')
-		{
-		  char *sp = NULL;
-		  /* Truncate where the literal number was.  */
-		  line[n] = '\0';
-		  number = strtoul (line + n + 1, &sp, 10);
-		  /* Client can ask for non synchronise literal,
-		     if a '+' is append to the octet count. */
-		  if (*sp != '+')
-		    util_send ("+ GO AHEAD\r\n");
-		}
-	    }
-	}
-    }
-  while (number > 0 || (total && line[total - 1] != '\n'));
-  if (imap4d_transcript)
-    mu_diag_output (MU_DIAG_DEBUG, "recv: %s", line);
-  return line;
-}
-
-char *
-imap4d_readline_ex (void)
-{
-  int len;
-  char *s = imap4d_readline ();
-
-  if (s && (len = strlen (s)) > 0 && s[len - 1] == '\n')
-    s[len - 1] = 0;
-  return s;
-}
-
 int
 int
-util_do_command (char *prompt)
+util_do_command (imap4d_tokbuf_t tok)
 {
 {
-  char *sp = NULL, *tag, *cmd;
+  char *tag, *cmd;
   struct imap4d_command *command;
   struct imap4d_command *command;
   static struct imap4d_command nullcommand;
   static struct imap4d_command nullcommand;
-  size_t len;
+  int argc = imap4d_tokbuf_argc (tok);
   
   
-  tag = util_getword (prompt, &sp);
-  cmd = util_getword (NULL, &sp);
-  if (!tag)
+  if (argc == 0)
     {
     {
       nullcommand.name = "";
       nullcommand.name = "";
       nullcommand.tag = (char *) "*";
       nullcommand.tag = (char *) "*";
       return util_finish (&nullcommand, RESP_BAD, "Null command");
       return util_finish (&nullcommand, RESP_BAD, "Null command");
     }
     }
-  else if (!cmd)
+  else if (argc == 1)
     {
     {
       nullcommand.name = "";
       nullcommand.name = "";
       nullcommand.tag = tag;
       nullcommand.tag = tag;
-      return util_finish (&nullcommand, RESP_BAD, "Missing arguments");
+      return util_finish (&nullcommand, RESP_BAD, "Missing command");
     }
     }
 
 
+  tag = imap4d_tokbuf_getarg (tok, 0);
+  cmd = imap4d_tokbuf_getarg (tok, 1);
+  
   command = util_getcommand (cmd, imap4d_command_table);
   command = util_getcommand (cmd, imap4d_command_table);
   if (command == NULL)
   if (command == NULL)
     {
     {
@@ -629,10 +430,7 @@ util_do_command (char *prompt)
   if (command->states && (command->states & state) == 0)
   if (command->states && (command->states & state) == 0)
     return util_finish (command, RESP_BAD, "Wrong state");
     return util_finish (command, RESP_BAD, "Wrong state");
 
 
-  len = strlen (sp);
-  if (len && sp[len - 1] == '\n')
-    sp[len - 1] = '\0';
-  return command->func (command, sp);
+  return command->func (command, tok);
 }
 }
 
 
 int
 int
@@ -702,7 +500,7 @@ add2set (size_t ** set, int *n, unsigned long val)
 }
 }
 
 
 int
 int
-util_parse_internal_date0 (char *date, time_t * timep, char **endp)
+util_parse_internal_date (char *date, time_t * timep)
 {
 {
   struct tm tm;
   struct tm tm;
   mu_timezone tz;
   mu_timezone tz;
@@ -717,19 +515,10 @@ util_parse_internal_date0 (char *date, time_t * timep, char **endp)
     return 2;
     return 2;
 
 
   *timep = time;
   *timep = time;
-  if (endp)
-    *endp = *datep;
   return 0;
   return 0;
 }
 }
 
 
 int
 int
-util_parse_internal_date (char *date, time_t * timep)
-{
-  return util_parse_internal_date0 (date, timep, NULL);
-}
-
-
-int
 util_parse_822_date (const char *date, time_t * timep)
 util_parse_822_date (const char *date, time_t * timep)
 {
 {
   struct tm tm;
   struct tm tm;
@@ -875,35 +664,6 @@ util_attribute_matches_flag (mu_attribute_t attr, const char *item)
   return flags & mask;
   return flags & mask;
 }
 }
 
 
-
-int
-util_parse_attributes (char *items, char **save, int *flags)
-{
-  int rc = 0;
-
-  *flags = 0;
-  while (*items)
-    {
-      int type = 0;
-      char item[64] = "";
-
-      util_token (item, sizeof (item), &items);
-      if (!util_attribute_to_type (item, &type))
-	*flags |= type;
-      /*FIXME: else? */
-
-      if (*items == ')')
-	{
-	  items++;
-	  rc = 0;
-	  break;
-	}
-    }
-
-  *save = items;
-  return rc;
-}
-
 int
 int
 util_base64_encode (const unsigned char *input, size_t input_len,
 util_base64_encode (const unsigned char *input, size_t input_len,
 		    unsigned char **output, size_t * output_len)
 		    unsigned char **output, size_t * output_len)
@@ -1324,3 +1084,327 @@ is_atom (const char *s)
   return 1;
   return 1;
 }
 }
      
      
+
+static size_t
+remove_cr (char *line, size_t len)
+{
+  char *prev = NULL;
+  size_t rlen = len;
+  char *p;
+  while ((p = memchr (line, '\r', len)))
+    {
+      if (prev)
+	{
+	  memmove (prev, line, p - line);
+	  prev += p - line;
+	}
+      else
+	prev = p;
+      rlen--;
+      len -= p - line + 1;
+      line = p + 1;
+    }
+  if (prev)
+    memmove (prev, line, len);
+  return rlen;
+}
+
+static size_t
+unquote (char *line, size_t len)
+{
+  char *prev = NULL;
+  size_t rlen = len;
+  char *p;
+  int off = 0;
+  while ((p = memchr (line + off, '\\', len - off)))
+    {
+      if (p[1] == '\\' || p[1] == '"')
+	{
+	  if (prev)
+	    {
+	      memmove (prev, line, p - line);
+	      prev += p - line;
+	    }
+	  else
+	    prev = p;
+	  off = p[1] == '\\';
+	  rlen--;
+	  len -= p - line + 1;
+	  line = p + 1;
+	}
+    }
+  if (prev)
+    memmove (prev, line, len);
+  return rlen;
+}
+
+struct imap4d_tokbuf {
+  char *buffer;
+  size_t size;
+  size_t level;
+  int argc;
+  int argmax;
+  size_t *argp;
+};
+
+struct imap4d_tokbuf *
+imap4d_tokbuf_init ()
+{
+  struct imap4d_tokbuf *tok = malloc (sizeof (tok[0]));
+  if (!tok)
+    imap4d_bye (ERR_NO_MEM);
+  memset (tok, 0, sizeof (*tok));
+  return tok;
+}
+
+void
+imap4d_tokbuf_destroy (struct imap4d_tokbuf **ptok)
+{
+  struct imap4d_tokbuf *tok = *ptok;
+  free (tok->buffer);
+  free (tok->argp);
+  free (tok);
+  *ptok = NULL;
+}
+
+int
+imap4d_tokbuf_argc (struct imap4d_tokbuf *tok)
+{
+  return tok->argc;
+}
+
+char *
+imap4d_tokbuf_getarg (struct imap4d_tokbuf *tok, int n)
+{
+  if (n < tok->argc)
+    return tok->buffer + tok->argp[n];
+  return NULL;
+}
+
+static void
+imap4d_tokbuf_unquote (struct imap4d_tokbuf *tok, size_t *poff, size_t *plen)
+{
+  char *buf = tok->buffer + *poff;
+  if (buf[0] == '"' && buf[*plen - 1] == '"')
+    {
+      ++*poff;
+      *plen = unquote (buf + 1, *plen - 1);
+    }
+}
+
+static void
+imap4d_tokbuf_expand (struct imap4d_tokbuf *tok, size_t size)
+{
+  if (tok->size - tok->level < size)	       
+    {						
+      tok->size = tok->level + size;
+      tok->buffer = realloc (tok->buffer, tok->size);
+      if (!tok->buffer)				
+	imap4d_bye (ERR_NO_MEM);
+    }
+}
+
+#define ISDELIM(c) (strchr (".()[]<>", (c)) != NULL)
+#define ISWS(c) (c == ' ' || c == '\t')
+
+int
+util_isdelim (const char *str)
+{
+  return str[1] == 0 && ISDELIM (str[0]);
+}
+
+static size_t
+insert_nul (struct imap4d_tokbuf *tok, size_t off)
+{
+  imap4d_tokbuf_expand (tok, 1);
+  if (off < tok->level)
+    {
+      memmove (tok->buffer + off + 1, tok->buffer + off, tok->level - off);
+      tok->level++;
+    }
+  tok->buffer[off] = 0;
+  return off + 1;
+}
+
+static size_t
+gettok (struct imap4d_tokbuf *tok, size_t off)
+{
+  char *buf = tok->buffer;
+  
+  while (off < tok->level && ISWS (buf[off]))
+    off++;
+
+  if (tok->argc == tok->argmax)
+    {
+      if (tok->argmax == 0)
+	tok->argmax = 16;
+      else
+	tok->argmax *= 2;
+      tok->argp = realloc(tok->argp, tok->argmax * sizeof (tok->argp[0]));
+      if (!tok->argp)
+	imap4d_bye (ERR_NO_MEM);
+    }
+  
+  if (buf[off] == '"')
+    {
+      char *start = buf + off + 1;
+      char *p = NULL;
+      
+      while (*start && (p = strchr (start, '"')))
+	{
+	  if (p == start || p[-1] != '\\')
+	    break;
+	  start = p + 1;
+	}
+
+      if (p)
+	{
+	  size_t len;
+	  off++;
+	  len  = unquote(buf + off, p - (buf + off));
+	  buf[off + len] = 0;
+	  tok->argp[tok->argc++] = off;
+	  return p - buf + 1;
+	}
+    }
+
+  tok->argp[tok->argc++] = off;
+  if (ISDELIM (buf[off]))
+    return insert_nul (tok, off + 1);
+
+  while (off < tok->level && !ISWS (buf[off]))
+    {
+      if (ISDELIM (buf[off]))
+	return insert_nul (tok, off);
+      off++;
+    }
+  buf[off++] = 0;
+  
+  return off;
+}
+
+static void
+imap4d_tokbuf_tokenize (struct imap4d_tokbuf *tok, size_t off)
+{
+  while (off < tok->level)
+    off = gettok (tok, off);
+}
+
+static void
+check_input_err (int rc, size_t sz)
+{
+  if (rc)
+    {
+      const char *p;
+      if (mu_stream_strerror (istream, &p))
+	p = mu_strerror (rc);
+      
+      mu_diag_output (MU_DIAG_INFO,
+		      _("Error reading from input file: %s"), p);
+      imap4d_bye (ERR_NO_OFILE);
+    }
+  else if (sz == 0)
+    {
+      mu_diag_output (MU_DIAG_INFO, _("Unexpected eof on input"));
+      imap4d_bye (ERR_NO_OFILE);
+    }
+}
+
+static size_t
+imap4d_tokbuf_getline (struct imap4d_tokbuf *tok)
+{
+  char buffer[512];
+  size_t level = tok->level;
+  
+  do
+    {
+      size_t len;
+      int rc;
+      
+      rc = mu_stream_sequential_readline (istream,
+					  buffer, sizeof (buffer), &len);
+      check_input_err (rc, len);
+      imap4d_tokbuf_expand (tok, len);
+      
+      memcpy (tok->buffer + tok->level, buffer, len);
+      tok->level += len;
+    }
+  while (tok->level && tok->buffer[tok->level - 1] != '\n');
+  tok->buffer[--tok->level] = 0;
+  if (tok->buffer[tok->level - 1] == '\r')
+    tok->buffer[--tok->level] = 0;
+  return level;
+}
+
+void
+imap4d_readline (struct imap4d_tokbuf *tok)
+{
+  tok->argc = 0;
+  for (;;)
+    {
+      char *last_arg;
+      size_t off = imap4d_tokbuf_getline (tok);
+      imap4d_tokbuf_tokenize (tok, off);
+      last_arg = tok->buffer + tok->argp[tok->argc - 1];
+      if (last_arg[0] == '{' && last_arg[strlen(last_arg)-1] == '}')
+	{
+	  int rc;
+	  unsigned long number;
+	  char *sp = NULL;
+	  char *buf;
+	  size_t len;
+	  
+	  number = strtoul (last_arg + 1, &sp, 10);
+	  /* Client can ask for non-synchronised literal,
+	     if a '+' is appended to the octet count. */
+	  if (*sp == '}')
+	    util_send ("+ GO AHEAD\r\n");
+	  else if (*sp != '+')
+	    break;
+	  imap4d_tokbuf_expand (tok, number + 1);
+	  off = tok->level;
+	  buf = tok->buffer + off;
+	  rc = mu_stream_sequential_read (istream, buf, number, &len);
+	  check_input_err (rc, len);
+	  len = remove_cr (buf, len);
+	  imap4d_tokbuf_unquote (tok, &off, &len);
+	  tok->level += len;
+	  tok->buffer[tok->level++] = 0;
+	  tok->argp[tok->argc - 1] = off;
+	  if (buf[len-1] != '\n')
+	    continue;
+	}
+      break;
+    }
+}  
+
+struct imap4d_tokbuf *
+imap4d_tokbuf_from_string (char *str)
+{
+  struct imap4d_tokbuf *tok = imap4d_tokbuf_init ();
+  tok->buffer = strdup (str);
+  if (!tok->buffer)
+    imap4d_bye (ERR_NO_MEM);
+  tok->level = strlen (str);
+  tok->size = tok->level + 1;
+  imap4d_tokbuf_tokenize (tok, 0);
+  return tok;
+}
+
+int
+imap4d_getline (char **pbuf, size_t *psize, size_t *pnbytes)
+{
+  size_t len;
+  int rc = mu_stream_sequential_getline (istream, pbuf, psize, &len);
+  if (rc == 0)
+    {
+      char *s = *pbuf;
+      if (s && len > 0 && s[len - 1] == '\n')
+	s[--len] = 0;
+      if (s && len > 0 && s[len - 1] == '\r')
+	s[--len] = 0;
+      if (pnbytes)
+	*pnbytes = len;
+    }
+  return rc;
+}

 /* GNU Mailutils -- a suite of utilities for electronic mail
 /* GNU Mailutils -- a suite of utilities for electronic mail
-   Copyright (C) 1999, 2001, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2001, 2007, 2008 Free Software Foundation, Inc.
 
 
    GNU Mailutils is free software; you can redistribute it and/or modify
    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
    it under the terms of the GNU General Public License as published by
@@ -19,8 +19,10 @@
 #include "imap4d.h"
 #include "imap4d.h"
 
 
 int
 int
-imap4d_version (struct imap4d_command *command, char *arg)
+imap4d_version (struct imap4d_command *command, imap4d_tokbuf_t tok)
 {
 {
+  if (imap4d_tokbuf_argc (tok) != 2)
+    return util_finish (command, RESP_BAD, "Invalid arguments");
   util_send ("* %s GNU %s\r\n", command->name, program_version);
   util_send ("* %s GNU %s\r\n", command->name, program_version);
   return util_finish (command, RESP_OK, "Completed");
   return util_finish (command, RESP_OK, "Completed");
 }
 }

@@ -145,7 +145,7 @@ mail_tmp_finish (struct mail_tmp *mtmp, mu_mailbox_t *mbox)
     }
     }
 
 
   mu_stream_flush (mtmp->stream);
   mu_stream_flush (mtmp->stream);
-  if ((status = mu_mailbox_create (mbox, "/dev/null")) 
+  if ((status = mu_mailbox_create (mbox, "mbox:/dev/null")) 
       || (status = mu_mailbox_open (*mbox, MU_STREAM_READ))
       || (status = mu_mailbox_open (*mbox, MU_STREAM_READ))
       || (status = mu_mailbox_set_stream (*mbox, mtmp->stream)))
       || (status = mu_mailbox_set_stream (*mbox, mtmp->stream)))
     {
     {

@@ -51,7 +51,7 @@ _memory_destroy (mu_stream_t stream)
   struct _memory_stream *mfs = mu_stream_get_owner (stream);
   struct _memory_stream *mfs = mu_stream_get_owner (stream);
   if (mfs && mfs->ptr != NULL)
   if (mfs && mfs->ptr != NULL)
     free (mfs->ptr);
     free (mfs->ptr);
-  if(mfs->filename)
+  if (mfs->filename)
     free (mfs->filename);
     free (mfs->filename);
   free (mfs);
   free (mfs);
 }
 }