socket.c

Go to the documentation of this file.

/*
Copyright (C) 2012  Gregory Nietsky <gregory@distrotetch.co.za>
        http://www.distrotech.co.za

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 3 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, see <http://www.gnu.org/licenses/>.
*/

#ifndef __WIN32__
#include <netdb.h>
#endif
#include <unistd.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <fcntl.h>
#ifdef __WIN32__
#include <winsock2.h>
#include <ws2tcpip.h>
#else
#include <arpa/inet.h>
#endif
#include <stdlib.h>

#include "include/dtsapp.h"
#include "include/private.h"

struct socket_handler {
    struct fwsocket *sock;
    void *data;
    socketrecv  client;
    threadcleanup   cleanup;
    socketrecv  connect;
};

static int32_t hash_socket(const void *data, int key) {
    int ret;
    const struct fwsocket *sock = data;
    const int *hashkey = (key) ? data : &sock->sock;

    ret = *hashkey;

    return (ret);
}

extern void close_socket(struct fwsocket *sock) {
    if (sock) {
        setflag(sock, SOCK_FLAG_CLOSE);
        objunref(sock);
    }
}

static void clean_fwsocket(void *data) {
    struct fwsocket *sock = data;

    if (sock->ssl) {
        objunref(sock->ssl);
    }

    /*im closing remove from parent list*/
    if (sock->parent) {
        if (sock->parent->children) {
            remove_bucket_item(sock->parent->children, sock);
        }
        objunref(sock->parent);
    }

    /*looks like the server is shut down*/
    if (sock->children) {
        objunref(sock->children);
    }

    if (sock->sock >= 0) {
        close(sock->sock);
    }
}

extern struct fwsocket *make_socket(int family, int type, int proto, void *ssl) {
    struct fwsocket *si;

    if (!(si = objalloc(sizeof(*si),clean_fwsocket))) {
        return NULL;
    }

    if ((si->sock = socket(family, type, proto)) < 0) {
        objunref(si);
        return NULL;
    };

    if (ssl) {
        si->ssl = ssl;
    }
    si->type = type;
    si->proto = proto;

    return (si);
}

extern struct fwsocket *accept_socket(struct fwsocket *sock) {
    struct fwsocket *si;
    socklen_t salen = sizeof(si->addr);

    if (!(si = objalloc(sizeof(*si),clean_fwsocket))) {
        return NULL;
    }

    objlock(sock);
    if ((si->sock = accept(sock->sock, &si->addr.sa, &salen)) < 0) {
        objunlock(sock);
        objunref(si);
        return NULL;
    }

    si->type = sock->type;
    si->proto = sock->proto;

    if (sock->ssl) {
        tlsaccept(si, sock->ssl);
    }
    objunlock(sock);

    return (si);
}

static struct fwsocket *_opensocket(int family, int stype, int proto, const char *ipaddr, const char *port, void *ssl, int ctype, int backlog) {
    struct  addrinfo hint, *result, *rp;
    struct fwsocket *sock = NULL;
    socklen_t salen = sizeof(union sockstruct);
#ifndef __WIN32__
    int on = 1;
#endif

    memset(&hint, 0, sizeof(hint));
    hint.ai_family = family;
    hint.ai_socktype = stype;
    hint.ai_protocol = proto;

    if (getaddrinfo(ipaddr, port, &hint, &result) || !result) {
        return (NULL);
    }

    for(rp = result; rp; rp = result->ai_next) {
        if (!(sock = make_socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol, ssl))) {
            continue;
        }
        if (ctype) {
#ifndef __WIN32__
            setsockopt(sock->sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
#ifdef SO_REUSEPORT
            setsockopt(sock->sock, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on));
#endif
#else
/*      ioctlsocket(sock->sock, SO_REUSEADDR, (unsigned long*)&on);*/
#endif
        }
        if ((!ctype && !connect(sock->sock, rp->ai_addr, rp->ai_addrlen)) ||
                (ctype && !bind(sock->sock, rp->ai_addr, rp->ai_addrlen))) {
            break;
        }
        objunref(sock);
        sock = NULL;
    }


    if (!sock || !rp) {
        if (sock) {
            objunref(sock);
        }
        freeaddrinfo(result);

        return (NULL);
    }


    if (ctype) {
        sock->flags |= SOCK_FLAG_BIND;
        memcpy(&sock->addr.ss, rp->ai_addr, sizeof(sock->addr.ss));
        switch(sock->type) {
            case SOCK_STREAM:
            case SOCK_SEQPACKET:
                listen(sock->sock, backlog);
                /* no break */
            default:
                break;
        }
    } else {
        getsockname(sock->sock, &sock->addr.sa, &salen);
    }

    freeaddrinfo(result);
    return (sock);
}

