daemon/ui.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 #define _GNU_SOURCE
  20 #include <unistd.h>
  21 #include <stdlib.h>
  22 #include <sys/socket.h>
  23 #include <netinet/in.h>
  24 #include <netinet/ip6.h>
  25 #include <arpa/inet.h>
  26 #include <sys/un.h>
  27 #include <errno.h>
  28 #include <string.h>
  29 #include <stdarg.h>
  30 #include <wchar.h>
  31 #include <wctype.h>
  32 #include <iconv.h>
  33 #include <pwd.h>
  34 #include <time.h>
  35 #include <fcntl.h>
  36 #include <signal.h>
  37
  38 #ifdef HAVE_CONFIG_H
  39 #include <config.h>
  40 #endif
  41 #include "conf.h"
  42 #include "auth.h"
  43 #include "utils.h"
  44 #include "net.h"
  45 #include "module.h"
  46 #include "sysevents.h"
  47 #include "filenet.h"
  48 #include "transfer.h"
  49 #include "search.h"
  50 #include "client.h"
  51
  52 #define PERM_DISALLOW 1
  53 #define PERM_ADMIN 2
  54 #define PERM_FNETCTL 4
  55 #define PERM_TRANS 8
  56 #define PERM_TRANSCU 16
  57 #define PERM_CHAT 32
  58 #define PERM_SRCH 64
  59
  60 #define NOTIF_END 0
  61 #define NOTIF_INT 1
  62 #define NOTIF_STR 2
  63 #define NOTIF_FLOAT 3
  64 #define NOTIF_ID 4
  65 #define NOTIF_OFF 5
  66 #define NOTIF_PEND 0
  67 #define NOTIF_WAIT 1
  68
  69 struct uidata;
  70
  71 struct command
  72 {
  73     wchar_t *name;
  74     void (*handler)(struct socket *sk, struct uidata *data, int argc, wchar_t **argv);
  75 };
  76
  77 struct qcommand
  78 {
  79     struct qcommand *next;
  80     struct command *cmd;
  81     int argc;
  82     wchar_t **argv;
  83 };
  84
  85 struct uiuser
  86 {
  87     struct uiuser *next, *prev;
  88     int used;
  89     wchar_t *name;
  90     unsigned long perms;
  91     int delete;
  92 };
  93
  94 struct notif
  95 {
  96     struct notif *next, *prev;
  97     struct uidata *ui;
  98     int state;
  99     int code;
 100     double rlimit;
 101     size_t argc;
 102     struct timer *exptimer;
 103     struct notifarg
 104     {
 105         int dt;
 106         union
 107         {
 108             int n;
 109             off_t o;
 110             wchar_t *s;
 111             double d;
 112         } d;
 113     } *argv;
 114 };
 115
 116 struct uidata
 117 {
 118     struct uidata *next, *prev;
 119     struct socket *sk;
 120     struct qcommand *queue, *queuelast;
 121     size_t queuesize;
 122     struct authhandle *auth;
 123     int close;
 124     union
 125     {
 126         struct
 127         {
 128             int fnact:1;
 129             int fnchat:1;
 130             int fnpeer:1;
 131             int tract:1;
 132             int trprog:1;
 133             int srch:1;
 134             int msg:1;
 135         } b;
 136         int w;
 137     } notify;
 138     wchar_t *username;
 139     struct uiuser *userinfo;
 140     int id;
 141     wchar_t *regname;
 142     uid_t uid;
 143     struct notif *fnotif, *lnotif;
 144     char *fcmdbuf;
 145     size_t fcmdbufdata, fcmdbufsize;
 146     pid_t fcmdpid;
 147     struct socket *fcmdsk;
 148     /* Read buffer */
 149     char *inbuf;
 150     size_t inbufsize, indata;
 151     /* Wordset storage */
 152     wchar_t **argv;
 153     size_t argc, args;
 154     /* WCS conversation stuff */
 155     wchar_t *cb; /* Conversation buffer */
 156     size_t cbsize, cbdata;
 157     iconv_t ichandle;
 158     /* Parser data */
 159     int ps; /* Parser state */
 160     wchar_t *pp; /* Current parse pointer */
 161     wchar_t *cw; /* Current word (building storage) */
 162     size_t cwsize, cwdata;
 163 };
 164
 165 static int srcheta(struct search *srch, void *uudata);
 166 static int srchcommit(struct search *srch, void *uudata);
 167 static int srchres(struct search *srch, struct srchres *sr, void *uudata);
 168 static struct notif *newnotif(struct uidata *data, int code, ...);
 169 static void notifappend(struct notif *notif, ...);
 170
 171 struct uiuser *users = NULL;
 172 struct uidata *actives = NULL;
 173 struct socket *tcpsocket = NULL;
 174 struct socket *unixsocket = NULL;
 175 static time_t starttime;
 176
 177 static wchar_t *quoteword(wchar_t *word)
 178 {
 179     wchar_t *wp, *buf, *bp;
 180     int dq, numbs, numc;
 181
 182     dq = 0;
 183     numbs = 0;
 184     numc = 0;
 185     if(*word == L'\0')
 186     {
 187         dq = 1;
 188     } else {
 189         for(wp = word; *wp != L'\0'; wp++)
 190         {
 191             if(!dq && iswspace(*wp))
 192                 dq = 1;
 193             if((*wp == L'\\') || (*wp == L'\"'))
 194                 numbs++;
 195             numc++;
 196         }
 197     }
 198     if(!dq && !numbs)
 199         return(NULL);
 200     bp = buf = smalloc(sizeof(wchar_t) * (numc + numbs + (dq?2:0) + 1));
 201     if(dq)
 202         *(bp++) = L'\"';
 203     for(wp = word; *wp != L'\0'; wp++)
 204     {
 205         if((*wp == L'\\') || (*wp == L'\"'))
 206             *(bp++) = L'\\';
 207         *(bp++) = *wp;
 208     }
 209     if(dq)
 210         *(bp++) = L'\"';
 211     *(bp++) = L'\0';
 212     return(buf);
 213 }
 214
 215 static void sq(struct socket *sk, int cont, ...)
 216 {
 217     int num, freepart;
 218     va_list al;
 219     char *final, *sarg;
 220     wchar_t *buf;
 221     wchar_t *part, *tpart;
 222     size_t bufsize, bufdata;
 223
 224     buf = NULL;
 225     bufsize = bufdata = 0;
 226     num = 0;
 227     va_start(al, cont);
 228     while((part = va_arg(al, wchar_t *)) != NULL)
 229     {
 230         freepart = 0;
 231         if(*part == L'%')
 232         {
 233             tpart = part + 1;
 234             if(!wcscmp(tpart, L"i"))
 235             {
 236                 freepart = 1;
 237                 part = swprintf2(L"%i", va_arg(al, int));
 238             } else if(!wcscmp(tpart, L"zi")) {
 239                 freepart = 1;
 240                 part = swprintf2(L"%zi", va_arg(al, size_t));
 241             } else if(!wcscmp(tpart, L"oi")) {
 242                 freepart = 1;
 243                 part = swprintf2(L"%ji", (intmax_t)va_arg(al, off_t));
 244             } else if(!wcscmp(tpart, L"s")) {
 245                 freepart = 1;
 246                 part = icmbstowcs(sarg = va_arg(al, char *), NULL);
 247                 if(part == NULL)
 248                 {
 249                     freepart = 0;
 250                     part = L"ERROR";
 251                     flog(LOG_ERR, "could not convert local string to wcs: %s", sarg);
 252                 }
 253             } else if(!wcscmp(tpart, L"ls")) {
 254                 part = va_arg(al, wchar_t *);
 255             } else if(!wcscmp(tpart, L"ll")) {
 256                 freepart = 1;
 257                 part = swprintf2(L"%lli", va_arg(al, long long));
 258             } else if(!wcscmp(tpart, L"f")) {
 259                 freepart = 1;
 260                 part = swprintf2(L"%f", va_arg(al, double));
 261             } else if(!wcscmp(tpart, L"x")) {
 262                 freepart = 1;
 263                 part = swprintf2(L"%x", va_arg(al, int));
 264             } else {
 265                 flog(LOG_CRIT, "BUG: unknown type code in sq: %ls", tpart);
 266                 abort();
 267             }
 268         }
 269         if((tpart = quoteword(part)) != NULL)
 270         {
 271             if(freepart)
 272                 free(part);
 273             part = tpart;
 274             freepart = 1;
 275         }
 276         if((num > 1) || ((num == 1) && !(cont & 1)))
 277             addtobuf(buf, L' ');
 278         bufcat(buf, part, wcslen(part));
 279         if((num == 0) && (cont & 1))
 280             addtobuf(buf, L'-');
 281         num++;
 282         if(freepart)
 283             free(part);
 284     }
 285     if(cont & 2)
 286         bufcat(buf, L" \0", 2);
 287     else
 288         bufcat(buf, L"\r\n\0", 3);
 289     if((final = icwcstombs(buf, "utf-8")) == NULL)
 290     {
 291         flog(LOG_CRIT, "could not convert \"%ls\" into utf-8: %s", buf, strerror(errno));
 292         free(buf);
 293         return;
 294     }
 295     va_end(al);
 296     free(buf);
 297     sockqueue(sk, final, strlen(final));
 298     free(final);
 299 }
 300
 301 struct uiuser *finduser(wchar_t *name)
 302 {
 303     struct uiuser *user;
 304
 305     for(user = users; user != NULL; user = user->next)
 306     {
 307         if(!wcscmp(user->name, name))
 308             break;
 309     }
 310     return(user);
 311 }
 312
 313 static void logout(struct uidata *data)
 314 {
 315     data->userinfo = NULL;
 316     if(data->username != NULL)
 317         free(data->username);
 318     data->username = NULL;
 319     if(data->auth != NULL)
 320         authputhandle(data->auth);
 321     data->auth = NULL;
 322 }
 323
 324 static int haspriv(struct uidata *data, int perm)
 325 {
 326     if(data->userinfo == NULL)
 327         return(0);
 328     if(data->userinfo->perms & perm)
 329         return(1);
 330     else
 331         return(0);
 332 }
 333
 334 /* Useful macros for the command functions: */
 335 #define haveargs(n) do { if(argc < n) { sq(sk, 0, L"501", L"Wrong number of arguments", NULL); return; } } while(0)
 336 #define havepriv(p) do { if((data->userinfo == NULL) || ((data->userinfo->perms & (p)) != (p))) { sq(sk, 0, L"502", L"Unauthorized request", L"needed", L"%x", (p), NULL); return; } } while(0)
 337
 338 static void cmd_connect(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 339 {
 340     int valid;
 341     struct in6_addr mv4lo;
 342
 343     if(confgetint("ui", "onlylocal"))
 344     {
 345         switch(sk->remote->sa_family)
 346         {
 347         case AF_INET:
 348             valid = ((struct sockaddr_in *)sk->remote)->sin_addr.s_addr == INADDR_LOOPBACK;
 349             break;
 350         case AF_INET6:
 351             inet_pton(AF_INET6, "::ffff:127.0.0.1", &mv4lo);
 352             valid = 0;
 353             if(!memcmp(&((struct sockaddr_in6 *)sk->remote)->sin6_addr, &in6addr_loopback, sizeof(in6addr_loopback)))
 354                 valid = 1;
 355             if(!memcmp(&((struct sockaddr_in6 *)sk->remote)->sin6_addr, &mv4lo, sizeof(in6addr_loopback)))
 356                 valid = 1;
 357             break;
 358         case AF_UNIX:
 359             valid = 1;
 360             break;
 361         default:
 362             valid = 0;
 363             break;
 364         }
 365         if(!valid)
 366         {
 367             sq(sk, 0, L"502", L"Only localhost connections allowed to this host", NULL);
 368             sk->close = 1;
 369             data->close = 1;
 370             return;
 371         }
 372     }
 373     sq(sk, 0, L"201", L"1", L"3", L"Dolda Connect daemon v" VERSION, NULL);
 374 }
 375
 376 static void cmd_notfound(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 377 {
 378     if((argv != NULL) && (argv[0] != NULL))
 379         sq(sk, 0, L"500", L"Command not found", NULL);
 380     else
 381         sq(sk, 0, L"500", L"No command", NULL);
 382 }
 383
 384 static void cmd_shutdown(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 385 {
 386     extern volatile int running;
 387
 388     havepriv(PERM_ADMIN);
 389     flog(LOG_NOTICE, "UI shutdown request from %ls, shutting down", data->username);
 390     running = 0;
 391     sq(sk, 0, L"200", L"Daemon shutting down", NULL);
 392 }
 393
 394 static void cmd_quit(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 395 {
 396     sq(sk, 0, L"200", L"Closing connection", NULL);
 397     data->close = 1;
 398 }
 399
 400 static void cmd_lsauth(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 401 {
 402     struct authmech *mech, *prev;
 403
 404     prev = NULL;
 405     for(mech = mechs; mech != NULL; mech = mech->next)
 406     {
 407         if(mech->enabled && authavailable(mech, sk))
 408         {
 409             if(prev != NULL)
 410                 sq(sk, 1, L"200", prev->name, NULL);
 411             prev = mech;
 412         }
 413     }
 414     if(prev == NULL)
 415         sq(sk, 0, L"201", L"No authentication methods supported", NULL);
 416     else
 417         sq(sk, 0, L"200", prev->name, NULL);
 418 }
 419
 420 static void cmd_login(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 421 {
 422     char *buf;
 423     int code;
 424     struct passwd *pwd;
 425
 426     haveargs(3);
 427     if(data->username != NULL)
 428     {
 429         if(data->userinfo != NULL)
 430             sq(sk, 0, L"503", L"Already logged in", NULL);
 431         else
 432             sq(sk, 0, L"503", L"Already logging in", NULL);
 433         return;
 434     }
 435     if((buf = icwcstombs(argv[2], NULL)) == NULL)
 436     {
 437         sq(sk, 0, L"504", L"Could not convert username to locale charset", NULL);
 438         return;
 439     }
 440     data->username = swcsdup(argv[2]);
 441     if((pwd = getpwnam(buf)) == NULL)
 442         data->uid = -1;
 443     else
 444         data->uid = pwd->pw_uid;
 445     if((data->auth = initauth(argv[1], buf)) == NULL)
 446     {
 447         if(errno == ENOENT)
 448             sq(sk, 0, L"508", L"No such authentication mechanism", NULL);
 449         else
 450             sq(sk, 0, L"505", L"Could not initialize authentication system", L"%s", strerror(errno), NULL);
 451         free(buf);
 452         logout(data);
 453         return;
 454     }
 455     free(buf);
 456     switch(authenticate(data->auth, sk, NULL))
 457     {
 458     case AUTH_SUCCESS:
 459         data->userinfo = finduser(data->username);
 460         if(data->userinfo == NULL)
 461             data->userinfo = finduser(L"default");
 462         if(data->uid == -1)
 463         {
 464             sq(sk, 0, L"506", L"Authentication error", NULL);
 465             flog(LOG_INFO, "user %ls authenticated successfully from %s, but no account existed", data->username, formataddress(sk->remote, sk->remotelen));
 466             logout(data);
 467         } else if((data->userinfo == NULL) || (data->userinfo->perms & PERM_DISALLOW)) {
 468             sq(sk, 0, L"506", L"Authentication error", NULL);
 469             flog(LOG_INFO, "user %ls authenticated successfully from %s, but was not authorized", data->username, formataddress(sk->remote, sk->remotelen));
 470             logout(data);
 471         } else {
 472             sq(sk, 0, L"200", L"Welcome", NULL);
 473             flog(LOG_INFO, "%ls (UID %i) logged in from %s", data->username, data->uid, formataddress(sk->remote, sk->remotelen));
 474         }
 475         break;
 476     case AUTH_DENIED:
 477         sq(sk, 0, L"506", L"Authentication error", L"%ls", (data->auth->text == NULL)?L"":(data->auth->text), NULL);
 478         flog(LOG_INFO, "authentication failed for %ls from %s", data->username, formataddress(sk->remote, sk->remotelen));
 479         logout(data);
 480         break;
 481     case AUTH_PASS:
 482         switch(data->auth->prompt)
 483         {
 484         case AUTH_PR_AUTO:
 485             code = 300;
 486             break;
 487         case AUTH_PR_NOECHO:
 488             code = 301;
 489             break;
 490         case AUTH_PR_ECHO:
 491             code = 302;
 492             break;
 493         case AUTH_PR_INFO:
 494             code = 303;
 495             break;
 496         case AUTH_PR_ERROR:
 497             code = 304;
 498             break;
 499         }
 500         sq(sk, 0, L"%i", code, data->auth->text, NULL);
 501         break;
 502     case AUTH_ERR:
 503         sq(sk, 0, L"505", L"System error", L"%s", strerror(errno), NULL);
 504         logout(data);
 505         break;
 506     default:
 507         flog(LOG_WARNING, "BUG? Non-caught return from authenticate in cmd_login");
 508         sq(sk, 0, L"505", L"System error", L"%s", strerror(errno), NULL);
 509         logout(data);
 510         break;
 511     }
 512 }
 513
 514 static void cmd_pass(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 515 {
 516     char *buf;
 517     int code;
 518
 519     haveargs(2);
 520     if((buf = icwcstombs(argv[1], NULL)) == NULL)
 521     {
 522         sq(sk, 0, L"504", L"Could not convert data to locale charset", NULL);
 523         return;
 524     }
 525     if((data->auth == NULL) || (data->userinfo != NULL))
 526     {
 527         sq(sk, 0, L"507", L"Data not expected", NULL);
 528         return;
 529     }
 530     switch(authenticate(data->auth, sk, buf))
 531     {
 532     case AUTH_SUCCESS:
 533         data->userinfo = finduser(data->username);
 534         if(data->userinfo == NULL)
 535             data->userinfo = finduser(L"default");
 536         if(data->uid == -1)
 537         {
 538             sq(sk, 0, L"506", L"Authentication error", NULL);
 539             flog(LOG_INFO, "user %ls authenticated successfully from %s, but no account existed", data->username, formataddress(sk->remote, sk->remotelen));
 540             logout(data);
 541         } else if((data->userinfo == NULL) || (data->userinfo->perms & PERM_DISALLOW)) {
 542             sq(sk, 0, L"506", L"Authentication error", NULL);
 543             flog(LOG_INFO, "user %ls authenticated successfully from %s, but was not authorized", data->username, formataddress(sk->remote, sk->remotelen));
 544             logout(data);
 545         } else {
 546             sq(sk, 0, L"200", L"Welcome", NULL);
 547             flog(LOG_INFO, "%ls (UID %i) logged in from %s", data->username, data->uid, formataddress(sk->remote, sk->remotelen));
 548         }
 549         break;
 550     case AUTH_DENIED:
 551         sq(sk, 0, L"506", L"Authentication error", L"%ls", (data->auth->text == NULL)?L"":(data->auth->text), NULL);
 552         flog(LOG_INFO, "authentication failed for %ls from %s", data->username, formataddress(sk->remote, sk->remotelen));
 553         logout(data);
 554         break;
 555     case AUTH_PASS:
 556         switch(data->auth->prompt)
 557         {
 558         case AUTH_PR_AUTO:
 559             code = 300;
 560             break;
 561         case AUTH_PR_NOECHO:
 562             code = 301;
 563             break;
 564         case AUTH_PR_ECHO:
 565             code = 302;
 566             break;
 567         case AUTH_PR_INFO:
 568             code = 303;
 569             break;
 570         case AUTH_PR_ERROR:
 571             code = 304;
 572             break;
 573         }
 574         sq(sk, 0, L"%i", code, data->auth->text, NULL);
 575         break;
 576     case AUTH_ERR:
 577         sq(sk, 0, L"505", L"System error", L"%s", strerror(errno), NULL);
 578         logout(data);
 579         break;
 580     default:
 581         flog(LOG_WARNING, "BUG? Non-caught return from authenticate in cmd_pass");
 582         sq(sk, 0, L"505", L"System error", L"%s", strerror(errno), NULL);
 583         logout(data);
 584         break;
 585     }
 586     free(buf);
 587 }
 588
 589 static void cmd_fnetconnect(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 590 {
 591     int i;
 592     char *buf;
 593     int err;
 594     struct fnetnode *fn;
 595     struct wcspair *args;
 596
 597     haveargs(3);
 598     havepriv(PERM_FNETCTL);
 599     for(i = 0, fn = fnetnodes; fn != NULL; i++, fn = fn->next);
 600     if((confgetint("fnet", "maxnodes") > 0) && (i >= confgetint("fnet", "maxnodes"))) {
 601         sq(sk, 0, L"515", L"Too many fnetnodes connected already", NULL);
 602         return;
 603     }
 604     if((buf = icwcstombs(argv[2], NULL)) == NULL)
 605     {
 606         sq(sk, 0, L"504", L"Could not convert data to locale charset", NULL);
 607         return;
 608     }
 609     args = NULL;
 610     for(i = 3; i < argc - 1; i += 2)
 611         newwcspair(argv[i], argv[i + 1], &args);
 612     fn = fnetinitconnect(argv[1], data->userinfo->name, buf, args);
 613     err = errno;
 614     free(buf);
 615     if(fn == NULL)
 616     {
 617         if(errno == EPROTONOSUPPORT)
 618             sq(sk, 0, L"511", L"No such network name", NULL);
 619         else
 620             sq(sk, 0, L"509", L"Could not parse the address", L"%s", strerror(err), NULL);
 621         return;
 622     }
 623     linkfnetnode(fn);
 624     fnetsetname(fn, argv[2]);
 625     sq(sk, 0, L"200", L"%i", fn->id, L"Connection under way", NULL);
 626     putfnetnode(fn);
 627 }
 628
 629 static void cmd_lsnodes(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 630 {
 631     struct fnetnode *fn;
 632
 633     if(fnetnodes == NULL)
 634     {
 635         sq(sk, 0, L"201", L"No connected nodes", NULL);
 636         return;
 637     }
 638     for(fn = fnetnodes; fn != NULL; fn = fn->next)
 639     {
 640         sq(sk, (fn->next != NULL)?1:0, L"200", L"%i", fn->id, fn->fnet->name, (fn->name == NULL)?L"":fn->name, L"%i", fn->numpeers, L"%i", fn->state, L"%ls", fn->pubid, NULL);
 641     }
 642 }
 643
 644 static void cmd_disconnect(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 645 {
 646     struct fnetnode *fn;
 647     int i;
 648
 649     haveargs(2);
 650     havepriv(PERM_FNETCTL);
 651     /* Note - Programmatical user interfaces must only give one
 652      * argument per command, the multiple argument form is only for
 653      * convenience when manually controlling the daemon via
 654      * eg. telnet. The reason is that the return codes aren't clear
 655      * enough for the multiple argument form. */
 656     for(i = 1; i < argc; i++)
 657     {
 658         if((fn = findfnetnode(wcstol(argv[i], NULL, 0))) == NULL)
 659         {
 660             sq(sk, 0, L"510", L"No such node", NULL);
 661             return;
 662         }
 663         if(wpfind(fn->args, L"locked") && !((data->userinfo->perms & PERM_ADMIN) || !wcscmp(data->userinfo->name, fn->owner)))
 664         {
 665             sq(sk, 0, L"502", L"This node is locked and you are neither administrator nor its owner", NULL);
 666             return;
 667         }
 668         killfnetnode(fn);
 669         unlinkfnetnode(fn);
 670     }
 671     sq(sk, 0, L"200", L"Node flagged for disconnection", NULL);
 672 }
 673
 674 static void cmd_lspa(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 675 {
 676     struct fnetnode *fn;
 677     struct fnetpeerdatum *datum;
 678
 679     haveargs(2);
 680     if((fn = findfnetnode(wcstol(argv[1], NULL, 0))) == NULL)
 681     {
 682         sq(sk, 0, L"510", L"No such node", NULL);
 683         return;
 684     }
 685     if(fn->peerdata == NULL)
 686     {
 687         sq(sk, 0, L"201", L"No data available", NULL);
 688     } else {
 689         for(datum = fn->peerdata; datum != NULL; datum = datum->next)
 690             sq(sk, (datum->next != NULL)?1:0, L"200", datum->id, L"%i", datum->datatype, NULL);
 691     }
 692 }
 693
 694 static void cmd_lspeers(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 695 {
 696     int i;
 697     struct fnetnode *fn;
 698     struct fnetpeer *peer, *npeer;
 699
 700     haveargs(2);
 701     if((fn = findfnetnode(wcstol(argv[1], NULL, 0))) == NULL)
 702     {
 703         sq(sk, 0, L"510", L"No such node", NULL);
 704         return;
 705     }
 706     if(fn->peers == NULL)
 707     {
 708         sq(sk, 0, L"201", L"No peers available", NULL);
 709     } else {
 710         for(peer = btreeiter(fn->peers); peer != NULL; peer = npeer)
 711         {
 712             npeer = btreeiter(NULL);
 713             sq(sk, 2 | ((npeer != NULL)?1:0), L"200", L"%ls", peer->id, L"%ls", peer->nick, NULL);
 714             for(i = 0; i < peer->dinum; i++)
 715             {
 716                 if(peer->peerdi[i].datum->datatype == FNPD_INT)
 717                     sq(sk, 2, peer->peerdi[i].datum->id, L"%i", peer->peerdi[i].data.num, NULL);
 718                 if(peer->peerdi[i].datum->datatype == FNPD_LL)
 719                     sq(sk, 2, peer->peerdi[i].datum->id, L"%ll", peer->peerdi[i].data.lnum, NULL);
 720                 if((peer->peerdi[i].datum->datatype == FNPD_STR) && (peer->peerdi[i].data.str != NULL))
 721                     sq(sk, 2, peer->peerdi[i].datum->id, L"%ls", peer->peerdi[i].data.str, NULL);
 722             }
 723             sq(sk, 0, NULL);
 724         }
 725     }
 726 }
 727
 728 static void cmd_download(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 729 {
 730     int i;
 731     struct fnet *net;
 732     struct fnetnode *fn;
 733     struct transfer *transfer;
 734     struct fnetpeer *peer;
 735
 736     haveargs(4);
 737     if((argc > 5) && ((argc % 2) == 0))
 738     {
 739         sq(sk, 0, L"501", L"Must have an even number of arguments", NULL);
 740         return;
 741     }
 742     havepriv(PERM_TRANS);
 743     if((*(argv[1]) >= L'0') && (*(argv[1]) <= L'9'))
 744     {
 745         if((fn = findfnetnode(wcstol(argv[1], NULL, 0))) == NULL)
 746         {
 747             sq(sk, 0, L"510", L"No such node", NULL);
 748             return;
 749         }
 750         net = fn->fnet;
 751     } else {
 752         fn = NULL;
 753         if((net = findfnet(argv[1])) == NULL)
 754         {
 755             sq(sk, 0, L"511", L"No such network name", NULL);
 756             return;
 757         }
 758     }
 759     transfer = newtransfer();
 760     authgethandle(transfer->auth = data->auth);
 761     transfer->fnet = net;
 762     transfer->peerid = swcsdup(argv[2]);
 763     transfer->path = swcsdup(argv[3]);
 764     transfer->dir = TRNSD_DOWN;
 765     transfer->owner = data->uid;
 766     if(fn != NULL)
 767     {
 768         transfer->fn = fn;
 769         getfnetnode(fn);
 770         linktransfer(transfer);
 771         if(((peer = fnetfindpeer(fn, transfer->peerid)) != NULL) && (peer->nick != NULL))
 772             transfersetnick(transfer, peer->nick);
 773     } else {
 774         linktransfer(transfer);
 775     }
 776     if(argc > 4)
 777         transfersetsize(transfer, wcstoll(argv[4], NULL, 0));
 778     if(argc > 5)
 779     {
 780         for(i = 5; i < argc; i += 2)
 781         {
 782             if(!wcscmp(argv[i], L"hash"))
 783             {
 784                 transfersethash(transfer, parsehash(argv[i + 1]));
 785             } else {
 786                 newwcspair(argv[i], argv[i + 1], &transfer->args);
 787             }
 788         }
 789     }
 790     sq(sk, 0, L"200", L"%i", transfer->id, L"Download queued", NULL);
 791     transfersetactivity(transfer, L"create");
 792 }
 793
 794 static void cmd_lstrans(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 795 {
 796     struct transfer *transfer, *pt;
 797
 798     havepriv(PERM_TRANS);
 799     pt = NULL;
 800     for(transfer = transfers; transfer != NULL; transfer = transfer->next)
 801     {
 802         if((transfer->dir != TRNSD_DOWN) || (transfer->owner == data->uid))
 803         {
 804             if(pt != NULL)
 805                 sq(sk, 1, L"200", L"%i", pt->id, L"%i", pt->dir,
 806                    L"%i", pt->state, pt->peerid,
 807                    (pt->peernick == NULL)?L"":(pt->peernick),
 808                    (pt->path == NULL)?L"":(pt->path),
 809                    L"%oi", pt->size, L"%oi", pt->curpos,
 810                    (pt->hash == NULL)?L"":unparsehash(pt->hash),
 811                    NULL);
 812             pt = transfer;
 813         }
 814     }
 815     if(pt == NULL)
 816         sq(sk, 0, L"201", L"No transfers", NULL);
 817     else
 818         sq(sk, 0, L"200", L"%i", pt->id, L"%i", pt->dir,
 819            L"%i", pt->state, pt->peerid,
 820            (pt->peernick == NULL)?L"":(pt->peernick),
 821            (pt->path == NULL)?L"":(pt->path),
 822            L"%oi", pt->size, L"%oi", pt->curpos,
 823            (pt->hash == NULL)?L"":unparsehash(pt->hash),
 824            NULL);
 825 }
 826
 827 static void cmd_cancel(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 828 {
 829     struct transfer *transfer;
 830
 831     haveargs(2);
 832     havepriv(PERM_TRANS);
 833     if((transfer = findtransfer(wcstol(argv[1], NULL, 0))) == NULL)
 834     {
 835         sq(sk, 0, L"512", L"No such transfer", NULL);
 836         return;
 837     }
 838     if((transfer->dir == TRNSD_UP) && !(data->userinfo->perms & PERM_TRANSCU))
 839     {
 840         sq(sk, 0, L"502", L"You are not allowed to cancel uploads", NULL);
 841         return;
 842     }
 843     if((transfer->dir == TRNSD_DOWN) && (transfer->owner != data->uid))
 844     {
 845         sq(sk, 0, L"502", L"You do not own that transfer", NULL);
 846         return;
 847     }
 848     transfer->close = 1;
 849     sq(sk, 0, L"200", L"Transfer cancelled", NULL);
 850 }
 851
 852 static void cmd_reset(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 853 {
 854     struct transfer *transfer;
 855
 856     haveargs(2);
 857     havepriv(PERM_TRANS);
 858     if((transfer = findtransfer(wcstol(argv[1], NULL, 0))) == NULL)
 859     {
 860         sq(sk, 0, L"512", L"No such transfer", NULL);
 861         return;
 862     }
 863     if(transfer->dir == TRNSD_UP)
 864     {
 865         sq(sk, 0, L"512", L"Only applicable to downloads", NULL);
 866         return;
 867     }
 868     resettransfer(transfer);
 869     sq(sk, 0, L"200", L"Transfer reset", NULL);
 870 }
 871
 872 static void cmd_notify(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 873 {
 874     int i, val;
 875
 876     if((argc % 2) != 1)
 877     {
 878         sq(sk, 0, L"501", L"Must have an even number of arguments", NULL);
 879         return;
 880     }
 881     for(i = 1; i < argc; i += 2)
 882     {
 883         if(!wcscasecmp(argv[i + 1], L"on"))
 884             val = 1;
 885         else
 886             val = 0;
 887         if(!wcscasecmp(argv[i], L"all"))
 888         {
 889             if(val)
 890                 data->notify.w = ~0;
 891             else
 892                 data->notify.w = 0;
 893         } else if(!wcscasecmp(argv[i], L"fn:chat")) {
 894             data->notify.b.fnchat = val;
 895         } else if(!wcscasecmp(argv[i], L"fn:act")) {
 896             data->notify.b.fnact = val;
 897         } else if(!wcscasecmp(argv[i], L"fn:peer")) {
 898             data->notify.b.fnpeer = val;
 899         } else if(!wcscasecmp(argv[i], L"trans:act")) {
 900             data->notify.b.tract = val;
 901         } else if(!wcscasecmp(argv[i], L"trans:prog")) {
 902             data->notify.b.trprog = val;
 903         } else if(!wcscasecmp(argv[i], L"srch:act")) {
 904             data->notify.b.srch = val;
 905         } else if(!wcscasecmp(argv[i], L"msg")) {
 906             data->notify.b.msg = val;
 907         }
 908     }
 909     sq(sk, 0, L"200", L"Notification alteration succeeded", NULL);
 910 }
 911
 912 static void cmd_sendchat(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 913 {
 914     struct fnetnode *fn;
 915     int public;
 916
 917     haveargs(5);
 918     havepriv(PERM_CHAT);
 919     if((fn = findfnetnode(wcstol(argv[1], NULL, 0))) == NULL)
 920     {
 921         sq(sk, 0, L"510", L"No such node", NULL);
 922         return;
 923     }
 924     public = wcstol(argv[2], NULL, 0);
 925     if((public != 0) && (public != 1))
 926     {
 927         sq(sk, 0, L"509", L"Second argument must be 0 or 1", NULL);
 928         return;
 929     }
 930     if(fn->state != FNN_EST)
 931     {
 932         sq(sk, 0, L"513", L"Hub is in state FNN_EST", NULL);
 933         return;
 934     }
 935     if(fnetsendchat(fn, public, argv[3], argv[4]))
 936     {
 937         if(errno == ENOTSUP)
 938             sq(sk, 0, L"513", L"This network does not support chatting", NULL);
 939         else if(errno == EPERM)
 940             sq(sk, 0, L"502", L"This node does not allow you to chat", NULL);
 941         else if(errno == EILSEQ)
 942             sq(sk, 0, L"504", L"This network could not support all the characters in that message", NULL);
 943         else
 944             sq(sk, 0, L"505", L"Could not chat", NULL);
 945         return;
 946     }
 947     sq(sk, 0, L"200", L"Chat string sent", NULL);
 948 }
 949
 950 static void cmd_search(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
 951 {
 952     struct search *srch;
 953     struct fnetnode *fn;
 954     struct sexpr *sexpr;
 955     int i;
 956
 957     haveargs(3);
 958     havepriv(PERM_SRCH);
 959     srch = newsearch(data->username, NULL);
 960     for(i = 1; i < argc; i++)
 961     {
 962         if(!wcscmp(argv[i], L"all"))
 963         {
 964             for(fn = fnetnodes; fn != NULL; fn = fn->next)
 965             {
 966                 if(fn->state == FNN_EST)
 967                     searchaddfn(srch, fn);
 968             }
 969             i++;
 970             break;
 971         } else if(!wcscmp(argv[i], L"prio")) {
 972             if(++i == argc)
 973             {
 974                 sq(sk, 0, L"501", L"No argument to prio", NULL);
 975                 freesearch(srch);
 976                 return;
 977             }
 978             srch->prio = wcstol(argv[i], NULL, 0);
 979         } else if(iswdigit(*argv[i])) {
 980             if((fn = findfnetnode(wcstol(argv[i], NULL, 0))) == NULL)
 981             {
 982                 sq(sk, 0, L"510", L"No such node", NULL);
 983                 freesearch(srch);
 984                 return;
 985             }
 986             searchaddfn(srch, fn);
 987         } else {
 988             break;
 989         }
 990     }
 991     if(srch->fnl == NULL)
 992     {
 993         sq(sk, 0, L"501", L"No fnetnodes to search found on line", NULL);
 994         freesearch(srch);
 995         return;
 996     }
 997     if(i == argc)
 998     {
 999         sq(sk, 0, L"501", L"No search expression found on line", NULL);
1000         freesearch(srch);
1001         return;
1002     }
1003     if((sexpr = parsesexpr(argc - i, argv + i)) == NULL)
1004     {
1005         sq(sk, 0, L"509", L"Could not parse search expression", NULL);
1006         freesearch(srch);
1007         return;
1008     }
1009     optsexpr(sexpr);
1010     getsexpr(srch->sexpr = sexpr);
1011     queuesearch(srch);
1012     CBREG(srch, search_eta, srcheta, NULL, NULL);
1013     CBREG(srch, search_commit, srchcommit, NULL, NULL);
1014     CBREG(srch, search_result, srchres, NULL, NULL);
1015     sq(sk, 0, L"200", L"%i", srch->id, L"%i", srch->eta - time(NULL), NULL);
1016     putsexpr(sexpr);
1017 }
1018
1019 static void cmd_lssrch(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
1020 {
1021     struct search *srch, *pt;
1022     time_t now;
1023
1024     havepriv(PERM_SRCH);
1025     pt = NULL;
1026     now = time(NULL);
1027     for(srch = searches; srch != NULL; srch = srch->next)
1028     {
1029         if(!wcscmp(srch->owner, data->username))
1030         {
1031             if(pt != NULL)
1032                 sq(sk, 1, L"200", L"%i", pt->id, L"%i", pt->state, L"%i", pt->eta - now, L"%i", pt->numres, NULL);
1033             pt = srch;
1034         }
1035     }
1036     if(pt == NULL)
1037         sq(sk, 0, L"201", L"No searches", NULL);
1038     else
1039         sq(sk, 0, L"200", L"%i", pt->id, L"%i", pt->state, L"%i", pt->eta - now, L"%i", pt->numres, NULL);
1040 }
1041
1042 static void cmd_lssr(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
1043 {
1044     struct search *srch;
1045     struct srchres *sr;
1046
1047     haveargs(2);
1048     havepriv(PERM_SRCH);
1049     if((srch = findsearch(wcstol(argv[1], NULL, 0))) == NULL)
1050     {
1051         sq(sk, 0, L"514", L"No such search", NULL);
1052         return;
1053     }
1054     if(srch->results == NULL)
1055     {
1056         sq(sk, 0, L"201", L"No results", NULL);
1057     } else {
1058         for(sr = srch->results; sr != NULL; sr = sr->next)
1059         {
1060             sq(sk, (sr->next != NULL)?1:0, L"200", L"%ls", sr->filename,
1061                sr->fnet->name, L"%ls", sr->peerid, L"%oi", sr->size,
1062                L"%i", sr->slots, L"%i", (sr->fn == NULL)?-1:(sr->fn->id),
1063                L"%f", sr->time,
1064                L"%ls", (sr->hash == NULL)?L"":unparsehash(sr->hash), NULL);
1065         }
1066     }
1067 }
1068
1069 static void cmd_cansrch(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
1070 {
1071     struct search *srch;
1072     int i;
1073
1074     haveargs(2);
1075     havepriv(PERM_SRCH);
1076     /* Note - Programmatical user interfaces must only give one
1077      * argument per command, the multiple argument form is only for
1078      * convenience when manually controlling the daemon via
1079      * eg. telnet. The reason is that the return codes aren't clear
1080      * enough for the multiple argument form. */
1081     for(i = 1; i < argc; i++)
1082     {
1083         if((srch = findsearch(wcstol(argv[i], NULL, 0))) == NULL)
1084         {
1085             sq(sk, 0, L"514", L"No such search", NULL);
1086             return;
1087         }
1088         freesearch(srch);
1089     }
1090     sq(sk, 0, L"200", L"Search cancelled", NULL);
1091 }
1092
1093 static void fcmdread(struct socket *sk, struct uidata *data)
1094 {
1095     char *buf;
1096     size_t bufsize;
1097
1098     if((buf = sockgetinbuf(sk, &bufsize)) == NULL)
1099         return;
1100     bufcat(data->fcmdbuf, buf, bufsize);
1101     free(buf);
1102 }
1103
1104 static void fcmderr(struct socket *sk, int err, struct uidata *data)
1105 {
1106     wchar_t *wbuf, *p, *p2;
1107
1108     if(err)
1109     {
1110         flog(LOG_WARNING, "error occurred on filtercmd pipe socket: %s", strerror(err));
1111         kill(-data->fcmdpid, SIGHUP);
1112         putsock(data->fcmdsk);
1113         data->fcmdsk = NULL;
1114         if(data->fcmdbuf != NULL)
1115         {
1116             free(data->fcmdbuf);
1117             data->fcmdbuf = NULL;
1118         }
1119         data->fcmdbufsize = data->fcmdbufdata = 0;
1120         sq(data->sk, 0, L"505", L"An error occurred on the pipe to the filtercmd", L"%s", strerror(err), NULL);
1121         return;
1122     }
1123     putsock(data->fcmdsk);
1124     data->fcmdsk = NULL;
1125     data->fcmdpid = 0;
1126     if(data->fcmdbuf == NULL)
1127     {
1128         wbuf = swcsdup(L"");
1129     } else {
1130         addtobuf(data->fcmdbuf, 0);
1131         wbuf = icmbstowcs(data->fcmdbuf, NULL);
1132         free(data->fcmdbuf);
1133     }
1134     data->fcmdbuf = NULL;
1135     data->fcmdbufsize = data->fcmdbufdata = 0;
1136     if(wbuf == NULL)
1137     {
1138         sq(data->sk, 0, L"504", L"Filtercmd sent data which could not be converted from the local charset", NULL);
1139         return;
1140     }
1141     p = wbuf;
1142     for(p2 = wcschr(p, L'\n'); p2 != NULL; p2 = wcschr(p, L'\n'))
1143     {
1144         *(p2++) = L'\0';
1145         sq(data->sk, (*p2 == L'\0')?0:1, L"200", L"%ls", p, NULL);
1146         p = p2;
1147     }
1148     if(*p == L'\0')
1149     {
1150         if(p == wbuf)
1151             sq(data->sk, 0, L"201", L"No data returned", NULL);
1152     } else {
1153         sq(data->sk, 0, L"200", L"%ls", p, NULL);
1154     }
1155     free(wbuf);
1156 }
1157
1158 static void cmd_filtercmd(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
1159 {
1160     int i;
1161     pid_t pid;
1162     int pipe;
1163     char **cargv, **pp;
1164     char *filtercmd, *argbuf;
1165     size_t cargvsize, cargvdata;
1166     struct passwd *pwent;
1167
1168     haveargs(2);
1169     havepriv(PERM_TRANS);
1170     if((pwent = getpwuid(data->uid)) == NULL)
1171     {
1172         flog(LOG_WARNING, "no passwd entry for UI user %i", data->uid);
1173         sq(sk, 0, L"505", L"System error - Could not fork session", "Internal error", NULL);
1174         return;
1175     }
1176     filtercmd = findfile("dc-filtercmd", pwent->pw_dir, 0);
1177     if(filtercmd == NULL)
1178         filtercmd = findfile(icswcstombs(confgetstr("ui", "filtercmd"), NULL, NULL), NULL, 0);
1179     if(filtercmd == NULL)
1180     {
1181         flog(LOG_WARNING, "could not find filtercmd executable for user %s", pwent->pw_name);
1182         sq(sk, 0, L"505", L"System error - Could not fork session", L"Could not find filtercmd executable", NULL);
1183         return;
1184     }
1185     cargv = NULL;
1186     cargvsize = cargvdata = 0;
1187     addtobuf(cargv, filtercmd);
1188     for(i = 1; i < argc; i++)
1189     {
1190         if((argbuf = icwcstombs(argv[i], NULL)) == NULL)
1191         {
1192             for(i = 0; i < cargvdata; i++)
1193                 free(cargv[i]);
1194             free(cargv);
1195             sq(sk, 0, L"504", L"Could not convert argument into local character set", L"%i", i, L"%s", strerror(errno), NULL);
1196             return;
1197         }
1198         addtobuf(cargv, argbuf);
1199     }
1200     addtobuf(cargv, NULL);
1201     if((pid = forksess(data->uid, data->auth, NULL, NULL, FD_FILE, 0, O_RDWR, "/dev/null", FD_PIPE, 1, O_RDONLY, &pipe, FD_FILE, 2, O_RDWR, "/dev/null", FD_END)) < 0)
1202     {
1203         flog(LOG_WARNING, "could not fork session in filtercmd: %s", strerror(errno));
1204         sq(sk, 0, L"505", L"System error - Could not fork session", L"%s", strerror(errno), NULL);
1205         return;
1206     }
1207     if(pid == 0)
1208     {
1209         execv(filtercmd, cargv);
1210         flog(LOG_WARNING, "could not exec filtercmd %s: %s", filtercmd, strerror(errno));
1211         exit(127);
1212     }
1213     for(pp = cargv; *pp; pp++)
1214         free(*pp);
1215     free(cargv);
1216     data->fcmdsk = wrapsock(pipe);
1217     data->fcmdpid = pid;
1218     if(data->fcmdbuf != NULL)
1219     {
1220         free(data->fcmdbuf);
1221         data->fcmdbuf = NULL;
1222     }
1223     data->fcmdbufsize = data->fcmdbufdata = 0;
1224     data->fcmdsk->data = data;
1225     data->fcmdsk->readcb = (void (*)(struct socket *, void *))fcmdread;
1226     data->fcmdsk->errcb = (void (*)(struct socket *, int, void *))fcmderr;
1227 }
1228
1229 static void cmd_lstrarg(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
1230 {
1231     struct transfer *transfer;
1232     struct wcspair *ta;
1233
1234     haveargs(2);
1235     havepriv(PERM_TRANS);
1236     if((transfer = findtransfer(wcstol(argv[1], NULL, 0))) == NULL)
1237     {
1238         sq(sk, 0, L"512", L"No such transfer", NULL);
1239         return;
1240     }
1241     if((transfer->dir == TRNSD_DOWN) && (transfer->owner != data->uid))
1242     {
1243         sq(sk, 0, L"502", L"You do not own that transfer", NULL);
1244         return;
1245     }
1246     if(transfer->args == NULL)
1247     {
1248         sq(sk, 0, L"201", L"Transfer has no arguments", NULL);
1249     } else {
1250         for(ta = transfer->args; ta != NULL; ta = ta->next)
1251             sq(sk, ta->next != NULL, L"200", L"%ls", ta->key, L"%ls", ta->val, NULL);
1252     }
1253 }
1254
1255 static void cmd_hashstatus(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
1256 {
1257     struct sharecache *node;
1258     int total, hashed;
1259
1260     total = hashed = 0;
1261     for(node = shareroot->child; node != NULL; node = nextscnode(node))
1262     {
1263         if(node->f.b.type == FILE_REG)
1264         {
1265             total++;
1266             if(node->f.b.hastth)
1267                 hashed++;
1268         }
1269     }
1270     sq(sk, 0, L"200", L"%i", total, L"tth", L"%i", hashed, NULL);
1271 }
1272
1273 static void cmd_transstatus(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
1274 {
1275     havepriv(PERM_TRANS);
1276     sq(sk, 0, L"200", L"down", L"%ll", bytesdownload, L"up", L"%ll", bytesupload, NULL);
1277 }
1278
1279 static void cmd_register(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
1280 {
1281     struct uidata *d2;
1282
1283     haveargs(2);
1284     if(data->userinfo == NULL) {
1285         sq(sk, 0, L"502", L"Must be logged in", NULL);
1286         return;
1287     }
1288     if(argv[1][0] == L'#') {
1289         sq(sk, 0, L"509", L"Name must not begin with a hash sign", NULL);
1290         return;
1291     }
1292     for(d2 = actives; d2 != NULL; d2 = d2->next) {
1293         if((d2 != data) && (d2->userinfo == data->userinfo) && d2->regname && !wcscmp(d2->regname, argv[1])) {
1294             sq(sk, 0, L"516", L"Name already in use", NULL);
1295             return;
1296         }
1297     }
1298     if(data->regname != NULL)
1299         free(data->regname);
1300     data->regname = swcsdup(argv[1]);
1301     sq(sk, 0, L"200", L"Registered", NULL);
1302 }
1303
1304 static void cmd_sendmsg(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
1305 {
1306     int i, rcptid;
1307     struct uidata *rcpt;
1308     wchar_t *myname;
1309     struct notif *notif;
1310
1311     haveargs(2);
1312     if(data->userinfo == NULL) {
1313         sq(sk, 0, L"502", L"Must be logged in", NULL);
1314         return;
1315     }
1316     if(argv[1][0] == L'#') {
1317         rcptid = wcstol(argv[1] + 1, NULL, 0);
1318         for(rcpt = actives; rcpt != NULL; rcpt = rcpt->next) {
1319             if((rcpt->userinfo == data->userinfo) && (rcpt->id == rcptid))
1320                 break;
1321         }
1322     } else {
1323         for(rcpt = actives; rcpt != NULL; rcpt = rcpt->next) {
1324             if((rcpt->userinfo == data->userinfo) && rcpt->regname && !wcscmp(rcpt->regname, argv[1]))
1325                 break;
1326         }
1327     }
1328     if(rcpt == NULL) {
1329         sq(sk, 0, L"517", L"No such recipient", NULL);
1330         return;
1331     }
1332     if(!rcpt->notify.b.msg) {
1333         sq(sk, 0, L"518", L"Recipient not listening for messages", NULL);
1334         return;
1335     }
1336     if(data->regname != NULL)
1337         myname = swcsdup(data->regname);
1338     else
1339         myname = swprintf2(L"#%i", data->id);
1340     notif = newnotif(rcpt, 640, NOTIF_STR, myname, NOTIF_END);
1341     for(i = 2; i < argc; i++)
1342         notifappend(notif, NOTIF_STR, argv[i], NOTIF_END);
1343     sq(sk, 0, L"200", L"Message sent", NULL);
1344 }
1345
1346 static void cmd_uptime(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
1347 {
1348     sq(sk, 0, L"200", L"%i", time(NULL) - starttime, NULL);
1349 }
1350
1351 static void cmd_hup(struct socket *sk, struct uidata *data, int argc, wchar_t **argv)
1352 {
1353     extern volatile int reinit;
1354
1355     havepriv(PERM_ADMIN);
1356     flog(LOG_NOTICE, "UI HUP request from %ls", data->username);
1357     reinit = 1;
1358     sq(sk, 0, L"200", L"Will reinit", NULL);
1359 }
1360
1361 #undef haveargs
1362 #undef havepriv
1363
1364 /*
1365  * Reserved command numbers for nameless commands:
1366  *  0: Issued when a client has connected
1367  *  1: Issued when a named command couldn't be found
1368  */
1369
1370 static struct command commands[] =
1371 {
1372     {NULL, cmd_connect},
1373     {NULL, cmd_notfound},
1374     {L"shutdown", cmd_shutdown},
1375     {L"quit", cmd_quit},
1376     {L"lsauth", cmd_lsauth},
1377     {L"login", cmd_login},
1378     {L"pass", cmd_pass},
1379     {L"cnct", cmd_fnetconnect},
1380     {L"lsnodes", cmd_lsnodes},
1381     {L"dcnct", cmd_disconnect},
1382     {L"lspa", cmd_lspa},
1383     {L"lspeers", cmd_lspeers},
1384     {L"download", cmd_download},
1385     {L"lstrans", cmd_lstrans},
1386     {L"cancel", cmd_cancel},
1387     {L"reset", cmd_reset},
1388     {L"notify", cmd_notify},
1389     {L"sendchat", cmd_sendchat},
1390     {L"search", cmd_search},
1391     {L"lssrch", cmd_lssrch},
1392     {L"lssr", cmd_lssr},
1393     {L"cansrch", cmd_cansrch},
1394     {L"filtercmd", cmd_filtercmd},
1395     {L"lstrarg", cmd_lstrarg},
1396     {L"hashstatus", cmd_hashstatus},
1397     {L"transstatus", cmd_transstatus},
1398     {L"register", cmd_register},
1399     {L"sendmsg", cmd_sendmsg},
1400     {L"uptime", cmd_uptime},
1401     {L"hup", cmd_hup},
1402     {NULL, NULL}
1403 };
1404
1405 static void freequeuecmd(struct qcommand *qcmd)
1406 {
1407     int i;
1408
1409     if(qcmd->argv != NULL)
1410     {
1411         for(i = 0; i < qcmd->argc; i++)
1412             free(qcmd->argv[i]);
1413         free(qcmd->argv);
1414     }
1415     free(qcmd);
1416 }
1417
1418 static struct qcommand *unlinkqcmd(struct uidata *data)
1419 {
1420     struct qcommand *qcmd;
1421
1422     qcmd = data->queue;
1423     if(qcmd != NULL)
1424     {
1425         data->queuesize--;
1426         data->queue = qcmd->next;
1427         if(qcmd == data->queuelast)
1428             data->queuelast = qcmd->next;
1429     }
1430     return(qcmd);
1431 }
1432
1433 static void notifappendv(struct notif *notif, va_list args)
1434 {
1435     int dt, ca;
1436
1437     while((dt = va_arg(args, int)) != NOTIF_END)
1438     {
1439         ca = notif->argc;
1440         notif->argv = realloc(notif->argv, sizeof(*notif->argv) * ++notif->argc);
1441         notif->argv[ca].dt = dt;
1442         switch(dt)
1443         {
1444         case NOTIF_INT:
1445         case NOTIF_ID:
1446             notif->argv[ca].d.n = va_arg(args, int);
1447             break;
1448         case NOTIF_OFF:
1449             notif->argv[ca].d.o = va_arg(args, off_t);
1450             break;
1451         case NOTIF_STR:
1452             notif->argv[ca].d.s = swcsdup(va_arg(args, wchar_t *));
1453             break;
1454         case NOTIF_FLOAT:
1455             notif->argv[ca].d.d = va_arg(args, double);
1456             break;
1457         }
1458     }
1459 }
1460
1461 static void notifappend(struct notif *notif, ...)
1462 {
1463     va_list args;
1464
1465     va_start(args, notif);
1466     notifappendv(notif, args);
1467     va_end(args);
1468 }
1469
1470 static struct notif *newnotif(struct uidata *data, int code, ...)
1471 {
1472     struct notif *notif;
1473     va_list args;
1474
1475     notif = smalloc(sizeof(*notif));
1476     memset(notif, 0, sizeof(*notif));
1477     notif->rlimit = 0.0;
1478     notif->ui = data;
1479     notif->code = code;
1480     va_start(args, code);
1481     notifappendv(notif, args);
1482     va_end(args);
1483     notif->next = NULL;
1484     notif->prev = data->lnotif;
1485     if(data->lnotif != NULL)
1486         data->lnotif->next = notif;
1487     else
1488         data->fnotif = notif;
1489     data->lnotif = notif;
1490     return(notif);
1491 }
1492
1493 static void freenotif(struct notif *notif)
1494 {
1495     int i;
1496
1497     if(notif->next != NULL)
1498         notif->next->prev = notif->prev;
1499     if(notif->prev != NULL)
1500         notif->prev->next = notif->next;
1501     if(notif == notif->ui->fnotif)
1502         notif->ui->fnotif = notif->next;
1503     if(notif == notif->ui->lnotif)
1504         notif->ui->lnotif = notif->prev;
1505     if(notif->exptimer != NULL)
1506         canceltimer(notif->exptimer);
1507     for(i = 0; i < notif->argc; i++)
1508     {
1509         if(notif->argv[i].dt == NOTIF_STR)
1510             free(notif->argv[i].d.s);
1511     }
1512     if(notif->argv != NULL)
1513         free(notif->argv);
1514     free(notif);
1515 }
1516
1517 static void notifexpire(int cancelled, struct notif *notif)
1518 {
1519     notif->exptimer = NULL;
1520     if(!cancelled)
1521         freenotif(notif);
1522 }
1523
1524 static struct notif *findnotif(struct notif *notif, int dir, int state, int code, int id)
1525 {
1526     int i, cont;
1527
1528     for(; notif != NULL; notif = (dir?notif->next:notif->prev))
1529     {
1530         if((notif->code == code) && ((state < 0) || (state == notif->state)))
1531         {
1532             cont = 0;
1533             if(id >= 0)
1534             {
1535                 for(i = 0; i < notif->argc; i++)
1536                 {
1537                     if((notif->argv[i].dt == NOTIF_ID) && (notif->argv[i].d.n != id))
1538                     {
1539                         cont = 1;
1540                         break;
1541                     }
1542                 }
1543             }
1544             if(cont)
1545                 continue;
1546             break;
1547         }
1548     }
1549     return(notif);
1550 }
1551
1552 static void freeuidata(struct uidata *data)
1553 {
1554     int i;
1555     struct qcommand *qcmd;
1556
1557     if(data->next != NULL)
1558         data->next->prev = data->prev;
1559     if(data->prev != NULL)
1560         data->prev->next = data->next;
1561     if(data == actives)
1562         actives = data->next;
1563     data->sk->readcb = NULL;
1564     data->sk->errcb = NULL;
1565     closesock(data->sk);
1566     putsock(data->sk);
1567     while((qcmd = unlinkqcmd(data)) != NULL)
1568         freequeuecmd(qcmd);
1569     iconv_close(data->ichandle);
1570     if(data->cw != NULL)
1571         free(data->cw);
1572     if(data->cb != NULL)
1573         free(data->cb);
1574     if(data->argv != NULL)
1575     {
1576         for(i = 0; i < data->argc; i++)
1577             free(data->argv[i]);
1578         free(data->argv);
1579     }
1580     if(data->auth != NULL)
1581         authputhandle(data->auth);
1582     if(data->regname != NULL)
1583         free(data->regname);
1584     if(data->username != NULL)
1585     {
1586         if(data->userinfo != NULL)
1587             flog(LOG_INFO, "%ls logged out", data->username);
1588         free(data->username);
1589     }
1590     free(data->inbuf);
1591     while(data->fnotif != NULL)
1592         freenotif(data->fnotif);
1593     if(data->fcmdbuf != NULL)
1594         free(data->fcmdbuf);
1595     if(data->fcmdpid != 0)
1596         kill(-data->fcmdpid, SIGHUP);
1597     if(data->fcmdsk != NULL)
1598         putsock(data->fcmdsk);
1599     free(data);
1600 }
1601
1602 static void queuecmd(struct uidata *data, struct command *cmd, int argc, wchar_t **argv)
1603 {
1604     struct qcommand *new;
1605
1606     new = smalloc(sizeof(*new));
1607     new->cmd = cmd;
1608     new->argc = argc;
1609     new->argv = argv;
1610     new->next = NULL;
1611     if(data->queuelast != NULL)
1612         data->queuelast->next = new;
1613     data->queuelast = new;
1614     if(data->queue == NULL)
1615         data->queue = new;
1616     data->queuesize++;
1617 }
1618
1619 static struct uidata *newuidata(struct socket *sk)
1620 {
1621     struct uidata *data;
1622     static int curid = 0;
1623
1624     data = smalloc(sizeof(*data));
1625     memset(data, 0, sizeof(*data));
1626     data->id = curid++;
1627     data->sk = sk;
1628     getsock(sk);
1629     data->inbuf = smalloc(1024);
1630     data->uid = -1;
1631     if((data->ichandle = iconv_open("wchar_t", "utf-8")) == (iconv_t)-1)
1632     {
1633         flog(LOG_CRIT, "iconv cannot handle UTF-8: %s", strerror(errno));
1634         return(NULL);
1635     }
1636     data->next = actives;
1637     data->prev = NULL;
1638     if(actives != NULL)
1639         actives->prev = data;
1640     actives = data;
1641     return(data);
1642 }
1643
1644 static void uiread(struct socket *sk, struct uidata *data)
1645 {
1646     int ret, done;
1647     char *newbuf;
1648     char *p1, *p2;
1649     wchar_t *porig;
1650     size_t datalen, len2;
1651     struct command *cur;
1652
1653     if(data->indata > 1024)
1654         data->indata = 0;
1655     if((newbuf = sockgetinbuf(sk, &datalen)) == NULL)
1656         return;
1657     sizebuf(&data->inbuf, &data->inbufsize, data->indata + datalen, 1, 1);
1658     memcpy(data->inbuf + data->indata, newbuf, datalen);
1659     free(newbuf);
1660     data->indata += datalen;
1661     if(data->cb == NULL)
1662     {
1663         data->cb = smalloc(sizeof(wchar_t) * (data->cbsize = 64));
1664         data->cbdata = 0;
1665         data->pp = data->cb;
1666     }
1667     done = 0;
1668     while(!done)
1669     {
1670         if(data->cbsize == data->cbdata)
1671         {
1672             len2 = data->pp - data->cb;
1673             data->cb = srealloc(data->cb, sizeof(wchar_t) * (data->cbsize *= 2));
1674             data->pp = data->cb + len2;
1675         }
1676         p1 = data->inbuf;
1677         p2 = (char *)(porig = (data->cb + data->cbdata));
1678         len2 = sizeof(wchar_t) * (data->cbsize - data->cbdata);
1679         ret = iconv(data->ichandle, &p1, &data->indata, &p2, &len2);
1680         memmove(data->inbuf, p1, data->indata);
1681         /* Just a sanity check */
1682         if(((p2 - ((char *)data->cb)) % sizeof(wchar_t)) != 0)
1683         {
1684             flog(LOG_CRIT, "Aiya! iconv does strange things to our wchar_t's!");
1685             abort();
1686         }
1687         data->cbdata += (((wchar_t *)p2) - porig);
1688         if(ret < 0)
1689         {
1690             switch(errno)
1691             {
1692             case EILSEQ:
1693                 /* XXX: Should this really just ignore it? */
1694                 data->indata = 0;
1695                 done = 1;
1696                 break;
1697             case EINVAL:
1698                 done = 1;
1699                 break;
1700             case E2BIG:
1701                 /* Just a sanity check */
1702                 if(data->cbsize != data->cbdata)
1703                 {
1704                     flog(LOG_CRIT, "Aiya! iconv doesn't give us wchar_t's!");
1705                     abort();
1706                 }
1707                 break;
1708             default:
1709                 flog(LOG_WARNING, "bug: strange error from iconv in uiread: %s", strerror(errno));
1710                 break;
1711             }
1712         } else {
1713             done = 1;
1714         }
1715     }
1716     done = 0;
1717     while(!done && (data->pp - data->cb < data->cbdata))
1718     {
1719         switch(data->ps)
1720         {
1721         case 0:
1722             if(iswspace(*data->pp))
1723             {
1724                 if(*data->pp == L'\r')
1725                 {
1726                     if(data->pp == data->cb + data->cbdata - 1)
1727                     {
1728                         done = 1;
1729                         break;
1730                     }
1731                     if(*(++data->pp) == L'\n')
1732                     {
1733                         if((data->argv != NULL) && (data->argv[0] != NULL))
1734                         {
1735                             for(cur = commands; cur->handler != NULL; cur++)
1736                             {
1737                                 if(cur->name == NULL)
1738                                     continue;
1739                                 if(!wcscasecmp(cur->name, data->argv[0]))
1740                                 {
1741                                     queuecmd(data, cur, data->argc, data->argv);
1742                                     break;
1743                                 }
1744                             }
1745                             if(cur->handler == NULL)
1746                                 queuecmd(data, &commands[1], data->argc, data->argv);
1747                         } else {
1748                             queuecmd(data, &commands[1], data->argc, data->argv);
1749                         }
1750                         data->argv = NULL;
1751                         data->args = 0;
1752                         data->argc = 0;
1753                         wmemmove(data->cb, data->pp, data->cbdata -= (data->pp - data->cb));
1754                         data->pp = data->cb;
1755                     } else {
1756                         data->pp++;
1757                     }
1758                 } else {
1759                     data->pp++;
1760                 }
1761             } else {
1762                 data->ps = 1;
1763                 data->cwdata = 0;
1764             }
1765             break;
1766         case 1:
1767             if(iswspace(*data->pp))
1768             {
1769                 addtobuf(data->cw, L'\0');
1770                 sizebuf(&data->argv, &data->args, data->argc + 1, sizeof(*data->argv), 1);
1771                 data->argv[data->argc++] = data->cw;
1772                 data->cw = NULL;
1773                 data->cwsize = 0;
1774                 data->cwdata = 0;
1775                 data->ps = 0;
1776             } else if(*data->pp == L'\"') {
1777                 data->ps = 2;
1778                 data->pp++;
1779             } else if(*data->pp == L'\\') {
1780                 if(data->pp == data->cb + data->cbdata - 1)
1781                 {
1782                     done = 1;
1783                     break;
1784                 }
1785                 addtobuf(data->cw, *(++data->pp));
1786                 data->pp++;
1787             } else {
1788                 addtobuf(data->cw, *(data->pp++));
1789             }
1790             break;
1791         case 2:
1792             if(*data->pp == L'\"')
1793             {
1794                 data->ps = 1;
1795             } else if(*data->pp == L'\\') {
1796                 if(data->pp == data->cb + data->cbdata - 1)
1797                 {
1798                     done = 1;
1799                     break;
1800                 }
1801                 addtobuf(data->cw, *(++(data->pp)));
1802             } else {
1803                 addtobuf(data->cw, *data->pp);
1804             }
1805             data->pp++;
1806             break;
1807         }
1808     }
1809     if(data->cbdata > 16384)
1810     {
1811         /* Kill clients that send us unreasonably long lines */
1812         data->close = 1;
1813     }
1814 }
1815
1816 static void uierror(struct socket *sk, int err, struct uidata *data)
1817 {
1818     if(err)
1819         flog(LOG_WARNING, "error occurred on UI socket: %s", strerror(err));
1820     freeuidata(data);
1821 }
1822
1823 static void uiaccept(struct socket *sk, struct socket *newsk, void *data)
1824 {
1825     struct uidata *uidata;
1826
1827     newsk->data = uidata = newuidata(newsk);
1828     socksettos(newsk, confgetint("ui", "uitos"));
1829     if(uidata == NULL)
1830         return;
1831     newsk->errcb = (void (*)(struct socket *, int, void *))uierror;
1832     newsk->readcb = (void (*)(struct socket *, void *))uiread;
1833     queuecmd(uidata, &commands[0], 0, NULL);
1834 }
1835
1836 static int srcheta(struct search *srch, void *uudata)
1837 {
1838     struct uidata *data;
1839
1840     for(data = actives; data != NULL; data = data->next)
1841     {
1842         if(haspriv(data, PERM_SRCH) && data->notify.b.srch && !wcscmp(srch->owner, data->username))
1843             newnotif(data, 620, NOTIF_ID, srch->id, NOTIF_INT, srch->eta - time(NULL), NOTIF_END);
1844     }
1845     return(0);
1846 }
1847
1848 static int srchcommit(struct search *srch, void *uudata)
1849 {
1850     struct uidata *data;
1851
1852     for(data = actives; data != NULL; data = data->next)
1853     {
1854         if(haspriv(data, PERM_SRCH) && data->notify.b.srch && !wcscmp(srch->owner, data->username))
1855             newnotif(data, 621, NOTIF_ID, srch->id, NOTIF_END);
1856     }
1857     return(0);
1858 }
1859
1860 static int srchres(struct search *srch, struct srchres *sr, void *uudata)
1861 {
1862     struct uidata *data;
1863
1864     for(data = actives; data != NULL; data = data->next)
1865     {
1866         if(haspriv(data, PERM_SRCH) && data->notify.b.srch && !wcscmp(srch->owner, data->username))
1867         {
1868             newnotif(data, 622, NOTIF_ID, srch->id, NOTIF_STR, sr->filename, NOTIF_STR, sr->fnet->name, NOTIF_STR, sr->peerid, NOTIF_OFF, sr->size,
1869                      NOTIF_INT, sr->slots, NOTIF_INT, (sr->fn == NULL)?-1:(sr->fn->id), NOTIF_FLOAT, sr->time, NOTIF_STR, (sr->hash == NULL)?L"":unparsehash(sr->hash), NOTIF_END);
1870         }
1871     }
1872     return(0);
1873 }
1874
1875 static int recvchat(struct fnetnode *fn, int public, wchar_t *name, wchar_t *peer, wchar_t *string, void *uudata)
1876 {
1877     struct uidata *data;
1878
1879     for(data = actives; data != NULL; data = data->next)
1880     {
1881         if(haspriv(data, PERM_CHAT) && data->notify.b.fnchat)
1882             newnotif(data, 600, NOTIF_ID, fn->id, NOTIF_INT, public, NOTIF_STR, name, NOTIF_STR, peer, NOTIF_STR, string, NOTIF_END);
1883     }
1884     return(0);
1885 }
1886
1887 static int fnactive(struct fnetnode *fn, wchar_t *attrib, void *uudata)
1888 {
1889     struct uidata *data;
1890     struct notif *notif;
1891
1892     if(!wcscmp(attrib, L"state"))
1893     {
1894         for(data = actives; data != NULL; data = data->next)
1895         {
1896             if(data->notify.b.fnact)
1897                 newnotif(data, 601, NOTIF_ID, fn->id, NOTIF_INT, fn->state, NOTIF_END);
1898         }
1899     } else if(!wcscmp(attrib, L"name")) {
1900         for(data = actives; data != NULL; data = data->next)
1901         {
1902             if(data->notify.b.fnact)
1903                 newnotif(data, 602, NOTIF_ID, fn->id, NOTIF_STR, fn->name, NOTIF_END);
1904         }
1905     } else if(!wcscmp(attrib, L"numpeers")) {
1906         for(data = actives; data != NULL; data = data->next)
1907         {
1908             if(data->notify.b.fnact)
1909             {
1910                 if((notif = findnotif(data->fnotif, 1, NOTIF_PEND, 605, fn->id)) != NULL)
1911                     notif->argv[1].d.n = fn->numpeers;
1912                 else
1913                     newnotif(data, 605, NOTIF_ID, fn->id, NOTIF_INT, fn->numpeers, NOTIF_END)->rlimit = 0.5;
1914             }
1915         }
1916     }
1917     return(0);
1918 }
1919
1920 static int fnunlink(struct fnetnode *fn, void *uudata)
1921 {
1922     struct uidata *data;
1923
1924     for(data = actives; data != NULL; data = data->next)
1925     {
1926         if(data->notify.b.fnact)
1927             newnotif(data, 603, NOTIF_ID, fn->id, NOTIF_END);
1928     }
1929     return(0);
1930 }
1931
1932 static int peernew(struct fnetnode *fn, struct fnetpeer *peer, void *uudata)
1933 {
1934     struct uidata *data;
1935
1936     for(data = actives; data != NULL; data = data->next)
1937     {
1938         if(data->notify.b.fnpeer)
1939             newnotif(data, 630, NOTIF_INT, fn->id, NOTIF_STR, peer->id, NOTIF_STR, peer->nick, NOTIF_END);
1940     }
1941     return(0);
1942 }
1943
1944 static int peerdel(struct fnetnode *fn, struct fnetpeer *peer, void *uudata)
1945 {
1946     struct uidata *data;
1947
1948     for(data = actives; data != NULL; data = data->next)
1949     {
1950         if(data->notify.b.fnpeer)
1951             newnotif(data, 631, NOTIF_INT, fn->id, NOTIF_STR, peer->id, NOTIF_END);
1952     }
1953     return(0);
1954 }
1955
1956 static int peerchange(struct fnetnode *fn, struct fnetpeer *peer, struct fnetpeerdi *di, void *uudata)
1957 {
1958     struct uidata *data;
1959     struct notif *notif;
1960     wchar_t buf[32];
1961
1962     for(data = actives; data != NULL; data = data->next)
1963     {
1964         if(data->notify.b.fnpeer)
1965         {
1966             for(notif = data->fnotif; notif != NULL; notif = notif->next)
1967             {
1968                 if((notif->code == 632) && (notif->state == NOTIF_PEND) && (notif->argv[0].d.n == fn->id) && !wcscmp(notif->argv[1].d.s, peer->id))
1969                     break;
1970             }
1971             if(notif == NULL)
1972                 notif = newnotif(data, 632, NOTIF_INT, fn->id, NOTIF_STR, peer->id, NOTIF_STR, peer->nick, NOTIF_END);
1973             notifappend(notif, NOTIF_STR, di->datum->id, NOTIF_INT, di->datum->datatype, NOTIF_END);
1974             switch(di->datum->datatype)
1975             {
1976             case FNPD_INT:
1977                 notifappend(notif, NOTIF_INT, di->data.num, NOTIF_END);
1978                 break;
1979             case FNPD_STR:
1980                 notifappend(notif, NOTIF_STR, di->data.str, NOTIF_END);
1981                 break;
1982             case FNPD_LL:
1983                 swprintf(buf, sizeof(buf) / sizeof(*buf), L"%lli", di->data.lnum);
1984                 notifappend(notif, NOTIF_STR, buf, NOTIF_END);
1985                 break;
1986             }
1987         }
1988     }
1989     return(0);
1990 }
1991
1992 static int newfnetnode(struct fnetnode *fn, void *uudata)
1993 {
1994     struct uidata *data;
1995
1996     for(data = actives; data != NULL; data = data->next)
1997     {
1998         if(data->notify.b.fnact)
1999             newnotif(data, 604, NOTIF_ID, fn->id, NOTIF_STR, fn->fnet->name, NOTIF_END);
2000     }
2001     CBREG(fn, fnetnode_ac, fnactive, NULL, NULL);
2002     CBREG(fn, fnetnode_chat, recvchat, NULL, NULL);
2003     CBREG(fn, fnetnode_unlink, fnunlink, NULL, NULL);
2004     CBREG(fn, fnetpeer_new, peernew, NULL, NULL);
2005     CBREG(fn, fnetpeer_del, peerdel, NULL, NULL);
2006     CBREG(fn, fnetpeer_chdi, peerchange, NULL, NULL);
2007     return(0);
2008 }
2009
2010 static int transferchattr(struct transfer *transfer, wchar_t *attrib, void *uudata)
2011 {
2012     struct uidata *data;
2013
2014     if(!wcscmp(attrib, L"state"))
2015     {
2016         for(data = actives; data != NULL; data = data->next)
2017         {
2018             if(haspriv(data, PERM_TRANS) && data->notify.b.tract && ((transfer->owner == 0) || (transfer->owner == data->uid)))
2019                 newnotif(data, 611, NOTIF_ID, transfer->id, NOTIF_INT, transfer->state, NOTIF_END);
2020         }
2021     } else if(!wcscmp(attrib, L"nick")) {
2022         for(data = actives; data != NULL; data = data->next)
2023         {
2024             if(haspriv(data, PERM_TRANS) && data->notify.b.tract && ((transfer->owner == 0) || (transfer->owner == data->uid)))
2025                 newnotif(data, 612, NOTIF_ID, transfer->id, NOTIF_STR, transfer->peernick, NOTIF_END);
2026         }
2027     } else if(!wcscmp(attrib, L"size")) {
2028         for(data = actives; data != NULL; data = data->next)
2029         {
2030             if(haspriv(data, PERM_TRANS) && data->notify.b.tract && ((transfer->owner == 0) || (transfer->owner == data->uid)))
2031                 newnotif(data, 613, NOTIF_ID, transfer->id, NOTIF_OFF, transfer->size, NOTIF_END);
2032         }
2033     } else if(!wcscmp(attrib, L"error")) {
2034         for(data = actives; data != NULL; data = data->next)
2035         {
2036             if(haspriv(data, PERM_TRANS) && data->notify.b.tract && ((transfer->owner == 0) || (transfer->owner == data->uid)))
2037                 newnotif(data, 614, NOTIF_ID, transfer->id, NOTIF_INT, transfer->error, NOTIF_END);
2038         }
2039     } else if(!wcscmp(attrib, L"path")) {
2040         for(data = actives; data != NULL; data = data->next)
2041         {
2042             if(haspriv(data, PERM_TRANS) && data->notify.b.tract && ((transfer->owner == 0) || (transfer->owner == data->uid)))
2043                 newnotif(data, 616, NOTIF_ID, transfer->id, NOTIF_STR, transfer->path, NOTIF_END);
2044         }
2045     } else if(!wcscmp(attrib, L"hash")) {
2046         for(data = actives; data != NULL; data = data->next)
2047         {
2048             if(haspriv(data, PERM_TRANS) && data->notify.b.tract && ((transfer->owner == 0) || (transfer->owner == data->uid)))
2049                 newnotif(data, 618, NOTIF_ID, transfer->id, NOTIF_STR, (transfer->hash == NULL)?L"":unparsehash(transfer->hash), NOTIF_END);
2050         }
2051     }
2052     return(0);
2053 }
2054
2055 static int transferprog(struct transfer *transfer, void *uudata)
2056 {
2057     struct uidata *data;
2058     struct notif *notif;
2059
2060     for(data = actives; data != NULL; data = data->next)
2061     {
2062         if(haspriv(data, PERM_TRANS) && data->notify.b.trprog && ((transfer->owner == 0) || (transfer->owner == data->uid)))
2063         {
2064             if((notif = findnotif(data->fnotif, 1, NOTIF_PEND, 615, transfer->id)) != NULL)
2065                 notif->argv[1].d.o = transfer->curpos;
2066             else
2067                 newnotif(data, 615, NOTIF_ID, transfer->id, NOTIF_OFF, transfer->curpos, NOTIF_END)->rlimit = 0.5;
2068         }
2069     }
2070     return(0);
2071 }
2072
2073 static int transferdestroyed(struct transfer *transfer, void *uudata)
2074 {
2075     struct uidata *data;
2076
2077     for(data = actives; data != NULL; data = data->next)
2078     {
2079         if(haspriv(data, PERM_TRANS) && data->notify.b.tract && ((transfer->owner == 0) || (transfer->owner == data->uid)))
2080             newnotif(data, 617, NOTIF_ID, transfer->id, NOTIF_STR, (transfer->exitstatus == NULL)?L"":(transfer->exitstatus), NOTIF_END);
2081     }
2082     return(0);
2083 }
2084
2085 static int newtransfernotify(struct transfer *transfer, void *uudata)
2086 {
2087     struct uidata *data;
2088
2089     for(data = actives; data != NULL; data = data->next)
2090     {
2091         if(haspriv(data, PERM_TRANS) && data->notify.b.tract && ((transfer->owner == 0) || (transfer->owner == data->uid)))
2092             newnotif(data, 610, NOTIF_ID, transfer->id, NOTIF_INT, transfer->dir, NOTIF_STR, transfer->peerid, NOTIF_STR, (transfer->path == NULL)?L"":transfer->path, NOTIF_END);
2093     }
2094     CBREG(transfer, trans_ac, transferchattr, NULL, NULL);
2095     CBREG(transfer, trans_p, transferprog, NULL, NULL);
2096     CBREG(transfer, trans_destroy, transferdestroyed, NULL, NULL);
2097     return(0);
2098 }
2099
2100 static struct uiuser *newuser(wchar_t *name, unsigned long perms)
2101 {
2102     struct uiuser *new;
2103
2104     new = smalloc(sizeof(*new));
2105     new->used = 0;
2106     new->name = swcsdup(name);
2107     new->perms = perms;
2108     new->delete = 0;
2109     new->next = users;
2110     new->prev = NULL;
2111     if(users != NULL)
2112         users->prev = new;
2113     users = new;
2114     return(new);
2115 }
2116
2117 static void freeuser(struct uiuser *user)
2118 {
2119     if(user->next != NULL)
2120         user->next->prev = user->prev;
2121     if(user->prev != NULL)
2122         user->prev->next = user->next;
2123     if(user == users)
2124         users = user->next;
2125     free(user->name);
2126     free(user);
2127 }
2128
2129 static int conf_user(int argc, wchar_t **argv)
2130 {
2131     int i, perms, permmod;
2132     struct uiuser *user;
2133     wchar_t *p;
2134
2135     if(argc < 3)
2136     {
2137         flog(LOG_WARNING, "not enough arguments given for user command");
2138         return(1);
2139     }
2140     perms = 0;
2141     for(i = 2; i < argc; i++)
2142     {
2143         if(!iswalpha(argv[i][0]))
2144             p = argv[i] + 1;
2145         else
2146             p = argv[i];
2147         if(!wcscmp(p, L"disallow"))
2148             permmod = PERM_DISALLOW;
2149         if(!wcscmp(p, L"admin"))
2150             permmod = PERM_ADMIN;
2151         if(!wcscmp(p, L"fnetctl"))
2152             permmod = PERM_FNETCTL;
2153         if(!wcscmp(p, L"trans"))
2154             permmod = PERM_TRANS;
2155         if(!wcscmp(p, L"transcu"))
2156             permmod = PERM_TRANSCU;
2157         if(!wcscmp(p, L"chat"))
2158             permmod = PERM_CHAT;
2159         if(!wcscmp(p, L"srch"))
2160             permmod = PERM_SRCH;
2161         if(!wcscmp(p, L"all"))
2162             permmod = ~0;
2163         if(argv[i][0] == L'-')
2164             perms &= ~permmod;
2165         else
2166             perms |= permmod;
2167     }
2168     if((user = finduser(argv[1])) == NULL)
2169     {
2170         newuser(argv[1], perms);
2171     } else {
2172         user->delete = 0;
2173         user->perms = perms;
2174     }
2175     return(0);
2176 }
2177
2178 static void preinit(int hup)
2179 {
2180     struct uiuser *user;
2181
2182     if(!hup)
2183     {
2184         newuser(L"default", PERM_DISALLOW);
2185     } else {
2186         for(user = users; user != NULL; user = user->next)
2187         {
2188             if(!wcscmp(user->name, L"default"))
2189                 user->delete = 1;
2190         }
2191     }
2192 }
2193
2194 static struct sockaddr_un *makeunixname(void)
2195 {
2196     static struct sockaddr_un buf;
2197     char *val;
2198     struct passwd *pwd;
2199     uid_t uid;
2200
2201     memset(&buf, 0, sizeof(buf));
2202     buf.sun_family = PF_UNIX;
2203     if((val = icswcstombs(confgetstr("ui", "unixsock"), NULL, NULL)) == NULL) {
2204         flog(LOG_WARNING, "could not map Unix socket name into local charset: %s", strerror(errno));
2205         return(NULL);
2206     }
2207     if(!strcmp(val, "none"))
2208         return(NULL);
2209     if(!strcmp(val, "default"))
2210     {
2211         if((uid = getuid()) == 0)
2212         {
2213             strcpy(buf.sun_path, "/var/run/doldacond.sock");
2214             return(&buf);
2215         } else {
2216             if((pwd = getpwuid(uid)) == NULL)
2217             {
2218                 flog(LOG_ERR, "could not get passwd entry for current user: %s", strerror(errno));
2219                 return(NULL);
2220             }
2221             strcpy(buf.sun_path, "/tmp/doldacond-");
2222             strcat(buf.sun_path, pwd->pw_name);
2223             return(&buf);
2224         }
2225     }
2226     if(strchr(val, '/'))
2227     {
2228         strcpy(buf.sun_path, val);
2229         return(&buf);
2230     }
2231     flog(LOG_WARNING, "invalid Unix socket name: %s", val);
2232     return(NULL);
2233 }
2234
2235 static int tcpportupdate(struct configvar *var, void *uudata)
2236 {
2237     struct socket *newsock;
2238
2239     newsock = NULL;
2240     if((var->val.num != -1) && ((newsock = netcstcplisten(var->val.num, 1, uiaccept, NULL)) == NULL))
2241     {
2242         flog(LOG_WARNING, "could not create new TCP UI socket, reverting to old: %s", strerror(errno));
2243         return(0);
2244     }
2245     if(tcpsocket != NULL)
2246     {
2247         putsock(tcpsocket);
2248         tcpsocket = NULL;
2249     }
2250     tcpsocket = newsock;
2251     return(0);
2252 }
2253
2254 static int unixsockupdate(struct configvar *var, void *uudata)
2255 {
2256     struct socket *newsock;
2257     struct sockaddr_un *un;
2258     mode_t ou;
2259
2260     newsock = NULL;
2261     ou = umask(0111);
2262     if(((un = makeunixname()) != NULL) && ((newsock = netcslistenlocal(SOCK_STREAM, (struct sockaddr *)un, sizeof(*un), uiaccept, NULL)) == NULL))
2263     {
2264         umask(ou);
2265         flog(LOG_WARNING, "could not create new Unix UI socket, reverting to old: %s", strerror(errno));
2266         return(0);
2267     }
2268     umask(ou);
2269     if(unixsocket != NULL)
2270     {
2271         putsock(unixsocket);
2272         unixsocket = NULL;
2273     }
2274     unixsocket = newsock;
2275     return(0);
2276 }
2277
2278 static int init(int hup)
2279 {
2280     struct uiuser *user, *next;
2281     struct sockaddr_un *un;
2282     struct passwd *pwd;
2283     wchar_t *wcsname;
2284     mode_t ou;
2285
2286     if(hup)
2287     {
2288         for(user = users; user != NULL; user = next)
2289         {
2290             next = user->next;
2291             if(user->delete)
2292                 freeuser(user);
2293         }
2294     }
2295     if(!hup)
2296     {
2297         starttime = time(NULL);
2298         if((confgetint("ui", "port") != -1) && ((tcpsocket = netcstcplisten(confgetint("ui", "port"), 1, uiaccept, NULL)) == NULL))
2299         {
2300             flog(LOG_CRIT, "could not create TCP UI socket: %s", strerror(errno));
2301             return(1);
2302         }
2303         CBREG(confgetvar("ui", "port"), conf_update, tcpportupdate, NULL, NULL);
2304         ou = umask(0111);
2305         if(((un = makeunixname()) != NULL) && ((unixsocket = netcslistenlocal(SOCK_STREAM, (struct sockaddr *)un, sizeof(*un), uiaccept, NULL)) == NULL))
2306         {
2307             umask(ou);
2308             flog(LOG_CRIT, "could not create Unix UI socket: %s", strerror(errno));
2309             return(1);
2310         }
2311         umask(ou);
2312         CBREG(confgetvar("ui", "unixsock"), conf_update, unixsockupdate, NULL, NULL);
2313         GCBREG(newfncb, newfnetnode, NULL);
2314         GCBREG(newtransfercb, newtransfernotify, NULL);
2315     }
2316     if(getuid() != 0)
2317     {
2318         for(user = users; user != NULL; user = user->next)
2319         {
2320             if(wcscmp(user->name, L"default"))
2321                 break;
2322         }
2323         if(!user)
2324         {
2325             if((pwd = getpwuid(getuid())) == NULL)
2326             {
2327                 flog(LOG_CRIT, "could not get login info: %s", strerror(errno));
2328                 return(1);
2329             }
2330             if((wcsname = icmbstowcs(pwd->pw_name, NULL)) == NULL)
2331             {
2332                 flog(LOG_CRIT, "could not convert user name into wcs: %s", strerror(errno));
2333                 return(1);
2334             }
2335             newuser(wcsname, ~PERM_DISALLOW);
2336             free(wcsname);
2337         }
2338     }
2339     return(0);
2340 }
2341
2342 static int run(void)
2343 {
2344     int i, id;
2345     struct uidata *data, *next;
2346     struct qcommand *qcmd;
2347     struct notif *notif, *nnotif;
2348
2349     for(data = actives; data != NULL; data = next)
2350     {
2351         next = data->next;
2352         if(data->close)
2353             freeuidata(data);
2354     }
2355     for(data = actives; data != NULL; data = data->next)
2356     {
2357         for(notif = data->fnotif; notif != NULL; notif = nnotif)
2358         {
2359             nnotif = notif->next;
2360             if(notif->state == NOTIF_WAIT)
2361                 continue;
2362             id = -1;
2363             for(i = 0; i < notif->argc; i++)
2364             {
2365                 if(notif->argv[i].dt == NOTIF_ID)
2366                 {
2367                     id = notif->argv[i].d.n;
2368                     break;
2369                 }
2370             }
2371             if(findnotif(notif->prev, 0, -1, notif->code, id) != NULL)
2372                 continue;
2373             sq(data->sk, 2, L"%i", notif->code, NULL);
2374             for(i = 0; i < notif->argc; i++)
2375             {
2376                 switch(notif->argv[i].dt)
2377                 {
2378                 case NOTIF_INT:
2379                 case NOTIF_ID:
2380                     sq(data->sk, 2, L"%i", notif->argv[i].d.n, NULL);
2381                     break;
2382                 case NOTIF_OFF:
2383                     sq(data->sk, 2, L"%oi", notif->argv[i].d.o, NULL);
2384                     break;
2385                 case NOTIF_STR:
2386                     if(notif->argv[i].d.s[0] == L'%')
2387                         sq(data->sk, 2, L"%ls", notif->argv[i].d.s, NULL);
2388                     else
2389                         sq(data->sk, 2, notif->argv[i].d.s, NULL);
2390                     break;
2391                 case NOTIF_FLOAT:
2392                     sq(data->sk, 2, L"%f", notif->argv[i].d.d, NULL);
2393                     break;
2394                 }
2395             }
2396             sq(data->sk, 0, NULL);
2397             if(notif->rlimit != 0)
2398             {
2399                 notif->state = NOTIF_WAIT;
2400                 notif->exptimer = timercallback(ntime() + notif->rlimit, (void (*)(int, void *))notifexpire, notif);
2401             } else {
2402                 freenotif(notif);
2403             }
2404         }
2405         if((qcmd = unlinkqcmd(data)) != NULL)
2406         {
2407             qcmd->cmd->handler(data->sk, data, qcmd->argc, qcmd->argv);
2408             freequeuecmd(qcmd);
2409             return(1);
2410         }
2411         if(data->queuesize > 10)
2412         {
2413             /* Clients should not be queue up commands at all, since
2414              * they should not send a new command before receiving a
2415              * reply to the previous command. Therefore, we
2416              * mercilessly massacre clients which are stacking up too
2417              * many commands. */
2418             data->close = 1;
2419         }
2420     }
2421     return(0);
2422 }
2423
2424 static void terminate(void)
2425 {
2426     while(users != NULL)
2427         freeuser(users);
2428     if(tcpsocket != NULL)
2429         putsock(tcpsocket);
2430     if(unixsocket != NULL)
2431         putsock(unixsocket);
2432 }
2433
2434 static struct configvar myvars[] =
2435 {
2436     /** If true, UI connections will only be accepted from localhost
2437      * addresses (127.0.0.1, ::1 or ::ffff:127.0.0.1). Unless you are
2438      * completely sure that you know what you are doing, never turn
2439      * this off when auth.authless is on. */
2440     {CONF_VAR_BOOL, "onlylocal", {.num = 1}},
2441     /** The TCP port number on which to accept UI client connections,
2442      * or -1 to not listen on TCP. */
2443     {CONF_VAR_INT, "port", {.num = 1500}},
2444     /**
2445      * Controls the the name to use for the Unix socket on which to
2446      * accept UI client connections. If the name contains a slash, it
2447      * is treated as a file name to bind on. If the name is "default",
2448      * the file name will be "/var/run/doldacond.sock" if doldacond
2449      * runs with UID == 0, or "/tmp/doldacond-NAME" otherwise, where
2450      * NAME is the user name of the UID which doldacond runs as. If
2451      * the name is "none", no Unix socket will be used. Otherwise, an
2452      * error is signaled.
2453      */
2454     {CONF_VAR_STRING, "unixsock", {.str = L"default"}},
2455     /** The TOS value to use for UI connections (see the TOS VALUES
2456      * section). */
2457     {CONF_VAR_INT, "uitos", {.num = SOCK_TOS_MINDELAY}},
2458     /** The name of the filtercmd script (see the FILES section for
2459      * lookup information). */
2460     {CONF_VAR_STRING, "filtercmd", {.str = L"dc-filtercmd"}},
2461     {CONF_VAR_END}
2462 };
2463
2464 static struct configcmd mycmds[] =
2465 {
2466     {"user", conf_user},
2467     {NULL}
2468 };
2469
2470 static struct module me =
2471 {
2472     .name = "ui",
2473     .conf =
2474     {
2475         .vars = myvars,
2476         .cmds = mycmds
2477     },
2478     .preinit = preinit,
2479     .init = init,
2480     .run = run,
2481     .terminate = terminate
2482 };
2483
2484 MODULE(me)