* mail/mail.c: Possibility to enable debuging output.

It should probably be a runtime option via set debug=1 or something for now it is disable between if (0) {...}. More cleanup in the IMAP code. A memory stream buffer is use to save the string literal sended by the IMAP server. The allocation is handle by the memory_stream which simplifies the code. * folder_imap.c (folder_imap.c): Create a memory stream to hold the literal or quoted string send by the IMAP server. (folder_imap_list folder_imap_lsub): There is no callback field the struct folder_list is in struct _f_imap now. (imap_literal_string imap_quoted_string imap_string): Use the memory string stream to save the result. (imap_body): Still need to be clean, but creates the cache header when doing the scan. (imap_parse): Do not use alloca().

* mail/mail.c: Possibility to enable debuging output.
It should probably be a runtime option via set debug=1 or something for now it is disable between if (0) {...}. More cleanup in the IMAP code. A memory stream buffer is use to save the string literal sended by the IMAP server. The allocation is handle by the memory_stream which simplifies the code. * folder_imap.c (folder_imap.c): Create a memory stream to hold the literal or quoted string send by the IMAP server. (folder_imap_list folder_imap_lsub): There is no callback field the struct folder_list is in struct _f_imap now. (imap_literal_string imap_quoted_string imap_string): Use the memory string stream to save the result. (imap_body): Still need to be clean, but creates the cache header when doing the scan. (imap_parse): Do not use alloca().
Alain Magloire
Commit ed1175f9 ... ed1175f91d78846077062af5cf8a969dbaff80a6 authored 2001-10-14 04:08:21 +0000 by Alain Magloire
Showing 7 changed files with 255 additions and 138 deletions
ChangeLog
mail/mail.c
mailbox/folder_imap.c
mailbox/include/imap0.h
mailbox/mbx_imap.c
mailbox/memory_stream.c
mailbox2/memstream.c
--- a/ChangeLog
View file @ed1175f
+++ b/ChangeLog
View file @ed1175f
-2001-10-13  Jeff Bailey  <jbailey@outpost.dnsalias.org>
+2001-10-13  Alain Malgoire
+	* mail/mail.c: Possibility to enable debuging output.
+	It should probably be a runtime option via set debug=1 or something
+	for now it is disable between if (0) {...}.
+	More cleanup in the IMAP code.  A memory stream buffer is
+	use to save the string literal sended by the IMAP server.
+	The allocation is handle by the memory_stream which simplifies
+	the code.
+	* folder_imap.c (folder_imap.c): Create a memory stream to
+	hold the literal or quoted string send by the IMAP server.
+	(folder_imap_list folder_imap_lsub): There is no callback
+	field the struct folder_list is in struct _f_imap now.
+	(imap_literal_string imap_quoted_string imap_string):  Use the
+	memory string stream to save the result.
+	(imap_body): Still need to be clean, but creates the cache
+	header when doing the scan.
+	(imap_parse): Do not use alloca().
+2001-10-13  Jeff Bailey
 	* guimb/Makefile.am: Remove GNU Makeism.
 	* libmu_scm/Makefile.am: Remove GNU Makeism.
-2001-10-12  Jeff Bailey  <jbailey@outpost.dnsalias.org>
+2001-10-12  Jeff Bailey
 	* libmu_scm/Makefile.am: Fixes for RO srcdir.
--- a/mail/mail.c
View file @ed1175f
+++ b/mail/mail.c
View file @ed1175f
@@ -345,6 +345,14 @@ main (int argc, char **argv)
 	  exit (EXIT_FAILURE);
 	}
+      /* Could we enable this at runtime, via the a set environment?  */
+      if (0)
+	{
+	  mu_debug_t debug = NULL;
+	  mailbox_get_debug (mbox, &debug);
+	  mu_debug_set_level (debug, MU_DEBUG_TRACE|MU_DEBUG_PROT);
+	}
      if (mailbox_open (mbox, MU_STREAM_RDWR) != 0)
 	{
 	  util_error ("Can not open mailbox");
--- a/mailbox/folder_imap.c
View file @ed1175f
+++ b/mailbox/folder_imap.c
View file @ed1175f
@@ -264,11 +264,15 @@ folder_imap_open (folder_t folder, int flags)
            {
              CHECK_ERROR (f_imap, ENOMEM);
            }
+	  memory_stream_create (&f_imap->string.stream);
        }
      else
        {
 	  /* Clear from any residue.  */
          memset (f_imap->buffer, '\0', f_imap->buflen);
+	  stream_truncate (f_imap->string.stream, 0);
+	  f_imap->string.offset = 0;
+	  f_imap->string.nleft = 0;
        }
      f_imap->ptr = f_imap->buffer;
@@ -598,10 +602,10 @@ folder_imap_list (folder_t folder, const char *ref, const char *name,
    }
  /* Build the folder list.  */
