/*
  *  Copyright 2006 Everton da Silva Marques <everton.marques@gmail.com>
  *
  *  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., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 

 #if HAVE_CONFIG_H
 #include "clamav-config.h"
 #endif
 
 #include "nonblock.h"
 

 #include <stdio.h>
 #include <stdlib.h>

 #ifdef	HAVE_UNISTD_H

 #include <unistd.h>

 #endif

 #include <string.h>
 #include <ctype.h>

 #ifndef	_WIN32

 #include <netinet/in.h>
 #include <netdb.h>

 #include <sys/socket.h>

 #include <sys/time.h>

 #endif

 #include <sys/types.h>

 #include <time.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <errno.h>
 

 #include "shared/output.h"

 #include "libclamav/clamav.h"

 #ifdef SO_ERROR
 

 #ifndef timercmp

 #define timercmp(a, b, cmp)          \

   (((a)->tv_sec == (b)->tv_sec) ?     \
    ((a)->tv_usec cmp (b)->tv_usec) :  \
    ((a)->tv_sec cmp (b)->tv_sec))
 #endif /* timercmp */
 
 #ifndef timersub

 #define timersub(a, b, result)                       \

   do {                                                \
     (result)->tv_sec = (a)->tv_sec - (b)->tv_sec;     \
     (result)->tv_usec = (a)->tv_usec - (b)->tv_usec;  \
     if ((result)->tv_usec < 0) {                      \
       --(result)->tv_sec;                             \
       (result)->tv_usec += 1000000;                   \
     }                                                 \
   } while (0)
 #endif /* timersub */
 
 #define NONBLOCK_SELECT_MAX_FAILURES 3
 #define NONBLOCK_MAX_BOGUS_LOOPS     10
 #undef  NONBLOCK_DEBUG
 

 static int
 connect_error (int sock)

 {

     int optval;
     socklen_t optlen;

     optlen = sizeof (optval);

     getsockopt (sock, SOL_SOCKET, SO_ERROR, &optval, (socklen_t *)&optlen);

     if (optval)
     {
         logg ("connect_error: getsockopt(SO_ERROR): fd=%d error=%d: %s\n",
               sock, optval, strerror (optval));
     }

     return optval ? -1 : 0;

 }
 

 static int
 nonblock_connect (int sock, const struct sockaddr *addr, socklen_t addrlen,
                   int secs)

 {

     /* Max. of unexpected select() failures */
     int select_failures = NONBLOCK_SELECT_MAX_FAILURES;
     /* Max. of useless loops */
     int bogus_loops = NONBLOCK_MAX_BOGUS_LOOPS;
     struct timeval timeout;     /* When we should time out */
     int numfd;                  /* Highest fdset fd plus 1 */
 
     /* Calculate into 'timeout' when we should time out */
     gettimeofday (&timeout, 0);
     timeout.tv_sec += secs;
 
     /* Launch (possibly) non-blocking connect() request */
     if (connect (sock, addr, addrlen))
     {
         int e = errno;

 #ifdef NONBLOCK_DEBUG

         logg ("DEBUG nonblock_connect: connect(): fd=%d errno=%d: %s\n",
               sock, e, strerror (e));

 #endif

         switch (e)
         {
         case EALREADY:
         case EINPROGRESS:
         case EAGAIN:
             break;              /* wait for connection */
         case EISCONN:
             return 0;           /* connected */
         default:
             logg ("nonblock_connect: connect(): fd=%d errno=%d: %s\n",
                   sock, e, strerror (e));
             return -1;          /* failed */
         }
     }
     else
     {
         return connect_error (sock);
     }
 
     numfd = sock + 1;           /* Highest fdset fd plus 1 */
 
     for (;;)
     {
         fd_set fds;
         struct timeval now;
         struct timeval wait;
         int n;
 
         /* Force timeout if we ran out of time */
         gettimeofday (&now, 0);
         if (timercmp (&now, &timeout, >))
         {
             logg ("nonblock_connect: connect timing out (%d secs)\n", secs);
             break;              /* failed */
         }
 
         /* Calculate into 'wait' how long to wait */
         timersub (&timeout, &now, &wait);   /* wait = timeout - now */
 
         /* Init fds with 'sock' as the only fd */
         FD_ZERO (&fds);
         FD_SET (sock, &fds);
 
         n = select (numfd, 0, &fds, 0, &wait);
         if (n < 0)
         {
             logg ("nonblock_connect: select() failure %d: errno=%d: %s\n",
                   select_failures, errno, strerror (errno));
             if (--select_failures >= 0)
                 continue;       /* keep waiting */
             break;              /* failed */
         }

 
 #ifdef NONBLOCK_DEBUG

         logg ("DEBUG nonblock_connect: select = %d\n", n);

 #endif
 

         if (n)
         {
             return connect_error (sock);
         }

         /* Select returned, but there is no work to do... */
         if (--bogus_loops < 0)
         {
             logg ("nonblock_connect: giving up due to excessive bogus loops\n");
             break;              /* failed */
         }

     }                           /* for loop: keep waiting */

     return -1;                  /* failed */

 }
 

 static ssize_t
 nonblock_recv (int sock, void *buf, size_t len, int flags, int secs)

 {

     /* Max. of unexpected select() failures */
     int select_failures = NONBLOCK_SELECT_MAX_FAILURES;
     /* Max. of useless loops */
     int bogus_loops = NONBLOCK_MAX_BOGUS_LOOPS;
     struct timeval timeout;     /* When we should time out */
     int numfd;                  /* Highest fdset fd plus 1 */
 

     /* Zero buffer to maintain sanity in case we're dealing with strings */
     memset(buf, 0x00, len);
 

     /* Calculate into 'timeout' when we should time out */
     gettimeofday (&timeout, 0);
     timeout.tv_sec += secs;
 
     numfd = sock + 1;           /* Highest fdset fd plus 1 */
 
     for (;;)
     {
         fd_set fds;
         struct timeval now;
         struct timeval wait;
         int n;

         ssize_t recvd;

 
         /* Force timeout if we ran out of time */
         gettimeofday (&now, 0);
         if (timercmp (&now, &timeout, >))
         {
             logg ("nonblock_recv: recv timing out (%d secs)\n", secs);
             break;              /* failed */
         }
 
         /* Calculate into 'wait' how long to wait */
         timersub (&timeout, &now, &wait);   /* wait = timeout - now */
 
         /* Init fds with 'sock' as the only fd */
         FD_ZERO (&fds);
         FD_SET (sock, &fds);
 
         n = select (numfd, &fds, 0, 0, &wait);
         if (n < 0)
         {
             logg ("nonblock_recv: select() failure %d: errno=%d: %s\n",
                   select_failures, errno, strerror (errno));
             if (--select_failures >= 0)
                 continue;       /* keep waiting */
             break;              /* failed */
         }
 

         if (FD_ISSET(sock, &fds))

         {

             recvd = recv(sock, buf, len, flags);
             if (recvd < 0) {

                 if (errno == EINTR)

                     continue;
 
                 return -1;
             }
 
             return recvd;

         }
 
         /* Select returned, but there is no work to do... */
         if (--bogus_loops < 0)
         {
             logg ("nonblock_recv: giving up due to excessive bogus loops\n");
             break;              /* failed */
         }
 
     }                           /* for loop: keep waiting */
 
     return -1;                  /* failed */

 }
 

 static long
 nonblock_fcntl (int sock)

 {

 #ifdef	F_GETFL

     long fcntl_flags;           /* Save fcntl() flags */
 
     fcntl_flags = fcntl (sock, F_GETFL, 0);
     if (fcntl_flags == -1)
     {
         logg ("nonblock_fcntl: saving: fcntl(%d, F_GETFL): errno=%d: %s\n",
               sock, errno, strerror (errno));
     }
     else if (fcntl (sock, F_SETFL, fcntl_flags | O_NONBLOCK))
     {
         logg ("nonblock_fcntl: fcntl(%d, F_SETFL, O_NONBLOCK): errno=%d: %s\n", sock, errno, strerror (errno));
     }
 
     return fcntl_flags;

 #else

     return 0;

 #endif

 }
 

 static void
 restore_fcntl (int sock, long fcntl_flags)

 {

 #ifdef	F_SETFL

     if (fcntl_flags != -1)
     {
         if (fcntl (sock, F_SETFL, fcntl_flags))
         {
             logg ("restore_fcntl: restoring: fcntl(%d, F_SETFL): errno=%d: %s\n", sock, errno, strerror (errno));
         }
     }

 #endif

 }
 
 /*
 	wait_connect(): wrapper for connect(), with explicit 'secs' timeout
 */

 int
 wait_connect (int sock, const struct sockaddr *addr, socklen_t addrlen,
               int secs)

 {

     long fcntl_flags;           /* Save fcntl() flags */
     int ret;

     /* Temporarily set socket to non-blocking mode */
     fcntl_flags = nonblock_fcntl (sock);

     ret = nonblock_connect (sock, addr, addrlen, secs);

     /* Restore socket's default blocking mode */
     restore_fcntl (sock, fcntl_flags);

     return ret;

 }
 
 /*
 	wait_recv(): wrapper for recv(), with explicit 'secs' timeout
 */

 ssize_t
 wait_recv (int sock, void *buf, size_t len, int flags, int secs)

 {

     long fcntl_flags;           /* Save fcntl() flags */
     int ret;

     /* Temporarily set socket to non-blocking mode */
     fcntl_flags = nonblock_fcntl (sock);

     ret = nonblock_recv (sock, buf, len, flags, secs);

     /* Restore socket's default blocking mode */
     restore_fcntl (sock, fcntl_flags);

     return ret;

 }
 

 #endif /* SO_ERROR */