@@ -84,7 +84,7 @@ ipv4_genport(char *portname, int fallback)

 {

         struct addrinfo hints,*ai;

         struct sockaddr_in *in;

-        char port;

+        int port;

         if(*portname>='0' && *portname<='9')

                 return(atoi(portname));

         memset(&hints,0,sizeof(hints));

@@ -95,7 +95,7 @@ ipv4_genport(char *portname, int fallback)

                 freeaddrinfo(ai),ai=NULL;

                 return(fallback);

         }

-        port=ntohs(in->sin_port);

+	port=htons(in->sin_port);

         freeaddrinfo(ai),ai=NULL;

         return(port);

 }

@@ -466,6 +466,19 @@ sock_setunsafe(int fd)

         setsockopt(fd,SOL_SOCKET,SO_LINGER,(void *)&ltime,sizeof(ltime));

 }

+void

+sock_setsafe(int fd)

+{

+        int val;

+        struct linger ltime;

+        val=0;

+        setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,(void *)&val,sizeof(val));

+        ltime.l_onoff=0;

+        ltime.l_linger=1;

+        setsockopt(fd,SOL_SOCKET,SO_LINGER,(void *)&ltime,sizeof(ltime));

+}

+

+

 /* local functions */

 static int

 sselect_adduserptr(_sselect *ssel, int fd, void *userptr)

@@ -480,7 +480,7 @@ sselect_adduserptr(_sselect *ssel, int fd, void *userptr)

                 if((newptr=realloc(ssel->userptr,sizeof(void *)*newsize))==NULL)

                         return(-1);

                 ssel->userptr=newptr;

-                memset(ssel->userptr+ssel->sizeuserptr,sizeof(void *)*(newsize-ssel->sizeuserptr),0);

+                memset(ssel->userptr+ssel->sizeuserptr,0,sizeof(void *)*(newsize-ssel->sizeuserptr));

                 ssel->sizeuserptr=newsize;

         }

         ssel->userptr[fd]=userptr;

@@ -231,6 +231,19 @@ sock_setblocking(int fd, int block)

         return(fcntl(fd,F_SETFL,fl));

 }

+int

+sock_readable(int fd) /* tests readability */

+{

+        struct timeval tv;

+        fd_set rset;

+        FILLTV(tv,0,0);

+        FD_ZERO(&rset);

+        FD_SET(fd,&rset);

+        if(select(fd+1,&rset,NULL,NULL,&tv)>0)

+                return(0);

+        return(-1);

+}

