path: root/camel/providers/imap/imap.c

/*  Spruce
 *  Copyright (C) 1999-2000 Jeffrey Stedfast
 *
 *  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
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/

#ifdef HAVE_CONFIG_H
#   include <config.h>
#endif

#include "imap.h"

#define IMAP_LOGGING

/* this is used in the tag before each command */
static guint32 imap_commands = 0;

extern gint timeout;
extern GList *mime_parts;


gint imap_ok (gint tag, gchar *line)
{
   /* returns 1 if <tag> OK was found */
   gchar find[64];
   gint ret;

   g_snprintf(find, sizeof(find)-1, "A%.5d OK", tag);

   ret = find_string (line, find);
   
   if (ret < 0)
      return 0;
      
   return 1;
}

gint imap_login_cram_md5 (gint socket, gchar *username, gchar *password)
{
   /* Log in to server using CRAM-MD5 keyed hash. */ 
   gchar buffer[512];
   gchar *retstr;
   gint pos;

   if (username == NULL || password == NULL) 
      return ERROR;

   memset(buffer, 0, sizeof(buffer));
   if (recvline(socket, buffer, sizeof(buffer)-1) < 0)
      return ERROR; /* Fetch the OK line from the server */

   if (find_string(buffer, "OK") == -1)
      return ERROR;

   g_snprintf(buffer, sizeof(buffer)-1, "A%.5d AUTHENTICATE CRAM-MD5\r\n", imap_commands);

   if (send(socket, buffer, strlen(buffer), 0) < 0)
      return ERROR;

   memset(buffer, 0, sizeof(buffer));
   if (recvline(socket, buffer, sizeof(buffer)-1) < 0)
      return ERROR;

   pos = find_string(buffer, "\r\n");
   if (pos != -1)
      buffer[pos] = '\0';
   retstr = cram_md5(username, password, buffer);

   if (retstr[strlen(retstr)-1] == '\n')
      retstr[strlen(retstr)-1] = '\0';

   g_snprintf(buffer, sizeof(buffer)-1, "%s\r\n", retstr);
   g_free(retstr);

   if (send (socket, buffer, strlen(buffer), 0) < 0) 
      return ERROR;

   if (recvline(socket, buffer, sizeof(buffer)-1) < 0)
      return ERROR;

   if (!imap_ok(imap_commands, buffer))
      return ERROR;

   imap_commands++;

   return SUCCESS;
}
      
gint imap_login (gint socket, gchar *username, gchar *password)
{
   /* this logs us in to the server */
   gchar buffer[512];
   gchar temp[64];
   
   if (username == NULL || password == NULL)
      return ERROR;

   g_snprintf(buffer, sizeof(buffer)-1, "A%.5d LOGIN \"%s\" \"%s\"\r\n", imap_commands, username, password);
#ifdef IMAP_LOGGING
   fprintf(stderr, "%s", buffer);
#endif

   if (send (socket, buffer, strlen(buffer), 0) < 0)
   {
      return ERROR;
   }
      
   g_snprintf(temp, sizeof(temp)-1, "A%.5d", imap_commands);

   memset(buffer, 0, sizeof(buffer));
   recvline_timeo(socket, buffer, sizeof(buffer)-1, timeout);
   while (!strstr(buffer, temp))
   {
      memset(buffer, 0, sizeof(buffer));
      recvline_timeo(socket, buffer, sizeof(buffer)-1, timeout);
   }

   if (!imap_ok(imap_commands, buffer))
      return ERROR;

   imap_commands++;
   
   return SUCCESS;   
}

