[doldaconnect.git] / common / utils.c

/*
 *  Dolda Connect - Modular multiuser Direct Connect-style client
 *  Copyright (C) 2004 Fredrik Tolf (fredrik@dolda2000.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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <wchar.h>
#include <iconv.h>
#include <errno.h>
#include <string.h>
#include <wctype.h>
#include <langinfo.h>
#include <pwd.h>
#include <unistd.h>
#include <sys/time.h>
#include <netinet/in.h>

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <utils.h>
#include <log.h>

static char *base64set = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static int base64rev[] = {
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
    -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
    -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
};
static char *base32set = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
static int base32rev[] = {
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, 26, 27, 28, 29, 30, 31, -1, -1, -1, -1, -1, -1, -1, -1,
    -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
    -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
};

char *vsprintf2(char *format, va_list al)
{
    int ret;
    char *buf;
    va_list al2;
    
    va_copy(al2, al);
    ret = vsnprintf(NULL, 0, format, al2);
    va_end(al2);
    if((buf = malloc(ret + 1)) == NULL)
    {
	LOGOOM(ret + 1);
	return(NULL);
    }
    va_copy(al2, al);
    vsnprintf(buf, ret + 1, format, al2);
    va_end(al2);
    return(buf);
}

char *sprintf2(char *format, ...)
{
    va_list args;
    char *buf;
    
    va_start(args, format);
    buf = vsprintf2(format, args);
    va_end(args);
    return(buf);
}

wchar_t *vswprintf2(wchar_t *format, va_list al)
{
    int ret;
    wchar_t *buf;
    size_t bufsize;
    va_list al2;
    
    buf = smalloc(sizeof(wchar_t) * (bufsize = 1024));
    while(1)
    {
	va_copy(al2, al);
	ret = vswprintf(buf, bufsize, format, al2);
	va_end(al2);
	if(ret >= 0)
	    break;
	buf = srealloc(buf, sizeof(wchar_t) * (bufsize *= 2));
    }
    if(bufsize > ret + 1)
	buf = srealloc(buf, sizeof(wchar_t) * (ret + 1));
    return(buf);
}

wchar_t *swprintf2(wchar_t *format, ...)
{
    va_list args;
    wchar_t *buf;
    
    va_start(args, format);
    buf = vswprintf2(format, args);
    va_end(args);
    return(buf);
}

int havecharset(char *charset)
{
    iconv_t cd;
    
    if((cd = iconv_open("wchar_t", charset)) == (iconv_t)-1)
	return(0);
    iconv_close(cd);
    if((cd = iconv_open(charset, "wchar_t")) == (iconv_t)-1)
	return(0);
    iconv_close(cd);
    return(1);
}

wchar_t *icmbstowcs(char *mbs, char *charset)
{
    int ret;
    char *buf;
    char *p, *p2;
    size_t len1, len2, bufsize, data;
    iconv_t cd;
    
    len1 = strlen(mbs) + 1;
    bufsize = len2 = len1 * sizeof(wchar_t);
    if((buf = malloc(bufsize)) == NULL)
    {
	LOGOOM(bufsize);
	return(NULL);
    }
    if(charset == NULL)
	charset = nl_langinfo(CODESET);
    if((cd = iconv_open("wchar_t", charset)) == (iconv_t)-1)
    {
#ifdef DAEMON
	flog(LOG_ERR, "icmbstowcs: could not open iconv structure for %s: %s", charset, strerror(errno));
#endif
	free(buf);
	return(NULL);
    }
    p = buf;
    while(len1 > 0)
    {
	ret = iconv(cd, &mbs, &len1, &p, &len2);
	if(ret < 0)
	{
	    if(errno == E2BIG)
	    {
		data = p - buf;
		len2 += 128;
		bufsize += 128;
		if((p2 = realloc(buf, bufsize)) == NULL)
		{
		    LOGOOM(bufsize);
		    free(buf);
		    iconv_close(cd);
		    return(NULL);
		}
		buf = p2;
		p = buf + data;
	    } else {
		free(buf);
		iconv_close(cd);
		return(NULL);
	    }
	}
    }
    if(len2 > 0)
	buf = realloc(buf, p - buf);
    iconv_close(cd);
    return((wchar_t *)buf);
}

wchar_t *icsmbstowcs(char *mbs, char *charset, wchar_t *def)
{
    static wchar_t *buf = NULL;
    
    if(buf != NULL)
	free(buf);
    if((buf = icmbstowcs(mbs, charset)) == NULL)
    {
	if((def != NULL) && (*def == L'~'))
	{
#ifdef DAEMON
	    flog(LOG_WARNING, "icsmbstowcs: could not convert wcs string into charset %s: %s", charset, strerror(errno));
#endif
	    def++;
	}
	return(def);
    }
    return(buf);
}

char *icwcstombs(wchar_t *wcs, char *charset)
{
    int ret;
    char *buf;
    char *p, *p2;
    size_t len1, len2, bufsize, data;
    iconv_t cd;
    
    len1 = sizeof(wchar_t) * (wcslen(wcs) + 1);
    bufsize = len2 = len1;
    if((buf = malloc(bufsize)) == NULL)
    {
#ifdef DAEMON
	LOGOOM(bufsize);
#endif
	return(NULL);
    }
    if(charset == NULL)
	charset = nl_langinfo(CODESET);
    if((cd = iconv_open(charset, "wchar_t")) == (iconv_t)-1)
    {
#ifdef DAEMON
	flog(LOG_ERR, "icwcstombs: could not open iconv structure for %s: %s", charset, strerror(errno));
#endif
	free(buf);
	return(NULL);
    }
    p = buf;
    while(len1 > 0)
    {
	ret = iconv(cd, (char **)&wcs, &len1, &p, &len2);
	if(ret < 0)
	{
	    if(errno == E2BIG)
	    {
		data = p - buf;
		len2 += 128;
		bufsize += 128;
		if((p2 = realloc(buf, bufsize)) == NULL)
		{
		    LOGOOM(bufsize);
		    free(buf);
		    iconv_close(cd);
		    return(NULL);
		}
		buf = p2;
		p = buf + data;
	    } else {
		free(buf);
		iconv_close(cd);
		return(NULL);
	    }
	}
    }
    if(len2 > 0)
	buf = realloc(buf, p - buf);
    iconv_close(cd);
    return(buf);
}

char *icswcstombs(wchar_t *wcs, char *charset, char *def)
{
    static char *buf = NULL;
    
    if(buf != NULL)
	free(buf);
    if((buf = icwcstombs(wcs, charset)) == NULL)
    {
	if((def != NULL) && (*def == '~'))
	{
#ifdef DAEMON
	    flog(LOG_WARNING, "icswcstombs: could not convert mbs string from charset %s: %s", charset, strerror(errno));
#endif
	    def++;
	}
	return(def);
    }
    return(buf);
}

wchar_t *wcstolower(wchar_t *wcs)
{
    wchar_t *p;
    
    for(p = wcs; *p != L'\0'; p++)
	*p = towlower(*p);
    return(wcs);
}

wchar_t ucptowc(int ucp)
{
    int ret;
    unsigned long ucpbuf;
    char *buf;
    char *mbsp, *p, *p2;
    wchar_t res;
    size_t len1, len2, bufsize, data;
    iconv_t cd;
    
    ucpbuf = htonl(ucp);
    mbsp = (char *)&ucpbuf;
    len1 = 4;
    bufsize = len2 = len1 * sizeof(wchar_t);
    if((buf = malloc(bufsize)) == NULL)
    {
	LOGOOM(bufsize);
	return(L'\0');
    }
    if((cd = iconv_open("wchar_t", "UCS-4BE")) == (iconv_t)-1)
    {
#ifdef DAEMON
	flog(LOG_ERR, "ucptowc: could not open iconv structure for UCS-4BE: %s", strerror(errno));
#endif
	free(buf);
	return(L'\0');
    }
    p = buf;
    while(len1 > 0)
    {
	ret = iconv(cd, &mbsp, &len1, &p, &len2);
	if(ret < 0)
	{
	    if(errno == E2BIG)
	    {
		data = p - buf;
		len2 += 128;
		bufsize += 128;
		if((p2 = realloc(buf, bufsize)) == NULL)
		{
		    LOGOOM(bufsize);
		    free(buf);
		    iconv_close(cd);
		    return(L'\0');
		}
		buf = p2;
		p = buf + data;
	    } else {
		free(buf);
		iconv_close(cd);
		return(L'\0');
	    }
	}
    }
    if(len2 > 0)
	buf = realloc(buf, p - buf);
    iconv_close(cd);
    res = *(wchar_t *)buf;
    free(buf);
    return(res);
}

void _sizebuf(void **buf, size_t *bufsize, size_t reqsize, size_t elsize, int algo)
{
    if(*bufsize >= reqsize)
	return;
    switch(algo)
    {
    case 0:
	*buf = srealloc(*buf, elsize * ((*bufsize) = reqsize));
	break;
    case 1:
	if(*bufsize == 0)
	    *bufsize = 1;
	while(*bufsize < reqsize)
	    *bufsize <<= 1;
	*buf = srealloc(*buf, elsize * (*bufsize));
	break;
    }
}

double ntime(void)
{
    struct timeval tv;
    
    gettimeofday(&tv, NULL);
    return((double)tv.tv_sec + ((double)tv.tv_usec / 1000000.0));
}

int wcsexists(wchar_t *h, wchar_t *n)
{
    int i, o, nl, hl;
    wchar_t *ln, *lh;
    
    ln = alloca(sizeof(*ln) * (nl = wcslen(n)));
    for(i = 0; i < nl; i++)
	ln[i] = towlower(n[i]);
    lh = alloca(sizeof(*lh) * (hl = wcslen(h)));
    if(nl > hl)
	return(0);
    for(i = 0; i < nl; i++)
	lh[i] = towlower(h[i]);
    i = 0;
    while(1)
    {
	for(o = 0; o < nl; o++)
	{
	    if(lh[i + o] != ln[o])
		break;
	}
	if(o == nl)
	    return(1);
	if(i == hl - nl)
	    return(0);
	lh[i + nl] = towlower(h[i + nl]);
	i++;
    }
}

#ifndef HAVE_WCSCASECMP
int wcscasecmp(const wchar_t *s1, const wchar_t *s2)
{
    while(towlower(*s1) == towlower(*s2))
    {
	if(*s1 == L'\0')
	    return(0);
    }
    return(towlower(*s1) - towlower(*s2));
}
#endif

char *hexencode(char *data, size_t datalen)
{
    char *buf, this;
    size_t bufsize, bufdata;
    int dig;
    
    buf = NULL;
    bufsize = bufdata = 0;
    for(; datalen > 0; datalen--, data++)
    {
	dig = (*data & 0xF0) >> 4;
	if(dig > 9)
	    this = 'A' + dig - 10;
	else
	    this = dig + '0';
	addtobuf(buf, this);
	dig = *data & 0x0F;
	if(dig > 9)
	    this = 'A' + dig - 10;
	else
	    this = dig + '0';
	addtobuf(buf, this);
    }
    addtobuf(buf, 0);
    return(buf);
}

char *hexdecode(char *data, size_t *len)
{
    char *buf, this;
    size_t bufsize, bufdata;
    
    buf = NULL;
    bufsize = bufdata = 0;
    for(; *data; data++)
    {
	if((*data >= 'A') && (*data <= 'F'))
	{
	    this = (this & 0x0F) | ((*data - 'A' + 10) << 4);
	} else if((*data >= '0') && (*data <= '9')) {
	    this = (this & 0x0F) | ((*data - '0') << 4);
	} else {
	    if(buf != NULL)
		free(buf);
	    return(NULL);
	}
	data++;
	if(!*data)
	{
	    if(buf != NULL)
		free(buf);
	    return(NULL);
	}
	if((*data >= 'A') && (*data <= 'F'))
	{
	    this = (this & 0xF0) | (*data - 'A' + 10);
	} else if((*data >= '0') && (*data <= '9')) {
	    this = (this & 0xF0) | (*data - '0');
	} else {
	    if(buf != NULL)
		free(buf);
	    return(NULL);
	}
	addtobuf(buf, this);
    }
    addtobuf(buf, 0);
    if(len != NULL)
	*len = bufdata - 1;
    return(buf);
}

char *base64encode(char *data, size_t datalen)
{
    char *buf;
    size_t bufsize, bufdata;
    
    if(datalen == 0)
	return(sstrdup(""));
    buf = NULL;
    bufsize = bufdata = 0;
    while(datalen >= 3)
    {
	addtobuf(buf, base64set[(data[0] & 0xfc) >> 2]);
	addtobuf(buf, base64set[((data[0] & 0x03) << 4) | ((data[1] & 0xf0) >> 4)]);
	addtobuf(buf, base64set[((data[1] & 0x0f) << 2) | ((data[2] & 0xc0) >> 6)]);
	addtobuf(buf, base64set[data[2] & 0x3f]);
	datalen -= 3;
	data += 3;
    }
    if(datalen == 1)
    {
	addtobuf(buf, base64set[(data[0] & 0xfc) >> 2]);
	addtobuf(buf, base64set[(data[0] & 0x03) << 4]);
	bufcat(buf, "==", 2);
    }
    if(datalen == 2)
    {
	addtobuf(buf, base64set[(data[0] & 0xfc) >> 2]);
	addtobuf(buf, base64set[((data[0] & 0x03) << 4) | ((data[1] & 0xf0) >> 4)]);
	addtobuf(buf, base64set[(data[1] & 0x0f) << 2]);
	addtobuf(buf, '=');
    }
    addtobuf(buf, 0);
    return(buf);
}

char *base64decode(char *data, size_t *datalen)
{
    int b, c;
    char *buf, cur;
    size_t bufsize, bufdata;
    
    buf = NULL;
    bufsize = bufdata = 0;
    cur = 0;
    b = 8;
    for(; *data > 0; data++)
    {
	c = (int)(unsigned char)*data;
	if(c == '=')
	    break;
	if(c == '\n')
	    continue;
	if(base64rev[c] == -1)
	{
	    if(buf != NULL)
		free(buf);
	    return(NULL);
	}
	b -= 6;
	if(b <= 0)
	{
	    cur |= base64rev[c] >> -b;
	    addtobuf(buf, cur);
	    b += 8;
	    cur = 0;
	}
	cur |= base64rev[c] << b;
    }
    if(datalen != NULL)
	*datalen = bufdata;
    addtobuf(buf, 0);
    return(buf);
}

char *base32encode(char *data, size_t datalen)
{
    char *buf;
    size_t bufsize, bufdata;
    
    if(datalen == 0)
	return(sstrdup(""));
    buf = NULL;
    bufsize = bufdata = 0;
    while(datalen >= 5)
    {
	addtobuf(buf, base32set[((data[0] & 0xf8) >> 3)]);
	addtobuf(buf, base32set[((data[0] & 0x07) << 2) | ((data[1] & 0xc0) >> 6)]);
	addtobuf(buf, base32set[((data[1] & 0x3e) >> 1)]);
	addtobuf(buf, base32set[((data[1] & 0x01) << 4) | ((data[2] & 0xf0) >> 4)]);
	addtobuf(buf, base32set[((data[2] & 0x0f) << 1) | ((data[3] & 0x80) >> 7)]);
	addtobuf(buf, base32set[((data[3] & 0x7c) >> 2)]);
	addtobuf(buf, base32set[((data[3] & 0x03) << 3) | ((data[4] & 0xe0) >> 5)]);
	addtobuf(buf, base32set[data[4] & 0x1f]);
	datalen -= 5;
	data += 5;
    }
    if(datalen == 1)
    {
	addtobuf(buf, base32set[((data[0] & 0xf8) >> 3)]);
	addtobuf(buf, base32set[((data[0] & 0x07) << 2)]);
	bufcat(buf, "======", 6);
    }
    if(datalen == 2)
    {
	addtobuf(buf, base32set[((data[0] & 0xf8) >> 3)]);
	addtobuf(buf, base32set[((data[0] & 0x07) << 2) | ((data[1] & 0xc0) >> 6)]);
	addtobuf(buf, base32set[((data[1] & 0x3e) >> 1)]);
	addtobuf(buf, base32set[((data[1] & 0x01) << 4)]);
	bufcat(buf, "====", 4);
    }
    if(datalen == 3)
    {
	addtobuf(buf, base32set[((data[0] & 0xf8) >> 3)]);
	addtobuf(buf, base32set[((data[0] & 0x07) << 2) | ((data[1] & 0xc0) >> 6)]);
	addtobuf(buf, base32set[((data[1] & 0x3e) >> 1)]);
	addtobuf(buf, base32set[((data[1] & 0x01) << 4) | ((data[2] & 0xf0) >> 4)]);
	addtobuf(buf, base32set[((data[2] & 0x0f) << 1)]);
	bufcat(buf, "===", 3);
    }
    if(datalen == 4)
    {
	addtobuf(buf, base32set[((data[0] & 0xf8) >> 3)]);
	addtobuf(buf, base32set[((data[0] & 0x07) << 2) | ((data[1] & 0xc0) >> 6)]);
	addtobuf(buf, base32set[((data[1] & 0x3e) >> 1)]);
	addtobuf(buf, base32set[((data[1] & 0x01) << 4) | ((data[2] & 0xf0) >> 4)]);
	addtobuf(buf, base32set[((data[2] & 0x0f) << 1) | ((data[3] & 0x80) >> 7)]);
	addtobuf(buf, base32set[((data[3] & 0x7c) >> 2)]);
	addtobuf(buf, base32set[((data[3] & 0x03) << 3)]);
	bufcat(buf, "=", 1);
    }
    addtobuf(buf, 0);
    return(buf);
}

char *base32decode(char *data, size_t *datalen)
{
    int b, c;
    char *buf, cur;
    size_t bufsize, bufdata;
    
    buf = NULL;
    bufsize = bufdata = 0;
    cur = 0;
    b = 8;
    for(; *data > 0; data++)
    {
	c = (int)(unsigned char)*data;
	if(c == '=')
	    break;
	if(c == '\n')
	    continue;
	if(base32rev[c] == -1)
	{
	    if(buf != NULL)
		free(buf);
	    return(NULL);
	}
	b -= 5;
	if(b <= 0)
	{
	    cur |= base32rev[c] >> -b;
	    addtobuf(buf, cur);
	    b += 8;
	    cur = 0;
	}
	cur |= base32rev[c] << b;
    }
    if(datalen != NULL)
	*datalen = bufdata;
    addtobuf(buf, 0);
    return(buf);
}

void _freeparr(void **arr)
{
    void **buf;
    
    if(arr == NULL)
	return;
    for(buf = arr; *buf != NULL; buf++)
	free(*buf);
    free(arr);
}

int _parrlen(void **arr)
{
    int i;
    
    if(arr == NULL)
	return(0);
    for(i = 0; *arr != NULL; arr++)
	i++;
    return(i);
}

char *getetcpath(char *binpath)
{
    int f;
    char *etcpath, *p;
    size_t etcpathsize, etcpathdata;

    etcpath = NULL;
    etcpathsize = etcpathdata = 0;
    f = 1;
    do
    {
	if(f)
	    f = 0;
	else
	    binpath++;
	for(p = binpath; *p && (*p != ':'); p++);
	for(; (p >= binpath) && (*p != '/'); p--);
	if(p >= binpath)
	{
	    if(etcpathdata > 0)
		addtobuf(etcpath, ':');
	    bufcat(etcpath, binpath, p - binpath + 1);
	    bufcat(etcpath, "etc", 3);
	}
    } while((binpath = strchr(binpath, ':')) != NULL);
    addtobuf(etcpath, 0);
    return(etcpath);
}

char *findfile(char *name, char *homedir, int filldef)
{
    char *path, *binpath, *etcpath, *p;
    struct passwd *pw;
    int mode, homeonly;
    
    if(name == NULL)
	return(NULL);

    mode = R_OK | (filldef ? W_OK : 0);
    homeonly = homedir != NULL;

    if(!strchr(name, '/'))
    {
	if(homedir == NULL)
	    homedir = getenv("HOME");
	if((homedir == NULL) && ((pw = getpwuid(getuid())) != NULL))
	    homedir = pw->pw_dir;
	if((homedir != NULL) && ((path = sprintf2("%s/.%s", homedir, name)) != NULL))
	{
	    if(!access(path, mode))
		return(path);
	    free(path);
	}
    }
    
    if(!homeonly)
    {
	if(strchr(name, '/') != NULL)
	{
	    if(!access(name, mode))
		return(sstrdup(name));
	} else {
	    if((binpath = getenv("PATH")) == NULL)
		etcpath = sstrdup("/usr/local/etc:/etc:/usr/etc");
	    else
		etcpath = getetcpath(binpath);
	    for(p = strtok(etcpath, ":"); p != NULL; p = strtok(NULL, ":"))
	    {
		if((path = sprintf2("%s/%s", p, name)) != NULL)
		{
		    if(!access(path, mode))
		    {
			free(etcpath);
			return(path);
		    }
		    free(path);
		}
	    }
	    free(etcpath);
	}
    }
    
    if(filldef) {
	if(homedir)
	    return(sprintf2("%s/.%s", homedir, name));
	return(sprintf2("/etc/%s", name));
    } else {
	return(NULL);
    }
}

struct wcspair *newwcspair(wchar_t *key, wchar_t *val, struct wcspair **list)
{
    struct wcspair *pair;
    
    pair = smalloc(sizeof(*pair));
    memset(pair, 0, sizeof(*pair));
    if(key != NULL)
	pair->key = swcsdup(key);
    if(val != NULL)
	pair->val = swcsdup(val);
    if(list == NULL)
    {
	pair->next = NULL;
    } else {
	pair->next = *list;
	*list = pair;
    }
    return(pair);
}

void freewcspair(struct wcspair *pair, struct wcspair **list)
{
    struct wcspair *cur;
    
    for(cur = *list; cur != NULL; list = &(cur->next), cur = cur->next)
    {
	if(cur == pair)
	{
	    *list = cur->next;
	    break;
	}
    }
    free(pair->key);
    free(pair->val);
    free(pair);
}

wchar_t *wpfind(struct wcspair *list, wchar_t *key)
{
    for(; list != NULL; list = list->next)
    {
	if(!wcscmp(list->key, key))
	    return(list->val);
    }
    return(NULL);
}
Commit	Line	Data
d3372da9	1	/*
	2	* Dolda Connect - Modular multiuser Direct Connect-style client
	3	* Copyright (C) 2004 Fredrik Tolf (fredrik@dolda2000.com)
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*/
b5010caa	19	#include <stdlib.h>
d3372da9	20	#include <stdarg.h>
	21	#include <stdio.h>
	22	#include <wchar.h>
	23	#include <iconv.h>
	24	#include <errno.h>
	25	#include <string.h>
	26	#include <wctype.h>
	27	#include <langinfo.h>
	28	#include <pwd.h>
	29	#include <unistd.h>
	30	#include <sys/time.h>
	31	#include <netinet/in.h>
	32
	33	#ifdef HAVE_CONFIG_H
	34	#include <config.h>
	35	#endif
