lib/uimisc.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
  20 #include <unistd.h>
  21 #include <stdlib.h>
  22 /* I'm very unsure about this, but for now it defines wcstoll (which
  23  * should be defined anyway) and doesn't break anything... let's keep
  24  * two eyes wide open, though. */
  25 #define __USE_ISOC99
  26 #include <wchar.h>
  27 #include <wctype.h>
  28 #include <pwd.h>
  29 #include <string.h>
  30 #include <stdio.h>
  31 #include <sys/poll.h>
  32
  33 #ifdef HAVE_CONFIG_H
  34 #include <config.h>
  35 #endif
  36 #include <doldaconnect/uilib.h>
  37 #include <doldaconnect/uimisc.h>
  38 #include <utils.h>
  39
  40 #ifdef HAVE_KRB5
  41 #include <krb5.h>
  42 #include <com_err.h>
  43 #endif
  44
  45 struct logindata;
  46
  47 struct authmech
  48 {
  49     wchar_t *name;
  50     void (*process)(struct dc_response *resp, struct logindata *data);
  51     int (*init)(struct logindata *data);
  52     void (*release)(struct logindata *data);
  53 };
  54
  55 struct logindata
  56 {
  57     int (*conv)(int type, wchar_t *text, char **resp, void *data);
  58     void (*callback)(int err, wchar_t *reason, void *data);
  59     char *username;
  60     int freeusername;
  61     int useauthless;
  62     void *data;
  63     void *mechdata;
  64     struct authmech *mech;
  65 };
  66
  67 struct synclogindata
  68 {
  69     int aborted;
  70     int err;
  71     wchar_t *reason;
  72 };
  73
  74 struct gencbdata
  75 {
  76     void (*callback)(int resp, void *data);
  77     void *data;
  78 };
  79
  80 struct fnetcbdata
  81 {
  82     void (*callback)(struct dc_fnetnode *fn, int resp, void *data);
  83     int fnid;
  84     void *data;
  85 };
  86
  87 struct dc_fnetnode *dc_fnetnodes = NULL;
  88 struct dc_transfer *dc_transfers = NULL;
  89
  90 static void message(int bits, char *format, ...)
  91 {
  92     static int hb = -1;
  93     char *v;
  94     va_list args;
  95
  96     if(hb == -1)
  97     {
  98         hb = 0;
  99         if((v = getenv("LIBDCUI_MSG")) != NULL)
 100             hb = strtol(v, NULL, 0) & 65535;
 101     }
 102     if(hb & bits)
 103     {
 104         va_start(args, format);
 105         vfprintf(stderr, format, args);
 106         va_end(args);
 107     }
 108 }
 109
 110 static void freelogindata(struct logindata *data)
 111 {
 112     if((data->mech != NULL) && (data->mech->release != NULL))
 113         data->mech->release(data);
 114     if(data->freeusername)
 115         free(data->username);
 116     free(data);
 117 }
 118
 119 static int logincallback(struct dc_response *resp);
 120
 121 static void process_authless(struct dc_response *resp, struct logindata *data)
 122 {
 123     switch(resp->code)
 124     {
 125     case 200:
 126         data->callback(DC_LOGIN_ERR_SUCCESS, NULL, data->data);
 127         freelogindata(data);
 128         break;
 129 /*
 130     case 303:
 131     case 304:
 132         if((ires = dc_interpret(resp)) != NULL)
 133         {
 134             buf = NULL;
 135             if(data->conv((resp->code == 303)?DC_LOGIN_CONV_INFO:DC_LOGIN_CONV_ERROR, ires->argv[0].val.str, &buf, data->data))
 136             {
 137                 data->callback(DC_LOGIN_ERR_CONV, NULL, data->data);
 138                 freelogindata(data);
 139             } else {
 140                 dc_queuecmd(logincallback, data, L"pass", L"", NULL);
 141             }
 142             if(buf != NULL)
 143             {
 144                 memset(buf, 0, strlen(buf));
 145                 free(buf);
 146             }
 147             dc_freeires(ires);
 148         }
 149         break;
 150 */
 151     case 505:
 152         data->callback(DC_LOGIN_ERR_SERVER, NULL, data->data);
 153         freelogindata(data);
 154         break;
 155     case 506:
 156         data->callback(DC_LOGIN_ERR_AUTHFAIL, NULL, data->data);
 157         freelogindata(data);
 158         break;
 159     default:
 160         data->callback(DC_LOGIN_ERR_USER, NULL, data->data);
 161         freelogindata(data);
 162         break;
 163     }
 164 }
 165
 166 static void process_pam(struct dc_response *resp, struct logindata *data)
 167 {
 168     struct dc_intresp *ires;
 169     int convtype;
 170     char *buf;
 171
 172     switch(resp->code)
 173     {
 174     case 200:
 175         data->callback(DC_LOGIN_ERR_SUCCESS, NULL, data->data);
 176         freelogindata(data);
 177         break;
 178     case 301:
 179     case 302:
 180     case 303:
 181     case 304:
 182         if(resp->code == 301)
 183             convtype = DC_LOGIN_CONV_NOECHO;
 184         else if(resp->code == 302)
 185             convtype = DC_LOGIN_CONV_ECHO;
 186         else if(resp->code == 303)
 187             convtype = DC_LOGIN_CONV_INFO;
 188         else if(resp->code == 304)
 189             convtype = DC_LOGIN_CONV_ERROR;
 190         if((ires = dc_interpret(resp)) != NULL)
 191         {
 192             buf = NULL;
 193             if(data->conv(convtype, ires->argv[0].val.str, &buf, data->data))
 194             {
 195                 data->callback(DC_LOGIN_ERR_CONV, NULL, data->data);
 196                 freelogindata(data);
 197             } else {
 198                 dc_queuecmd(logincallback, data, L"pass", L"%s", buf, NULL);
 199             }
 200             if(buf != NULL)
 201             {
 202                 memset(buf, 0, strlen(buf));
 203                 free(buf);
 204             }
 205             dc_freeires(ires);
 206         }
 207         break;
 208     case 505:
 209         data->callback(DC_LOGIN_ERR_SERVER, NULL, data->data);
 210         freelogindata(data);
 211         break;
 212     case 506:
 213         data->callback(DC_LOGIN_ERR_AUTHFAIL, NULL, data->data);
 214         freelogindata(data);
 215         break;
 216     default:
 217         data->callback(DC_LOGIN_ERR_USER, NULL, data->data);
 218         freelogindata(data);
 219         break;
 220     }
 221 }
 222
 223 #ifdef HAVE_KRB5
 224 struct krb5data
 225 {
 226     int state;
 227     krb5_context context;
 228     krb5_principal sprinc, myprinc;
 229     krb5_ccache ccache;
 230     krb5_auth_context authcon;
 231     krb5_data reqbuf;
 232     krb5_creds *servcreds;
 233     int valid, fwd, fwded;
 234 };
 235
 236 static void process_krb5(struct dc_response *resp, struct logindata *data)
 237 {
 238     int ret;
 239     struct dc_intresp *ires;
 240     struct krb5data *krb;
 241     krb5_data k5d;
 242     krb5_ap_rep_enc_part *repl;
 243     char *buf;
 244
 245     krb = data->mechdata;
 246     switch(resp->code)
 247     {
 248     case 200:
 249         data->callback(DC_LOGIN_ERR_SUCCESS, NULL, data->data);
 250         freelogindata(data);
 251         break;
 252     case 300:
 253         switch(krb->state)
 254         {
 255         case 0:
 256             buf = hexencode(krb->reqbuf.data, krb->reqbuf.length);
 257             dc_queuecmd(logincallback, data, L"pass", L"%s", buf, NULL);
 258             free(buf);
 259             krb->state = 1;
 260             break;
 261         case 1:
 262             if((ires = dc_interpret(resp)) != NULL)
 263             {
 264                 k5d.data = hexdecode(icswcstombs(ires->argv[0].val.str, NULL, NULL), &k5d.length);
 265                 if(!krb->valid)
 266                 {
 267                     if((ret = krb5_rd_rep(krb->context, krb->authcon, &k5d, &repl)) != 0)
 268                     {
 269                         data->callback(DC_LOGIN_ERR_SERVER, NULL, data->data);
 270                         freelogindata(data);
 271                         break;
 272                     }
 273                     /* XXX: Do I need to do something with this? */
 274                     krb->valid = 1;
 275                     krb5_free_ap_rep_enc_part(krb->context, repl);
 276                 }
 277                 if(krb->fwd && !krb->fwded)
 278                 {
 279                     if(krb->reqbuf.data != NULL)
 280                         free(krb->reqbuf.data);
 281                     krb->reqbuf.data = NULL;
 282                     if((ret = krb5_fwd_tgt_creds(krb->context, krb->authcon, NULL, krb->servcreds->client, krb->servcreds->server, 0, 1, &krb->reqbuf)) != 0)
 283                     {
 284                         message(1, "krb5_fwd_tgt_creds reported an error: %s\n", error_message(ret));
 285                         dc_queuecmd(logincallback, data, L"pass", L"31", NULL);
 286                         krb->fwd = 0;
 287                         krb->state = 2;
 288                     } else {
 289                         dc_queuecmd(logincallback, data, L"pass", L"32", NULL);
 290                         krb->state = 0;
 291                         krb->fwded = 1;
 292                     }
 293                 } else {
 294                     dc_queuecmd(logincallback, data, L"pass", L"31", NULL);
 295                     krb->state = 2;
 296                 }
 297                 free(k5d.data);
 298                 dc_freeires(ires);
 299             }
 300             break;
 301         default:
 302             data->callback(DC_LOGIN_ERR_USER, NULL, data->data);
 303             freelogindata(data);
 304             break;
 305         }
 306         break;
 307     case 505:
 308         data->callback(DC_LOGIN_ERR_SERVER, NULL, data->data);
 309         freelogindata(data);
 310         break;
 311     case 506:
 312         data->callback(DC_LOGIN_ERR_AUTHFAIL, NULL, data->data);
 313         freelogindata(data);
 314         break;
 315     default:
 316         data->callback(DC_LOGIN_ERR_USER, NULL, data->data);
 317         freelogindata(data);
 318         break;
 319     }
 320 }
 321
 322 static int init_krb5(struct logindata *data)
 323 {
 324     int ret;
 325     struct krb5data *krb;
 326     krb5_data cksum;
 327     krb5_creds creds;
 328
 329     if(dc_gethostname() == NULL)
 330     {
 331         message(1, "cannot use krb5 without a host name\n");
 332         return(1);
 333     }
 334     krb = smalloc(sizeof(*krb));
 335     memset(krb, 0, sizeof(*krb));
 336     krb->fwd = 1;
 337     krb->fwded = 0;
 338     data->mechdata = krb;
 339     if((ret = krb5_init_context(&krb->context)) != 0)
 340     {
 341         message(1, "krb5_init_context reported an error: %s\n", error_message(ret));
 342         return(1);
 343     }
 344     if((ret = krb5_auth_con_init(krb->context, &krb->authcon)) != 0)
 345     {
 346         message(1, "krb5_auth_con_init reported an error: %s\n", error_message(ret));
 347         return(1);
 348     }
 349     krb5_auth_con_setflags(krb->context, krb->authcon, KRB5_AUTH_CONTEXT_DO_SEQUENCE);
 350     if((ret = krb5_sname_to_principal(krb->context, dc_gethostname(), "doldacond", KRB5_NT_SRV_HST, &krb->sprinc)) != 0)
 351     {
 352         message(1, "krb5_sname_to_principal reported an error: %s\n", error_message(ret));
 353         return(1);
 354     }
 355     if((ret = krb5_cc_default(krb->context, &krb->ccache)) != 0)
 356     {
 357         message(1, "krb5_cc_default reported an error: %s\n", error_message(ret));
 358         return(1);
 359     }
 360     if((ret = krb5_cc_get_principal(krb->context, krb->ccache, &krb->myprinc)) != 0)
 361     {
 362         message(1, "krb5_cc_default reported an error: %s\n", error_message(ret));
 363         return(1);
 364     }
 365     memset(&creds, 0, sizeof(creds));
 366     creds.client = krb->myprinc;
 367     creds.server = krb->sprinc;
 368     if((ret = krb5_get_credentials(krb->context, 0, krb->ccache, &creds, &krb->servcreds)) != 0)
 369     {
 370         message(1, "krb5_get_credentials reported an error: %s\n", error_message(ret));
 371         return(1);
 372     }
 373     /* WTF is this checksum stuff?! The Krb docs don't say a word about it! */
 374     cksum.data = sstrdup(dc_gethostname());
 375     cksum.length = strlen(cksum.data);
 376     if((ret = krb5_mk_req_extended(krb->context, &krb->authcon, AP_OPTS_MUTUAL_REQUIRED, &cksum, krb->servcreds, &krb->reqbuf)) != 0)
 377     {
 378         message(1, "krb5_mk_req_extended reported an error: %s\n", error_message(ret));
 379         return(1);
 380     }
 381     free(cksum.data);
 382     krb->state = 0;
 383     return(0);
 384 }
 385
 386 static void release_krb5(struct logindata *data)
 387 {
 388     struct krb5data *krb;
 389
 390     if((krb = data->mechdata) == NULL)
 391         return;
 392     if(krb->servcreds != NULL)
 393         krb5_free_creds(krb->context, krb->servcreds);
 394     if(krb->reqbuf.data != NULL)
 395         free(krb->reqbuf.data);
 396     if(krb->sprinc != NULL)
 397         krb5_free_principal(krb->context, krb->sprinc);
 398     if(krb->myprinc != NULL)
 399         krb5_free_principal(krb->context, krb->myprinc);
 400     if(krb->ccache != NULL)
 401         krb5_cc_close(krb->context, krb->ccache);
 402     if(krb->authcon != NULL)
 403         krb5_auth_con_free(krb->context, krb->authcon);
 404     if(krb->context != NULL)
 405         krb5_free_context(krb->context);
 406     free(krb);
 407 }
 408 #endif
 409
 410 /* Arranged in order of priority */
 411 static struct authmech authmechs[] =
 412 {
 413 #ifdef HAVE_KRB5
 414     {
 415         .name = L"krb5",
 416         .process = process_krb5,
 417         .init = init_krb5,
 418         .release = release_krb5
 419     },
 420 #endif
 421     {
 422         .name = L"unix",
 423         .process = process_authless,
 424         .init = NULL,
 425         .release = NULL
 426     },
 427     {
 428         .name = L"authless",
 429         .process = process_authless,
 430         .init = NULL,
 431         .release = NULL
 432     },
 433     {
 434         .name = L"pam",
 435         .process = process_pam,
 436         .init = NULL,
 437         .release = NULL
 438     },
 439     {
 440         .name = NULL
 441     }
 442 };
 443
 444 int dc_convtty(int type, wchar_t *text, char **resp, void *data)
 445 {
 446     char *buf, *pass;
 447
 448     if(isatty(0))
 449     {
 450         if((buf = icwcstombs(text, NULL)) == NULL)
 451             return(1);
 452         pass = getpass(buf);
 453         free(buf);
 454         *resp = sstrdup(pass);
 455         memset(pass, 0, strlen(pass));
 456         return(0);
 457     }
 458     return(1);
 459 }
 460
 461 int dc_convnone(int type, wchar_t *text, char **resp, void *data)
 462 {
 463     return(1);
 464 }
 465
 466 static int logincallback(struct dc_response *resp)
 467 {
 468     int i;
 469     struct dc_intresp *ires;
 470     struct logindata *data;
 471     int mech;
 472     char *username;
 473     struct passwd *pwent;
 474     void *odata, *ndata;
 475
 476     data = resp->data;
 477     if(!wcscmp(resp->cmdname, L"lsauth"))
 478     {
 479         if(resp->code == 201)
 480         {
 481             data->callback(DC_LOGIN_ERR_NOLOGIN, NULL, data->data);
 482             freelogindata(data);
 483         } else {
 484             mech = -1;
 485             while((ires = dc_interpret(resp)) != NULL)
 486             {
 487                 if(!data->useauthless && !wcscmp(ires->argv[0].val.str, L"authless"))
 488                 {
 489                     dc_freeires(ires);
 490                     continue;
 491                 }
 492                 for(i = 0; authmechs[i].name != NULL; i++)
 493                 {
 494                     if(!wcscmp(authmechs[i].name, ires->argv[0].val.str) && ((i < mech) || (mech == -1)))
 495                     {
 496                         odata = data->mechdata;
 497                         data->mechdata = NULL;
 498                         message(4, "trying auth mech %ls\n", authmechs[i].name);
 499                         if((authmechs[i].init != NULL) && authmechs[i].init(data))
 500                         {
 501                             if(authmechs[i].release != NULL)
 502                                 authmechs[i].release(data);
 503                             data->mechdata = odata;
 504                             message(2, "authentication mechanism %ls failed, trying further...\n", authmechs[i].name);
 505                         } else {
 506                             if((data->mech != NULL) && data->mech->release != NULL)
 507                             {
 508                                 ndata = data->mechdata;
 509                                 data->mechdata = odata;
 510                                 data->mech->release(data);
 511                                 data->mechdata = ndata;
 512                             }
 513                             mech = i;
 514                             data->mech = authmechs + i;
 515                         }
 516                         break;
 517                     }
 518                 }
 519                 dc_freeires(ires);
 520             }
 521             if(mech == -1)
 522             {
 523                 data->callback(DC_LOGIN_ERR_NOLOGIN, NULL, data->data);
 524                 freelogindata(data);
 525             } else {
 526                 if((username = data->username) == NULL)
 527                 {
 528                     if((pwent = getpwuid(getuid())) == NULL)
 529                     {
 530                         data->callback(DC_LOGIN_ERR_USER, NULL, data->data);
 531                         freelogindata(data);
 532                         return(1);
 533                     }
 534                     username = pwent->pw_name;
 535                 }
 536                 dc_queuecmd(logincallback, data, L"login", data->mech->name, L"%s", username, NULL);
 537             }
 538         }
 539     } else if(!wcscmp(resp->cmdname, L"login") || !wcscmp(resp->cmdname, L"pass")) {
 540         data->mech->process(resp, data);
 541     }
 542     return(1);
 543 }
 544
 545 void dc_loginasync(char *username, int useauthless, int (*conv)(int, wchar_t *, char **, void *), void (*callback)(int, wchar_t *, void *), void *udata)
 546 {
 547     struct logindata *data;
 548
 549     data = smalloc(sizeof(*data));
 550     if(conv == NULL)
 551         conv = dc_convtty;
 552     data->conv = conv;
 553     data->mech = NULL;
 554     data->data = udata;
 555     data->mechdata = NULL;
 556     data->callback = callback;
 557     data->useauthless = useauthless;
 558     data->freeusername = 0;
 559     if(username == NULL)
 560     {
 561         data->username = NULL;
 562     } else {
 563         data->username = sstrdup(username);
 564         data->freeusername = 1;
 565     }
 566     dc_queuecmd(logincallback, data, L"lsauth", NULL);
 567 }
 568
 569 static void synclogincb(int err, wchar_t *reason, struct synclogindata *data)
 570 {
 571     if(data->aborted)
 572     {
 573         free(data);
 574         return;
 575     }
 576     data->err = err;
 577     if(reason == NULL)
 578         data->reason = NULL;
 579     else
 580         data->reason = swcsdup(reason);
 581 }
 582
 583 int dc_login(char *username, int useauthless, int (*conv)(int, wchar_t *, char **, void *), wchar_t **reason)
 584 {
 585     int ret, abort;
 586     struct synclogindata *dbuf;
 587     struct pollfd pfd;
 588
 589     dbuf = smalloc(sizeof(*dbuf));
 590     memset(dbuf, 0, sizeof(*dbuf));
 591     dbuf->err = -1;
 592     dc_loginasync(username, useauthless, conv, (void (*)(int, wchar_t *, void *))synclogincb, dbuf);
 593     while(dbuf->err == -1)
 594     {
 595         pfd.fd = dc_getfd();
 596         pfd.events = POLLIN;
 597         if(dc_wantwrite())
 598             pfd.events |= POLLOUT;
 599         abort = 0;
 600         if(poll(&pfd, 1, -1) < 0)
 601             abort = 1;
 602         if(!abort && (pfd.revents & POLLIN) && dc_handleread())
 603             abort = 1;
 604         if(!abort && (pfd.revents & POLLOUT) && dc_handlewrite())
 605             abort = 1;
 606         if(abort)
 607         {
 608             dbuf->aborted = 1;
 609             return(-1);
 610         }
 611     }
 612     if(reason != NULL)
 613         *reason = dbuf->reason;
 614     else if(dbuf->reason != NULL)
 615         free(dbuf->reason);
 616     ret = dbuf->err;
 617     free(dbuf);
 618     return(ret);
 619 }
 620
 621 static struct dc_fnetpeerdatum *finddatum(struct dc_fnetnode *fn, wchar_t *id)
 622 {
 623     struct dc_fnetpeerdatum *datum;
 624
 625     for(datum = fn->peerdata; datum != NULL; datum = datum->next)
 626     {
 627         if(!wcscmp(datum->id, id))
 628             break;
 629     }
 630     return(datum);
 631 }
 632
 633 static struct dc_fnetpeerdatum *adddatum(struct dc_fnetnode *fn, wchar_t *id, int dt)
 634 {
 635     struct dc_fnetpeerdatum *datum;
 636
 637     datum = smalloc(sizeof(*datum));
 638     memset(datum, 0, sizeof(*datum));
 639     datum->refcount = 0;
 640     datum->dt = dt;
 641     datum->id = swcsdup(id);
 642     datum->prev = NULL;
 643     datum->next = fn->peerdata;
 644     if(fn->peerdata != NULL)
 645         fn->peerdata->prev = datum;
 646     fn->peerdata = datum;
 647     return(datum);
 648 }
 649
 650 static struct dc_fnetpeerdi *difindoradd(struct dc_fnetpeer *peer, struct dc_fnetpeerdatum *datum)
 651 {
 652     int i;
 653
 654     for(i = 0; i < peer->dinum; i++)
 655     {
 656         if(peer->di[i].datum == datum)
 657             return(&peer->di[i]);
 658     }
 659     peer->di = srealloc(peer->di, sizeof(struct dc_fnetpeerdi) * ++(peer->dinum));
 660     memset(&peer->di[i], 0, sizeof(struct dc_fnetpeerdi));
 661     peer->di[i].datum = datum;
 662     datum->refcount++;
 663     return(&peer->di[i]);
 664 }
 665
 666 static void putdatum(struct dc_fnetnode *fn, struct dc_fnetpeerdatum *datum)
 667 {
 668     if(--datum->refcount > 0)
 669         return;
 670     if(datum->next != NULL)
 671         datum->next->prev = datum->prev;
 672     if(datum->prev != NULL)
 673         datum->prev->next = datum->next;
 674     if(fn->peerdata == datum)
 675         fn->peerdata = datum->next;
 676     free(datum->id);
 677     free(datum);
 678 }
 679
 680 static void peersetnum(struct dc_fnetpeer *peer, wchar_t *id, int value)
 681 {
 682     struct dc_fnetpeerdatum *datum;
 683     struct dc_fnetpeerdi *di;
 684
 685     if((datum = finddatum(peer->fn, id)) == NULL)
 686         datum = adddatum(peer->fn, id, DC_FNPD_INT);
 687     di = difindoradd(peer, datum);
 688     di->d.num = value;
 689 }
 690
 691 static void peersetlnum(struct dc_fnetpeer *peer, wchar_t *id, long long value)
 692 {
 693     struct dc_fnetpeerdatum *datum;
 694     struct dc_fnetpeerdi *di;
 695
 696     if((datum = finddatum(peer->fn, id)) == NULL)
 697         datum = adddatum(peer->fn, id, DC_FNPD_INT);
 698     di = difindoradd(peer, datum);
 699     di->d.lnum = value;
 700 }
 701
 702 static void peersetstr(struct dc_fnetpeer *peer, wchar_t *id, wchar_t *value)
 703 {
 704     struct dc_fnetpeerdatum *datum;
 705     struct dc_fnetpeerdi *di;
 706
 707     if((datum = finddatum(peer->fn, id)) == NULL)
 708         datum = adddatum(peer->fn, id, DC_FNPD_INT);
 709     di = difindoradd(peer, datum);
 710     if(di->d.str != NULL)
 711         free(di->d.str);
 712     di->d.str = swcsdup(value);
 713 }
 714
 715 struct dc_fnetpeer *dc_fnetfindpeer(struct dc_fnetnode *fn, wchar_t *id)
 716 {
 717     struct dc_fnetpeer *peer;
 718
 719     for(peer = fn->peers; peer != NULL; peer = peer->next)
 720     {
 721         if(!wcscmp(peer->id, id))
 722             break;
 723     }
 724     return(peer);
 725 }
 726
 727 static struct dc_fnetpeer *addpeer(struct dc_fnetnode *fn, wchar_t *id, wchar_t *nick)
 728 {
 729     struct dc_fnetpeer *peer;
 730
 731     peer = smalloc(sizeof(*peer));
 732     memset(peer, 0, sizeof(*peer));
 733     peer->fn = fn;
 734     peer->id = swcsdup(id);
 735     peer->nick = swcsdup(nick);
 736     peer->next = fn->peers;
 737     peer->prev = NULL;
 738     if(fn->peers != NULL)
 739         fn->peers->prev = peer;
 740     fn->peers = peer;
 741     return(peer);
 742 }
 743
 744 static void delpeer(struct dc_fnetpeer *peer)
 745 {
 746     int i;
 747
 748     if(peer->next != NULL)
 749         peer->next->prev = peer->prev;
 750     if(peer->prev != NULL)
 751         peer->prev->next = peer->next;
 752     if(peer->fn->peers == peer)
 753         peer->fn->peers = peer->next;
 754     free(peer->id);
 755     free(peer->nick);
 756     for(i = 0; i < peer->dinum; i++)
 757     {
 758         if((peer->di[i].datum->dt == DC_FNPD_STR) && (peer->di[i].d.str != NULL))
 759             free(peer->di[i].d.str);
 760         putdatum(peer->fn, peer->di[i].datum);
 761     }
 762     free(peer->di);
 763     free(peer);
 764 }
 765
 766 static struct dc_fnetnode *newfn(void)
 767 {
 768     struct dc_fnetnode *fn;
 769
 770     fn = smalloc(sizeof(*fn));
 771     memset(fn, 0, sizeof(*fn));
 772     fn->id = -1;
 773     fn->name = NULL;
 774     fn->fnet = NULL;
 775     fn->state = fn->numusers = fn->found = 0;
 776     fn->destroycb = NULL;
 777     fn->udata = NULL;
 778     fn->next = dc_fnetnodes;
 779     fn->prev = NULL;
 780     if(dc_fnetnodes != NULL)
 781         dc_fnetnodes->prev = fn;
 782     dc_fnetnodes = fn;
 783     return(fn);
 784 }
 785
 786 static void freefn(struct dc_fnetnode *fn)
 787 {
 788     if(fn->next != NULL)
 789         fn->next->prev = fn->prev;
 790     if(fn->prev != NULL)
 791         fn->prev->next = fn->next;
 792     if(fn == dc_fnetnodes)
 793         dc_fnetnodes = fn->next;
 794     if(fn->destroycb != NULL)
 795         fn->destroycb(fn);
 796     while(fn->peers != NULL)
 797         delpeer(fn->peers);
 798     while(fn->peerdata != NULL)
 799     {
 800         fn->peerdata->refcount = 0;
 801         putdatum(fn, fn->peerdata);
 802     }
 803     if(fn->name != NULL)
 804         free(fn->name);
 805     if(fn->fnet != NULL)
 806         free(fn->fnet);
 807     free(fn);
 808 }
 809
 810 struct dc_fnetnode *dc_findfnetnode(int id)
 811 {
 812     struct dc_fnetnode *fn;
 813
 814     for(fn = dc_fnetnodes; fn != NULL; fn = fn->next)
 815     {
 816         if(fn->id == id)
 817             break;
 818     }
 819     return(fn);
 820 }
 821
 822 static struct dc_transfer *newtransfer(void)
 823 {
 824     struct dc_transfer *transfer;
 825
 826     transfer = smalloc(sizeof(*transfer));
 827     memset(transfer, 0, sizeof(*transfer));
 828     transfer->id = -1;
 829     transfer->peerid = transfer->peernick = transfer->path = NULL;
 830     transfer->state = DC_TRNS_WAITING;
 831     transfer->dir = DC_TRNSD_UNKNOWN;
 832     transfer->size = -1;
 833     transfer->curpos = -1;
 834     transfer->destroycb = NULL;
 835     transfer->udata = NULL;
 836     transfer->next = dc_transfers;
 837     transfer->prev = NULL;
 838     if(dc_transfers != NULL)
 839         dc_transfers->prev = transfer;
 840     dc_transfers = transfer;
 841     return(transfer);
 842 }
 843
 844 static void freetransfer(struct dc_transfer *transfer)
 845 {
 846     if(transfer->next != NULL)
 847         transfer->next->prev = transfer->prev;
 848     if(transfer->prev != NULL)
 849         transfer->prev->next = transfer->next;
 850     if(transfer == dc_transfers)
 851         dc_transfers = transfer->next;
 852     if(transfer->destroycb != NULL)
 853         transfer->destroycb(transfer);
 854     if(transfer->peerid != NULL)
 855         free(transfer->peerid);
 856     if(transfer->peernick != NULL)
 857         free(transfer->peernick);
 858     if(transfer->path != NULL)
 859         free(transfer->path);
 860     free(transfer);
 861 }
 862
 863 struct dc_transfer *dc_findtransfer(int id)
 864 {
 865     struct dc_transfer *transfer;
 866
 867     for(transfer = dc_transfers; transfer != NULL; transfer = transfer->next)
 868     {
 869         if(transfer->id == id)
 870             break;
 871     }
 872     return(transfer);
 873 }
 874
 875 static int getfnlistcallback(struct dc_response *resp)
 876 {
 877     struct dc_intresp *ires;
 878     struct gencbdata *data;
 879     struct dc_fnetnode *fn, *next;
 880
 881     data = resp->data;
 882     if(resp->code == 200)
 883     {
 884         for(fn = dc_fnetnodes; fn != NULL; fn = fn->next)
 885             fn->found = 0;
 886         while((ires = dc_interpret(resp)) != NULL)
 887         {
 888             if((fn = dc_findfnetnode(ires->argv[0].val.num)) != NULL)
 889             {
 890                 fn->found = 1;
 891                 if(fn->fnet != NULL)
 892                     free(fn->fnet);
 893                 fn->fnet = swcsdup(ires->argv[1].val.str);
 894                 if(fn->name != NULL)
 895                     free(fn->name);
 896                 fn->name = swcsdup(ires->argv[2].val.str);
 897                 fn->numusers = ires->argv[3].val.num;
 898                 fn->state = ires->argv[4].val.num;
 899                 if(fn->pubid != NULL)
 900                     free(fn->pubid);
 901                 fn->pubid = swcsdup(ires->argv[5].val.str);
 902             } else {
 903                 fn = newfn();
 904                 fn->id = ires->argv[0].val.num;
 905                 fn->fnet = swcsdup(ires->argv[1].val.str);
 906                 fn->name = swcsdup(ires->argv[2].val.str);
 907                 fn->numusers = ires->argv[3].val.num;
 908                 fn->state = ires->argv[4].val.num;
 909                 fn->pubid = swcsdup(ires->argv[5].val.str);
 910                 fn->found = 1;
 911             }
 912             dc_freeires(ires);
 913         }
 914         for(fn = dc_fnetnodes; fn != NULL; fn = next)
 915         {
 916             next = fn->next;
 917             if(!fn->found)
 918                 freefn(fn);
 919         }
 920         data->callback(200, data->data);
 921         free(resp->data);
 922     } else if(resp->code == 201) {
 923         while(dc_fnetnodes != NULL)
 924             freefn(dc_fnetnodes);
 925         data->callback(201, data->data);
 926         free(resp->data);
 927     } else if(resp->code == 502) {
 928         while(dc_fnetnodes != NULL)
 929             freefn(dc_fnetnodes);
 930         data->callback(502, data->data);
 931         free(resp->data);
 932     }
 933     return(1);
 934 }
 935
 936 static int gettrlistcallback(struct dc_response *resp)
 937 {
 938     struct dc_intresp *ires;
 939     struct gencbdata *data;
 940     struct dc_transfer *transfer, *next;
 941
 942     data = resp->data;
 943     if(resp->code == 200)
 944     {
 945         for(transfer = dc_transfers; transfer != NULL; transfer = transfer->next)
 946             transfer->found = 0;
 947         while((ires = dc_interpret(resp)) != NULL)
 948         {
 949             if((transfer = dc_findtransfer(ires->argv[0].val.num)) != NULL)
 950             {
 951                 transfer->found = 1;
 952                 if((transfer->path == NULL) || wcscmp(transfer->path, ires->argv[5].val.str))
 953                 {
 954                     if(transfer->path != NULL)
 955                         free(transfer->path);
 956                     transfer->path = swcsdup(ires->argv[5].val.str);
 957                 }
 958                 if((transfer->peerid == NULL) || wcscmp(transfer->peerid, ires->argv[3].val.str))
 959                 {
 960                     if(transfer->peerid != NULL)
 961                         free(transfer->peerid);
 962                     transfer->peerid = swcsdup(ires->argv[3].val.str);
 963                 }
 964                 if((transfer->peernick == NULL) || wcscmp(transfer->peernick, ires->argv[4].val.str))
 965                 {
 966                     if(transfer->peernick != NULL)
 967                         free(transfer->peernick);
 968                     transfer->peernick = swcsdup(ires->argv[4].val.str);
 969                 }
 970                 transfer->dir = ires->argv[1].val.num;
 971                 transfer->state = ires->argv[2].val.num;
 972                 transfer->size = ires->argv[6].val.num;
 973                 transfer->curpos = ires->argv[7].val.num;
 974                 if(transfer->hash != NULL)
 975                 {
 976                     free(transfer->hash);
 977                     transfer->hash = NULL;
 978                 }
 979                 if(wcslen(ires->argv[8].val.str) > 0)
 980                     transfer->hash = swcsdup(ires->argv[8].val.str);
 981             } else {
 982                 transfer = newtransfer();
 983                 transfer->id = ires->argv[0].val.num;
 984                 transfer->dir = ires->argv[1].val.num;
 985                 transfer->state = ires->argv[2].val.num;
 986                 transfer->peerid = swcsdup(ires->argv[3].val.str);
 987                 transfer->peernick = swcsdup(ires->argv[4].val.str);
 988                 transfer->path = swcsdup(ires->argv[5].val.str);
 989                 transfer->size = ires->argv[6].val.num;
 990                 transfer->curpos = ires->argv[7].val.num;
 991                 if(wcslen(ires->argv[8].val.str) > 0)
 992                     transfer->hash = swcsdup(ires->argv[8].val.str);
 993                 transfer->found = 1;
 994             }
 995             dc_freeires(ires);
 996         }
 997         for(transfer = dc_transfers; transfer != NULL; transfer = next)
 998         {
 999             next = transfer->next;
1000             if(!transfer->found)
1001                 freetransfer(transfer);
1002         }
1003         data->callback(200, data->data);
1004         free(data);
1005     } else if(resp->code == 201) {
1006         while(dc_transfers != NULL)
1007             freetransfer(dc_transfers);
1008         data->callback(201, data->data);
1009         free(data);
1010     } else if(resp->code == 502) {
1011         while(dc_transfers != NULL)
1012             freetransfer(dc_transfers);
1013         data->callback(502, data->data);
1014         free(data);
1015     }
1016     return(1);
1017 }
1018
1019 static int sortlist1(const struct dc_respline *l1, const struct dc_respline *l2)
1020 {
1021     return(wcscmp(l1->argv[1], l2->argv[1]));
1022 }
1023
1024 static int sortlist2(const struct dc_fnetpeer **p1, const struct dc_fnetpeer **p2)
1025 {
1026     return(wcscmp((*p1)->id, (*p2)->id));
1027 }
1028
1029 static void fillpeer(struct dc_fnetpeer *peer, struct dc_respline *r)
1030 {
1031     int i;
1032     struct dc_fnetpeerdatum *datum;
1033
1034     for(i = 3; i < r->argc; i += 2)
1035     {
1036         if((datum = finddatum(peer->fn, r->argv[i])) != NULL)
1037         {
1038             switch(datum->dt)
1039             {
1040             case DC_FNPD_INT:
1041                 peersetnum(peer, datum->id, wcstol(r->argv[i + 1], NULL, 10));
1042                 break;
1043             case DC_FNPD_LL:
1044                 peersetlnum(peer, datum->id, wcstoll(r->argv[i + 1], NULL, 10));
1045                 break;
1046             case DC_FNPD_STR:
1047                 peersetstr(peer, datum->id, r->argv[i + 1]);
1048                 break;
1049             }
1050         }
1051     }
1052 }
1053
1054 static int getpeerlistcallback(struct dc_response *resp)
1055 {
1056     int i, o, c;
1057     struct dc_fnetnode *fn;
1058     struct fnetcbdata *data;
1059     struct dc_fnetpeer *peer;
1060     struct dc_fnetpeer **plist;
1061     size_t plistsize, plistdata;
1062
1063     data = resp->data;
1064     if((fn = dc_findfnetnode(data->fnid)) == NULL)
1065     {
1066         data->callback(NULL, -1, data->data);
1067         free(data);
1068         return(1);
1069     }
1070     if(resp->code == 200)
1071     {
1072         qsort(resp->rlines, resp->numlines, sizeof(*resp->rlines), (int (*)(const void *, const void *))sortlist1);
1073         plist = NULL;
1074         plistsize = plistdata = 0;
1075         for(i = 0, peer = fn->peers; peer != NULL; peer = peer->next)
1076             addtobuf(plist, peer);
1077         qsort(plist, plistdata, sizeof(*plist), (int (*)(const void *, const void *))sortlist2);
1078         i = o = 0;
1079         while(1)
1080         {
1081             if((i < resp->numlines) && (o < plistdata))
1082             {
1083                 c = wcscmp(resp->rlines[i].argv[1], plist[o]->id);
1084                 if(c < 0)
1085                 {
1086                     peer = addpeer(fn, resp->rlines[i].argv[1], resp->rlines[i].argv[2]);
1087                     fillpeer(peer, resp->rlines + i);
1088                     i++;
1089                 } else if(c > 0) {
1090                     delpeer(plist[o]);
1091                     o++;
1092                 } else {
1093                     fillpeer(plist[o], resp->rlines + i);
1094                     i++;
1095                     o++;
1096                 }
1097             } else if(i < resp->numlines) {
1098                 peer = addpeer(fn, resp->rlines[i].argv[1], resp->rlines[i].argv[2]);
1099                 fillpeer(peer, resp->rlines + i);
1100                 i++;
1101             } else if(o < plistdata) {
1102                 delpeer(plist[o]);
1103                 o++;
1104             } else {
1105                 break;
1106             }
1107         }
1108         free(plist);
1109     } else if(resp->code == 201) {
1110         while(fn->peers != NULL)
1111             delpeer(fn->peers);
1112     }
1113     data->callback(fn, resp->code, data->data);
1114     free(data);
1115     return(1);
1116 }
1117
1118 static int getpalistcallback(struct dc_response *resp)
1119 {
1120     struct dc_fnetnode *fn;
1121     struct dc_intresp *ires;
1122     struct fnetcbdata *data;
1123
1124     data = resp->data;
1125     if((fn = dc_findfnetnode(data->fnid)) == NULL)
1126     {
1127         data->callback(NULL, -1, data->data);
1128         free(data);
1129         return(1);
1130     }
1131     if(resp->code == 200)
1132     {
1133         while((ires = dc_interpret(resp)) != NULL)
1134         {
1135             adddatum(fn, ires->argv[0].val.str, ires->argv[1].val.num);
1136             dc_freeires(ires);
1137         }
1138         dc_queuecmd(getpeerlistcallback, data, L"lspeers", L"%i", fn->id, NULL);
1139     } else if(resp->code == 201) {
1140         dc_queuecmd(getpeerlistcallback, data, L"lspeers", L"%i", fn->id, NULL);
1141     } else {
1142         data->callback(fn, resp->code, data->data);
1143         free(data);
1144     }
1145     return(1);
1146 }
1147
1148 void dc_getfnlistasync(void (*callback)(int, void *), void *udata)
1149 {
1150     struct gencbdata *data;
1151
1152     data = smalloc(sizeof(*data));
1153     data->callback = callback;
1154     data->data = udata;
1155     dc_queuecmd(getfnlistcallback, data, L"lsnodes", NULL);
1156 }
1157
1158 void dc_gettrlistasync(void (*callback)(int, void *), void *udata)
1159 {
1160     struct gencbdata *data;
1161
1162     data = smalloc(sizeof(*data));
1163     data->callback = callback;
1164     data->data = udata;
1165     dc_queuecmd(gettrlistcallback, data, L"lstrans", NULL);
1166 }
1167
1168 void dc_getpeerlistasync(struct dc_fnetnode *fn, void (*callback)(struct dc_fnetnode *, int, void *), void *udata)
1169 {
1170     struct fnetcbdata *data;
1171
1172     data = smalloc(sizeof(*data));
1173     data->callback = callback;
1174     data->fnid = fn->id;
1175     data->data = udata;
1176     dc_queuecmd(getpalistcallback, data, L"lspa", L"%i", fn->id, NULL);
1177 }
1178
1179 void dc_uimisc_disconnected(void)
1180 {
1181     while(dc_fnetnodes != NULL)
1182         freefn(dc_fnetnodes);
1183     while(dc_transfers != NULL)
1184         freetransfer(dc_transfers);
1185 }
1186
1187 void dc_uimisc_handlenotify(struct dc_response *resp)
1188 {
1189     int i;
1190     struct dc_fnetnode *fn;
1191     struct dc_transfer *transfer;
1192     struct dc_fnetpeer *peer;
1193     struct dc_intresp *ires;
1194
1195     if((ires = dc_interpret(resp)) == NULL)
1196         return;
1197     switch(resp->code)
1198     {
1199     case 601:
1200         if((fn = dc_findfnetnode(ires->argv[0].val.num)) != NULL)
1201             fn->state = ires->argv[1].val.num;
1202         break;
1203     case 602:
1204         if((fn = dc_findfnetnode(ires->argv[0].val.num)) != NULL)
1205         {
1206             if(fn->name != NULL)
1207                 free(fn->name);
1208             fn->name = swcsdup(ires->argv[1].val.str);
1209         }
1210         break;
1211     case 603:
1212         if((fn = dc_findfnetnode(ires->argv[0].val.num)) != NULL)
1213             freefn(fn);
1214         break;
1215     case 604:
1216         fn = newfn();
1217         fn->id = ires->argv[0].val.num;
1218         if(fn->fnet != NULL)
1219             free(fn->fnet);
1220         fn->fnet = swcsdup(ires->argv[1].val.str);
1221         fn->state = DC_FNN_STATE_SYN;
1222         fn->numusers = 0;
1223         break;
1224     case 605:
1225         if((fn = dc_findfnetnode(ires->argv[0].val.num)) != NULL)
1226             fn->numusers = ires->argv[1].val.num;
1227         break;
1228     case 610:
1229         transfer = newtransfer();
1230         transfer->id = ires->argv[0].val.num;
1231         transfer->dir = ires->argv[1].val.num;
1232         if(transfer->dir == DC_TRNSD_UP)
1233             transfer->state = DC_TRNS_HS;
1234         transfer->peerid = swcsdup(ires->argv[2].val.str);
1235         if(ires->argv[3].val.str[0])
1236             transfer->path = swcsdup(ires->argv[3].val.str);
1237         break;
1238     case 611:
1239         if((transfer = dc_findtransfer(ires->argv[0].val.num)) != NULL)
1240             transfer->state = ires->argv[1].val.num;
1241         break;
1242     case 612:
1243         if((transfer = dc_findtransfer(ires->argv[0].val.num)) != NULL)
1244         {
1245             if(transfer->peernick != NULL)
1246                 free(transfer->peernick);
1247             transfer->peernick = swcsdup(ires->argv[1].val.str);
1248         }
1249         break;
1250     case 613:
1251         if((transfer = dc_findtransfer(ires->argv[0].val.num)) != NULL)
1252             transfer->size = ires->argv[1].val.num;
1253         break;
1254     case 614:
1255         if((transfer = dc_findtransfer(ires->argv[0].val.num)) != NULL)
1256         {
1257             transfer->error = ires->argv[1].val.num;
1258             time(&transfer->errortime);
1259         }
1260         break;
1261     case 615:
1262         if((transfer = dc_findtransfer(ires->argv[0].val.num)) != NULL)
1263             transfer->curpos = ires->argv[1].val.num;
1264         break;
1265     case 616:
1266         if((transfer = dc_findtransfer(ires->argv[0].val.num)) != NULL)
1267         {
1268             if(transfer->path != NULL)
1269                 free(transfer->path);
1270             transfer->path = swcsdup(ires->argv[1].val.str);
1271         }
1272         break;
1273     case 617:
1274         if((transfer = dc_findtransfer(ires->argv[0].val.num)) != NULL)
1275             freetransfer(transfer);
1276         break;
1277     case 618:
1278         if((transfer = dc_findtransfer(ires->argv[0].val.num)) != NULL)
1279         {
1280             if(transfer->hash != NULL)
1281             {
1282                 free(transfer->hash);
1283                 transfer->hash = NULL;
1284             }
1285             if(wcslen(ires->argv[1].val.str) > 0)
1286                 transfer->hash = swcsdup(ires->argv[1].val.str);
1287         }
1288         break;
1289     case 630:
1290         if((fn = dc_findfnetnode(ires->argv[0].val.num)) != NULL)
1291         {
1292             if((peer = dc_fnetfindpeer(fn, ires->argv[1].val.str)) == NULL)
1293             {
1294                 peer = addpeer(fn, ires->argv[1].val.str, ires->argv[2].val.str);
1295                 if(fn->newpeercb != NULL)
1296                     fn->newpeercb(peer);
1297             }
1298         }
1299         break;
1300     case 631:
1301         if((fn = dc_findfnetnode(ires->argv[0].val.num)) != NULL)
1302         {
1303             if((peer = dc_fnetfindpeer(fn, ires->argv[1].val.str)) != NULL)
1304             {
1305                 if(fn->delpeercb != NULL)
1306                     fn->delpeercb(peer);
1307                 delpeer(peer);
1308             }
1309         }
1310         break;
1311     case 632:
1312         if((fn = dc_findfnetnode(ires->argv[0].val.num)) != NULL)
1313         {
1314             if((peer = dc_fnetfindpeer(fn, ires->argv[1].val.str)) != NULL)
1315             {
1316                 if(wcscmp(ires->argv[2].val.str, peer->nick))
1317                 {
1318                     free(peer->nick);
1319                     peer->nick = swcsdup(ires->argv[2].val.str);
1320                 }
1321                 for(i = 4; i < resp->rlines[0].argc; i += 3)
1322                 {
1323                     switch(wcstol(resp->rlines[0].argv[i + 1], NULL, 10))
1324                     {
1325                     case DC_FNPD_INT:
1326                         peersetnum(peer, resp->rlines[0].argv[i], wcstol(resp->rlines[0].argv[i + 2], NULL, 10));
1327                         break;
1328                     case DC_FNPD_LL:
1329                         peersetlnum(peer, resp->rlines[0].argv[i], wcstoll(resp->rlines[0].argv[i + 2], NULL, 10));
1330                         break;
1331                     case DC_FNPD_STR:
1332                         peersetstr(peer, resp->rlines[0].argv[i], resp->rlines[0].argv[i + 2]);
1333                         break;
1334                     }
1335                 }
1336                 if(fn->chpeercb != NULL)
1337                     fn->chpeercb(peer);
1338             }
1339         }
1340         break;
1341     default:
1342         break;
1343     }
1344     dc_freeires(ires);
1345     resp->curline = 0;
1346 }
1347
1348 /* Note the backspace handling - it's not as elegant as possible, but
1349  * it helps avoid the "box-of-toothpicks" syndrome when writing search
1350  * expressions manually. */
1351 wchar_t **dc_lexsexpr(wchar_t *sexpr)
1352 {
1353     wchar_t **ret;
1354     wchar_t *buf;
1355     size_t retsize, retdata, bufsize, bufdata;
1356     int state;
1357
1358     ret = NULL;
1359     buf = NULL;
1360     retsize = retdata = bufsize = bufdata = 0;
1361     state = 0;
1362     while(*sexpr != L'\0')
1363     {
1364         switch(state)
1365         {
1366         case 0:
1367             if(!iswspace(*sexpr))
1368                 state = 1;
1369             else
1370                 sexpr++;
1371             break;
1372         case 1:
1373             if(iswspace(*sexpr))
1374             {
1375                 if(buf != NULL)
1376                 {
1377                     addtobuf(buf, L'\0');
1378                     addtobuf(ret, buf);
1379                     buf = NULL;
1380                     bufsize = bufdata = 0;
1381                 }
1382                 state = 0;
1383             } else if((*sexpr == L'(') ||
1384                       (*sexpr == L')') ||
1385                       (*sexpr == L'&') ||
1386                       (*sexpr == L'|') ||
1387                       (*sexpr == L'!')) {
1388                 if(buf != NULL)
1389                 {
1390                     addtobuf(buf, L'\0');
1391                     addtobuf(ret, buf);
1392                     buf = NULL;
1393                     bufsize = bufdata = 0;
1394                 }
1395                 addtobuf(buf, *sexpr);
1396                 addtobuf(buf, L'\0');
1397                 addtobuf(ret, buf);
1398                 buf = NULL;
1399                 bufsize = bufdata = 0;
1400                 sexpr++;
1401             } else if(*sexpr == L'\"') {
1402                 sexpr++;
1403                 state = 2;
1404             } else if(*sexpr == L'\\') {
1405                 sexpr++;
1406                 if(*sexpr == L'\0')
1407                 {
1408                     addtobuf(buf, *sexpr);
1409                 } else if((*sexpr == L'\\') || (*sexpr == L'\"')) {
1410                     addtobuf(buf, *sexpr);
1411                     sexpr++;
1412                 } else {
1413                     addtobuf(buf, L'\\');
1414                     addtobuf(buf, *sexpr);
1415                     sexpr++;
1416                 }
1417             } else {
1418                 addtobuf(buf, *(sexpr++));
1419             }
1420             break;
1421         case 2:
1422             if(*sexpr == L'\\')
1423             {
1424                 sexpr++;
1425                 if(*sexpr == L'\0')
1426                 {
1427                     addtobuf(buf, *sexpr);
1428                 } else if((*sexpr == L'\\') || (*sexpr == L'\"')) {
1429                     addtobuf(buf, *sexpr);
1430                     sexpr++;
1431                 } else {
1432                     addtobuf(buf, L'\\');
1433                     addtobuf(buf, *sexpr);
1434                     sexpr++;
1435                 }
1436             } else if(*sexpr == L'\"') {
1437                 state = 1;
1438                 sexpr++;
1439             } else {
1440                 addtobuf(buf, *(sexpr++));
1441             }
1442             break;
1443         }
1444     }
1445     if(buf != NULL)
1446     {
1447         addtobuf(buf, L'\0');
1448         addtobuf(ret, buf);
1449     }
1450     addtobuf(ret, NULL);
1451     return(ret);
1452 }
1453
1454 void dc_freewcsarr(wchar_t **arr)
1455 {
1456     wchar_t **buf;
1457
1458     if(arr == NULL)
1459         return;
1460     for(buf = arr; *buf != NULL; buf++)
1461         free(*buf);
1462     free(arr);
1463 }