GList *imap_list (gint socket, gchar *namespace)
{
   /* this gets the names of all the mailboxes */
   gchar buffer[512];
   gchar flags[256];
   gchar temp[64], *ptr = NULL, *flagptr = NULL;
   gchar slashdot = '\0';
   GList *list = NULL;
   gint ret, size = 0, flaglen = 0;

   if (namespace && *namespace)
   {
      if (*namespace && namespace[strlen(namespace)-1] != '/' && namespace[strlen(namespace)-1] != '.')
         slashdot = '/';
      g_snprintf(buffer, sizeof(buffer)-1, "A%.5d LIST \"\" %s%c*\r\n", imap_commands, namespace, slashdot);
   }
   else
      g_snprintf(buffer, sizeof(buffer)-1, "A%.5d LIST \"\" INBOX.*\r\n", imap_commands);
#ifdef IMAP_LOGGING
   fprintf(stderr, "%s", buffer);
#endif

   if (send(socket, buffer, strlen(buffer), 0) < 0)
   {
      return NULL;
   }

   do
   {
      memset(buffer, 0, sizeof(buffer));
      ret = recvline(socket, buffer, sizeof(buffer)-1);
      if (ret > 0)
      {
#ifdef IMAP_LOGGING
         fprintf(stderr, "received: %s", buffer);
#endif
         if (buffer[0] == '*')
         {
            strip(buffer, '\r');
            strip(buffer, '\n');

            /* skip ahead to the flag section */
            ptr = strstr(buffer, "(");

            /* find the end of the flags section */
            flagptr = ptr + 1;
            ptr = strstr(ptr, ")") + 1;

            /* eventually we will need to parse this */
            memset(flags, 0, sizeof(flags));
            flaglen = (gint)(ptr - flagptr) - 1;
            size = sizeof(flags);
            strncpy(flags, flagptr, flaglen > size ? size : flaglen);
            if (!strstrcase(flags, "\\NoSelect")) /* is this a selectable mailbox? */
            {
               /* skip the reference name */
               ptr += imap_get_string (ptr, temp, sizeof(temp)-1, "");

               /* the rest of the return string is fair play... */
               g_strstrip(ptr);       /* trim off any extra white space */
               unquote(ptr);           /* unquote the mailbox name if it is quoted */
               if (slashdot)
                  strcut(ptr, 0, strlen(namespace)+1); /* cut out the namespace and the '/' */
               else
                  strcut(ptr, 0, strlen(namespace));   /* cut out the namespace */
                    

               list = g_list_append (list, g_strdup(ptr));
            }
         }
         else 
             break;
      }
   } while (ret > 0);

   imap_commands++;

   return list;
}

gint imap_select_mailbox (gint socket, gchar *mailbox, gchar *namespace)
{
   /* selects a mailbox, returns the number of messages in that mailbox
    * or -1 on error */
   gchar *cmdbuf, buffer[512], temp[64], *index, mesgs[16];
   gchar slashdot = '\0';
   gint ret, i;

   if (mailbox == NULL)
      return ERROR;

   if (namespace && strcmp(mailbox, "INBOX"))
   {
      if (*namespace && namespace[strlen(namespace)-1] != '/' && namespace[strlen(namespace)-1] != '.')
         slashdot = '/';

      cmdbuf = g_strdup_printf("A%.5d SELECT %s%c%s\r\n", imap_commands, namespace, slashdot, mailbox);
   }
   else
      cmdbuf = g_strdup_printf("A%.5d SELECT %s\r\n", imap_commands, mailbox);
#ifdef IMAP_LOGGING
   fprintf(stderr, "%s", cmdbuf);
#endif

   if (send(socket, cmdbuf, strlen(cmdbuf), 0) < 0)
   {
      g_free(cmdbuf);
      return -1;
   }
   g_free(cmdbuf);
   
   g_snprintf(temp, sizeof(temp)-1, "A%.5d", imap_commands);

   memset(buffer, 0, sizeof(buffer));
   ret = recvline(socket, buffer, sizeof(buffer)-1);
   while (ret > 0)
   {
#ifdef IMAP_LOGGING
      fprintf(stderr, "received: %s", buffer);
#endif
      if (strstr(buffer, temp))
         break;
      if (buffer[0] == '*')
      {
         if (strstr(buffer, "EXISTS"))
         {
            index = buffer;
            while (*index != ' ')
               index++;
            index++;
            
            i = 0;
            memset(mesgs, 0, sizeof(mesgs));
            while (*index != ' ' && i < sizeof(mesgs)-1)
            {
               mesgs[i] = *index;
               index++;
               i++;
            }
         }
      }
      memset(buffer, 0, sizeof(buffer));
      ret = recvline(socket, buffer, sizeof(buffer)-1);   
   }
   
   if (!imap_ok(imap_commands, buffer))
      return -1;
   
   imap_commands++;

   return atoi(mesgs);
}

gint imap_logout (gint socket)
{
   /* logs out */
   gchar buffer[256];

   g_snprintf(buffer, sizeof(buffer)-1, "A%.5d LOGOUT\r\n", imap_commands);
#ifdef IMAP_LOGGING
   fprintf(stderr, "%s", buffer);
#endif

   if (send(socket, buffer, strlen(buffer), 0) < 0)
   {
      return ERROR;
   }

   return SUCCESS;
}

