queries.c

Go to the documentation of this file.

/* this is queries.c file.
 * this is part of the libspopc library sources
 * copyright © 2002 Benoit Rouits <brouits@free.fr>
 * released under the terms of GNU LGPL
 * (GNU Lesser General Public Licence).
 * libspopc offers simple API for a pop3 client (MTA).
 * See RFC 1725 for pop3 specifications.
 * more information on http://brouits.free.fr/libspopc/
 */

#include <sys/types.h>

#ifdef _MSC_VER
#include <winsock.h>
#else
#include <sys/socket.h>
#endif

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "libspopc.h"

/* enable timeout sockets with 'select' */
int timedrselect(fd_set *rfds, int max, int time){
struct timeval timeout;
timeout.tv_sec = time;
timeout.tv_usec = 0;

   if(select(max, rfds, NULL, NULL, &timeout) <= 0){
      perror("timeout reached\n");
      return(1);
   }
   return(0);
}
/* prepare the socket ito be read */
int timedrread(int sock, int time) {
fd_set rfds;

   FD_ZERO(&rfds);
   FD_SET(sock, &rfds);
   timedrselect(&rfds, sock + 1, time);
   return FD_ISSET(sock, &rfds);
}

char* pop3_query(int sock, const char* query){
/* performs a simple pop query and returns server's <512 bytes response */
int r;
char* buf;

#ifdef EBUG
        fprintf(stderr,"<pop3_query>\n");
        fprintf(stderr,"send %s",query);
#endif
        r=send(sock,query,strlen(query),0);
        if(r==-1){
                perror("pop3_query.send");
                return(NULL);
        }
        buf=(char*)malloc(512 +1); /* 512 chars + '\0' */
        if(!buf){
                perror("pop3_query.malloc");
                return(NULL);
        }
        /* memset(buf,0,512); SUGGEST: should not be an obligation */
        r=recv(sock,buf,512,0);
        buf[r]='\0';
#ifdef EBUG
        fprintf(stderr,"recv %s",buf);
        fprintf(stderr,"</pop3_query>\n");
#endif
        return(buf);
}

char* pop3_user(int sock, const char* name){
/* performs "USER" pop query and returns server's <512 bytes response */
char query[512]; /* total "USER ****your_name****\n" is < 512  */

        sprintf(query,"USER %s\r\n",name);
        return(pop3_query(sock,query));
}

char* pop3_pass(int sock, const char* pw){
/* performs "PASS" pop query and return server's <512 bytes response */
char query[512]; /* total "PASS ****your_pass****\n" is <512 */

        sprintf(query,"PASS %s\r\n",pw);
        return(pop3_query(sock,query));
}

char* pop3_quit(int sock){
/* performs "QUIT" pop query and returns server's <512 bytes response */
char query[]="QUIT\r\n";

        return(pop3_query(sock,query));
}

char* pop3_stat(int sock){
/* performs "STAT" pop query and returns server's <512 bytes response */
char query[]="STAT\r\n";

        return(pop3_query(sock,query));
}

char* recv_rest(int sock, char* buf, int cs, int bs){
/* recv rest of data through sock, given a cs  pre-filled buffer sized of bs.
* end of data is assumed when data has a "\n.\n" or "\n.\r" string
* recv() is TCPBUFLEN  bytes stepped, SUGGEST any good value... */
char* ret;
char* cur; /* current position ready to receive */
int tr;    /* total received */
#ifdef EBUG
   fprintf(stderr,"<recv_rest>\n");
#endif
   if(!buf){
#ifdef EBUG
      fprintf(stderr,"was given NULL buf !\n");
#endif
      return(NULL);
}
   tr = cs;
   cur = buf;
   while(!dotline(cur)){
      if (tr >= (bs - TCPBUFLEN)){
#ifdef EBUG
         fprintf(stderr,"realloc bs*2 + 1 == %d\n", bs*2 +1);
#endif
         ret = (char*)realloc(buf, (bs *=2) +1);
      }
      if(!ret){
         perror("recv_rest.realloc");
         return(buf);
      }
      buf = ret;
      cur = buf + tr;
      if(timedrread(sock, SOCKET_TIMEOUT)){
         cs=recv(sock, cur, TCPBUFLEN, 0);
         if (cs < 0){ /* socket error */
            perror("Socket Error");
            free(cur);
            return(NULL);
         }
      }else{
         printf("timeout reached\n");
         return(buf);
      }
      if (cs > 0){
         tr+=cs;
         cur[cs] = '\0';
      }else{
         cs = 0;
      }
   }
   cur[cs] = '\0';
#ifdef EBUG
   fprintf(stderr, "total recv %d bytes\n", tr);
   fprintf(stderr, "</recv_rest>\n");
#endif
   return(buf);
}
      
