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             putfnetnode(fn);
  72         putsock(fn->sk);
  73         fn->sk = NULL;
  74     }
  75 }
  76
  77 void getfnetnode(struct fnetnode *fn)
  78 {
  79     fn->refcount++;
  80 #ifdef DEBUG
  81     fprintf(stderr, "getfnetnode on id %i at %p, refcount=%i\n", fn->id, fn, fn->refcount);
  82 #endif
  83 }
  84
  85 void putfnetnode(struct fnetnode *fn)
  86 {
  87     struct fnetnode *cur;
  88
  89 #ifdef DEBUG
  90     fprintf(stderr, "putfnetnode on id %i at %p, refcount=%i\n", fn->id, fn, fn->refcount - 1);
  91 #endif
  92     if(--fn->refcount)
  93         return;
  94     for(cur = fnetnodes; cur != NULL; cur = cur->next)
  95     {
  96         if(cur == fn)
  97             flog(LOG_CRIT, "BUG: fnetnode reached refcount 0 while still in list - id %i", fn->id);
  98     }
  99     CBCHAINDOCB(fn, fnetnode_destroy, fn);
 100     CBCHAINFREE(fn, fnetnode_ac);
 101     CBCHAINFREE(fn, fnetnode_chat);
 102     CBCHAINFREE(fn, fnetnode_unlink);
 103     CBCHAINFREE(fn, fnetnode_destroy);
 104     CBCHAINFREE(fn, fnetpeer_new);
 105     CBCHAINFREE(fn, fnetpeer_del);
 106     CBCHAINFREE(fn, fnetpeer_chdi);
 107     if(fn->fnet->destroy != NULL)
 108         fn->fnet->destroy(fn);
 109     while(fn->args != NULL)
 110         freewcspair(fn->args, &fn->args);
 111     while(fn->peers != NULL)
 112         fnetdelpeer(fn->peers);
 113     if(fn->mynick != NULL)
 114         free(fn->mynick);
 115     if(fn->pubid != NULL)
 116         free(fn->pubid);
 117     if(fn->name != NULL)
 118         free(fn->name);
 119     if(fn->sk != NULL)
 120         putsock(fn->sk);
 121     free(fn);
 122     numfnetnodes--;
 123 }
 124
 125 struct fnetnode *findfnetnode(int id)
 126 {
 127     struct fnetnode *fn;
 128
 129     for(fn = fnetnodes; (fn != NULL) && (fn->id != id); fn = fn->next);
 130     return(fn);
 131 }
 132
 133 void linkfnetnode(struct fnetnode *fn)
 134 {
 135     if(fn->linked)
 136         return;
 137     getfnetnode(fn);
 138     fn->next = fnetnodes;
 139     if(fnetnodes != NULL)
 140         fnetnodes->prev = fn;
 141     fnetnodes = fn;
 142     fn->linked = 1;
 143     GCBCHAINDOCB(newfncb, fn);
 144 }
 145
 146 void unlinkfnetnode(struct fnetnode *fn)
 147 {
 148     if(!fn->linked)
 149         return;
 150     if(fnetnodes == fn)
 151         fnetnodes = fn->next;
 152     if(fn->next != NULL)
 153         fn->next->prev = fn->prev;
 154     if(fn->prev != NULL)
 155         fn->prev->next = fn->next;
 156     fn->linked = 0;
 157     CBCHAINDOCB(fn, fnetnode_unlink, fn);
 158     putfnetnode(fn);
 159 }
 160
 161 static void conncb(struct socket *sk, int err, struct fnetnode *data)
 162 {
 163     if(err != 0)
 164     {
 165         killfnetnode(data);
 166         putfnetnode(data);
 167         return;
 168     }
 169     data->sk = sk;
 170     fnetsetstate(data, FNN_HS);
 171     socksettos(sk, confgetint("fnet", "fntos"));
 172     data->fnet->connect(data);
 173     putfnetnode(data);
 174 }
 175
 176 static void resolvecb(struct sockaddr *addr, int addrlen, struct fnetnode *data)
 177 {
 178     if(addr == NULL)
 179     {
 180         killfnetnode(data);
 181         putfnetnode(data);
 182     } else {
 183         netcsconn(addr, addrlen, (void (*)(struct socket *, int, void *))conncb, data);
 184     }
 185 }
 186
 187 static struct fnetpeerdatum *finddatum(struct fnetnode *fn, wchar_t *id)
 188 {
 189     struct fnetpeerdatum *datum;
 190
 191     for(datum = fn->peerdata; datum != NULL; datum = datum->next)
 192     {
 193         if(!wcscmp(datum->id, id))
 194             break;
 195     }
 196     return(datum);
 197 }
 198
 199 static struct fnetpeerdatum *adddatum(struct fnetnode *fn, wchar_t *id, int datatype)
 200 {
 201     struct fnetpeerdatum *new;
 202
 203     new = smalloc(sizeof(*new));
 204     new->refcount = 0;
 205     new->id = swcsdup(id);
 206     new->datatype = datatype;
 207     new->prev = NULL;
 208     new->next = fn->peerdata;
 209     if(fn->peerdata != NULL)
 210         fn->peerdata->prev = new;
 211     fn->peerdata = new;
 212     return(new);
 213 }
 214
 215 static struct fnetpeerdi *difindoradd(struct fnetpeer *peer, struct fnetpeerdatum *datum, int *isnew)
 216 {
 217     int i;
 218
 219     for(i = 0; i < peer->dinum; i++)
 220     {
 221         if(peer->peerdi[i].datum == datum)
 222             break;
 223     }
 224     if(i >= peer->dinum)
 225     {
 226         peer->peerdi = srealloc(peer->peerdi, sizeof(struct fnetpeerdi) * (peer->dinum + 1));
 227         memset(&peer->peerdi[peer->dinum], 0, sizeof(struct fnetpeerdi));
 228         peer->peerdi[peer->dinum].datum = datum;
 229         datum->refcount++;
 230         if(isnew != NULL)
 231             *isnew = 1;
 232         return(&peer->peerdi[peer->dinum++]);
 233     } else {
 234         if(isnew != NULL)
 235             *isnew = 0;
 236         return(&peer->peerdi[i]);
 237     }
 238 }
 239
 240 void fnetpeersetstr(struct fnetpeer *peer, wchar_t *id, wchar_t *value)
 241 {
 242     struct fnetpeerdatum *datum;
 243     struct fnetpeerdi *di;
 244     int changed;
 245
 246     if((datum = finddatum(peer->fn, id)) == NULL)
 247         datum = adddatum(peer->fn, id, FNPD_STR);
 248     di = difindoradd(peer, datum, &changed);
 249     if(di->data.str != NULL) {
 250         changed = (changed || wcscmp(value, di->data.str));
 251         free(di->data.str);
 252     } else {
 253         changed = 1;
 254     }
 255     di->data.str = swcsdup(value);
 256     if(changed)
 257         CBCHAINDOCB(peer->fn, fnetpeer_chdi, peer->fn, peer, di);
 258 }
 259
 260 void fnetpeersetnum(struct fnetpeer *peer, wchar_t *id, int value)
 261 {
 262     struct fnetpeerdatum *datum;
 263     struct fnetpeerdi *di;
 264     int changed;
 265
 266     if((datum = finddatum(peer->fn, id)) == NULL)
 267         datum = adddatum(peer->fn, id, FNPD_INT);
 268     di = difindoradd(peer, datum, &changed);
 269     changed = (changed || (di->data.num != value));
 270     di->data.num = value;
 271     if(changed)
 272         CBCHAINDOCB(peer->fn, fnetpeer_chdi, peer->fn, peer, di);
 273 }
 274
 275 void fnetpeersetlnum(struct fnetpeer *peer, wchar_t *id, long long value)
 276 {
 277     struct fnetpeerdatum *datum;
 278     struct fnetpeerdi *di;
 279     int changed;
 280
 281     if((datum = finddatum(peer->fn, id)) == NULL)
 282         datum = adddatum(peer->fn, id, FNPD_LL);
 283     di = difindoradd(peer, datum, &changed);
 284     changed = (changed || (di->data.lnum != value));
 285     di->data.lnum = value;
 286     if(changed)
 287         CBCHAINDOCB(peer->fn, fnetpeer_chdi, peer->fn, peer, di);
 288 }
 289
 290 static void putdatum(struct fnetpeer *peer, struct fnetpeerdatum *datum)
 291 {
 292     if(--datum->refcount > 0)
 293         return;
 294     if(datum->next != NULL)
 295         datum->next->prev = datum->prev;
 296     if(datum->prev != NULL)
 297         datum->prev->next = datum->next;
 298     if(datum == peer->fn->peerdata)
 299         peer->fn->peerdata = datum->next;
 300     free(datum->id);
 301     free(datum);
 302 }
 303
 304 void fnetpeerunset(struct fnetpeer *peer, wchar_t *id)
 305 {
 306     int i;
 307     struct fnetpeerdatum *datum;
 308
 309     if((datum = finddatum(peer->fn, id)) == NULL)
 310         return;
 311     for(i = 0; i < peer->dinum; i++)
 312     {
 313         if(peer->peerdi[i].datum == datum)
 314             break;
 315     }
 316     if(i >= peer->dinum)
 317         return;
 318     if((datum->datatype == FNPD_STR) && (peer->peerdi[i].data.str != NULL))
 319         free(peer->peerdi[i].data.str);
 320     peer->dinum--;
 321     memmove(&peer->peerdi[i], &peer->peerdi[i + 1], sizeof(struct fnetpeerdi) * (peer->dinum - i));
 322     putdatum(peer, datum);
 323 }
 324
 325 struct fnetpeer *fnetaddpeer(struct fnetnode *fn, wchar_t *id, wchar_t *nick)
 326 {
 327     struct fnetpeer *new;
 328
 329     new = smalloc(sizeof(*new));
 330     new->fn = fn;
 331     new->id = swcsdup(id);
 332     new->nick = swcsdup(nick);
 333     new->flags.w = 0;
 334     new->dinum = 0;
 335     new->peerdi = NULL;
 336     new->next = fn->peers;
 337     new->prev = NULL;
 338     if(fn->peers != NULL)
 339         fn->peers->prev = new;
 340     fn->peers = new;
 341     fn->numpeers++;
 342     CBCHAINDOCB(fn, fnetnode_ac, fn, L"numpeers");
 343     CBCHAINDOCB(fn, fnetpeer_new, fn, new);
 344     return(new);
 345 }
 346
 347 void fnetdelpeer(struct fnetpeer *peer)
 348 {
 349     int i;
 350
 351     if(peer->next != NULL)
 352         peer->next->prev = peer->prev;
 353     if(peer->prev != NULL)
 354         peer->prev->next = peer->next;
 355     if(peer->fn->peers == peer)
 356         peer->fn->peers = peer->next;
 357     peer->fn->numpeers--;
 358     CBCHAINDOCB(peer->fn, fnetnode_ac, peer->fn, L"numpeers");
 359     CBCHAINDOCB(peer->fn, fnetpeer_del, peer->fn, peer);
 360     free(peer->id);
 361     free(peer->nick);
 362     for(i = 0; i < peer->dinum; i++)
 363     {
 364         if((peer->peerdi[i].datum->datatype == FNPD_STR) && (peer->peerdi[i].data.str != NULL))
 365             free(peer->peerdi[i].data.str);
 366         putdatum(peer, peer->peerdi[i].datum);
 367     }
 368     if(peer->peerdi != NULL)
 369         free(peer->peerdi);
 370     free(peer);
 371 }
 372
 373 struct fnetpeer *fnetfindpeer(struct fnetnode *fn, wchar_t *id)
 374 {
 375     struct fnetpeer *cur;
 376
 377     for(cur = fn->peers; (cur != NULL) && wcscmp(cur->id, id); cur = cur->next);
 378     return(cur);
 379 }
 380
 381 int fnetsetnick(struct fnetnode *fn, wchar_t *newnick)
 382 {
 383     int ret;
 384
 385     if(fn->fnet->setnick != NULL)
 386         ret = fn->fnet->setnick(fn, newnick);
 387     else
 388         ret = 0;
 389     if(!ret)
 390     {
 391         if(fn->mynick != NULL)
 392             free(fn->mynick);
 393         fn->mynick = swcsdup(newnick);
 394     }
 395     return(ret);
 396 }
 397
 398 int fnetsendchat(struct fnetnode *fn, int public, wchar_t *to, wchar_t *string)
 399 {
 400     if(fn->fnet->sendchat == NULL)
 401     {
 402         errno = ENOTSUP;
 403         return(-1);
 404     }
 405     return(fn->fnet->sendchat(fn, public, to, string));
 406 }
 407
 408 int fnetsearch(struct fnetnode *fn, struct search *srch, struct srchfnnlist *ln)
 409 {
 410     if(fn->fnet->search == NULL)
 411     {
 412         errno = ENOTSUP;
 413         return(-1);
 414     }
 415     return(fn->fnet->search(fn, srch, ln));
 416 }
 417
 418 void fnetsetname(struct fnetnode *fn, wchar_t *newname)
 419 {
 420     if(fn->name != NULL)
 421         free(fn->name);
 422     fn->name = swcsdup(newname);
 423     CBCHAINDOCB(fn, fnetnode_ac, fn, L"name");
 424 }
 425
 426 void fnetsetstate(struct fnetnode *fn, int newstate)
 427 {
 428     fn->state = newstate;
 429     CBCHAINDOCB(fn, fnetnode_ac, fn, L"state");
 430 }
 431
 432 struct fnet *findfnet(wchar_t *name)
 433 {
 434     struct fnet *fnet;
 435
 436     for(fnet = networks; fnet != NULL; fnet = fnet->next)
 437     {
 438         if(!wcscmp(name, fnet->name))
 439             break;
 440     }
 441     return(fnet);
 442 }
 443
 444 struct fnetnode *fnetinitconnect(wchar_t *name, char *addr, struct wcspair *args)
 445 {
 446     struct fnet *fnet;
 447     struct fnetnode *fn;
 448     struct wcspair *arg;
 449
 450     if((fnet = findfnet(name)) == NULL)
 451     {
 452         errno = EPROTONOSUPPORT;
 453         return(NULL);
 454     }
 455     fn = newfn(fnet);
 456     fn->pubid = icmbstowcs(addr, NULL);
 457     if(fn->pubid == NULL)
 458         fn->pubid = swcsdup(L"");
 459     fn->args = args;
 460     for(arg = fn->args; arg != NULL; arg = arg->next)
 461     {
 462         if(!wcscmp(arg->key, L"nick"))
 463             fnetsetnick(fn, arg->val);
 464     }
 465     getfnetnode(fn);
 466     if(netresolve(addr, (void (*)(struct sockaddr *, int, void *))resolvecb, fn) < 0)
 467         return(NULL);
 468     return(fn);
 469 }
 470
 471 void regfnet(struct fnet *fnet)
 472 {
 473     fnet->next = networks;
 474     networks = fnet;
 475 }
 476
 477 /*
 478  * Note on the chat string: Must be in UNIX text file format - that
 479  * is, LF line endings. The filenet-specific code must see to it that
 480  * any other kind of format is converted into that. In the future,
 481  * certain control characters and escape sequences will be parsed by
 482  * the client. Make sure that any filenet-specific code strips any
 483  * such that aren't supposed to be in the protocol.
 484  *
 485  * Note on "name": This is supposed to be an identifier for the
 486  * source. If the chat is a public message, set "public" to non-zero
 487  * and "name" to whatever "chat room" name is appropriate for the
 488  * fnetnode, but not NULL. If there is a "default" channel in this
 489  * filenet, set "name" to the empty string. If the chat is a private
 490  * message, name is ignored.
 491  */
 492 void fnethandlechat(struct fnetnode *fn, int public, wchar_t *name, wchar_t *peer, wchar_t *chat)
 493 {
 494     CBCHAINDOCB(fn, fnetnode_chat, fn, public, name, peer, chat);
 495 }
 496
 497 static struct configvar myvars[] =
 498 {
 499     {CONF_VAR_INT, "srchwait", {.num = 15}},
 500     {CONF_VAR_INT, "fntos", {.num = 0}},
 501     {CONF_VAR_INT, "fnptos", {.num = 0}},
 502     {CONF_VAR_END}
 503 };
 504
 505 static struct module me =
 506 {
 507     .conf =
 508     {
 509         .vars = myvars
 510     },
 511     .name = "fnet"
 512 };
 513
 514 MODULE(me)