8b17e919	36	#include <utils.h>
8b17e919	37	#include <log.h>
d3372da9	38
	39	static char *base64set = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
	40	static int base64rev[] = {
	41	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	42	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	43	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
	44	52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
	45	-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
	46	15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
	47	-1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
	48	41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
	49	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	50	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	51	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	52	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	53	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	54	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	55	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	56	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	57	};
	58	static char *base32set = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
	59	static int base32rev[] = {
	60	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	61	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	62	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	63	-1, -1, 26, 27, 28, 29, 30, 31, -1, -1, -1, -1, -1, -1, -1, -1,
	64	-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
	65	15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
	66	-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
	67	15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
	68	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	69	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	70	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	71	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	72	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	73	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	74	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	75	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	76	};
	77
	78	char vsprintf2(char format, va_list al)
	79	{
	80	int ret;
	81	char *buf;
4dffb251	82	va_list al2;
d3372da9	83
4dffb251	84	va_copy(al2, al);
fe8c6c8e	85	ret = vsnprintf(NULL, 0, format, al2);
fe8c6c8e	86	va_end(al2);
d3372da9	87	if((buf = malloc(ret + 1)) == NULL)
	88	{
	89	LOGOOM(ret + 1);
	90	return(NULL);
	91	}
4dffb251	92	va_copy(al2, al);
fe8c6c8e	93	vsnprintf(buf, ret + 1, format, al2);
fe8c6c8e	94	va_end(al2);
d3372da9	95	return(buf);
	96	}
	97
	98	char sprintf2(char format, ...)
	99	{
	100	va_list args;
	101	char *buf;
	102
	103	va_start(args, format);
	104	buf = vsprintf2(format, args);
	105	va_end(args);
	106	return(buf);
	107	}
	108
	109	wchar_t vswprintf2(wchar_t format, va_list al)
	110	{
	111	int ret;
	112	wchar_t *buf;
	113	size_t bufsize;
4dffb251	114	va_list al2;
d3372da9	115
d3372da9	116	buf = smalloc(sizeof(wchar_t) * (bufsize = 1024));
4dffb251	117	while(1)
	118	{
	119	va_copy(al2, al);
	120	ret = vswprintf(buf, bufsize, format, al2);
fe8c6c8e	121	va_end(al2);
4dffb251	122	if(ret >= 0)
4dffb251	123	break;
d3372da9	124	buf = srealloc(buf, sizeof(wchar_t) * (bufsize *= 2));
4dffb251	125	}
d3372da9	126	if(bufsize > ret + 1)
	127	buf = srealloc(buf, sizeof(wchar_t) * (ret + 1));
	128	return(buf);
	129	}
	130
	131	wchar_t swprintf2(wchar_t format, ...)
	132	{
	133	va_list args;
	134	wchar_t *buf;
	135
	136	va_start(args, format);
	137	buf = vswprintf2(format, args);
	138	va_end(args);
	139	return(buf);
	140	}
	141