char* pop3_list(int sock, int id){
/* performs a "LIST" pop query and returns server's (long) response */
int r;
char query[512]; /* total query "LIST ID\n" string is < 512 */
char* buf;

#ifdef EBUG
        fprintf(stderr,"<pop3_list>\n");
#endif
        if(id>0){
                sprintf(query,"LIST %d\r\n",id);
        }else{
                sprintf(query,"LIST\r\n");
        }
#ifdef EBUG
        fprintf(stderr,"send %s",query);
#endif
        r=send(sock,query,strlen(query),0);
        if(r==-1){
                perror("pop3_list.send");
                return(NULL);
        }
        /* now prepare a first short 512 bytes recv() */
        /* it might be now enough for recv() from "LIST X" */
        buf=(char*)malloc(512 +1); /* 512 chars + '\0' */
        if(!buf){
                perror("pop3_list.malloc");
                return(NULL);
        }
        r=recv(sock,buf,512,0);
   if(r < 0){ /* socket error */
      perror("Socket Error");
      free(buf);
      return(NULL);
   }
   buf[r]='\0';
        if(id>0){/* +OK id size */
                return(buf); /* hope 512 bytes were enough */
        }
        /* else : +OK X messages (YYY octets)\n id size\n... */
        if(pop3_error(buf)){
#ifdef EBUG
                fprintf(stderr,"%s",buf);
#endif
                return(buf);
        }
#ifdef EBUG
        fprintf(stderr,"</>\n");
#endif
        return(recv_rest(sock,buf,r,512));
}

char* pop3_retr(int sock, int id){
int r;
char query[512];
char *buf;

#ifdef EBUG
   fprintf(stderr, "<pop3_retr>\n");
#endif
   sprintf(query, "RETR %d\r\n", id);
   r=send(sock, query, strlen(query), 0);
   if(r == -1){
      perror("pop3_retr.send");
      return(NULL);
   }
   buf=(char*)malloc(512 +1);/* 512 chars + '\0' */
   if(!buf) {
      perror("pop3_retr.malloc");
      return(NULL);
   }
   if(timedrread(sock, SOCKET_TIMEOUT)){
      r=recv(sock, buf, 512, 0); 
      if(r < 0){ /* socket error */
         perror("Socket Error");
         free(buf);
         return(NULL);
      }
   }else{
      perror("timeout reached\n");
      return(NULL);
   }
   if(pop3_error(buf)){
      buf[r+1] = '\0';
      return(buf); /* hope 512 was enough */
   }
#ifdef EBUG
   fprintf(stderr,"</>\n");
#endif
   if (r > 0) {
      return(recv_rest(sock, buf, r, 512));
   }else{
      perror("nothing returned\n");
      return(NULL);
   }
}

char* pop3_dele(int sock, int id){
/* performs a "DELE" pop query and returns server's <512 bytes response */
char query[512]; /* total "DELE X\n" string < 512 */

        if(id<=0){
#ifdef EBUG
                fprintf(stderr,"pop3_dele : won't delete %d\n",id);
#endif
                return(NULL);
        }
        sprintf(query,"DELE %d\r\n",id);
        return(pop3_query(sock,query));
}