gint imap_mailbox_create (gint socket, gchar *mailbox)
{
   /* creates a new mailbox */
   gchar buffer[256];

   if (mailbox == NULL)
      return ERROR;

   g_snprintf(buffer, sizeof(buffer)-1, "A%.5d CREATE %s\r\n", imap_commands, mailbox);
#ifdef IMAP_LOGGING
   fprintf(stderr, "%s", buffer);
#endif

   if (send(socket, buffer, strlen(buffer), 0) < 0)
   {
      return ERROR;
   }

   memset(buffer, 0, sizeof(buffer));
   if (recvline(socket, buffer, sizeof(buffer)-1) < 0 || !imap_ok(imap_commands, buffer))
   {
      return ERROR;
   }

   imap_commands++;

   return SUCCESS;
}

gint imap_mailbox_delete (gint socket, gchar *mailbox)
{
   /* deletes a mailbox */
   gchar buffer[256];

   if (mailbox == NULL)
      return ERROR;

   g_snprintf(buffer, sizeof(buffer)-1, "A%.5d DELETE %s\r\n", imap_commands, mailbox);
#ifdef IMAP_LOGGING
   fprintf(stderr, "%s", buffer);
#endif

   if (send(socket, buffer, strlen(buffer), 0) < 0)
   {
      return ERROR;
   }

   memset(buffer, 0, sizeof(buffer));
   if (recvline(socket, buffer, sizeof(buffer)-1) < 0 ||
      !imap_ok(imap_commands, buffer))
   {
      return ERROR;
   }

   imap_commands++;

   return SUCCESS;
}

/* fetches the specified part of a message, which can be alot of 
 * if you use peek the \Seen flag is not set */
gchar *imap_fetch (gint socket, gint mesgnum, gchar *part, gint *seen)
{
   /* fetches the specified part of the mesg. */
   gchar *mesg = NULL;
   gchar buffer[512], *index;
   gchar flags[128], size[16], temp[64];
   gint i, n, msgsize = 1000;

   if (mesgnum < 0)
      return (gchar *)NULL;

   g_snprintf(buffer, sizeof(buffer)-1, "A%.5d FETCH %d (FLAGS %s)\r\n", imap_commands, mesgnum, part);
#ifdef IMAP_LOGGING
   fprintf(stderr, "%s", buffer);
#endif

   if (send(socket, buffer, strlen(buffer), 0) < 0)
   {
      return (gchar *)NULL;
   }   


   memset(buffer, 0, sizeof(buffer));
   n = recvline(socket, buffer, sizeof(buffer)-1);

   if (buffer[0] != '*' && imap_ok(imap_commands, buffer))
   {
       memset(buffer, 0, sizeof(buffer));
       n = recvline(socket, buffer, sizeof(buffer)-1);
   }
     
   if (buffer[0] == '*')
   /*if (imap_ok(imap_commands, buffer))*/
   {
      index = strstrcase(buffer, "FLAGS");
      if (index == NULL) /* hmm */
      {
         fprintf(stderr, _("IMAP server replied using unknown tokens.\n"));
         return (gchar *)NULL;
      }
      else
      {
#ifdef IMAP_LOGGING
         fprintf(stderr, "received: %s", buffer);
#endif
         /* skip to the FLAGS token */
         for ( ; *index && *index != '('; index++);
         index++;

         i = 0;
         memset(flags, 0, sizeof(flags));
         while (*index != ')' && i < sizeof(flags)-1)
         {
            flags[i] = *index;
            index++;
            i++;
         }
         flags[i] = '\0';

         /* skip to the next significant token */
         for (index++; *index && *index != '{'; index++);
         index++;
         
         i = 0;
         memset(size, 0, sizeof(size));
         while (*index != '}' && i < sizeof(size)-1)
         {
            size[i] = *index;
            index++;
            i++;
         }
         size[i] = '\0';
         msgsize = atoi(size);
      }
   }
   else
   {
      g_snprintf(temp, sizeof(temp)-1, "A%.5d", imap_commands);
      if (strstr(buffer, temp)) /* this means there's no such message */
      {
         fprintf(stderr, _("IMAP responded with \"no such message\".\n"));
         return (gchar *)NULL;
      }
   }
   

   mesg = g_malloc0(msgsize + 50); /* just to be safe */
   n = recvline(socket, buffer, sizeof(buffer)-1);
   
   while (!(n <= 0) && !imap_ok(imap_commands, buffer))
   {
      strip(buffer, '\r');  /* strip all the \r's */
      strcat(mesg, buffer);
      memset(buffer, 0, sizeof(buffer));
      n = recvline(socket, buffer, sizeof(buffer)-1);
   }

   if (mesg)
      mesg[strlen(mesg)-3] = '\0';   /* strip the ending ) */

   if (seen != NULL)
   {
      if (strstrcase(flags, "\\Seen"))
         *seen = 1;
      else
         *seen = 0;
   }
   
   imap_commands++;

   return (gchar*)mesg;
}