edccab15	142	int havecharset(char *charset)
	143	{
	144	iconv_t cd;
	145
	146	if((cd = iconv_open("wchar_t", charset)) == (iconv_t)-1)
	147	return(0);
	148	iconv_close(cd);
	149	if((cd = iconv_open(charset, "wchar_t")) == (iconv_t)-1)
	150	return(0);
	151	iconv_close(cd);
	152	return(1);
	153	}
	154
d3372da9	155	wchar_t icmbstowcs(char mbs, char *charset)
	156	{
	157	int ret;
	158	char *buf;
	159	char p, p2;
	160	size_t len1, len2, bufsize, data;
	161	iconv_t cd;
	162
	163	len1 = strlen(mbs) + 1;
	164	bufsize = len2 = len1 * sizeof(wchar_t);
	165	if((buf = malloc(bufsize)) == NULL)
	166	{
	167	LOGOOM(bufsize);
	168	return(NULL);
	169	}
	170	if(charset == NULL)
	171	charset = nl_langinfo(CODESET);
	172	if((cd = iconv_open("wchar_t", charset)) == (iconv_t)-1)
	173	{
8b17e919	174	#ifdef DAEMON
d3372da9	175	flog(LOG_ERR, "icmbstowcs: could not open iconv structure for %s: %s", charset, strerror(errno));
8b17e919	176	#endif
d3372da9	177	free(buf);
	178	return(NULL);
	179	}
	180	p = buf;
	181	while(len1 > 0)
	182	{
	183	ret = iconv(cd, &mbs, &len1, &p, &len2);
	184	if(ret < 0)
	185	{
	186	if(errno == E2BIG)
	187	{
	188	data = p - buf;
	189	len2 += 128;
	190	bufsize += 128;
	191	if((p2 = realloc(buf, bufsize)) == NULL)
	192	{
	193	LOGOOM(bufsize);
	194	free(buf);
	195	iconv_close(cd);
	196	return(NULL);
	197	}
	198	buf = p2;
	199	p = buf + data;
	200	} else {
	201	free(buf);
	202	iconv_close(cd);
	203	return(NULL);
	204	}
	205	}
	206	}
	207	if(len2 > 0)
	208	buf = realloc(buf, p - buf);
	209	iconv_close(cd);
	210	return((wchar_t *)buf);
	211	}
	212
	213	wchar_t icsmbstowcs(char mbs, char charset, wchar_t def)
	214	{
	215	static wchar_t *buf = NULL;
	216
	217	if(buf != NULL)
	218	free(buf);
	219	if((buf = icmbstowcs(mbs, charset)) == NULL)
	220	{
96cf7d1f	221	if((def != NULL) && (*def == L'~'))
d3372da9	222	{
8b17e919	223	#ifdef DAEMON
d3372da9	224	flog(LOG_WARNING, "icsmbstowcs: could not convert wcs string into charset %s: %s", charset, strerror(errno));
8b17e919	225	#endif
d3372da9	226	def++;
	227	}
	228	return(def);
	229	}
	230	return(buf);
	231	}
	232
	233	char icwcstombs(wchar_t wcs, char *charset)
	234	{
	235	int ret;
	236	char *buf;
	237	char p, p2;
	238	size_t len1, len2, bufsize, data;
	239	iconv_t cd;
	240
	241	len1 = sizeof(wchar_t) * (wcslen(wcs) + 1);
	242	bufsize = len2 = len1;
	243	if((buf = malloc(bufsize)) == NULL)
	244	{
8b17e919	245	#ifdef DAEMON
d3372da9	246	LOGOOM(bufsize);
8b17e919	247	#endif
d3372da9	248	return(NULL);
	249	}
	250	if(charset == NULL)
	251	charset = nl_langinfo(CODESET);
	252	if((cd = iconv_open(charset, "wchar_t")) == (iconv_t)-1)
	253	{
8b17e919	254	#ifdef DAEMON
d3372da9	255	flog(LOG_ERR, "icwcstombs: could not open iconv structure for %s: %s", charset, strerror(errno));
8b17e919	256	#endif
d3372da9	257	free(buf);
	258	return(NULL);
	259	}
	260	p = buf;
	261	while(len1 > 0)
	262	{
	263	ret = iconv(cd, (char **)&wcs, &len1, &p, &len2);
	264	if(ret < 0)
	265	{
	266	if(errno == E2BIG)
	267	{
	268	data = p - buf;
	269	len2 += 128;
	270	bufsize += 128;
	271	if((p2 = realloc(buf, bufsize)) == NULL)
	272	{
	273	LOGOOM(bufsize);
	274	free(buf);
	275	iconv_close(cd);
	276	return(NULL);
	277	}
	278	buf = p2;
	279	p = buf + data;
	280	} else {
	281	free(buf);
	282	iconv_close(cd);
	283	return(NULL);
	284	}
	285	}
	286	}
	287	if(len2 > 0)
	288	buf = realloc(buf, p - buf);
	289	iconv_close(cd);
	290	return(buf);
	291	}
	292
	293	char icswcstombs(wchar_t wcs, char charset, char def)
	294	{
	295	static char *buf = NULL;
	296
	297	if(buf != NULL)
	298	free(buf);
	299	if((buf = icwcstombs(wcs, charset)) == NULL)
	300	{
96cf7d1f	301	if((def != NULL) && (*def == '~'))
d3372da9	302	{
8b17e919	303	#ifdef DAEMON
d3372da9	304	flog(LOG_WARNING, "icswcstombs: could not convert mbs string from charset %s: %s", charset, strerror(errno));
8b17e919	305	#endif
d3372da9	306	def++;
	307	}
	308	return(def);
	309	}
	310	return(buf);
	311	}
	312
	313	wchar_t wcstolower(wchar_t wcs)
	314	{
	315	wchar_t *p;
	316
	317	for(p = wcs; *p != L'\0'; p++)
	318	p = towlower(p);
	319	return(wcs);
	320	}
	321
	322	wchar_t ucptowc(int ucp)
	323	{
	324	int ret;
	325	unsigned long ucpbuf;
	326	char *buf;
	327	char mbsp, p, *p2;
	328	wchar_t res;
	329	size_t len1, len2, bufsize, data;
	330	iconv_t cd;
	331
	332	ucpbuf = htonl(ucp);
	333	mbsp = (char *)&ucpbuf;
	334	len1 = 4;
	335	bufsize = len2 = len1 * sizeof(wchar_t);
	336	if((buf = malloc(bufsize)) == NULL)
	337	{
	338	LOGOOM(bufsize);
	339	return(L'\0');
	340	}
	341	if((cd = iconv_open("wchar_t", "UCS-4BE")) == (iconv_t)-1)
	342	{
8b17e919	343	#ifdef DAEMON
d3372da9	344	flog(LOG_ERR, "ucptowc: could not open iconv structure for UCS-4BE: %s", strerror(errno));
8b17e919	345	#endif
d3372da9	346	free(buf);
	347	return(L'\0');
	348	}
	349	p = buf;
	350	while(len1 > 0)
	351	{
	352	ret = iconv(cd, &mbsp, &len1, &p, &len2);
	353	if(ret < 0)
	354	{
	355	if(errno == E2BIG)
	356	{
	357	data = p - buf;
	358	len2 += 128;
	359	bufsize += 128;
	360	if((p2 = realloc(buf, bufsize)) == NULL)
	361	{
	362	LOGOOM(bufsize);
	363	free(buf);
	364	iconv_close(cd);
	365	return(L'\0');
	366	}
	367	buf = p2;
	368	p = buf + data;
	369	} else {
	370	free(buf);
	371	iconv_close(cd);
	372	return(L'\0');
	373	}
	374	}
	375	}
	376	if(len2 > 0)
	377	buf = realloc(buf, p - buf);
	378	iconv_close(cd);
	379	res = (wchar_t )buf;
	380	free(buf);
	381	return(res);
	382	}
	383
	384	void _sizebuf(void *buf, size_t bufsize, size_t reqsize, size_t elsize, int algo)
	385	{
	386	if(*bufsize >= reqsize)
	387	return;
	388	switch(algo)
	389	{
	390	case 0:
	391	buf = srealloc(buf, elsize * ((*bufsize) = reqsize));
	392	break;
	393	case 1:
	394	if(*bufsize == 0)
	395	*bufsize = 1;
	396	while(*bufsize < reqsize)
	397	*bufsize <<= 1;
	398	buf = srealloc(buf, elsize * (*bufsize));
	399	break;
	400	}
	401	}
	402
	403	double ntime(void)
	404	{
	405	struct timeval tv;
	406
	407	gettimeofday(&tv, NULL);
	408	return((double)tv.tv_sec + ((double)tv.tv_usec / 1000000.0));
	409	}