extern struct fwsocket *sockconnect(int family, int stype, int proto, const char *ipaddr, const char *port, void *ssl) {
    return(_opensocket(family, stype, proto, ipaddr, port, ssl, 0, 0));
}

extern struct fwsocket *udpconnect(const char *ipaddr, const char *port, void *ssl) {
    return (_opensocket(PF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP, ipaddr, port, ssl, 0, 0));
}

extern struct fwsocket *tcpconnect(const char *ipaddr, const char *port, void *ssl) {
    return (_opensocket(PF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, ipaddr, port, ssl, 0, 0));
}

extern struct fwsocket *sockbind(int family, int stype, int proto, const char *ipaddr, const char *port, void *ssl, int backlog) {
    return(_opensocket(family, stype, proto, ipaddr, port, ssl, 1, backlog));
}

extern struct fwsocket *udpbind(const char *ipaddr, const char *port, void *ssl) {
    return (_opensocket(PF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP, ipaddr, port, ssl, 1, 0));
}

extern struct fwsocket *tcpbind(const char *ipaddr, const char *port, void *ssl, int backlog) {
    return (_opensocket(PF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, ipaddr, port, ssl, 1, backlog));
}

static void _socket_handler_clean(void *data) {
    struct socket_handler *fwsel = data;

    /*call cleanup and remove refs to data*/
    if (fwsel->cleanup) {
        fwsel->cleanup(fwsel->data);
    }
    if (fwsel->data) {
        objunref(fwsel->data);
    }
}