gboolean imap_delete(const ImapAccount_t *imap, GList *sorted)
{
   GList *p = sorted;
   gchar buffer[256];
   gchar temp[16];
   gint ret;

   do
   {
      gint id = GPOINTER_TO_INT(p->data);
      g_snprintf(buffer, sizeof(buffer)-1, "A%.5d STORE %d +FLAGS (\\Deleted)\r\n", imap_commands, id);
#ifdef IMAP_LOGGING
      fprintf(stderr, "%s", buffer);
#endif
      if (send(imap->socket, buffer, strlen(buffer), 0) < 0)
      {
         return FALSE;
      }
      g_snprintf(temp, sizeof(temp)-1, "A%.5d", imap_commands);

      memset(buffer, 0, sizeof(buffer));
      ret = recvline(imap->socket, buffer, sizeof(buffer)-1);
      while (ret > 0)
      {
         if (find_string(buffer, temp) >= 0)
            break;

         memset(buffer, 0, sizeof(buffer));
         ret = recvline(imap->socket, buffer, sizeof(buffer)-1);
      }

      if (!imap_ok(imap_commands, buffer))
      {
         return FALSE;
      }
      imap_commands++;
   } while ((p = g_list_next(p)));

   g_snprintf(buffer, 255, "A%.5d EXPUNGE\r\n", imap_commands);
#ifdef IMAP_LOGGING
   fprintf(stderr, "%s", buffer);
#endif
   if (send(imap->socket, buffer, strlen(buffer), 0) < 0)
   {
      return FALSE;
   }   

   g_snprintf (temp, 15, "A%.5d", imap_commands);

   memset(buffer, 0, sizeof(buffer));
   ret = recvline(imap->socket, buffer, sizeof(buffer)-1);
   while (ret > 0)
   {
      if (find_string(buffer, temp) >= 0)
        break;

     memset(buffer, 0, sizeof(buffer));
     ret = recvline(imap->socket, buffer, sizeof(buffer)-1);
   }
    
   if (!imap_ok(imap_commands, buffer))
   {
      return FALSE;
   }

   imap_commands++;

   return TRUE;
}

gint imap_connect (Server *server)
{
   /* connects to the server and returns the socket or -1 on error */
   gchar buffer[512];
   gint sock;

   if (!Resolve(server))
      return -1;

   sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
   if (sock < 0)
      return -1;

   server->sin.sin_family = AF_INET;
   server->sin.sin_port = htons(server->port);

#ifdef IMAP_LOGGING
   fprintf(stderr, _("Connecting to IMAP server (%s)..."), server->ip);
#endif
   if (connect_timeo(sock, (struct sockaddr*)&server->sin, sizeof(server->sin), timeout) < 0)
   {
      fprintf(stderr, _("failed.\n"));
      close(sock);
      return -1;
   }
   fprintf(stderr, _("success.\n"));

   {
      /* read the connect responce */
      memset(buffer, 0, sizeof(buffer));
      recvline_timeo(sock, buffer, sizeof(buffer)-1, timeout);
   }

   return sock;
}

gint imap_add_part(gchar *c)
{
   gchar name[64], value[64];
   gchar temp[64];
   gchar *start = c;
   struct mime_part *part;

   part = g_malloc0(sizeof(struct mime_part));

   c += imap_get_string (c, part->type, sizeof(part->type)-1, "text");
   c += imap_get_string (c, part->subtype, sizeof(part->subtype)-1, "plain");

   /* seek to the beginning of the parameter... */
   for ( ; *c && *c == ' '; c++);

   if (*c)
   {
      gchar *p = part->parameter;
      if (*c == '(')
      {
         c++;
         while (*c && *c != ')')
         {
            c += imap_get_string (c, name, sizeof(name)-1, "");
            c += imap_get_string (c, value, sizeof(value)-1, "");
            /* don't buffer overrun */
            g_snprintf(p, sizeof(part->parameter)-1, "%s=\"%s\"; ", name, value);
            p += strlen(p);
   
            while (*c && *c == ' ') /* skip any spaces */
               c++;
         }
      }
      else
      {
         c += imap_get_string (c, name, sizeof(name)-1, "");
         strcpy(value, name);
         *p++ = '\0';
      }

      c++; /* skip over the ')' belonging to the parameter values */
      if (*c)
      {
         /* ignore id and description */
         c += imap_get_string (c, temp, sizeof(temp)-1, "");       
         c += imap_get_string (c, temp, sizeof(temp)-1, "");

         /* encoding */
         c += imap_get_string (c, part->encoding, sizeof(part->encoding)-1, "");

         /* size */
         c += imap_get_number (c, &part->len);

         /* skip the optional info */
         c += imap_skip_section(c);

         part->pos = 0; /* isn't useful in imap */
#ifdef IMAP_LOGGING
         fprintf(stderr, "type = %s/%s\n", part->type, part->subtype);
            fprintf(stderr, "encoding = %s\n", part->encoding);
            fprintf(stderr, "param = %s\n", part->parameter);
#endif
         mime_parts = g_list_append (mime_parts, part);

         return (c - start);
      }
   }
   return -1;
}

