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