char* pop3_noop(int sock){
/* performs a "NOOP" pop query and returns server's <512 bytes response */
char query[]="NOOP\r\n";
        
        return(pop3_query(sock,query));
}

char* pop3_rset(int sock){
/* performs a "RSET" pop query and returns server's <512 bytes response */
char query[]="RSET\r\n";

        return(pop3_query(sock,query));
}

char* pop3_top(int sock, int id, int lines){
/* performs a "TOP" pop query and returns server's (long) response */
int r;
char query[512]; /* total "TOP X Y\n" is < 512 */
char* buf;

#ifdef EBUG
        fprintf(stderr,"<pop3_top>\n");
#endif
        sprintf(query,"TOP %d %d\r\n",id,lines);
#ifdef EBUG
        fprintf(stderr,"send %s",query);
#endif
        r=send(sock,query,strlen(query),0);
        if(r==-1){
                perror("pop3_top.send");
                return(NULL);
        }
        /* prepare first recv() of 512 bytes */
        buf=(char*)malloc(512 +1); /* 512 chars + '\0' */
        if(!buf){
                perror("pop3_top.malloc");
                return(NULL);
        }
/*      memset(buf,0,512); SUGGEST: no obligation */
        r=recv(sock,buf,512,0);
   if(r < 0){ /* socket error */
      perror("Socket Error");
      free(buf);
      return(NULL);
   }
   buf[r]='\0';
   
        if(pop3_error(buf)){
#ifdef EBUG
                fprintf(stderr,"%s",buf);
#endif
                return(buf); /* hope 512 bytes were enough */
        }
#ifdef EBUG
        fprintf(stderr,"</>\n");
#endif
        return(recv_rest(sock,buf,r,512));
}

char* pop3_uidl(int sock, int id){
/* performs a "UIDL" pop query and returns server's (long) response */
int r;
char query[512]; /* total "UIDL X\n" is < 512 */
char* buf;

#ifdef EBUG
        fprintf(stderr,"<pop3_uidl>\n");
#endif
        if(id>0){
                sprintf(query,"UIDL %d\r\n",id);
        }else{
                sprintf(query,"UIDL\r\n");
        }
#ifdef EBUG
        fprintf(stderr,"send %s",query);
#endif
        r=send(sock,query,strlen(query),0);
        if(r==-1){
                perror("pop3_uidl.send");
                return(NULL);
        }
        /* prepare first 512 bytes for recv() */
        /* i hope this is also enough for the 'one line' short response */
        buf=(char*)malloc(512 +1); /* 512 chars + '\0' */
        if(!buf){
                perror("pop3_uidl.malloc");
                return(NULL);
        }
        memset(buf,0,512);
        r=recv(sock,buf,512,0);
   if (r < 0){ /* socket errorr */
      perror("Socket Error");
      free(buf);
      return(NULL);
   }
   buf[r]='\0';
   
        if(id>0){/* +OK id sig */
#ifdef EBUG
                if(pop3_error(buf)){
                        fprintf(stderr,"%s",buf);
                }
#endif
                /* anyway, we return the short buf, error or not */
                return(buf); /* hope 512 were enough */
        }
        /* else : +OK\n id sig\nid sig\nid sig\n... */
        if(pop3_error(buf)){
#ifdef EBUG
                fprintf(stderr,"%s",buf);
#endif
                return(buf); /* hope error msg were < 512 bytes */
        }
#ifdef EBUG
        fprintf(stderr,"buf=%s</>\n",buf);
#endif
        return(recv_rest(sock,buf,r,512));
}

char* pop3_apop(int sock, const char* name, const char* digest){
/* performs a "APOP" secure query and returns server's <512 bytes response */
char query[512]; /* total "APOP name digest\n" is < 512 */

        sprintf(query,"APOP %s %s\r\n",name,digest);
        return(pop3_query(sock,query));
}