utils.c

/* Copyright (c) 2006-2012, DNSPod Inc.
 * All rights reserved.

 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met: 
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer. 
 * 2. 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. 
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER OR 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.

 * The views and conclusions contained in the software and documentation are those
 * of the authors and should not be interpreted as representing official policies, 
 * either expressed or implied, of the FreeBSD Project.
 */


#include "utils.h"


int
slog(uchar * msg, int fd, pthread_mutex_t * lock)
{
    return 0;
}


//get random things
int
get_random_data(uchar * buffer, int len)
{
    int fd = -1;
    if ((buffer == NULL) || (len < 0))
        return -1;
    fd = open("/dev/urandom", O_RDONLY);
    if (fd <= 0)
        return fd;
    read(fd, buffer, len);
    close(fd);
    return 0;
}


//get a c string
//little function,will be replaced by mm sonn.
//-----------------------begin-----------------//
uchar *
get_str(uchar * str, int len)
{
    uchar *ret = malloc(len + 1);
    strncpy(ret, str, len + 1);
    ret[len] = 0;
    return ret;
}


//free it
void
put_str(uchar * str)
{
    free((void *) str);
}

//----------------------end---------------------//


//signal handler,be enhenced soon.
//---------------------system func begin---------------//
static void
sig_segment_fault(int signo)
{
    printf("sig number is %d\n", signo);
    exit(0);
}


//spider and author and
//main thread may have
//different handlers
int
trig_signals(int sig)
{
    sigset_t bset, oset;
    int sigs[] = { SIGINT, SIGBUS, SIGSEGV, SIGPIPE, }, i, sig_num;
    struct sigaction sa, oa;
    bzero(&sa, sizeof(sa));
    sa.sa_handler = sig_segment_fault;
    sa.sa_flags = SA_RESTART;
    for (i = 0; i < sizeof(sigs) / sizeof(sigs[0]); i++) {
        sig_num = sigs[i];
        sigaction(sig_num, &sa, &oa);
    }
    sigemptyset(&bset);
    sigaddset(&bset, SIGUSR1);
    if (pthread_sigmask(SIG_BLOCK, &bset, &oset) != 0)
        dns_error(0, "sig error");
    return 0;
}


void
drop_privilege(uchar * root)
{
    if (root == NULL)
        return;
    //chroot(root);
}

//------------------system func end--------------------------//


//for dict
//-------------------compare func begin---------------------//
int
dict_comp_uint_equ(void *a, void *b)
{
    uint *u1 = a;
    uint *u2 = b;
    if (u1 == NULL)
        return -1;
    if (u2 == NULL)
        return 1;
    if (*u1 == *u2)
        return 0;
    return u1 > u2 ? 1 : -1;
}


int
dict_comp_str_equ(void *a, void *b)
{
    uchar *d1 = a;
    uchar *d2 = b;
    int to = 256;
    if (d1 == NULL)
        return -1;
    if (d2 == NULL)
        return 1;
    while (*d1 != 0 && *d2 != 0) {
        if (*d1 > *d2)
            return 1;
        if (*d1 < *d2)
            return -1;
        d1++;
        d2++;
        if (to-- == 0)          //maybe an invalid string
        {
            printf("str compare error\n");
            exit(0);
        }
    }
    if (*d1 == 0 && *d2 == 0)
        return 0;
    if (*d1 == 0)
        return -1;
    return 1;
}


//if elems put in the same time
//the one who has bigger idx will be bigger.
int
rbt_comp_ttl_gt(void *v1, void *v2, void *argv)
{
    int ret;
    //argv not used
    struct ttlnode *n1, *n2;
    //if v1=v2=null. v1 > v2 by default.
    if (v2 == NULL)
        return 1;
    if (v1 == NULL)             //v1 is null,v2 not null.
        return -1;
    n1 = (struct ttlnode *) v1;
    n2 = (struct ttlnode *) v2;
    if (n1->exp > n2->exp)
        return 1;
    if (n1->exp < n2->exp)
        return -1;
    ret = strcmp(n1->data, n2->data);
    if (ret > 0)
        return 1;
    if (ret < 0)
        return -1;
    return 0;
}


