root/cserver/server_utils.c

/*
 * Copyright (c) 2006, Federico Tomassini AKA efphe (effetom AT gmail DOT com)
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the University of California, Berkeley nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "server_utils.h"
#include "wlog.h"

void w_listen(int s,int b)
{
    if (listen(s,b))
        fatal("Fatal listen(): %s", strerror(errno));
    return;
}


int w_poll(struct pollfd *p, int n, int timeout)
{
    int res;

    if ((res=poll(p, n, timeout))==-1)
        fatal("Fatal poll: %s.", strerror(errno));
    return res;
}

void w_pthread_cond_signal(pthread_cond_t *cond)
{
    if (pthread_cond_signal(cond))
        fatal("Fatal pthread_cond_signal()");
    return;
}

void w_pthread_mutex_lock(pthread_mutex_t *m)
{
    int res;
    char buf[10];

    res=pthread_mutex_lock(m);
    if (res) {
        switch(res) { 
        /* 
         * The values are not all necessary, but
         * i can define all them here and paste them
         * elsewhere.
         * Note that the slowing of the process does
         * not matter, because of fatal()
         */
        case EBUSY:
            sprintf(buf,"EBUSY");
            break;
        case EINVAL:
            sprintf(buf,"EINVAL");
            break;
        case EAGAIN:
            sprintf(buf,"EAGAIN");
            break;
        case EDEADLK:
            sprintf(buf,"EDEADLK");
            break;
        case EPERM:
            sprintf(buf,"EPERM");
            break;
        default:
            sprintf(buf,"EUNKNOW");
            break;
        }
        fatal("Fatal pthread_mutex_lock(): %s.", buf);
    }
    return;
}

void w_pthread_mutex_unlock(pthread_mutex_t *m)
{
    int res;
    char buf[10];

    if ((res=pthread_mutex_unlock(m))) {
        switch(res) {
        case EINVAL:
            sprintf(buf,"EINVAL");
            break;
        case EBUSY:
            sprintf(buf,"EBUSY");
            break;
        case EAGAIN:
            sprintf(buf,"EAGAIN");
            break;
        case EDEADLK:
            sprintf(buf,"EDEADLK");
            break;
        case EPERM:
            sprintf(buf,"EPERM");
            break;
        default:
            sprintf(buf,"EUNKNOW");
            break;
        }
        fatal("Fatal pthread_mutex_lock(): %s.", buf);
    }
    return;
}

void w_pthread_mutex_lock_unlock(pthread_mutex_t *m)
{
    w_pthread_mutex_lock(m);
    w_pthread_mutex_unlock(m);
    return;
}

void w_pthread_create(pthread_t *t,pthread_attr_t *a,
              void *(*f)(void*), void *arg)
{
    int res;
    char buf[10];

    if ((res=pthread_create(t,a,f,arg))) {
        switch(res) {
        case EINVAL:
            sprintf(buf,"EINVAL");
            break;
        case EBUSY:
            sprintf(buf,"EBUSY");
            break;
        case EAGAIN:
            sprintf(buf,"EAGAIN");
            break;
        case EDEADLK:
            sprintf(buf,"EDEADLK");
            break;
        case EPERM:
            sprintf(buf,"EPERM");
            break;
        default:
            sprintf(buf,"EUNKNOW");
            break;
        }
        fatal("Fatal pthread_mutex_lock(): %s.", buf);
    }
    return;
}

void w_pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *m)
{
    int res;
    char buf[10];

    if ((res=pthread_cond_wait(cond,m))) {
        switch(res) {
        case EINVAL:
            sprintf(buf,"EINVAL");
            break;
        case EBUSY:
            sprintf(buf,"EBUSY");
            break;
        case EAGAIN:
            sprintf(buf,"EAGAIN");
            break;
        case ETIMEDOUT:
            sprintf(buf,"ETIMEDOUT");
            break;
        case EPERM:
            sprintf(buf,"EPERM");
            break;
        default:
            sprintf(buf,"EUNKNOW");
            break;
        }
        fatal("Fatal pthread_mutex_lock(): %s.", buf);
    }
    return;
}

void w_pthread_cond_wait_unlock(pthread_cond_t *cond, pthread_mutex_t *m)
{
    w_pthread_cond_wait(cond,m);
    w_pthread_mutex_unlock(m);
    return;
}

void w_pthread_attr_init(pthread_attr_t *a)
{
    if (pthread_attr_init(a))
        fatal("Fatal pthread_attr_init().");
    return;
}

void w_pthread_attr_setdetachstate(pthread_attr_t *a,int s)
{
    if (pthread_attr_setdetachstate(a,s))
        fatal("Fatal pthread_attr_setdetachstate().");
    return;
}

void w_pthread_attr_destroy(pthread_attr_t *a)
{
    if (pthread_attr_destroy(a))
        fatal("Fatal pthread_attr_destroy().");
    return;
}

void w_pthread_mutex_init(pthread_mutex_t *t,pthread_mutexattr_t *a)
{
    if (pthread_mutex_init(t,a))
        fatal("Fatal pthread_mutex_init().");
    return;
}

void w_pthread_mutex_destroy(pthread_mutex_t *t)
{
    if (pthread_mutex_destroy(t))
        fatal("Fatal pthread_mutex_destroy().");
    return;
}

void w_pthread_cond_init(pthread_cond_t *c,pthread_condattr_t *a)
{
    if (pthread_cond_init(c,a))
        fatal("Fatal pthread_cond_init().");
    return;
}

int any_sockaddr(struct sockaddr *sa,int family)
{
    struct sockaddr_in *si;
    struct sockaddr_in6 *si6;

    if (family==AF_INET) {
        si=(struct sockaddr_in*)sa;
        si->sin_addr.s_addr=htonl(INADDR_ANY);
        return sizeof(struct sockaddr_in);
    } else if (family==AF_INET6) {
        si6=(struct sockaddr_in6*)sa;
        si6->sin6_addr = in6addr_any;
        return sizeof(struct sockaddr_in6);
    } else
        fatal("Fatal any_sockaddr(): family not supported.");
    return -1;
}

void w_setsockopt(int s,int lvl,int opt,void *optval,socklen_t optlen)
{
    if (setsockopt(s,lvl,opt,optval,optlen))
        fatal("Fatal setsockopt(): %s.", strerror(errno));
    return;
}

void w_setsockopt_reuseaddr(int s)
{
    int status=1;
    w_setsockopt(s,SOL_SOCKET,SO_REUSEADDR,&status,sizeof(int));
    return;
}

int w_accept(int skt,struct sockaddr *sa, socklen_t *salen)
{

    return accept(skt,sa,salen);
}

const char* w_inet_ntop(struct sockaddr *s, socklen_t slen, char *buf, int buflen)
{
    struct sockaddr_in *si;
    struct sockaddr_in6 *si6;
    const char *res;

    switch (slen) {
        case sizeof(struct sockaddr_in):
            si=(struct sockaddr_in*)s;
            res=inet_ntop(AF_INET,(void*)(&(si->sin_addr)),buf,buflen);
            break;
        case sizeof(struct sockaddr_in6):
            si6=(struct sockaddr_in6*)s;
            res=inet_ntop(AF_INET6,(void*)(&(si6->sin6_addr)),buf,buflen);
            break;
        default:
            strncpy(buf,"Unknow family.",buflen);
            res=0;
    }
    return res;
}
                        
int w_socket(int family,int type, int proto,int die)
{
    int sk;
    sk=socket(family,type,proto);
    if (sk==-1) {
        if (die)
            fatal("Fatal socket(): %s.", strerror(errno));
        return -1;
    }
    return sk;
}