common/utils.c

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