daemon/filenet.c

   1 /*
   2  *  Dolda Connect - Modular multiuser Direct Connect-style client
   3  *  Copyright (C) 2004 Fredrik Tolf (fredrik@dolda2000.com)
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 */
  19 #include <string.h>
  20 #include <wchar.h>
  21 #include <sys/socket.h>
  22 #include <errno.h>
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27 #include "filenet.h"
  28 #include "search.h"
  29 #include "module.h"
  30 #include "utils.h"
  31 #include "net.h"
  32
  33 static struct fnet *networks = NULL;
  34 struct fnetnode *fnetnodes = NULL;
  35 int numfnetnodes = 0;
  36 GCBCHAIN(newfncb, struct fnetnode *);
  37
  38 static struct fnetnode *newfn(struct fnet *fnet)
  39 {
  40     static int curid = 0;
  41     struct fnetnode *new;
  42
  43     new = smalloc(sizeof(*new));
  44     memset(new, 0, sizeof(*new));
  45     new->fnet = fnet;
  46     new->refcount = 1;
  47     new->id = curid++;
  48     new->mynick = swcsdup(confgetstr("cli", "defnick"));
  49     new->srchwait = confgetint("fnet", "srchwait");
  50     new->state = FNN_SYN;
  51     CBCHAININIT(new, fnetnode_ac);
  52     CBCHAININIT(new, fnetnode_chat);
  53     CBCHAININIT(new, fnetnode_unlink);
  54     CBCHAININIT(new, fnetnode_destroy);
  55     CBCHAININIT(new, fnetpeer_new);
  56     CBCHAININIT(new, fnetpeer_del);
  57     CBCHAININIT(new, fnetpeer_chdi);
  58     new->next = NULL;
  59     new->prev = NULL;
  60     numfnetnodes++;
  61     return(new);
  62 }
  63
  64 void killfnetnode(struct fnetnode *fn)
  65 {
  66     fnetsetstate(fn, FNN_DEAD);
  67     if(fn->sk != NULL)
  68     {
  69         fn->sk->close = 1;
  70         if(fn->sk->data == fn)
  71         {
  72             fn->sk->data = NULL;
  73             putfnetnode(fn);
  74         }
  75         putsock(fn->sk);
  76         fn->sk = NULL;
  77     }
  78 }
  79
  80 void getfnetnode(struct fnetnode *fn)
  81 {
  82     fn->refcount++;
  83 #ifdef DEBUG
  84     fprintf(stderr, "getfnetnode on id %i at %p, refcount=%i\n", fn->id, fn, fn->refcount);
  85 #endif
  86 }
  87
  88 void putfnetnode(struct fnetnode *fn)
  89 {
  90     struct fnetnode *cur;
  91
  92 #ifdef DEBUG
  93     fprintf(stderr, "putfnetnode on id %i at %p, refcount=%i\n", fn->id, fn, fn->refcount - 1);
  94 #endif
  95     if(--fn->refcount)
  96         return;
  97     for(cur = fnetnodes; cur != NULL; cur = cur->next)
  98     {
  99         if(cur == fn)
 100             flog(LOG_CRIT, "BUG: fnetnode reached refcount 0 while still in list - id %i", fn->id);
 101     }
 102     CBCHAINDOCB(fn, fnetnode_destroy, fn);
 103     CBCHAINFREE(fn, fnetnode_ac);
 104     CBCHAINFREE(fn, fnetnode_chat);
 105     CBCHAINFREE(fn, fnetnode_unlink);
 106     CBCHAINFREE(fn, fnetnode_destroy);
 107     CBCHAINFREE(fn, fnetpeer_new);
 108     CBCHAINFREE(fn, fnetpeer_del);
 109     CBCHAINFREE(fn, fnetpeer_chdi);
 110     if(fn->fnet->destroy != NULL)
 111         fn->fnet->destroy(fn);
 112     while(fn->args != NULL)
 113         freewcspair(fn->args, &fn->args);
 114     while(fn->peers != NULL)
 115         fnetdelpeer(fn->peers);
 116     if(fn->mynick != NULL)
 117         free(fn->mynick);
 118     if(fn->pubid != NULL)
 119         free(fn->pubid);
 120     if(fn->name != NULL)
 121         free(fn->name);
 122     if(fn->sk != NULL)
 123         putsock(fn->sk);
 124     if(fn->owner != NULL)
 125         free(fn->owner);
 126     free(fn);
 127     numfnetnodes--;
 128 }
 129
 130 struct fnetnode *findfnetnode(int id)
 131 {
 132     struct fnetnode *fn;
 133
 134     for(fn = fnetnodes; (fn != NULL) && (fn->id != id); fn = fn->next);
 135     return(fn);
 136 }
 137
 138 void linkfnetnode(struct fnetnode *fn)
 139 {
 140     if(fn->linked)
 141         return;
 142     getfnetnode(fn);
 143     fn->next = fnetnodes;
 144     if(fnetnodes != NULL)
 145         fnetnodes->prev = fn;
 146     fnetnodes = fn;
 147     fn->linked = 1;
 148     GCBCHAINDOCB(newfncb, fn);
 149 }
 150
 151 void unlinkfnetnode(struct fnetnode *fn)
 152 {
 153     if(!fn->linked)
 154         return;
 155     if(fnetnodes == fn)
 156         fnetnodes = fn->next;
 157     if(fn->next != NULL)
 158         fn->next->prev = fn->prev;
 159     if(fn->prev != NULL)
 160         fn->prev->next = fn->next;
 161     fn->linked = 0;
 162     CBCHAINDOCB(fn, fnetnode_unlink, fn);
 163     putfnetnode(fn);
 164 }
 165
 166 static void conncb(struct socket *sk, int err, struct fnetnode *data)
 167 {
 168     if(err != 0)
 169     {
 170         killfnetnode(data);
 171         putfnetnode(data);
 172         return;
 173     }
 174     data->sk = sk;
 175     fnetsetstate(data, FNN_HS);
 176     socksettos(sk, confgetint("fnet", "fntos"));
 177     data->fnet->connect(data);
 178     putfnetnode(data);
 179 }
 180
 181 static void resolvecb(struct sockaddr *addr, int addrlen, struct fnetnode *data)
 182 {
 183     if(addr == NULL)
 184     {
 185         killfnetnode(data);
 186         putfnetnode(data);
 187     } else {
 188         netcsconn(addr, addrlen, (void (*)(struct socket *, int, void *))conncb, data);
 189     }
 190 }
 191
 192 static struct fnetpeerdatum *finddatum(struct fnetnode *fn, wchar_t *id)
 193 {
 194     struct fnetpeerdatum *datum;
 195
 196     for(datum = fn->peerdata; datum != NULL; datum = datum->next)
 197     {
 198         if(!wcscmp(datum->id, id))
 199             break;
 200     }
 201     return(datum);
 202 }
 203
 204 static struct fnetpeerdatum *adddatum(struct fnetnode *fn, wchar_t *id, int datatype)
 205 {
 206     struct fnetpeerdatum *new;
 207
 208     new = smalloc(sizeof(*new));
 209     new->refcount = 0;
 210     new->id = swcsdup(id);
 211     new->datatype = datatype;
 212     new->prev = NULL;
 213     new->next = fn->peerdata;
 214     if(fn->peerdata != NULL)
 215         fn->peerdata->prev = new;
 216     fn->peerdata = new;
 217     return(new);
 218 }
 219
 220 static struct fnetpeerdi *difindoradd(struct fnetpeer *peer, struct fnetpeerdatum *datum, int *isnew)
 221 {
 222     int i;
 223
 224     for(i = 0; i < peer->dinum; i++)
 225     {
 226         if(peer->peerdi[i].datum == datum)
 227             break;
 228     }
 229     if(i >= peer->dinum)
 230     {
 231         peer->peerdi = srealloc(peer->peerdi, sizeof(struct fnetpeerdi) * (peer->dinum + 1));
 232         memset(&peer->peerdi[peer->dinum], 0, sizeof(struct fnetpeerdi));
 233         peer->peerdi[peer->dinum].datum = datum;
 234         datum->refcount++;
 235         if(isnew != NULL)
 236             *isnew = 1;
 237         return(&peer->peerdi[peer->dinum++]);
 238     } else {
 239         if(isnew != NULL)
 240             *isnew = 0;
 241         return(&peer->peerdi[i]);
 242     }
 243 }
 244
 245 void fnetpeersetstr(struct fnetpeer *peer, wchar_t *id, wchar_t *value)
 246 {
 247     struct fnetpeerdatum *datum;
 248     struct fnetpeerdi *di;
 249     int changed;
 250
 251     if((datum = finddatum(peer->fn, id)) == NULL)
 252         datum = adddatum(peer->fn, id, FNPD_STR);
 253     di = difindoradd(peer, datum, &changed);
 254     if(di->data.str != NULL) {
 255         changed = (changed || wcscmp(value, di->data.str));
 256         free(di->data.str);
 257     } else {
 258         changed = 1;
 259     }
 260     di->data.str = swcsdup(value);
 261     if(changed)
 262         CBCHAINDOCB(peer->fn, fnetpeer_chdi, peer->fn, peer, di);
 263 }
 264
 265 void fnetpeersetnum(struct fnetpeer *peer, wchar_t *id, int value)
 266 {
 267     struct fnetpeerdatum *datum;
 268     struct fnetpeerdi *di;
 269     int changed;
 270
 271     if((datum = finddatum(peer->fn, id)) == NULL)
 272         datum = adddatum(peer->fn, id, FNPD_INT);
 273     di = difindoradd(peer, datum, &changed);
 274     changed = (changed || (di->data.num != value));
 275     di->data.num = value;
 276     if(changed)
 277         CBCHAINDOCB(peer->fn, fnetpeer_chdi, peer->fn, peer, di);
 278 }
 279
 280 void fnetpeersetlnum(struct fnetpeer *peer, wchar_t *id, long long value)
 281 {
 282     struct fnetpeerdatum *datum;
 283     struct fnetpeerdi *di;
 284     int changed;
 285
 286     if((datum = finddatum(peer->fn, id)) == NULL)
 287         datum = adddatum(peer->fn, id, FNPD_LL);
 288     di = difindoradd(peer, datum, &changed);
 289     changed = (changed || (di->data.lnum != value));
 290     di->data.lnum = value;
 291     if(changed)
 292         CBCHAINDOCB(peer->fn, fnetpeer_chdi, peer->fn, peer, di);
 293 }
 294
 295 static void putdatum(struct fnetpeer *peer, struct fnetpeerdatum *datum)
 296 {
 297     if(--datum->refcount > 0)
 298         return;
 299     if(datum->next != NULL)
 300         datum->next->prev = datum->prev;
 301     if(datum->prev != NULL)
 302         datum->prev->next = datum->next;
 303     if(datum == peer->fn->peerdata)
 304         peer->fn->peerdata = datum->next;
 305     free(datum->id);
 306     free(datum);
 307 }
 308
 309 void fnetpeerunset(struct fnetpeer *peer, wchar_t *id)
 310 {
 311     int i;
 312     struct fnetpeerdatum *datum;
 313
 314     if((datum = finddatum(peer->fn, id)) == NULL)
 315         return;
 316     for(i = 0; i < peer->dinum; i++)
 317     {
 318         if(peer->peerdi[i].datum == datum)
 319             break;
 320     }
 321     if(i >= peer->dinum)
 322         return;
 323     if((datum->datatype == FNPD_STR) && (peer->peerdi[i].data.str != NULL))
 324         free(peer->peerdi[i].data.str);
 325     peer->dinum--;
 326     memmove(&peer->peerdi[i], &peer->peerdi[i + 1], sizeof(struct fnetpeerdi) * (peer->dinum - i));
 327     putdatum(peer, datum);
 328 }
 329
 330 struct fnetpeer *fnetaddpeer(struct fnetnode *fn, wchar_t *id, wchar_t *nick)
 331 {
 332     struct fnetpeer *new;
 333
 334     new = smalloc(sizeof(*new));
 335     new->fn = fn;
 336     new->id = swcsdup(id);
 337     new->nick = swcsdup(nick);
 338     new->flags.w = 0;
 339     new->dinum = 0;
 340     new->peerdi = NULL;
 341     new->next = fn->peers;
 342     new->prev = NULL;
 343     if(fn->peers != NULL)
 344         fn->peers->prev = new;
 345     fn->peers = new;
 346     fn->numpeers++;
 347     CBCHAINDOCB(fn, fnetnode_ac, fn, L"numpeers");
 348     CBCHAINDOCB(fn, fnetpeer_new, fn, new);
 349     return(new);
 350 }
 351
 352 void fnetdelpeer(struct fnetpeer *peer)
 353 {
 354     int i;
 355
 356     if(peer->next != NULL)
 357         peer->next->prev = peer->prev;
 358     if(peer->prev != NULL)
 359         peer->prev->next = peer->next;
 360     if(peer->fn->peers == peer)
 361         peer->fn->peers = peer->next;
 362     peer->fn->numpeers--;
 363     CBCHAINDOCB(peer->fn, fnetnode_ac, peer->fn, L"numpeers");
 364     CBCHAINDOCB(peer->fn, fnetpeer_del, peer->fn, peer);
 365     free(peer->id);
 366     free(peer->nick);
 367     for(i = 0; i < peer->dinum; i++)
 368     {
 369         if((peer->peerdi[i].datum->datatype == FNPD_STR) && (peer->peerdi[i].data.str != NULL))
 370             free(peer->peerdi[i].data.str);
 371         putdatum(peer, peer->peerdi[i].datum);
 372     }
 373     if(peer->peerdi != NULL)
 374         free(peer->peerdi);
 375     free(peer);
 376 }
 377
 378 struct fnetpeer *fnetfindpeer(struct fnetnode *fn, wchar_t *id)
 379 {
 380     struct fnetpeer *cur;
 381
 382     for(cur = fn->peers; (cur != NULL) && wcscmp(cur->id, id); cur = cur->next);
 383     return(cur);
 384 }
 385
 386 int fnetsetnick(struct fnetnode *fn, wchar_t *newnick)
 387 {
 388     int ret;
 389
 390     if(fn->fnet->setnick != NULL)
 391         ret = fn->fnet->setnick(fn, newnick);
 392     else
 393         ret = 0;
 394     if(!ret)
 395     {
 396         if(fn->mynick != NULL)
 397             free(fn->mynick);
 398         fn->mynick = swcsdup(newnick);
 399     }
 400     return(ret);
 401 }
 402
 403 int fnetsendchat(struct fnetnode *fn, int public, wchar_t *to, wchar_t *string)
 404 {
 405     if(fn->fnet->sendchat == NULL)
 406     {
 407         errno = ENOTSUP;
 408         return(-1);
 409     }
 410     return(fn->fnet->sendchat(fn, public, to, string));
 411 }
 412
 413 int fnetsearch(struct fnetnode *fn, struct search *srch, struct srchfnnlist *ln)
 414 {
 415     if(fn->fnet->search == NULL)
 416     {
 417         errno = ENOTSUP;
 418         return(-1);
 419     }
 420     return(fn->fnet->search(fn, srch, ln));
 421 }
 422
 423 void fnetsetname(struct fnetnode *fn, wchar_t *newname)
 424 {
 425     if(fn->name != NULL)
 426         free(fn->name);
 427     fn->name = swcsdup(newname);
 428     CBCHAINDOCB(fn, fnetnode_ac, fn, L"name");
 429 }
 430
 431 void fnetsetstate(struct fnetnode *fn, int newstate)
 432 {
 433     fn->state = newstate;
 434     CBCHAINDOCB(fn, fnetnode_ac, fn, L"state");
 435 }
 436
 437 struct fnet *findfnet(wchar_t *name)
 438 {
 439     struct fnet *fnet;
 440
 441     for(fnet = networks; fnet != NULL; fnet = fnet->next)
 442     {
 443         if(!wcscmp(name, fnet->name))
 444             break;
 445     }
 446     return(fnet);
 447 }
 448
 449 struct fnetnode *fnetinitconnect(wchar_t *name, wchar_t *owner, char *addr, struct wcspair *args)
 450 {
 451     struct fnet *fnet;
 452     struct fnetnode *fn;
 453     struct wcspair *arg;
 454
 455     if((fnet = findfnet(name)) == NULL)
 456     {
 457         errno = EPROTONOSUPPORT;
 458         return(NULL);
 459     }
 460     fn = newfn(fnet);
 461     fn->owner = swcsdup(owner);
 462     fn->pubid = icmbstowcs(addr, NULL);
 463     if(fn->pubid == NULL)
 464         fn->pubid = swcsdup(L"");
 465     fn->args = args;
 466     for(arg = fn->args; arg != NULL; arg = arg->next)
 467     {
 468         if(!wcscmp(arg->key, L"nick"))
 469             fnetsetnick(fn, arg->val);
 470     }
 471     getfnetnode(fn);
 472     if(netresolve(addr, (void (*)(struct sockaddr *, int, void *))resolvecb, fn) < 0)
 473         return(NULL);
 474     return(fn);
 475 }
 476
 477 void regfnet(struct fnet *fnet)
 478 {
 479     fnet->next = networks;
 480     networks = fnet;
 481 }
 482
 483 /*
 484  * Note on the chat string: Must be in UNIX text file format - that
 485  * is, LF line endings. The filenet-specific code must see to it that
 486  * any other kind of format is converted into that. In the future,
 487  * certain control characters and escape sequences will be parsed by
 488  * the client. Make sure that any filenet-specific code strips any
 489  * such that aren't supposed to be in the protocol.
 490  *
 491  * Note on "name": This is supposed to be an identifier for the
 492  * source. If the chat is a public message, set "public" to non-zero
 493  * and "name" to whatever "chat room" name is appropriate for the
 494  * fnetnode, but not NULL. If there is a "default" channel in this
 495  * filenet, set "name" to the empty string. If the chat is a private
 496  * message, name is ignored.
 497  */
 498 void fnethandlechat(struct fnetnode *fn, int public, wchar_t *name, wchar_t *peer, wchar_t *chat)
 499 {
 500     CBCHAINDOCB(fn, fnetnode_chat, fn, public, name, peer, chat);
 501 }
 502
 503 static struct configvar myvars[] =
 504 {
 505     /** The number of seconds to wait between searches. Most hubs
 506      * require at least ten seconds, and quite often network lag will
 507      * often make searches arrive to the hub more often than sent. It
 508      * may be semi-dangerous to specify too low a value, since hubs
 509      * will often kick users that search too often (even when the
 510      * reason is network lag -- there is no way for the hub to know
 511      * this), but it is quite annoying to set too high a value. 15 to
 512      * 40 seconds are the recommended range (although the default is
 513      * 15 seconds, it is recommended to set to 30 seconds). */
 514     {CONF_VAR_INT, "srchwait", {.num = 15}},
 515     /** The TOS value to use for hub connections (see the TOS VALUES
 516      * section). */
 517     {CONF_VAR_INT, "fntos", {.num = 0}},
 518     /** The TOS value to use for peer connections (see the TOS VALUES
 519      * section). */
 520     {CONF_VAR_INT, "fnptos", {.num = 0}},
 521     /** Specifies a maximum number of simultaneously connected
 522      * hubs. Attempts to connect to new hubs beyond this limit will
 523      * return an error. Set to zero to remove the limit. */
 524     {CONF_VAR_INT, "maxnodes", {.num = 0}},
 525     {CONF_VAR_END}
 526 };
 527
 528 static struct module me =
 529 {
 530     .conf =
 531     {
 532         .vars = myvars
 533     },
 534     .name = "fnet"
 535 };
 536
 537 MODULE(me)