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