410
411	int wcsexists(wchar_t h, wchar_t n)
412	{
413	int i, o, nl, hl;
414	wchar_t ln, lh;
415
416	ln = alloca(sizeof(ln) (nl = wcslen(n)));
417	for(i = 0; i < nl; i++)
418	ln[i] = towlower(n[i]);
419	lh = alloca(sizeof(lh) (hl = wcslen(h)));
420	if(nl > hl)
421	return(0);
422	for(i = 0; i < nl; i++)
423	lh[i] = towlower(h[i]);
424	i = 0;
425	while(1)
426	{
427	for(o = 0; o < nl; o++)
428	{
429	if(lh[i + o] != ln[o])
430	break;
431	}
432	if(o == nl)
433	return(1);
434	if(i == hl - nl)
435	return(0);
436	lh[i + nl] = towlower(h[i + nl]);
437	i++;
438	}
439	}
440
441	#ifndef HAVE_WCSCASECMP
442	int wcscasecmp(const wchar_t s1, const wchar_t s2)
443	{
444	while(towlower(s1) == towlower(s2))
445	{
446	if(*s1 == L'\0')
447	return(0);
448	}
449	return(towlower(s1) - towlower(s2));
450	}
451	#endif
452
453	char hexencode(char data, size_t datalen)
454	{
455	char *buf, this;
456	size_t bufsize, bufdata;
457	int dig;
458
459	buf = NULL;
460	bufsize = bufdata = 0;
461	for(; datalen > 0; datalen--, data++)
462	{
463	dig = (*data & 0xF0) >> 4;
464	if(dig > 9)
465	this = 'A' + dig - 10;
466	else
467	this = dig + '0';
468	addtobuf(buf, this);
469	dig = *data & 0x0F;
470	if(dig > 9)
471	this = 'A' + dig - 10;
472	else
473	this = dig + '0';
474	addtobuf(buf, this);
475	}
476	addtobuf(buf, 0);
477	return(buf);
478	}
479
480	char hexdecode(char data, size_t *len)
481	{
482	char *buf, this;
483	size_t bufsize, bufdata;
484
485	buf = NULL;
486	bufsize = bufdata = 0;
487	for(; *data; data++)
488	{
489	if((data >= 'A') && (data <= 'F'))
490	{
491	this = (this & 0x0F) \| ((*data - 'A' + 10) << 4);
492	} else if((data >= '0') && (data <= '9')) {
493	this = (this & 0x0F) \| ((*data - '0') << 4);
494	} else {
495	if(buf != NULL)
496	free(buf);
497	return(NULL);
498	}
499	data++;
500	if(!*data)
501	{
502	if(buf != NULL)
503	free(buf);
504	return(NULL);
505	}
506	if((data >= 'A') && (data <= 'F'))
507	{
508	this = (this & 0xF0) \| (*data - 'A' + 10);
509	} else if((data >= '0') && (data <= '9')) {
510	this = (this & 0xF0) \| (*data - '0');
511	} else {
512	if(buf != NULL)
513	free(buf);
514	return(NULL);
515	}
516	addtobuf(buf, this);
517	}
518	addtobuf(buf, 0);
519	if(len != NULL)
520	*len = bufdata - 1;
521	return(buf);
522	}
523
524	char base64encode(char data, size_t datalen)
525	{
526	char *buf;
527	size_t bufsize, bufdata;
528
529	if(datalen == 0)
530	return(sstrdup(""));
531	buf = NULL;
532	bufsize = bufdata = 0;
533	while(datalen >= 3)
534	{
535	addtobuf(buf, base64set[(data[0] & 0xfc) >> 2]);
536	addtobuf(buf, base64set[((data[0] & 0x03) << 4) \| ((data[1] & 0xf0) >> 4)]);
537	addtobuf(buf, base64set[((data[1] & 0x0f) << 2) \| ((data[2] & 0xc0) >> 6)]);
538	addtobuf(buf, base64set[data[2] & 0x3f]);
539	datalen -= 3;
540	data += 3;
541	}
542	if(datalen == 1)
543	{
544	addtobuf(buf, base64set[(data[0] & 0xfc) >> 2]);
545	addtobuf(buf, base64set[(data[0] & 0x03) << 4]);
546	bufcat(buf, "==", 2);
547	}
548	if(datalen == 2)
549	{
550	addtobuf(buf, base64set[(data[0] & 0xfc) >> 2]);
551	addtobuf(buf, base64set[((data[0] & 0x03) << 4) \| ((data[1] & 0xf0) >> 4)]);
552	addtobuf(buf, base64set[(data[1] & 0x0f) << 2]);
553	addtobuf(buf, '=');
554	}
555	addtobuf(buf, 0);
556	return(buf);
557	}
558
559	char base64decode(char data, size_t *datalen)
560	{
561	int b, c;
562	char *buf, cur;
563	size_t bufsize, bufdata;
564
565	buf = NULL;
566	bufsize = bufdata = 0;
567	cur = 0;
568	b = 8;
569	for(; *data > 0; data++)
570	{
571	c = (int)(unsigned char)*data;
572	if(c == '=')
573	break;
65399bc2	574	if(c == '\n')
65399bc2	575	continue;
d3372da9	576	if(base64rev[c] == -1)
	577	{
	578	if(buf != NULL)
	579	free(buf);
	580	return(NULL);
	581	}
	582	b -= 6;
	583	if(b <= 0)
	584	{
	585	cur \|= base64rev[c] >> -b;
	586	addtobuf(buf, cur);
	587	b += 8;
	588	cur = 0;
	589	}
	590	cur \|= base64rev[c] << b;
	591	}
	592	if(datalen != NULL)
	593	*datalen = bufdata;
	594	addtobuf(buf, 0);
	595	return(buf);
	596	}
	597
	598	char base32encode(char data, size_t datalen)
	599	{
	600	char *buf;
	601	size_t bufsize, bufdata;
	602
	603	if(datalen == 0)
	604	return(sstrdup(""));
	605	buf = NULL;
	606	bufsize = bufdata = 0;
	607	while(datalen >= 5)
	608	{
	609	addtobuf(buf, base32set[((data[0] & 0xf8) >> 3)]);
	610	addtobuf(buf, base32set[((data[0] & 0x07) << 2) \| ((data[1] & 0xc0) >> 6)]);
	611	addtobuf(buf, base32set[((data[1] & 0x3e) >> 1)]);
	612	addtobuf(buf, base32set[((data[1] & 0x01) << 4) \| ((data[2] & 0xf0) >> 4)]);
	613	addtobuf(buf, base32set[((data[2] & 0x0f) << 1) \| ((data[3] & 0x80) >> 7)]);
	614	addtobuf(buf, base32set[((data[3] & 0x7c) >> 2)]);
	615	addtobuf(buf, base32set[((data[3] & 0x03) << 3) \| ((data[4] & 0xe0) >> 5)]);
	616	addtobuf(buf, base32set[data[4] & 0x1f]);
	617	datalen -= 5;
	618	data += 5;
	619	}
	620	if(datalen == 1)
	621	{
	622	addtobuf(buf, base32set[((data[0] & 0xf8) >> 3)]);
	623	addtobuf(buf, base32set[((data[0] & 0x07) << 2)]);
	624	bufcat(buf, "======", 6);
	625	}
	626	if(datalen == 2)
	627	{
	628	addtobuf(buf, base32set[((data[0] & 0xf8) >> 3)]);
	629	addtobuf(buf, base32set[((data[0] & 0x07) << 2) \| ((data[1] & 0xc0) >> 6)]);
	630	addtobuf(buf, base32set[((data[1] & 0x3e) >> 1)]);
	631	addtobuf(buf, base32set[((data[1] & 0x01) << 4)]);
	632	bufcat(buf, "====", 4);
	633	}
	634	if(datalen == 3)
	635	{
	636	addtobuf(buf, base32set[((data[0] & 0xf8) >> 3)]);
	637	addtobuf(buf, base32set[((data[0] & 0x07) << 2) \| ((data[1] & 0xc0) >> 6)]);
	638	addtobuf(buf, base32set[((data[1] & 0x3e) >> 1)]);
	639	addtobuf(buf, base32set[((data[1] & 0x01) << 4) \| ((data[2] & 0xf0) >> 4)]);
640	addtobuf(buf, base32set[((data[2] & 0x0f) << 1)]);
641	bufcat(buf, "===", 3);
642	}
643	if(datalen == 4)
644	{
645	addtobuf(buf, base32set[((data[0] & 0xf8) >> 3)]);
646	addtobuf(buf, base32set[((data[0] & 0x07) << 2) \| ((data[1] & 0xc0) >> 6)]);
647	addtobuf(buf, base32set[((data[1] & 0x3e) >> 1)]);
648	addtobuf(buf, base32set[((data[1] & 0x01) << 4) \| ((data[2] & 0xf0) >> 4)]);
649	addtobuf(buf, base32set[((data[2] & 0x0f) << 1) \| ((data[3] & 0x80) >> 7)]);
650	addtobuf(buf, base32set[((data[3] & 0x7c) >> 2)]);
651	addtobuf(buf, base32set[((data[3] & 0x03) << 3)]);
652	bufcat(buf, "=", 1);
653	}
654	addtobuf(buf, 0);
655	return(buf);
656	}
657
658	char base32decode(char data, size_t *datalen)
659	{
660	int b, c;
661	char *buf, cur;
662	size_t bufsize, bufdata;
663
664	buf = NULL;
665	bufsize = bufdata = 0;
666	cur = 0;
667	b = 8;
668	for(; *data > 0; data++)
669	{
670	c = (int)(unsigned char)*data;
671	if(c == '=')
672	break;
65399bc2	673	if(c == '\n')
65399bc2	674	continue;
d3372da9	675	if(base32rev[c] == -1)
	676	{
	677	if(buf != NULL)
	678	free(buf);
	679	return(NULL);
	680	}
	681	b -= 5;
	682	if(b <= 0)
	683	{
	684	cur \|= base32rev[c] >> -b;
	685	addtobuf(buf, cur);
	686	b += 8;
	687	cur = 0;
	688	}
	689	cur \|= base32rev[c] << b;
	690	}
	691	if(datalen != NULL)
	692	*datalen = bufdata;
	693	addtobuf(buf, 0);
	694	return(buf);
	695	}
	696
	697	void _freeparr(void **arr)
	698	{
	699	void **buf;
	700
	701	if(arr == NULL)
	702	return;
	703	for(buf = arr; *buf != NULL; buf++)
	704	free(*buf);
	705	free(arr);
	706	}
	707
	708	int _parrlen(void **arr)
	709	{
	710	int i;
	711
	712	if(arr == NULL)
	713	return(0);
	714	for(i = 0; *arr != NULL; arr++)
	715	i++;
	716	return(i);
	717	}
	718
	719	char getetcpath(char binpath)
	720	{
73247114	721	int f;
d3372da9	722	char etcpath, p;
	723	size_t etcpathsize, etcpathdata;
	724
	725	etcpath = NULL;
	726	etcpathsize = etcpathdata = 0;
73247114	727	f = 1;
d3372da9	728	do
d3372da9	729	{
73247114	730	if(f)
	731	f = 0;
	732	else
	733	binpath++;
d3372da9	734	for(p = binpath; p && (p != ':'); p++);
	735	for(; (p >= binpath) && (*p != '/'); p--);
	736	if(p >= binpath)
	737	{
	738	if(etcpathdata > 0)
	739	addtobuf(etcpath, ':');
	740	bufcat(etcpath, binpath, p - binpath + 1);
	741	bufcat(etcpath, "etc", 3);
	742	}
	743	} while((binpath = strchr(binpath, ':')) != NULL);
	744	addtobuf(etcpath, 0);
	745	return(etcpath);
	746	}
	747
