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