int
rbt_comp_uint_gt(void *v1, void *v2, void *argv)
{
    //argv not used
    uint n1, n2;
    //if v1=v2=null. v1 > v2 by default.
    if (v2 == NULL)
        return 1;
    if (v1 == NULL)             //v1 is null,v2 not null.
        return -1;
    n1 = *(uint *) v1;
    n2 = *(uint *) v2;
    if (n1 == n2)
        return 0;
    return n1 > n2 ? 1 : -1;
}

//-----------------compare func end---------------------//


//str functions,no error check,no test
//-----------------------str begin----------------------//
int
to_lowercase(uchar * msg, int len)
{
    int i;
    for (i = 0; i < len; i++)
        if (msg[i] >= 'A' && msg[i] <= 'Z')
            msg[i] = msg[i] + 'a' - 'A';
    return 0;
}


int
to_uppercase(uchar * buf, int n)
{
    int i;
    for (i = 0; i < n; i++) {
        if (buf[i] >= 'a' && buf[i] <= 'z')
            buf[i] = buf[i] + 'A' - 'a';
    }
    return 0;
}


int
str_to_uchar4(const char *addr, uchar * val)
{
    uint v = 0, tv[4] = { 0 }, idx = 0;
    int i, n = strlen(addr);
    for (i = 0; i < n; i++) {
        if (addr[i] >= '0' && addr[i] <= '9')
            tv[idx] = tv[idx] * 10 + addr[i] - '0';
        else {
            idx++;
            if (addr[i] != '.' || idx == 4)     //format error
            {
                *val = 0;
                return -1;
            }
        }
    }
    for (i = 0; i < 4; i++)
        val[i] = tv[i];
    return 0;
}


int
str_to_uchar6(uchar * addr, uchar * val)
{
    ushort tv[8] = { 0 };
    int idx = 0, gap = 0, gapidx = -1, hasgap = 0;
    int i, n = strlen(addr);
    char tmp;
    to_lowercase(addr, n);
    memset(val, 0, 16);
    for (i = 0; i < n; i++) {
        tmp = addr[i];
        if (tmp >= '0' && tmp <= '9') {
            gap = 0;
            tv[idx] = tv[idx] * 16 + tmp - '0';
        } else if (tmp >= 'a' && tmp <= 'z') {
            gap = 0;
            tv[idx] = tv[idx] * 16 + tmp - 'a' + 10;
        } else {
            idx++;
            if (gap == 1) {
                if (hasgap == 1)        //format error
                    return -1;
                hasgap = 1;
                gapidx = idx - 1;
            }
            if (gap == 0)
                gap = 1;
            if (tmp != ':' || idx == 8) {
                val[0] = val[1] = val[2] = val[3] = 0;
                return 0;
            }
        }
    }
    if (hasgap == 1)            //we have an gap
    {
        for (i = 0; i < gapidx; i++) {
            val[i * 2] = tv[i] / 256;
            val[i * 2 + 1] = tv[i] % 256;
        }
        for (i = idx - 1; i >= gapidx; i--) {
            val[(i + 7 - idx + 1) * 2] = tv[i + 1] / 256;
            val[(i + 7 - idx + 1) * 2 + 1] = tv[i + 1] % 256;
        }
    } else {
        for (i = 0; i < 8; i++) {
            val[i * 2] = tv[i] / 256;
            val[i * 2 + 1] = tv[i] % 256;
        }
    }
    return 0;
}


int
fix_tail(char *domain)
{
    int len = strlen(domain);
    char c;
    len--;
    c = domain[len];
    if (c == '\r' || c == '\n') {
        domain[len] = 0;
        len--;
    }
    c = domain[len];
    if (c == '\r' || c == '\n') {
        domain[len] = 0;
        len--;
    }
    return 0;
}

//-------------------str end--------------------------//


