dc-filtercmd needs bash, not sh.
[doldaconnect.git] / 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)