+

 sselect *

 sselect_init(void)

 {

@@ -362,7 +362,7 @@ sselect_getread(sselect *paramssel, int *fds, int sizefds)

         _sselect *ssel=(_sselect *)paramssel;

         if(ssel==NULL || fds==NULL || sizefds<1)

                 return(-1);

-        for(n=0,i=ssel->readresultreturned;i<ssel->maxfd && n<sizefds;i++) {

+        for(n=0,i=ssel->readresultreturned;i<=ssel->maxfd && n<sizefds;i++) {

                 if(FD_ISSET(i,&(ssel->readresult))) {

                         fds[n++]=i;

                         FD_CLR(i,&(ssel->readresult));

@@ -379,7 +379,7 @@ sselect_getwrite(sselect *paramssel, int *fds, int sizefds)

         _sselect *ssel=(_sselect *)paramssel;

         if(ssel==NULL || fds==NULL || sizefds<1)

                 return(-1);

-        for(n=0,i=ssel->writeresultreturned;i<ssel->maxfd && n<sizefds;i++) {

+        for(n=0,i=ssel->writeresultreturned;i<=ssel->maxfd && n<sizefds;i++) {

                 if(FD_ISSET(i,&(ssel->writeresult))) {

                         fds[n++]=i;

                         FD_CLR(i,&(ssel->writeresult));

@@ -397,7 +397,7 @@ sselect_getreadfiltered(sselect *paramssel, fd_set *filter, int *fds, int sizefd

         _sselect *ssel=(_sselect *)paramssel;

         if(ssel==NULL || fds==NULL || sizefds<1)

                 return(-1);

-        for(n=0,i=0;i<ssel->maxfd && n<sizefds;i++) {

+        for(n=0,i=0;i<=ssel->maxfd && n<sizefds;i++) {

                 if(FD_ISSET(i,&(ssel->readresult)) && FD_ISSET(i,filter)) {

                         fds[n++]=i;

                         FD_CLR(i,&(ssel->readresult));

@@ -413,7 +413,7 @@ sselect_getwritefiltered(sselect *paramssel, fd_set *filter, int *fds, int sizef

         _sselect *ssel=(_sselect *)paramssel;

         if(ssel==NULL || fds==NULL || sizefds<1)

                 return(-1);

-        for(n=0,i=0;i<ssel->maxfd && n<sizefds;i++) {

+        for(n=0,i=0;i<=ssel->maxfd && n<sizefds;i++) {

                 if(FD_ISSET(i,&(ssel->writeresult)) && FD_ISSET(i,filter)) {

                         fds[n++]=i;

                         FD_CLR(i,&(ssel->writeresult));

@@ -468,6 +468,7 @@ sselect_adduserptr(_sselect *ssel, int fd, void *userptr)

                         return(-1);

                 ssel->userptr=newptr;

                 memset(ssel->userptr+ssel->sizeuserptr,sizeof(void *)*(newsize-ssel->sizeuserptr),0);

+                ssel->sizeuserptr=newsize;

         }

         ssel->userptr[fd]=userptr;

         return(0);

@@ -65,12 +65,16 @@ ipv4_genip(char *hostname, long *resulthostsize)

         if(getaddrinfo(hostname,NULL,&hints,&ai)!=0)

                 return(NULL);

         in=(struct sockaddr_in *)ai->ai_addr;

-        if(in==NULL || (host=malloc(ai->ai_addrlen))==NULL) {

+        if(in->sin_family!=AF_INET) {

                 freeaddrinfo(ai),ai=NULL;

                 return(NULL);

         }

-        memcpy(host,ai->ai_addr,ai->ai_addrlen);

-        *resulthostsize=ai->ai_addrlen;

+        *resulthostsize=4;

+        if(in==NULL || (host=malloc(*resulthostsize))==NULL) {

+                freeaddrinfo(ai),ai=NULL;

+                return(NULL);

+        }

+        memcpy(host,&(in->sin_addr),*resulthostsize);

         freeaddrinfo(ai),ai=NULL;

         return(host);

 }

@@ -32,6 +32,8 @@ typedef struct _sselect {

         int sizeresult;

         int readresultreturned;

         int writeresultreturned;

+        int sizeuserptr;

+        void **userptr;

 } _sselect;

@@ -47,6 +49,11 @@ typedef struct _sselect {

                 s.sin_port=htons(port)

 #endif

+#define USERPTRBLOCKSIZE 1024

+

+static int sselect_adduserptr(_sselect *ssel, int fd, void *userptr);

+static int sselect_clearuserptr(_sselect *ssel, int fd);

+

 char *

 ipv4_genip(char *hostname, long *resulthostsize)

 {

@@ -231,6 +238,20 @@ sselect_init(void)

         return((sselect *)ssel);

 }

+void

+sselect_free(sselect *paramssel)

+{

+        _sselect *ssel=(_sselect *)paramssel;

+        if(ssel==NULL)

+                return;

+        if(ssel->userptr!=NULL) {

+                ssel->sizeuserptr=0;

+                free(ssel->userptr),ssel->userptr=NULL;

+        }

+        free(ssel),ssel=NULL;

+}

+

+

 int

 sselect_reset(sselect *paramssel)

 {

@@ -243,15 +264,21 @@ sselect_reset(sselect *paramssel)

         ssel->numfd=0;

         FD_ZERO(&(ssel->readresult));

         FD_ZERO(&(ssel->writeresult));

+        memset(ssel->userptr,0,sizeof(void *)*ssel->sizeuserptr);

         return(0);

 }

 int

-sselect_addread(sselect *paramssel, int fd)

+sselect_addread(sselect *paramssel, int fd, void *userptr)

 {

         _sselect *ssel=(_sselect *)paramssel;

         if(ssel==NULL || fd<0 || FD_ISSET(fd,&(ssel->readset)))

                 return(-1);

+        if(userptr!=NULL) {

+                if(sselect_adduserptr(ssel, fd, userptr)!=0)

+                        return(-1);

+        } else

+                sselect_clearuserptr(ssel,fd);

         FD_SET(fd,&(ssel->readset));

         if(fd>ssel->maxfd)

                 ssel->maxfd=fd;

@@ -261,11 +288,16 @@ sselect_addread(sselect *paramssel, int fd)

 int

-sselect_addwrite(sselect *paramssel, int fd)

+sselect_addwrite(sselect *paramssel, int fd, void *userptr)

 {

         _sselect *ssel=(_sselect *)paramssel;

         if(ssel==NULL || fd<0 || FD_ISSET(fd,&(ssel->writeset)))

                 return(-1);

+        if(userptr!=NULL) {

+                if(sselect_adduserptr(ssel, fd, userptr)!=0)

+                        return(-1);

+        } else

+                sselect_clearuserptr(ssel,fd);

         FD_SET(fd,&(ssel->writeset));

         if(fd>ssel->maxfd)

                 ssel->maxfd=fd;

@@ -386,6 +418,15 @@ sselect_getwritefiltered(sselect *paramssel, fd_set *filter, int *fds, int sizef

         return(n);

 }

+void *

+sselect_getuserptr(sselect *paramssel, int fd)

+{

+        _sselect *ssel=(_sselect *)paramssel;

+        if(ssel==NULL || fd<0 || fd>=ssel->sizeuserptr)

+                return(NULL);

+        return(ssel->userptr[fd]);

+}

+

 /* aux functions */

 void

@@ -408,3 +449,34 @@ sock_setunsafe(int fd)

         setsockopt(fd,SOL_SOCKET,SO_LINGER,(void *)&ltime,sizeof(ltime));

 }

+/* local functions */

+static int

+sselect_adduserptr(_sselect *ssel, int fd, void *userptr)

+{

+        if(ssel==NULL || fd<0)

+                return(-1);

+        if(ssel->sizeuserptr<(fd+1)) {

+                void **newptr;

+                int newsize;

+                newsize=(fd+USERPTRBLOCKSIZE)/USERPTRBLOCKSIZE;

+                newsize*=USERPTRBLOCKSIZE;

+                if((newptr=realloc(ssel->userptr,sizeof(void *)*newsize))==NULL)

+                        return(-1);

+                ssel->userptr=newptr;

+                memset(ssel->userptr+ssel->sizeuserptr,sizeof(void *)*(newsize-ssel->sizeuserptr),0);

+        }

+        ssel->userptr[fd]=userptr;

+        return(0);

+}

+

+static int

+sselect_clearuserptr(_sselect *ssel, int fd)

+{

+        if(ssel==NULL || fd<0)

+                return(-1);

+        if(ssel->sizeuserptr<(fd+1))

+                return(0);

+        ssel->userptr[fd]=NULL;

+        return(0);

+}

+

@@ -3,12 +3,6 @@

  *

  * Handy functions for IPv4 socket connections.

  *

- * History:

- *      28/01/2014 Creation

- *      27/05/2014 New API.

- *      28/05/2014 Implement the ipv4_* functions.

- *      10/06/2014 Implement the sselect functions using select as backend.

- *

  * Author: Dario Rodriguez dario@softhome.net

  * This file is licensed under the terms of the GNU LGPL v2+

  */

@@ -333,8 +327,10 @@ sselect_getread(sselect *paramssel, int *fds, int sizefds)

         if(ssel==NULL || fds==NULL || sizefds<1)

                 return(-1);

         for(n=0,i=ssel->readresultreturned;i<ssel->maxfd && n<sizefds;i++) {

-                if(FD_ISSET(i,&(ssel->readresult)))

+                if(FD_ISSET(i,&(ssel->readresult))) {

                         fds[n++]=i;

+                        FD_CLR(i,&(ssel->readresult));

+                }

         }

         ssel->readresultreturned=i;

         return(n);

@@ -348,13 +344,49 @@ sselect_getwrite(sselect *paramssel, int *fds, int sizefds)

         if(ssel==NULL || fds==NULL || sizefds<1)

                 return(-1);

         for(n=0,i=ssel->writeresultreturned;i<ssel->maxfd && n<sizefds;i++) {

-                if(FD_ISSET(i,&(ssel->writeresult)))

+                if(FD_ISSET(i,&(ssel->writeresult))) {

                         fds[n++]=i;

+                        FD_CLR(i,&(ssel->writeresult));

+                }

         }

         ssel->writeresultreturned=i;

         return(n);

 }

+/* advanced sselect functions */

+int

+sselect_getreadfiltered(sselect *paramssel, fd_set *filter, int *fds, int sizefds)

+{

+        int i,n;

+        _sselect *ssel=(_sselect *)paramssel;

+        if(ssel==NULL || fds==NULL || sizefds<1)

+                return(-1);

+        for(n=0,i=0;i<ssel->maxfd && n<sizefds;i++) {

+                if(FD_ISSET(i,&(ssel->readresult)) && FD_ISSET(i,filter)) {

+                        fds[n++]=i;

+                        FD_CLR(i,&(ssel->readresult));

+                }

+        }

+        return(n);

+}

+

+int

+sselect_getwritefiltered(sselect *paramssel, fd_set *filter, int *fds, int sizefds)

+{

+        int i,n;

+        _sselect *ssel=(_sselect *)paramssel;

+        if(ssel==NULL || fds==NULL || sizefds<1)

+                return(-1);

+        for(n=0,i=0;i<ssel->maxfd && n<sizefds;i++) {

+                if(FD_ISSET(i,&(ssel->writeresult)) && FD_ISSET(i,filter)) {

+                        fds[n++]=i;

+                        FD_CLR(i,&(ssel->writeresult));

+                }

+        }

+        return(n);

+}

+

+

 /* aux functions */

 void

 sock_setfast(int fd)

@@ -29,12 +29,12 @@

 #include "socklib.h"

 typedef struct _sselect {

-        int fd_set readset;

-        int fd_set writeset;

+        fd_set readset;

+        fd_set writeset;

         int maxfd;

         int numfd;

-        int fd_set readresult;

-        int fd_set writeresult;

+        fd_set readresult;

+        fd_set writeresult;

         int sizeresult;

         int readresultreturned;

         int writeresultreturned;

@@ -240,7 +240,6 @@ sselect_init(void)

 int

 sselect_reset(sselect *paramssel)

 {

-        int i;

         _sselect *ssel=(_sselect *)paramssel;

         if(ssel==NULL)

                 return(-1);

@@ -256,9 +255,8 @@ sselect_reset(sselect *paramssel)

 int

 sselect_addread(sselect *paramssel, int fd)

 {

-        int i;

         _sselect *ssel=(_sselect *)paramssel;

-        if(ssel==NULL || fd<0 ||  FD_ISSET(fd,&(ssel->readset))

+        if(ssel==NULL || fd<0 || FD_ISSET(fd,&(ssel->readset)))

                 return(-1);

         FD_SET(fd,&(ssel->readset));

         if(fd>ssel->maxfd)

@@ -271,9 +269,8 @@ sselect_addread(sselect *paramssel, int fd)

 int

 sselect_addwrite(sselect *paramssel, int fd)

 {

-        int i;

         _sselect *ssel=(_sselect *)paramssel;

-        if(ssel==NULL || fd<0 ||  FD_ISSET(fd,&(ssel->writeset))

+        if(ssel==NULL || fd<0 || FD_ISSET(fd,&(ssel->writeset)))

                 return(-1);

         FD_SET(fd,&(ssel->writeset));

         if(fd>ssel->maxfd)

@@ -285,12 +282,11 @@ sselect_addwrite(sselect *paramssel, int fd)

 int

 sselect_delread(sselect *paramssel, int fd)

 {

-        int i;

         _sselect *ssel=(_sselect *)paramssel;

-        if(ssel==NULL || fd<0 || !FD_ISSET(fd,&(ssel->readset))

+        if(ssel==NULL || fd<0 || !FD_ISSET(fd,&(ssel->readset)))

                 return(-1);

         FD_CLR(fd,&(ssel->readset));

-        if(fd>0 && fd==ssel->maxfd && !FD_ISSET(fd,&(ssel->writeset))

+        if(fd>0 && fd==ssel->maxfd && !FD_ISSET(fd,&(ssel->writeset)))

                 ssel->maxfd=fd-1;

         ssel->numfd--;

         return(0);

@@ -300,12 +296,11 @@ sselect_delread(sselect *paramssel, int fd)

 int

 sselect_delwrite(sselect *paramssel, int fd)

 {

-        int i;

         _sselect *ssel=(_sselect *)paramssel;

-        if(ssel==NULL || fd<0 || !FD_ISSET(fd,&(ssel->writeset))

+        if(ssel==NULL || fd<0 || !FD_ISSET(fd,&(ssel->writeset)))

                 return(-1);

         FD_CLR(fd,&(ssel->writeset));

-        if(fd>0 && fd==ssel->maxfd && !FD_ISSET(fd,&(ssel->readset))

+        if(fd>0 && fd==ssel->maxfd && !FD_ISSET(fd,&(ssel->readset)))

                 ssel->maxfd=fd-1;

         ssel->numfd--;

         return(0);

@@ -314,8 +309,7 @@ sselect_delwrite(sselect *paramssel, int fd)

 int

 sselect_wait(sselect *paramssel, int ms)

 {

-        fd_set readset,writefd;

-        timeval tv;

+        struct timeval tv;

         _sselect *ssel=(_sselect *)paramssel;

         if(ssel==NULL || ms<0)

                 return(-1);

@@ -338,7 +332,7 @@ sselect_getread(sselect *paramssel, int *fds, int sizefds)

         _sselect *ssel=(_sselect *)paramssel;

         if(ssel==NULL || fds==NULL || sizefds<1)

                 return(-1);

-        for(n=0,i=ssel->readresultreturned;i<ssel->maxfd && n<sizeofds;i++) {

+        for(n=0,i=ssel->readresultreturned;i<ssel->maxfd && n<sizefds;i++) {

                 if(FD_ISSET(i,&(ssel->readresult)))

                         fds[n++]=i;

         }

@@ -353,7 +347,7 @@ sselect_getwrite(sselect *paramssel, int *fds, int sizefds)

         _sselect *ssel=(_sselect *)paramssel;

         if(ssel==NULL || fds==NULL || sizefds<1)

                 return(-1);

-        for(n=0,i=ssel->writeresultreturned;i<ssel->maxfd && n<sizeofds;i++) {

+        for(n=0,i=ssel->writeresultreturned;i<ssel->maxfd && n<sizefds;i++) {

                 if(FD_ISSET(i,&(ssel->writeresult)))

                         fds[n++]=i;

         }

@@ -7,6 +7,7 @@

  *      28/01/2014 Creation

  *      27/05/2014 New API.

  *      28/05/2014 Implement the ipv4_* functions.

+ *      10/06/2014 Implement the sselect functions using select as backend.

  *

  * Author: Dario Rodriguez dario@softhome.net

  * This file is licensed under the terms of the GNU LGPL v2+

@@ -28,12 +29,20 @@

 #include "socklib.h"

 typedef struct _sselect {

-        int dummy;

+        int fd_set readset;

+        int fd_set writeset;

+        int maxfd;

+        int numfd;

+        int fd_set readresult;

+        int fd_set writeresult;

+        int sizeresult;

+        int readresultreturned;

+        int writeresultreturned;

 } _sselect;

 #ifndef FILLTV

-#define FILLTV(tv,sec,usec) tv.tv_sec=sec,tv.tv_usec=usec

+#define FILLTV(tv,sec,usec) (tv).tv_sec=(sec),(tv).tv_usec=(usec)

 #endif

 #ifndef FILLIPV4ADDR

@@ -217,16 +226,140 @@ sock_setblocking(int fd, int block)

         return(fcntl(fd,F_SETFL,fl));

 }

-sselect *sselect_init(void);

-int sselect_reset(sselect *ssel);

-int sselect_addread(sselect *ssel, int fd);

-int sselect_addwrite(sselect *ssel, int fd);

-int sselect_delread(sselect *ssel, int fd);

-int sselect_delwrite(sselect *ssel, int fd);

-int sselect_wait(sselect *ssel, int ms);

-int sselect_getread(sselect *ssel, int *fds, int sizefds);

-int sselect_getwrite(sselect *ssel, int *fds, int sizefds);

+sselect *

+sselect_init(void)

+{

+        _sselect *ssel;

+        if((ssel=malloc(sizeof(_sselect)))==NULL)

+                return(NULL);

+        memset(ssel,0,sizeof(_sselect));

+        sselect_reset((sselect *)ssel);

+        return((sselect *)ssel);

+}

+

+int

+sselect_reset(sselect *paramssel)

+{

+        int i;

+        _sselect *ssel=(_sselect *)paramssel;

+        if(ssel==NULL)

+                return(-1);

+        FD_ZERO(&(ssel->readset));

+        FD_ZERO(&(ssel->writeset));

+        ssel->maxfd=0;

+        ssel->numfd=0;

+        FD_ZERO(&(ssel->readresult));

+        FD_ZERO(&(ssel->writeresult));

+        return(0);

+}

+

+int

+sselect_addread(sselect *paramssel, int fd)

+{

+        int i;

+        _sselect *ssel=(_sselect *)paramssel;

+        if(ssel==NULL || fd<0 ||  FD_ISSET(fd,&(ssel->readset))

+                return(-1);

+        FD_SET(fd,&(ssel->readset));

+        if(fd>ssel->maxfd)

+                ssel->maxfd=fd;

+        ssel->numfd++;

+        return(0);

+}

+

+

+int

+sselect_addwrite(sselect *paramssel, int fd)

+{

+        int i;

+        _sselect *ssel=(_sselect *)paramssel;

+        if(ssel==NULL || fd<0 ||  FD_ISSET(fd,&(ssel->writeset))

+                return(-1);

+        FD_SET(fd,&(ssel->writeset));

+        if(fd>ssel->maxfd)

+                ssel->maxfd=fd;

+        ssel->numfd++;

+        return(0);

+}

+

+int

+sselect_delread(sselect *paramssel, int fd)

+{

+        int i;

+        _sselect *ssel=(_sselect *)paramssel;

+        if(ssel==NULL || fd<0 || !FD_ISSET(fd,&(ssel->readset))

+                return(-1);

+        FD_CLR(fd,&(ssel->readset));

+        if(fd>0 && fd==ssel->maxfd && !FD_ISSET(fd,&(ssel->writeset))

+                ssel->maxfd=fd-1;

+        ssel->numfd--;

+        return(0);

+}

+

+

+int

+sselect_delwrite(sselect *paramssel, int fd)

+{

+        int i;

+        _sselect *ssel=(_sselect *)paramssel;

+        if(ssel==NULL || fd<0 || !FD_ISSET(fd,&(ssel->writeset))

+                return(-1);

+        FD_CLR(fd,&(ssel->writeset));

+        if(fd>0 && fd==ssel->maxfd && !FD_ISSET(fd,&(ssel->readset))

+                ssel->maxfd=fd-1;

+        ssel->numfd--;

+        return(0);

+}

+

+int

+sselect_wait(sselect *paramssel, int ms)

+{

+        fd_set readset,writefd;

+        timeval tv;

+        _sselect *ssel=(_sselect *)paramssel;

+        if(ssel==NULL || ms<0)

+                return(-1);

+        memcpy(&(ssel->readresult),&(ssel->readset),sizeof(fd_set));

+        memcpy(&(ssel->writeresult),&(ssel->writeset),sizeof(fd_set));

+        ssel->readresultreturned=0;

+        ssel->writeresultreturned=0;

+        FILLTV(tv,(ms/1000),(ms%1000)*1000);

+        if((ssel->sizeresult=select(

+          ssel->maxfd+1,&(ssel->readresult),

+          &(ssel->writeresult),NULL,&tv))<0)

+                return(-1);

+        return(ssel->sizeresult);

+}

+int

+sselect_getread(sselect *paramssel, int *fds, int sizefds)

+{

+        int i,n;

+        _sselect *ssel=(_sselect *)paramssel;

+        if(ssel==NULL || fds==NULL || sizefds<1)

+                return(-1);

+        for(n=0,i=ssel->readresultreturned;i<ssel->maxfd && n<sizeofds;i++) {

+                if(FD_ISSET(i,&(ssel->readresult)))

+                        fds[n++]=i;

+        }

+        ssel->readresultreturned=i;

+        return(n);

+}

+

+int

+sselect_getwrite(sselect *paramssel, int *fds, int sizefds)

+{

+        int i,n;

+        _sselect *ssel=(_sselect *)paramssel;

+        if(ssel==NULL || fds==NULL || sizefds<1)

+                return(-1);

+        for(n=0,i=ssel->writeresultreturned;i<ssel->maxfd && n<sizeofds;i++) {

+                if(FD_ISSET(i,&(ssel->writeresult)))

+                        fds[n++]=i;

+        }

+        ssel->writeresultreturned=i;

+        return(n);

+}

 /* aux functions */

 void

@@ -6,36 +6,216 @@

  * History:

  *      28/01/2014 Creation

  *      27/05/2014 New API.

+ *      28/05/2014 Implement the ipv4_* functions.

  *

  * Author: Dario Rodriguez dario@softhome.net

  * This file is licensed under the terms of the GNU LGPL v2+

  */

 #include <stdlib.h>

+#include <unistd.h>

 #include <string.h>

 #include <netdb.h>

+#include <errno.h>

+#include <fcntl.h>

 #include <netinet/in.h>

+#include <netinet/tcp.h>

 #include <sys/types.h>

 #include <sys/socket.h>

 #include <sys/select.h>

+#include <sys/ioctl.h>

 #include "socklib.h"

 typedef struct _sselect {

-        int dummy

+        int dummy;

 } _sselect;

-char *ipv4_genip(char *hostname, long *resulthostsize);

-int ipv4_genport(char *portname, int fallback);

-int ipv4_preconnect(char *host, long hostsize, int port); /* setup socket, set non-blocking, connect(2) call */

-int ipv4_connect(int fd); /* tests writeability */

-int ipv4_postconnect(int fd); /* hopefully connect(2) suceeded, set blocking */

-int ipv4_server(int port);

-int ipv4_serverbinded(char *host, long hostsize, int port);

-int sock_accept(int fd);

-int sock_getinfo(int socket, int *iplen, char *ip, int *port); /* ip must be at least 16 bytes to have room for an ipv6 address */

-int sock_queued(int socket);

-int sock_setblocking(int socket, int block);

+

+#ifndef FILLTV

+#define FILLTV(tv,sec,usec) tv.tv_sec=sec,tv.tv_usec=usec

+#endif

+

+#ifndef FILLIPV4ADDR

+#define FILLIPV4ADDR(a,family,addr,port) \

+                memset(&(a),0,sizeof(struct sockaddr_in)),\

+                s.sin_family=family,\

+                s.sin_addr.s_addr=addr,\

+                s.sin_port=htons(port)

+#endif

+

+char *

+ipv4_genip(char *hostname, long *resulthostsize)

+{

+        struct addrinfo hints,*ai;

+        struct sockaddr_in *in;

+        char *host;

+        memset(&hints,0,sizeof(hints));

+        hints.ai_family=AF_INET;

+        if(getaddrinfo(hostname,NULL,&hints,&ai)!=0)

+                return(NULL);

+        in=(struct sockaddr_in *)ai->ai_addr;

+        if(in==NULL || (host=malloc(ai->ai_addrlen))==NULL) {

+                freeaddrinfo(ai),ai=NULL;

+                return(NULL);

+        }

+        memcpy(host,ai->ai_addr,ai->ai_addrlen);

+        *resulthostsize=ai->ai_addrlen;

+        freeaddrinfo(ai),ai=NULL;

+        return(host);

+}

+

+int

+ipv4_genport(char *portname, int fallback)

+{

+        struct addrinfo hints,*ai;

+        struct sockaddr_in *in;

+        char port;

+        if(*portname>='0' && *portname<='9')

+                return(atoi(portname));

+        memset(&hints,0,sizeof(hints));

+        hints.ai_family=AF_INET;

+        if(getaddrinfo(NULL,portname,&hints,&ai)!=0)

+                return(fallback);

+        if((in=((struct sockaddr_in *)ai->ai_addr))==NULL) {

+                freeaddrinfo(ai),ai=NULL;

+                return(fallback);

+        }

+        port=ntohs(in->sin_port);

+        freeaddrinfo(ai),ai=NULL;

+        return(port);

+}

+

+int

+ipv4_preconnect(char *host, long hostsize, int port) /* setup socket, set non-blocking, connect(2) call */

+{

+        struct sockaddr_in c,s;

+        int fd;

+        int res,err;

+        FILLIPV4ADDR(c,AF_INET,htonl(INADDR_ANY),0);

+        FILLIPV4ADDR(c,AF_INET,htonl(INADDR_ANY),port);

+        memcpy(&(s.sin_addr.s_addr),host,hostsize);

+        if((fd=socket(AF_INET,SOCK_STREAM,0 /* any protocol */))==-1)

+                return(-1);

+        if(bind(fd,(struct sockaddr *)&c,sizeof(c))!=0) {

+                close(fd),fd=-1;

+                return(-1);

+        }

+        sock_setblocking(fd,0);

+        res=connect(fd,(struct sockaddr *)&s,sizeof(s));

+        err=errno;

+        if(res==-1 && err!=EINPROGRESS) {

+                close(fd),fd=-1;

+                return(-1);

+        }

+        return(fd);

+}

+

+int

+ipv4_connect(int fd, long timeoutmsec) /* tests writeability */

+{

+        struct timeval tv;

+        fd_set wset;

+        FILLTV(tv,timeoutmsec/1000L,(timeoutmsec%(1000L))*1000L);

+        FD_ZERO(&wset);

+        FD_SET(fd,&wset);

+        if(select(fd+1,NULL,&wset,NULL,&tv)>0)

+                return(0);

+        return(-1);

+}

+

+int

+ipv4_postconnect(int fd) /* hopefully connect(2) suceeded, set blocking */

+{

+        sock_setblocking(fd,1);

+        return(0);

+}

+

+int

+ipv4_server(int port)

+{

+        return(ipv4_serverbinded(NULL,0,port));

+}

+

+int

+ipv4_serverbinded(char *host, long hostsize, int port)

+{

+        struct sockaddr_in s;

+        int fd;

+        if((fd=socket(AF_INET,SOCK_STREAM,0 /* any protocol */))==-1)

+                return(-1);

+        FILLIPV4ADDR(s,AF_INET,htonl(INADDR_ANY),port);

+        if(host!=NULL)

+                memcpy(&(s.sin_addr.s_addr),host,hostsize);

+        if(bind(fd,(struct sockaddr *)&s,sizeof(s))!=0) {

+                close(fd),fd=-1;

+                return(-1);

+        }

+        if(listen(fd,4)==-1) {

+                close(fd),fd=-1;

+                return(-1);

+        }

+        return(fd);

+}

+

+int

+sock_accept(int fd)

+{

+        int newfd;

+        struct sockaddr_in s;

+        socklen_t slen;

+        slen=sizeof(s);

+        if(fd==-1 || (newfd=accept(fd,(struct sockaddr *)&s,&slen))==-1)

+                return(-1);

+        return(newfd);

+}

+

+int

+sock_getinfo(int fd, int *iplen, char *ip, int *port) /* ip must be at least 16 bytes to have room for an ipv6 address */

+{

+        struct sockaddr c;

+        struct sockaddr_in *c4;

+        struct sockaddr_in6 *c6;

+        socklen_t clen;

+        if(fd==-1)

+                return(-1);

+        clen=sizeof(c);

+        if(getsockname(fd,(struct sockaddr *)&c,&clen)==-1)

+                return(-1);

+        if(c.sa_family!=AF_INET && c.sa_family!=AF_INET6)

+                return(-1);

+        if(c.sa_family==AF_INET) {

+                c4=(struct sockaddr_in *) &c;

+                *iplen=sizeof(c4->sin_addr.s_addr);

+                memcpy(ip,&(c4->sin_addr.s_addr),*iplen);

+                *port=ntohs(c4->sin_port);

+        } else {

+                c6=(struct sockaddr_in6 *) &c;

+                *iplen=sizeof(c6->sin6_addr);

+                memcpy(ip,&(c6->sin6_addr),*iplen);

+                *port=ntohs(c6->sin6_port);

+        }

+        return(0);

+}

+

+int

+sock_queued(int fd)

+{

+        int n;

+        if(ioctl(fd,FIONREAD,&n)!=0)

+                return(-1);

+        return(n);

+}

+

+int

+sock_setblocking(int fd, int block)

+{

+        int fl;

+        if((fl=fcntl(fd,F_GETFL,0))==-1)

+                return(-1);

+        fl=(block)?(fl&(~O_NONBLOCK)):(fl|O_NONBLOCK);

+        return(fcntl(fd,F_SETFL,fl));

+}

 sselect *sselect_init(void);

 int sselect_reset(sselect *ssel);

@@ -43,7 +223,29 @@ int sselect_addread(sselect *ssel, int fd);

 int sselect_addwrite(sselect *ssel, int fd);

 int sselect_delread(sselect *ssel, int fd);

 int sselect_delwrite(sselect *ssel, int fd);

-int sselect_wait(sslect *ssel, int ms);

+int sselect_wait(sselect *ssel, int ms);

 int sselect_getread(sselect *ssel, int *fds, int sizefds);

 int sselect_getwrite(sselect *ssel, int *fds, int sizefds);

+

+/* aux functions */

+void

+sock_setfast(int fd)