//offset [0,15]
//tested by rbtree_test() in datas.c.
//-------------------bit functions begin--------
int
opr_bit(unsigned short *bit, int off, int set)
{
    unsigned short mask = 1;
    if (off > 15 || off < 0)
        return -1;
    mask <<= off;
    if (set == 0)               //clear
        mask = ~mask;
    if (set == 0)
        *bit = *bit & mask;
    else
        *bit = *bit | mask;
    return 0;
}


int
set_bit(unsigned short *bit, int off)
{
    opr_bit(bit, off, 1);
    return 0;
}


int
clr_bit(unsigned short *bit, int off)
{
    opr_bit(bit, off, 0);
    return 0;
}

int
tst_bit(const unsigned short bit, int off)
{
    unsigned short mask = 1;
    if (off > 15 || off < 0)
        return -1;
    mask <<= off;
    if ((bit & mask) == 0)
        return 0;
    return 1;
}

//----------------bit functions end---------------------


//multi threads safe
//test by rbtree_test() in datas.c
int
get_time_usage(struct timeval *tv, int start)
{
    ulong msec = 0;
    struct timeval tmp;
    if (tv == NULL)
        return -1;
    if (start == 1)             //start
        gettimeofday(tv, NULL);
    else                        //end
    {
        tmp = *tv;
        gettimeofday(tv, NULL);
        if (tv->tv_usec < tmp.tv_usec) {
            msec = (tv->tv_usec - tmp.tv_usec + 1000000) / 1000;
            tv->tv_sec--;
        }
        printf("%lu s,%lu ms\n", tv->tv_sec - tmp.tv_sec, msec);
    }
    return 0;
}


//------------trivial function begin---------------------------
//for debug


int
is_uppercase(int c)
{
    if (c >= 'A' && c <= 'Z')
        return 1;
    return 0;
}


int
is_lowercase(int c)
{
    if (c >= 'a' && c <= 'z')
        return 1;
    return 0;
}


int
empty_function(int i)
{
    int j;
    j = i;
    return 0;
}


void
insert_mem_bar(void)
{
    int i, size = random() % 99 + 10000;
    uchar *ptr = malloc(size);
    if (ptr == NULL)
        return;
    for (i = 0; i < size; i++)
        ptr[i] = i;
    free(ptr);
}


int
test_lock(pthread_mutex_t * l)
{
    if (pthread_mutex_trylock(l) < 0)
        return -1;
    pthread_mutex_unlock(l);
    return 0;
}

//------------trivial function end------------------------------


//-------------------debug print begin-------------------------
void
dbg_print_bit(unsigned short bit)
{
    int i;
    unsigned short val = 1 << 15;
    for (i = 0; i < 16; i++) {
        if ((bit & val) == 0)
            printf("0");
        else
            printf("1");
        if (((i + 1) % 4) == 0 && (i != 15))
            printf(",");
        val = val >> 1;
    }
    printf("\n");
}


void
print_hex(uchar * val, int n)
{
    int i;
    for (i = 0; i < n; i++)
        printf("%x,", val[i]);
    printf("\n");
}


//global error function
void
dns_error(int level, char *msg)
{
    dbg("Error:%s\n", msg);
    fflush(stdout);
    if (level == 0)
        exit(-1);
}


//output debug infomartion
int
dbg(const char *format, ...)
{
    int ret;
    va_list ap;
    va_start(ap, format);
    printf("dbg:");
    ret = vprintf(format, ap);
    va_end(ap);
    return ret;
}

//-----------------------debug print end--------------------


hashval_t
uint_hash_function(void *ptr)
{
    uint key = *(uint *) ptr;
    key += ~(key << 15);
    key ^= (key >> 10);
    key += (key << 3);
    key ^= (key >> 6);
    key += ~(key << 11);
    key ^= (key >> 16);
    return key;
}


hashval_t
nocase_char_hash_function(void *argv)
{
    int len = strlen(argv);
    uchar *buf = argv;
    hashval_t hash = 5381;
    to_lowercase(buf, len);
    while (len--)
        hash = (((hash << 5) + hash) + *buf++);
    return hash;
}