gint imap_parts (gint socket, gint mesg_num)
{
   GList *tmp;
   gchar *buffer = NULL, *c;
   gint res = 1, cnt;

   tmp = mime_parts;
   while (tmp != NULL)
   {
      g_free(tmp->data);
      tmp = tmp->next;
   }

   if (mime_parts != NULL)
   {
      g_list_free(mime_parts);
      mime_parts = NULL;
   }
  
   buffer = g_malloc0(sizeof(gchar)*2048);   
  
   g_snprintf(buffer, 2047, "A%.5d FETCH %d (BODYSTRUCTURE)\r\n", imap_commands, mesg_num);
#ifdef IMAP_LOGGING
   fprintf(stderr, "%s", buffer);
#endif

   if (send(socket, buffer, strlen(buffer), 0) < 0)
   {
      g_free(buffer);
      return 0;
   }
  
   /* get the structure of the body */
   memset (buffer, 0, sizeof(gchar)*2048);
   recvline (socket, buffer, sizeof(gchar)*2048);
#ifdef IMAP_LOGGING
   fprintf(stderr, "received: %s", buffer);
#endif

   c = buffer;
   /* skip to the BODYSTRUCTURE */
   c = strstr(c, "BODYSTRUCTURE");
   if (c == NULL)
      return 0;

   c += strlen("BODYSTRUCTURE");
   if (*c)
   {
      /* looks good so far, skip to the parts */
      for ( ; *c && *c != '('; c++);

      if (*c && *(c+1) == '(')
      {
         c++;
#ifdef IMAP_LOGGING
         fprintf(stderr, "message is multipart\n");
#endif
         /* multipart */
         while (*c == '(')
         {
            cnt = imap_skip_section(c);
            if (cnt > 1)
            {
               c[cnt-1] = '\0';
               cnt = imap_add_part(c);
               if (cnt == -1)
               {
                  res = 0;
                  break;
               }
               c += cnt;
            }
            else
            {
               res = 0;
               break;
            }
            /* skip to the next mime part */
            for ( ; *c && *c == ' '; c++);
         }
      }
      else
         if (*c)
         {
            /* one part */
            cnt = imap_add_part(c);
            res = res != -1;
         }
         /* just forget the rest, who cares?? */
   }
  
   g_free(buffer);

   return res;
}

gint imap_get_string (gchar *index, gchar *dest, gint destlen, gchar *def)
{
   /* gets a string ("data" or NIL) , if NIL it copies def instead */
   gint i;
   gchar *start = index;

   while (*index && *index == ' ') /* skip white space */
     index++;

   if (strncmp(index, "NIL", 3))
   {
      /* progress to the first quote (we should already be there but just in case) */
      while (*index && *index != '"')
         index++;

      index++;
   
      i = 0;
      while (*index && *index != '"')
      {
         if (i < destlen-1)
         {
            dest[i] = *index;
            i++;
         }
         index++;
      }
      dest[i] = '\0';
   }
   else
   {
      /* if there were no data we just copy def */
      index += 3;
      strncpy (dest, def, destlen);
   }

   return index - start + 1;
}

gint imap_get_number (gchar *index, gint *dest)
{
   /* gets a number */
   gchar number[32];
   gchar *start = index;
   gint i;

   /* skip white space **/
   while (*index == ' ')
     index++;

   i = 0;
   while (*index != ' ' && i < sizeof(number)-1)
   {
      number[i] = *index;
      index++;
      i++;
   }
   number[i] = '\0';

   *dest = atoi(number);

   return index - start;
}

gint imap_skip_section(gchar *index)
{
   gint depth = 1;
   gchar *start = index;

   while (depth != 0 && *index)
   {
      if (*index == '(')
         depth++;
      else if ( *index == ')' )
         depth--;
      index++;
   }

   return index - start;
}