1df8650c	748	char findfile(char name, char *homedir, int filldef)
d3372da9	749	{
d3372da9	750	char path, binpath, etcpath, p;
48b2d6d1	751	struct passwd *pw;
1df8650c	752	int mode, homeonly;
d3372da9	753
1df8650c	754	if(name == NULL)
	755	return(NULL);
	756
41ac4371	757	mode = R_OK \| (filldef ? W_OK : 0);
1df8650c	758	homeonly = homedir != NULL;
	759
	760	if(!strchr(name, '/'))
	761	{
41ac4371	762	if(homedir == NULL)
41ac4371	763	homedir = getenv("HOME");
48b2d6d1	764	if((homedir == NULL) && ((pw = getpwuid(getuid())) != NULL))
48b2d6d1	765	homedir = pw->pw_dir;
1df8650c	766	if((homedir != NULL) && ((path = sprintf2("%s/.%s", homedir, name)) != NULL))
48b2d6d1	767	{
41ac4371	768	if(!access(path, mode))
48b2d6d1	769	return(path);
	770	free(path);
	771	}
d3372da9	772	}
1df8650c	773
1df8650c	774	if(!homeonly)
d3372da9	775	{
1df8650c	776	if(strchr(name, '/') != NULL)
d3372da9	777	{
1df8650c	778	if(!access(name, mode))
1df8650c	779	return(sstrdup(name));
d3372da9	780	} else {
	781	if((binpath = getenv("PATH")) == NULL)
	782	etcpath = sstrdup("/usr/local/etc:/etc:/usr/etc");
	783	else
	784	etcpath = getetcpath(binpath);
	785	for(p = strtok(etcpath, ":"); p != NULL; p = strtok(NULL, ":"))
	786	{
1df8650c	787	if((path = sprintf2("%s/%s", p, name)) != NULL)
d3372da9	788	{
41ac4371	789	if(!access(path, mode))
d3372da9	790	{
	791	free(etcpath);
	792	return(path);
	793	}
	794	free(path);
	795	}
	796	}
	797	free(etcpath);
	798	}
	799	}
1df8650c	800
48b2d6d1	801	if(filldef) {
1df8650c	802	if(homedir)
	803	return(sprintf2("%s/.%s", homedir, name));
	804	return(sprintf2("/etc/%s", name));
48b2d6d1	805	} else {
	806	return(NULL);
	807	}
d3372da9	808	}
9ec790e8	809
	810	struct wcspair newwcspair(wchar_t key, wchar_t val, struct wcspair *list)
	811	{
	812	struct wcspair *pair;
	813
	814	pair = smalloc(sizeof(*pair));
	815	memset(pair, 0, sizeof(*pair));
	816	if(key != NULL)
	817	pair->key = swcsdup(key);
	818	if(val != NULL)
	819	pair->val = swcsdup(val);
	820	if(list == NULL)
	821	{
	822	pair->next = NULL;
	823	} else {
	824	pair->next = *list;
	825	*list = pair;
	826	}
	827	return(pair);
	828	}
	829
	830	void freewcspair(struct wcspair pair, struct wcspair *list)
	831	{
497fe07b	832	struct wcspair *cur;
	833
	834	for(cur = *list; cur != NULL; list = &(cur->next), cur = cur->next)
9ec790e8	835	{
497fe07b	836	if(cur == pair)
	837	{
	838	*list = cur->next;
	839	break;
	840	}
9ec790e8	841	}
	842	free(pair->key);
	843	free(pair->val);
	844	free(pair);
	845	}
a2761258	846
	847	wchar_t wpfind(struct wcspair list, wchar_t *key)
	848	{
	849	for(; list != NULL; list = list->next)
	850	{
	851	if(!wcscmp(list->key, key))
	852	return(list->val);
	853	}
	854	return(NULL);
	855	}