static void *_socket_handler(void *data) {
    struct socket_handler *sockh = data;
    struct fwsocket *sock = sockh->sock;
    struct fwsocket *newsock;
    struct  timeval tv;
    fd_set  rd_set, act_set;
    int selfd, sockfd, type, flags;
    struct bucket_loop *bloop;
#ifdef __WIN32
    int errcode;
#endif
    objlock(sock);
    FD_ZERO(&rd_set);
    sockfd = sock->sock;
    type = sock->type;
    if ((sock->flags & SOCK_FLAG_BIND) && (sock->ssl || !(sock->type == SOCK_DGRAM))) {
        flags = (SOCK_FLAG_BIND & sock->flags);
    } else {
        flags = 0;
    }
    FD_SET(sockfd, &rd_set);
    objunlock(sock);

    while (framework_threadok() && !testflag(sock, SOCK_FLAG_CLOSE)) {
        act_set = rd_set;
        tv.tv_sec = 0;
        tv.tv_usec = 20000;

        selfd = select(sockfd + 1, &act_set, NULL, NULL, &tv);

        /*returned due to interupt continue or timed out*/
#ifndef __WIN32
        if ((selfd < 0 && errno == EINTR) || (!selfd)) {
#else
        errcode = WSAGetLastError();
        if (((selfd == SOCKET_ERROR) && (errcode == WSAEINTR)) || (!selfd)) {
#endif
            if ((type == SOCK_DGRAM) && (flags & SOCK_FLAG_BIND)) {
                dtlshandltimeout(sock);
            }
            continue;
        } else if (selfd < 0) {
            break;
        }

        if (FD_ISSET(sockfd, &act_set)) {
            if (flags & SOCK_FLAG_BIND) {
                switch (type) {
                    case SOCK_STREAM:
                    case SOCK_SEQPACKET:
                        newsock = accept_socket(sock);
                        break;
                    case SOCK_DGRAM:
                        newsock = dtls_listenssl(sock);
                        break;
                    default:
                        newsock = NULL;
                        break;
                }
                if (newsock) {
                    objref(sock);
                    newsock->parent = sock;
                    addtobucket(sock->children, newsock);
                    socketclient(newsock, sockh->data, sockh->client, NULL);
                    if (sockh->connect) {
                        sockh->connect(newsock, sockh->data);
                    }
                    objunref(newsock); /*pass ref to thread*/
                }
            } else {
                sockh->client(sockh->sock, sockh->data);
            }
        }
    }

    if (sock->ssl) {
        ssl_shutdown(sock->ssl, sock->sock);
    }

    /*close children*/
    if (sock->children) {
        bloop = init_bucket_loop(sock->children);
        while(bloop && (newsock = next_bucket_loop(bloop))) {
            remove_bucket_loop(bloop);
            objlock(newsock);
            if (newsock->parent) {
                objunref(newsock->parent);
                newsock->parent = NULL;
            }
            objunlock(newsock);
            close_socket(newsock); /*remove ref*/
        }
        objunref(bloop);
    }

    objunref(sock);

    return NULL;
}

static void _start_socket_handler(struct fwsocket *sock, socketrecv read,
                                  socketrecv acceptfunc, threadcleanup cleanup, void *data) {
    struct socket_handler *sockh;

    if (!sock || !read || !(sockh = objalloc(sizeof(*sockh), NULL))) {
        return;
    }

    sockh->sock = sock;
    sockh->client = read;
    sockh->cleanup = cleanup;
    sockh->connect = acceptfunc;
    sockh->data = data;

    /* grab ref for data and pass sockh*/
    objref(data);
    objref(sock);
    framework_mkthread(_socket_handler, _socket_handler_clean, NULL, sockh, 0);
    objunref(sockh);
}

extern void socketserver(struct fwsocket *sock, socketrecv read,
                         socketrecv acceptfunc, threadcleanup cleanup, void *data) {

    objlock(sock);
    if (sock->flags & SOCK_FLAG_BIND) {
        if (sock->ssl || !(sock->type == SOCK_DGRAM)) {
            sock->children = create_bucketlist(6, hash_socket);
        }
        if (sock->ssl && (sock->type == SOCK_DGRAM)) {
            objunlock(sock);
            dtsl_serveropts(sock);
        } else {
            objunlock(sock);
        }
    } else {
        objunlock(sock);
    }
    _start_socket_handler(sock, read, acceptfunc, cleanup, data);
}

extern void socketclient(struct fwsocket *sock, void *data, socketrecv read, threadcleanup cleanup) {
    startsslclient(sock);

    _start_socket_handler(sock, read, NULL, cleanup, data);
}

const char *sockaddr2ip(union sockstruct *addr, char *buff, int blen) {
    if (!buff) {
        return NULL;
    }

    switch (addr->ss.ss_family) {
        case PF_INET:
            inet_ntop(PF_INET, &addr->sa4.sin_addr, buff, blen);
            break;
        case PF_INET6:
            inet_ntop(PF_INET6, &addr->sa6.sin6_addr, buff, blen);
            break;
    }
    return buff;
}

struct fwsocket *mcast_socket(const char *iface, int family, const char *mcastip, const char *port, int flags) {
    struct fwsocket *fws;
    struct  addrinfo hint, *result, *rp;
    struct in_addr *srcif;
    const char *srcip;
    int ifidx;
    int on = 1;
    int off = 0;
    int ttl = 50;
    socklen_t slen = sizeof(union sockstruct);
#ifdef __WIN32
    struct ifinfo *ifinf;
#endif

        memset(&hint, 0, sizeof(hint));
    hint.ai_family = PF_UNSPEC;
    hint.ai_socktype = SOCK_DGRAM;
    hint.ai_protocol = IPPROTO_UDP;

#ifndef __WIN32
    if (!(srcip = get_ifipaddr(iface, family))) {
                return NULL;
    }

        if (getaddrinfo(srcip, port, &hint, &result) || !result) {
        free((void*)srcip);
                return NULL;
        }
    free((void*)srcip);
#else
    if (!(ifinf = get_ifinfo(iface))) {
        return NULL;
    }
    ifidx = ifinf->idx;
    
    srcip = (family == AF_INET) ? ifinf->ipv4addr : ifinf->ipv6addr;
        if (!srcip || (getaddrinfo(srcip, port, &hint, &result) || !result)) {
        objunref(ifinf);
                return NULL;
        }
    objunref(ifinf);
#endif

    for(rp = result; rp; rp = result->ai_next) {
        if (!(fws = make_socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol, NULL))) {
            continue;
        }
        break;
    }

    if (!rp || !fws) {
        freeaddrinfo(result);
        return NULL;
    }

    if(setsockopt(fws->sock, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on))) {
        objunref(fws);
        freeaddrinfo(result);
        return NULL;
    }

    if (rp->ai_family == PF_INET) {
        struct in_addr mcastip4;
        struct ip_mreq mg;
        struct sockaddr_in *src_ip;

        src_ip = (struct sockaddr_in*)rp->ai_addr;

        if (setsockopt(fws->sock, IPPROTO_IP, IP_MULTICAST_TTL, (char*)&ttl, sizeof(ttl))) {
            objunref(fws);
            freeaddrinfo(result);
            return NULL;
        }

        if (flags && setsockopt(fws->sock, IPPROTO_IP, IP_MULTICAST_LOOP, (char*)&off, sizeof(off))) {
            freeaddrinfo(result);
            objunref(fws);
            return NULL;
        }

        if (mcastip) {
            inet_lookup(PF_INET, mcastip, &mcastip4, sizeof(mcastip4));
        } else {
            seedrand();
            mcast4_ip(&mcastip4);
        }

        mg.imr_multiaddr = mcastip4;
        mg.imr_interface.s_addr = src_ip->sin_addr.s_addr;
        if (setsockopt(fws->sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&mg, sizeof(mg))) {
            objunref(fws);
            freeaddrinfo(rp);
            return NULL;
        }

        memset(&srcif, 0, sizeof(srcif));
        srcif = &src_ip->sin_addr;
        if(setsockopt(fws->sock, IPPROTO_IP, IP_MULTICAST_IF, (char*)srcif, sizeof(*srcif))) {
            freeaddrinfo(rp);
            objunref(fws);
            return NULL;
        }
        src_ip->sin_addr.s_addr = mcastip4.s_addr;
    } else if (rp->ai_family == PF_INET6) {
        struct in6_addr mcastip6;
        struct ipv6_mreq mg;
        struct sockaddr_in6 *src_ip;

#ifndef __WIN32
        ifidx = get_iface_index(iface);
#endif
        src_ip = (struct sockaddr_in6*)rp->ai_addr;

        if (setsockopt(fws->sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (char*)&ttl, sizeof(ttl))) {
            objunref(fws);
            freeaddrinfo(result);
            return NULL;
        }

        if (flags && setsockopt(fws->sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char*)&off, sizeof(off))) {
            freeaddrinfo(result);
            objunref(fws);
            return NULL;
        }

        if (mcastip) {
            inet_lookup(PF_INET6, mcastip, &mcastip6, sizeof(mcastip6));
        } else {
            seedrand();
            mcast6_ip(&mcastip6);
        }

        mg.ipv6mr_multiaddr = mcastip6;
        mg.ipv6mr_interface = ifidx;
        if (setsockopt(fws->sock, IPPROTO_IPV6, IPV6_JOIN_GROUP, (char*)&mg, sizeof(mg))) {
            objunref(fws);
            freeaddrinfo(rp);
            return NULL;
        }

        if (setsockopt(fws->sock, IPPROTO_IPV6, IPV6_MULTICAST_IF, (char*)&ifidx, sizeof(ifidx))) {
            objref(fws);
            freeaddrinfo(rp);
            return NULL;
        }

        src_ip->sin6_addr = mcastip6;
    }

    if (bind(fws->sock, (struct sockaddr*)rp->ai_addr, sizeof(struct sockaddr_storage))) {
        freeaddrinfo(result);
        objunref(fws);
        return NULL;
    }

    getsockname(fws->sock, &fws->addr.sa, &slen);
    freeaddrinfo(result);
    fws->flags |= SOCK_FLAG_MCAST;

    return fws;
}