-  if (f_imap->callback.flist.num > 0)
+  if (f_imap->flist.num > 0)
    {
      struct list_response **plist = NULL;
-      size_t num = f_imap->callback.flist.num;
+      size_t num = f_imap->flist.num;
      size_t j = 0;
      plist = calloc (num, sizeof (*plist));
      if (plist)
@@ -609,7 +613,7 @@ folder_imap_list (folder_t folder, const char *ref, const char *name,
 	  size_t i;
 	  for (i = 0; i < num; i++)
 	    {
-	      struct list_response *lr = f_imap->callback.flist.element[i];
+	      struct list_response *lr = f_imap->flist.element[i];
 	      /* printf ("%s --> %s\n", lr->name, name); */
 	      if (fnmatch (name, lr->name, 0) == 0)
 		{
@@ -628,7 +632,7 @@ folder_imap_list (folder_t folder, const char *ref, const char *name,
      pflist->element = plist;
      pflist->num = j;
    }
-  folder_list_destroy (&(f_imap->callback.flist));
+  folder_list_destroy (&(f_imap->flist));
  f_imap->state = IMAP_NO_STATE;
  return status;
 }
@@ -671,10 +675,10 @@ folder_imap_lsub (folder_t folder, const char *ref, const char *name,
    }
  /* Build the folder list.  */
-  if (f_imap->callback.flist.num > 0)
+  if (f_imap->flist.num > 0)
    {
      struct list_response **plist = NULL;
-      size_t num = f_imap->callback.flist.num;
+      size_t num = f_imap->flist.num;
      size_t j = 0;
      plist = calloc (num, sizeof (*plist));
      if (plist)
@@ -682,7 +686,7 @@ folder_imap_lsub (folder_t folder, const char *ref, const char *name,
 	  size_t i;
 	  for (i = 0; i < num; i++)
 	    {
-	      struct list_response *lr = f_imap->callback.flist.element[i];
+	      struct list_response *lr = f_imap->flist.element[i];
 	      /* printf ("%s --> %s\n", lr->name, name); */
 	      plist[i] = calloc (1, sizeof (**plist));
 	      if (plist[i] == NULL
@@ -697,7 +701,7 @@ folder_imap_lsub (folder_t folder, const char *ref, const char *name,
 	}
      pflist->element = plist;
      pflist->num = j;
-      folder_list_destroy (&(f_imap->callback.flist));
+      folder_list_destroy (&(f_imap->flist));
    }
  f_imap->state = IMAP_NO_STATE;
  f_imap->state = IMAP_NO_STATE;
@@ -811,8 +815,7 @@ folder_imap_unsubscribe (folder_t folder, const char *name)
 /* 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.  The sequence is read
-   and put in the callback buffer, hopefully the callee did have enough
+   and put in the string buffer.  */
-   room.  */
 static int
 imap_literal_string (f_imap_t f_imap, char **ptr)
 {
@@ -820,7 +823,7 @@ imap_literal_string (f_imap_t f_imap, char **ptr)
  int status = 0;
  int nl;
  /* The (len + 1) in the for is to count the strip '\r' by imap_readline.  */
-  for (len0 = len = total = 0; total < f_imap->callback.nleft; total += (len + 1))
+  for (len0 = len = total = 0; total < f_imap->string.nleft; total += (len + 1))
    {
      status = imap_readline (f_imap);
      /*fprintf (stderr, "%d: %s", strlen (f_imap->buffer), f_imap->buffer);*/
@@ -834,12 +837,12 @@ imap_literal_string (f_imap_t f_imap, char **ptr)
      /* How much ?  */
      len0 = len = f_imap->nl - f_imap->buffer;
      /* Check if the last read did not finish on a line, if yes do not copy in
-	 callback buffer the terminating sequence ")\r\n".  We are doing this
+	 string buffer the terminating sequence ")\r\n".  We are doing this
         by checking if the amount(total) we got so far + the len of the line
         +1 (taking to account the strip '\r') goes behond the request.  */
-      if ((total + len + 1) > f_imap->callback.nleft)
+      if ((total + len + 1) > f_imap->string.nleft)
 	{
-	  len0 = len = f_imap->callback.nleft - total;
+	  len0 = len = f_imap->string.nleft - total;
 	  /* ALERT: if we ask for a substring, for example we have :
 	     "123456\n", and ask for body[]<0.7> the server will send
 	     body[] {7} --> "123456\r".  There was not enough space
@@ -848,35 +851,29 @@ imap_literal_string (f_imap_t f_imap, char **ptr)
 	    len0--;
 	}
-      if (f_imap->callback.total < f_imap->callback.buflen)
+      stream_write (f_imap->string.stream, f_imap->buffer,
-	{
+		    len0, f_imap->string.offset, NULL);
-	  /* Check how much we can fill the callback buffer.  */
+      f_imap->string.offset += len0;
-          int x = (f_imap->callback.buflen - f_imap->callback.total) - len0;
-          x = (x >= 0) ? len0 : (x + len0);
-	  if (f_imap->callback.buffer)
-	    memcpy (f_imap->callback.buffer + f_imap->callback.total,
-		    f_imap->buffer, x);
-          f_imap->callback.total += x;
      /* Depending on the type of request we incremente the xxxx_lines
 	 and  xxxx_sizes.  */
      nl = (memchr (f_imap->buffer, '\n', len0)) ? 1 : 0;
-	  if (f_imap->callback.msg_imap)
+      if (f_imap->string.msg_imap)
 	{
-	      switch (f_imap->callback.type)
+	  switch (f_imap->string.type)
 	    {
 	    case IMAP_HEADER:
-		  f_imap->callback.msg_imap->header_lines += nl;
+	      f_imap->string.msg_imap->header_lines += nl;
-		  f_imap->callback.msg_imap->header_size += x;
+	      f_imap->string.msg_imap->header_size += len0;
 	      break;
 	    case IMAP_BODY:
-		  f_imap->callback.msg_imap->body_lines += nl;
+	      f_imap->string.msg_imap->body_lines += nl;
-		  f_imap->callback.msg_imap->body_size += x;
+	      f_imap->string.msg_imap->body_size += len0;
 	      break;
 	    case IMAP_MESSAGE:
-		  f_imap->callback.msg_imap->message_lines += nl;
+	      f_imap->string.msg_imap->message_lines += nl;
 	      /* The message size is known by sending RFC822.SIZE.  */
 	    default:
@@ -884,9 +881,9 @@ imap_literal_string (f_imap_t f_imap, char **ptr)
 	    }
 	}
    }
-    }
+  f_imap->string.nleft -= total;
-  f_imap->callback.nleft -= total;
+  /* We may have trailing junk like the closing ")\r\n" from a literal string
-  /* Move the command buffer, or do a full readline.  */
+     glob it by moving the command buffer, or doing a full readline.  */
  if (len == (size_t)(f_imap->nl - f_imap->buffer))
    {
      len = 0;
@@ -899,12 +896,14 @@ imap_literal_string (f_imap_t f_imap, char **ptr)
 /* A quoted string is a sequence of zero or more 7-bit characters,
   excluding CR and LF, with double quote (<">) characters at each end.
   Same thing as the literal, diferent format the result is put in the
-   callback buffer for the mailbox/callee.  */
+   string buffer for the mailbox/callee.  */
 static int
 imap_quoted_string (f_imap_t f_imap, char **ptr)
 {
  char *bquote;
  int escaped = 0;
+  size_t len;
  (*ptr)++;
  bquote = *ptr;
  while (**ptr && (**ptr != '"' || escaped))
@@ -912,23 +911,18 @@ imap_quoted_string (f_imap_t f_imap, char **ptr)
      escaped = (**ptr == '\\') ? 1 : 0;
      (*ptr)++;
    }
-  f_imap->callback.total = *ptr - bquote;
-  if (f_imap->callback.buffer)
+  len = *ptr - bquote;
-    free (f_imap->callback.buffer);
+  stream_write (f_imap->string.stream, bquote, len,
-  f_imap->callback.buffer = calloc (f_imap->callback.total + 1, 1);
+		f_imap->string.offset, NULL);
-  f_imap->callback.buflen = f_imap->callback.total;
+  f_imap->string.offset += len;
-  /* Fill the call back buffer. The if is redundant there should always
-     be enough room since the request is base on the buffer size.  */
-  if (f_imap->callback.total <= f_imap->callback.buflen
-      && f_imap->callback.buffer)
-    memcpy (f_imap->callback.buffer, bquote, f_imap->callback.total);
  if (**ptr == '"')
    (*ptr)++;
  return 0;
 }
 /* Find which type of string the response is: literal or quoted and let the
-   function fill the callback buffer.  */
+   function fill the string buffer.  */
 static int
 imap_string (f_imap_t f_imap, char **ptr)
 {
@@ -940,15 +934,11 @@ imap_string (f_imap_t f_imap, char **ptr)
  switch (**ptr)
    {
    case '{':
-      f_imap->callback.nleft = strtol ((*ptr) + 1, ptr, 10);
+      f_imap->string.nleft = strtol ((*ptr) + 1, ptr, 10);
      if (**ptr == '}')
 	{
 	  (*ptr)++;
 	  /* Reset the buffer to the beginning.  */
-	  if (f_imap->callback.buffer)
-	    free (f_imap->callback.buffer);
-	  f_imap->callback.buffer = calloc (f_imap->callback.nleft + 1, 1);
-	  f_imap->callback.buflen = f_imap->callback.nleft;
 	  f_imap->ptr = f_imap->buffer;
 	  status = imap_literal_string (f_imap, ptr);
 	}
@@ -984,15 +974,15 @@ imap_list (f_imap_t f_imap)
  buffer = alloca (len);
  memcpy (buffer, f_imap->buffer, len);
  buffer[len] = '\0';
-  plr = realloc (f_imap->callback.flist.element,
+  plr = realloc (f_imap->flist.element,
-		 (f_imap->callback.flist.num + 1) * sizeof (*plr));
+		 (f_imap->flist.num + 1) * sizeof (*plr));
  if (plr == NULL)
    return ENOMEM;
-  f_imap->callback.flist.element = plr;
+  f_imap->flist.element = plr;
-  lr = plr[f_imap->callback.flist.num] = calloc (1, sizeof (*lr));
+  lr = plr[f_imap->flist.num] = calloc (1, sizeof (*lr));
  if (lr == NULL)
    return ENOMEM;
-  (f_imap->callback.flist.num)++;
+  (f_imap->flist.num)++;
  /* Glob untag.  */
  tok = strtok_r (buffer, " ", &sp);
@@ -1215,7 +1205,7 @@ imap_bodystructure0 (msg_imap_t msg_imap, char **ptr)
 static int
 imap_bodystructure (f_imap_t f_imap, char **ptr)
 {
-  return imap_bodystructure0 (f_imap->callback.msg_imap, ptr);
+  return imap_bodystructure0 (f_imap->string.msg_imap, ptr);
 }
 /* The Format for a FLAG response is :
@@ -1241,10 +1231,10 @@ imap_bodystructure (f_imap_t f_imap, char **ptr)
 static int
 imap_flags (f_imap_t f_imap, char **ptr)
 {
-  char *start_flag;
+  char *start;
-  char *end_flag;
+  char *end;
  /* msg_imap may be null for an untag response deal with it.  */
-  msg_imap_t msg_imap = f_imap->callback.msg_imap;
+  msg_imap_t msg_imap = f_imap->string.msg_imap;
  /* Skip space.  */
  while (**ptr == ' ')
@@ -1262,21 +1252,21 @@ imap_flags (f_imap_t f_imap, char **ptr)
 	(*ptr)++;
      /* Save the beginning of the word.  */
-      start_flag = *ptr;
+      start = *ptr;
      /* Get the next word boundary.  */
      while (**ptr && **ptr != ' ' && **ptr != ')')
 	++(*ptr);
      /* Make a C string for the strcasecmp.  */
-      end_flag = *ptr;
+      end = *ptr;
      /* Bail out.  */
-      if (*start_flag == '\0')
+      if (*start == '\0')
 	break;
      /* Guess the flag.  */
-      if (strncasecmp (start_flag, "\\Seen", end_flag - start_flag) == 0)
+      if (strncasecmp (start, "\\Seen", end - start) == 0)
 	{
 	  if (msg_imap)
 	    {
@@ -1286,28 +1276,28 @@ imap_flags (f_imap_t f_imap, char **ptr)
 	  else
 	    f_imap->flags |= MU_ATTRIBUTE_SEEN;
 	}
-      else if (strncasecmp (start_flag, "\\Answered", end_flag - start_flag) == 0)
+      else if (strncasecmp (start, "\\Answered", end - start) == 0)
 	{
 	  if (msg_imap)
 	    msg_imap->flags |= MU_ATTRIBUTE_ANSWERED;
 	  else
 	    f_imap->flags |= MU_ATTRIBUTE_ANSWERED;
 	}
-      else if (strncasecmp (start_flag, "\\Flagged", end_flag - start_flag) == 0)
+      else if (strncasecmp (start, "\\Flagged", end - start) == 0)
 	{
 	  if (msg_imap)
 	    msg_imap->flags |= MU_ATTRIBUTE_FLAGGED;
 	  else
 	    f_imap->flags |= MU_ATTRIBUTE_FLAGGED;
 	}
-      else if (strncasecmp (start_flag, "\\Deleted", end_flag - start_flag) == 0)
+      else if (strncasecmp (start, "\\Deleted", end - start) == 0)
 	{
 	  if (msg_imap)
 	    msg_imap->flags |= MU_ATTRIBUTE_DELETED;
 	  else
 	    f_imap->flags |= MU_ATTRIBUTE_DELETED;
 	}
-      else if (strncasecmp (start_flag, "\\Draft", end_flag - start_flag) == 0)
+      else if (strncasecmp (start, "\\Draft", end - start) == 0)
 	{
 	  if (msg_imap)
 	    msg_imap->flags |= MU_ATTRIBUTE_DRAFT;
@@ -1343,20 +1333,20 @@ imap_body (f_imap_t f_imap, char **ptr)
 	  section[len] = '\0';
 	  /* strupper.  */
 	  for (; *p; p++) if (isupper((unsigned)*p)) *p = toupper ((unsigned)*p);
-	  /* Set the callback type to update the correct line count.  */
+	  /* Set the string type to update the correct line count.  */
 	  //if (!strstr (section, "FIELD"))
 	    {
              if (strstr (section, "MIME") || (strstr (section, "HEADER")))
                {
-                  f_imap->callback.type = IMAP_HEADER;
+                  f_imap->string.type = IMAP_HEADER;
                }
              else if (strstr (section, "TEXT") || len > 0)
                {
-                  f_imap->callback.type = IMAP_BODY;
+                  f_imap->string.type = IMAP_BODY;
                }
              else if (len == 0) /* body[]  */
                {
-                  f_imap->callback.type = IMAP_MESSAGE;
+                  f_imap->string.type = IMAP_MESSAGE;
                }
 	    }
 	  sep++; /* Move pass the ']'  */
@@ -1379,16 +1369,19 @@ imap_body (f_imap_t f_imap, char **ptr)
  /* If the state scan.  Catch it here.  */
  if (f_imap->state == IMAP_SCAN_ACK)
    {
-      if (f_imap->callback.msg_imap->fheader)
+      char *buffer;
-	header_destroy (&f_imap->callback.msg_imap->fheader, NULL);
+      off_t total = 0;
-      status = header_create (&f_imap->callback.msg_imap->fheader,
+      if (f_imap->string.msg_imap && f_imap->string.msg_imap->fheader)
-			      f_imap->callback.buffer, f_imap->callback.total,
+	header_destroy (&f_imap->string.msg_imap->fheader, NULL);
-			      NULL);
+      stream_size (f_imap->string.stream, &total);
-      free (f_imap->callback.buffer);
+      buffer = malloc (total + 1);
-      f_imap->callback.buffer = NULL;
+      stream_read (f_imap->string.stream, buffer, total, 0, NULL);
-      f_imap->callback.buflen = 0;
+      status = header_create (&f_imap->string.msg_imap->fheader,
-      f_imap->callback.total = 0;
+			      buffer, total, NULL);
-      f_imap->callback.nleft = 0;
+      free (buffer);
+      stream_truncate (f_imap->string.stream, 0);
+      f_imap->string.offset = 0;
+      f_imap->string.nleft = 0;
    }
  return status;
 }
@@ -1404,8 +1397,8 @@ imap_uid (f_imap_t f_imap, char **ptr)
 {
  char token[128];
  imap_token (token, sizeof (token), ptr);
-  if (f_imap->callback.msg_imap)
+  if (f_imap->string.msg_imap)
-    f_imap->callback.msg_imap->uid = strtoul (token, NULL, 10);
+    f_imap->string.msg_imap->uid = strtoul (token, NULL, 10);
  return 0;
 }
@@ -1413,9 +1406,9 @@ static int
 imap_rfc822 (f_imap_t f_imap, char **ptr)
 {
  int status;
-  f_imap->callback.type = IMAP_MESSAGE;
+  f_imap->string.type = IMAP_MESSAGE;
  status = imap_body (f_imap, ptr);
-  f_imap->callback.type = 0;
+  f_imap->string.type = 0;
  return status;
 }
@@ -1424,8 +1417,8 @@ imap_rfc822_size (f_imap_t f_imap, char **ptr)
 {
  char token[128];
  imap_token (token, sizeof (token), ptr);
-  if (f_imap->callback.msg_imap)
+  if (f_imap->string.msg_imap)
-    f_imap->callback.msg_imap->message_size = strtoul (token, NULL, 10);
+    f_imap->string.msg_imap->message_size = strtoul (token, NULL, 10);
  return 0;
 }
@@ -1433,9 +1426,9 @@ static int
 imap_rfc822_header (f_imap_t f_imap, char **ptr)
 {
  int status;
-  f_imap->callback.type = IMAP_HEADER;
+  f_imap->string.type = IMAP_HEADER;
  status = imap_string (f_imap, ptr);
-  f_imap->callback.type = 0;
+  f_imap->string.type = 0;
  return status;
 }
@@ -1443,9 +1436,9 @@ static int
 imap_rfc822_text (f_imap_t f_imap, char **ptr)
 {
  int status;
-  f_imap->callback.type = IMAP_HEADER;
+  f_imap->string.type = IMAP_HEADER;
  status = imap_string (f_imap, ptr);
-  f_imap->callback.type = 0;
+  f_imap->string.type = 0;
  return status;
 }
@@ -1493,8 +1486,8 @@ imap_fetch (f_imap_t f_imap)
  /* It is actually possible, but higly unlikely that we do not have the
     message yet, for example a "FETCH (FLAGS (\Recent))" notification
     for a newly messsage.  */
-  if (f_imap->callback.msg_imap == NULL
+  if (f_imap->string.msg_imap == NULL
-      || f_imap->callback.msg_imap->num != msgno)
+      || f_imap->string.msg_imap->num != msgno)
    {
      /* Find the imap mesg struct.  */
      size_t i;
@@ -1504,7 +1497,7 @@ imap_fetch (f_imap_t f_imap)
 	{
 	  if (m_imap->imessages[i] && m_imap->imessages[i]->num == msgno)
 	    {
-	      f_imap->callback.msg_imap = m_imap->imessages[i];
+	      f_imap->string.msg_imap = m_imap->imessages[i];
 	      break;
 	    }
 	}
@@ -1767,6 +1760,7 @@ imap_parse (f_imap_t f_imap)
  int done = 0;
  int status = 0;
  char empty[2];
+  char *buffer = NULL;
  /* We use that moronic hack to not check null for the tockenize strings.  */
  empty[0] = '\0';
@@ -1774,7 +1768,7 @@ imap_parse (f_imap_t f_imap)
  while (! done)
    {
      char *tag, *response, *remainder;
-      char *buffer;
      status = imap_readline (f_imap);
      if (status != 0)
 	{
@@ -1787,17 +1781,24 @@ imap_parse (f_imap_t f_imap)
      /* We do not want to step over f_imap->buffer since it can be use
 	 further down the chain.  */
-      buffer = alloca ((f_imap->ptr - f_imap->buffer) + 1);
+      if (buffer)
-      memcpy (buffer, f_imap->buffer, (f_imap->ptr - f_imap->buffer) + 1);
+	{
+	  free (buffer);
+	  buffer = NULL;
+	}
+      buffer = calloc ((f_imap->ptr - f_imap->buffer) + 1, 1);
+      memcpy (buffer, f_imap->buffer, (f_imap->ptr - f_imap->buffer));
      /* Tokenize the string.  */
      {
 	char *sp = NULL;
 	tag = strtok_r (buffer, " ", &sp);
 	response = strtok_r (NULL, " ", &sp);
-	if (!response) response = empty;
+	if (!response)
+	  response = empty;
 	remainder = strtok_r (NULL, "\n", &sp);
-	if (!remainder) remainder = empty;
+	if (!remainder)
+	  remainder = empty;
      }
      /* Is the response untagged ?  */
@@ -1831,6 +1832,7 @@ imap_parse (f_imap_t f_imap)
 			 is not supported by this implementation.  If the
 			 optional list of charsets is given, this lists the
 			 charsets that are supported by this implementation. */
+		      mu_error ("BADCHARSET: %s\n", (sp) ? sp : "");
 		    }
 		  else if (strcasecmp (subtag, "CAPABILITY") == 0)
 		    {
@@ -1851,12 +1853,14 @@ imap_parse (f_imap_t f_imap)
 			 mailbox name.  This is a hint to the client that the
 			 operation can succeed if the SELECT or EXAMINE is
 			 reissued with the new mailbox name. */
+		      mu_error ("NEWNAME: %s\n", (sp) ? sp : "");
 		    }
 		  else if (strcasecmp (subtag, "PARSE") == 0)
 		    {
 		      /* The human-readable text represents an error in
 			 parsing the [RFC-822] header or [MIME-IMB] headers
 			 of a message in the mailbox.  */
+		      mu_error ("PARSE: %s\n", (sp) ? sp : "");
 		    }
 		  else if (strcasecmp (subtag, "PERMANENTFLAGS") == 0)
 		    {
@@ -1892,6 +1896,7 @@ imap_parse (f_imap_t f_imap)
 			 other reason).  This is a hint to the client that
 			 the operation can succeed if the mailbox is first
 			 created by the CREATE command.  */
+		      mu_error ("TRYCREATE: %s\n", (sp) ? sp : "");
 		    }
 		  else if (strcasecmp (subtag, "UIDNEXT") == 0)
 		    {
@@ -2031,5 +2036,8 @@ imap_parse (f_imap_t f_imap)
 	}
      f_imap->ptr = f_imap->buffer;
    }
+  if (buffer)
+    free (buffer);
  return status;
 }
--- a/mailbox/include/imap0.h
View file @ed1175f
+++ b/mailbox/include/imap0.h
View file @ed1175f
@@ -140,10 +140,24 @@ struct _f_imap
  size_t seq; /* Sequence number to build a tag.  */
  char *capa; /* Cabilities of the server.  */
  size_t flags;
-  struct literal_string callback;
+  /* IO use to hold the literal and quoted strings send by
+     the IMAP server.  */
+  struct
+  {
+    stream_t stream;
+    off_t offset;
+    size_t nleft;  /* nleft to read in the literal. */
+    msg_imap_t msg_imap;
+    enum imap_state type;
+  } string;
+  /* Use for LIST and LSUB.  */
+  struct folder_list flist;
  int isopen;
-  /* Buffer I/O  */
+  /* Server channel buffer I/O  */
  size_t buflen;
  char *buffer;
  char *ptr;
@@ -155,7 +169,6 @@ struct _f_imap
  /* Login  */
  char *user;
  char *passwd;
 };
 struct _m_imap
@@ -187,6 +200,7 @@ struct _msg_imap
  size_t uid;
  header_t fheader;
+  char *internal_date;
  size_t message_size;
  size_t message_lines;
--- a/mailbox/mbx_imap.c
View file @ed1175f
+++ b/mailbox/mbx_imap.c
View file @ed1175f
@@ -174,6 +174,8 @@ free_subparts (msg_imap_t msg_imap)
    free (msg_imap->parts);
  if (msg_imap->fheader)
    header_destroy (&msg_imap->fheader, NULL);
+  if (msg_imap->internal_date)
+    free (msg_imap->internal_date);
  free(msg_imap);
 }
@@ -672,9 +674,15 @@ imap_expunge (mailbox_t mailbox)
    {
    case IMAP_NO_STATE:
      {
-	char *set;
+	char *set = NULL;
 	status = delete_to_string (m_imap, &set);
 	CHECK_ERROR (f_imap, status);
+	if (set == NULL || *set == '\0')
+	  {
+	    if (set)
+	      free (set);
+	    return 0;
+	  }
 	status = imap_writeline (f_imap,
 				 "g%d STORE %s +FLAGS.SILENT (\\Deleted)\r\n",
 				 f_imap->seq++, set);
@@ -1224,6 +1232,9 @@ imap_envelope_date (envelope_t envelope, char *buffer, size_t buflen,
  const char** datep = &date;
    /* reserve as much space as we need for internal-date */
  int status;
+  if (msg_imap->internal_date == NULL)
+    {
      if (f_imap->state == IMAP_NO_STATE)
 	{
 	  /* Select first.  */
@@ -1237,9 +1248,17 @@ imap_envelope_date (envelope_t envelope, char *buffer, size_t buflen,
 	  MAILBOX_DEBUG0 (m_imap->mailbox, MU_DEBUG_PROT, f_imap->buffer);
 	  f_imap->state = IMAP_FETCH;
 	}
-  status = fetch_operation (f_imap, msg_imap, datebuf, sizeof datebuf, NULL);
+      status = fetch_operation (f_imap, msg_imap, datebuf,
+				sizeof datebuf, NULL);
      if (status != 0)
 	return status;
+      msg_imap->internal_date = strdup (datebuf);
+    }
+  else
+    {
+      date = msg_imap->internal_date;
+      datep = &date;
+    }
  if (mu_parse_imap_date_time(datep, &tm, &tz) != 0)
    now = (time_t)-1;
@@ -1323,6 +1342,10 @@ imap_attr_set_flags (attribute_t attribute, int flag)
  f_imap_t f_imap = m_imap->f_imap;
  int status = 0;
+  /* If already set don't bother.  */
+  if (msg_imap->flags & flag)
+    return 0;
  /* The delete FLAG is not pass yet but only on the expunge.  */
  if (flag & MU_ATTRIBUTE_DELETED)
    {
@@ -1705,13 +1728,11 @@ fetch_operation (f_imap_t f_imap, msg_imap_t msg_imap, char *buffer,
    case IMAP_FETCH:
      status = imap_send (f_imap);
      CHECK_EAGAIN (f_imap, status);
-      if (f_imap->callback.buffer)
+      stream_truncate (f_imap->string.stream, 0);
-	free (f_imap->callback.buffer);
+      f_imap->string.offset = 0;
-      f_imap->callback.buffer = NULL;
+      f_imap->string.nleft = 0;
-      f_imap->callback.buflen = 0;
+      f_imap->string.type = IMAP_NO_STATE;
-      f_imap->callback.total = 0;
+      f_imap->string.msg_imap = msg_imap;
-      f_imap->callback.nleft = 0;
-      f_imap->callback.msg_imap = msg_imap;
      f_imap->state = IMAP_FETCH_ACK;
    case IMAP_FETCH_ACK:
@@ -1725,25 +1746,21 @@ fetch_operation (f_imap_t f_imap, msg_imap_t msg_imap, char *buffer,
      break;
    }
-  if (status == 0 && f_imap->isopen == 0 && f_imap->callback.total == 0)
+  f_imap->state = IMAP_NO_STATE;
+  /* The server may have timeout any case connection is gone away.  */
+  if (status == 0 && f_imap->isopen == 0 && f_imap->string.offset == 0)
    status = EBADF;
-  buflen = min (buflen, f_imap->callback.total);
-  if (f_imap->callback.buffer)
-    {
  if (buffer)
-	memcpy (buffer, f_imap->callback.buffer, buflen);
+    stream_read (f_imap->string.stream, buffer, buflen, 0, plen);
-      free (f_imap->callback.buffer);
+  else if (plen)
-    }
+    *plen = 0;
-  if (plen)
+  stream_truncate (f_imap->string.stream, 0);
-    *plen = buflen;
+  f_imap->string.offset = 0;
-  f_imap->callback.buffer = NULL;
+  f_imap->string.nleft = 0;
-  f_imap->callback.buflen = 0;
+  f_imap->string.type = IMAP_NO_STATE;
-  f_imap->callback.total = 0;
+  f_imap->string.msg_imap = NULL;
-  f_imap->callback.nleft = 0;
-  f_imap->callback.type = 0;
-  f_imap->callback.msg_imap = NULL;
-  f_imap->state = IMAP_NO_STATE;
  return status;
 }
--- a/mailbox/memory_stream.c
View file @ed1175f
+++ b/mailbox/memory_stream.c
View file @ed1175f
@@ -22,15 +22,24 @@
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <stdio.h>
 #include <sys/types.h>
 #include <mailutils/stream.h>
+#undef min
+#define min(a,b) ((a) < (b) ? (a) : (b))
+#define MU_STREAM_MEMORY_BLOCKSIZE 128
 struct _memory_stream
 {
  char *ptr;
  size_t size;
+  size_t capacity;
 };
 static void
@@ -71,7 +80,7 @@ _memory_readline (stream_t stream, char *optr, size_t osize,
      osize--;
      nl = memchr (mfs->ptr + offset, '\n', mfs->size - offset);
      n = (nl) ? (size_t)(nl - (mfs->ptr + offset) + 1) : mfs->size - offset;
-      n = (n > osize)  ? osize : n;
+      n = min (n, osize);
      memcpy (optr, mfs->ptr + offset, n);
      optr[n] = '\0';
    }
@@ -87,13 +96,17 @@ _memory_write (stream_t stream, const char *iptr, size_t isize,
  struct _memory_stream *mfs = stream_get_owner (stream);
  /* Bigger we have to realloc.  */
-  if (mfs->size < (offset + isize))
+  if (mfs->capacity < (offset + isize))
    {
-      char *tmp =  realloc (mfs->ptr, offset + isize);
+      /* Realloc by fixed blocks of 128.  */
+      int newsize = MU_STREAM_MEMORY_BLOCKSIZE *
+	(((offset + isize)/MU_STREAM_MEMORY_BLOCKSIZE) + 1);
+      char *tmp =  realloc (mfs->ptr, newsize);
      if (tmp == NULL)
 	return ENOMEM;
      mfs->ptr = tmp;
      mfs->size = offset + isize;
+      mfs->capacity = newsize;
    }
  memcpy (mfs->ptr + offset, iptr, isize);
@@ -109,6 +122,7 @@ _memory_truncate (stream_t stream, off_t len)
  if (len == 0)
    {
+      if (mfs->ptr)
 	free (mfs->ptr);
      mfs->ptr = NULL;
    }
@@ -120,6 +134,7 @@ _memory_truncate (stream_t stream, off_t len)
      mfs->ptr = tmp;
    }
  mfs->size = len;
+  mfs->capacity = len;
  return 0;
 }
@@ -137,11 +152,10 @@ _memory_close (stream_t stream)
 {
  struct _memory_stream *mfs = stream_get_owner (stream);
  if (mfs->ptr)
-    {
    free (mfs->ptr);
  mfs->ptr = NULL;
  mfs->size = 0;
-    }
+  mfs->capacity = 0;
  return 0;
 }
@@ -149,6 +163,7 @@ static int
 _memory_open (stream_t stream, const char *filename, int port, int flags)
 {
  struct _memory_stream *mfs = stream_get_owner (stream);
+  int status = 0;
  (void)port; /* Ignored.  */
  (void)filename; /* Ignored.  */
@@ -156,13 +171,47 @@ _memory_open (stream_t stream, const char *filename, int port, int flags)
  /* Close any previous file.  */
  if (mfs->ptr)
+    free (mfs->ptr);
+  mfs->ptr = NULL;
+  mfs->size = 0;
+  mfs->capacity = 0;
+  stream_set_flags (stream, flags |MU_STREAM_NO_CHECK);
+  if (filename)
+    {
+      struct stat statbuf;
+      if (stat (filename, &statbuf) == 0)
+        {
+          mfs->ptr = calloc (statbuf.st_size, 1);
+          if (mfs->ptr)
+            {
+              FILE *fp;
+              mfs->capacity = statbuf.st_size;
+              mfs->size = statbuf.st_size;
+              fp = fopen (filename, "r");
+              if (fp)
+                {
+                  size_t r = fread (mfs->ptr, mfs->size, 1, fp);
+                  if (r != mfs->size)
+                    status = EIO;
+                  fclose (fp);
+                }
+              else
+                status = errno;
+              if (status != 0)
                {
                  free (mfs->ptr);
                  mfs->ptr = NULL;
+                  mfs->capacity = 0;
                  mfs->size = 0;
                }
-  stream_set_flags (stream, flags |MU_STREAM_NO_CHECK);
+            }
-  return 0;
+          else
+            status = ENOMEM;
+        }
+      else
+        status = EIO;
+    }
+  return status;
 }
 int
--- a/mailbox2/memstream.c
View file @ed1175f
+++ b/mailbox2/memstream.c
View file @ed1175f
@@ -60,8 +60,7 @@ _stream_memory_read (stream_t stream, void *optr, size_t osize,
  mu_refcount_lock (mem->refcount);
  if (mem->ptr != NULL && (offset < (off_t)mem->size))
    {
-      n = ((offset + osize) > mem->size) ?
+      n = ((offset + osize) > mem->size) ? mem->size - offset :  osize;
-	mem->size - offset :  osize;
      memcpy (optr, mem->ptr + offset, n);
    }
  mu_refcount_unlock (mem->refcount);
@@ -130,6 +129,7 @@ _stream_memory_truncate (stream_t stream, off_t len)
  mu_refcount_lock (mem->refcount);
  if (len == 0)
    {
+      if (mem->ptr)
 	free (mem->ptr);
      mem->ptr = NULL;
    }