]> git.meshlink.io Git - catta/blob - avahi-daemon/static-services.c
improve documentation
[catta] / avahi-daemon / static-services.c
1 /* $Id$ */
2
3 /***
4   This file is part of avahi.
5  
6   avahi is free software; you can redistribute it and/or modify it
7   under the terms of the GNU Lesser General Public License as
8   published by the Free Software Foundation; either version 2.1 of the
9   License, or (at your option) any later version.
10  
11   avahi is distributed in the hope that it will be useful, but WITHOUT
12   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
14   Public License for more details.
15  
16   You should have received a copy of the GNU Lesser General Public
17   License along with avahi; if not, write to the Free Software
18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
19   USA.
20 ***/
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <sys/stat.h>
27 #include <glob.h>
28 #include <limits.h>
29 #include <string.h>
30 #include <errno.h>
31 #include <fcntl.h>
32 #include <unistd.h>
33
34 #include <glib.h>
35 #include <expat.h>
36
37 #include <avahi-core/llist.h>
38 #include <avahi-core/log.h>
39
40 #include "main.h"
41
42 typedef struct StaticService StaticService;
43 typedef struct StaticServiceGroup StaticServiceGroup;
44
45 struct StaticService {
46     StaticServiceGroup *group;
47     
48     gchar *type;
49     gchar *domain_name;
50     gchar *host_name;
51     guint16 port;
52
53     AvahiStringList *txt_records;
54     
55     AVAHI_LLIST_FIELDS(StaticService, services);
56 };
57
58 struct StaticServiceGroup {
59     gchar *filename;
60     time_t mtime;
61
62     gchar *name, *chosen_name;
63     gboolean replace_wildcards;
64
65     AvahiEntryGroup *entry_group;
66     AVAHI_LLIST_HEAD(StaticService, services);
67     AVAHI_LLIST_FIELDS(StaticServiceGroup, groups);
68 };
69
70 static AVAHI_LLIST_HEAD(StaticServiceGroup, groups) = NULL;
71
72 static gchar *replacestr(const gchar *pattern, const gchar *a, const gchar *b) {
73     gchar *r = NULL, *e, *n;
74
75     while ((e = strstr(pattern, a))) {
76         gchar *k;
77
78         k = g_strndup(pattern, e - pattern);
79         if (r)
80             n = g_strconcat(r, k, b, NULL);
81         else
82             n = g_strconcat(k, b, NULL);
83
84         g_free(k);
85         g_free(r);
86         r = n;
87
88         pattern = e + strlen(a);
89     }
90
91     if (!r)
92         return g_strdup(pattern);
93
94     n = g_strconcat(r, pattern, NULL);
95     g_free(r);
96
97     return n;
98 }
99
100 static void add_static_service_group_to_server(StaticServiceGroup *g);
101 static void remove_static_service_group_from_server(StaticServiceGroup *g);
102
103 static StaticService *static_service_new(StaticServiceGroup *group) {
104     StaticService *s;
105     
106     g_assert(group);
107     s = g_new(StaticService, 1);
108     s->group = group;
109
110     s->type = s->host_name = s->domain_name = NULL;
111     s->port = 0;
112
113     s->txt_records = NULL;
114
115     AVAHI_LLIST_PREPEND(StaticService, services, group->services, s);
116
117     return s;
118 }
119
120 static StaticServiceGroup *static_service_group_new(gchar *filename) {
121     StaticServiceGroup *g;
122     g_assert(filename);
123
124     g = g_new(StaticServiceGroup, 1);
125     g->filename = g_strdup(filename);
126     g->mtime = 0;
127     g->name = g->chosen_name = NULL;
128     g->replace_wildcards = FALSE;
129     g->entry_group = NULL;
130
131     AVAHI_LLIST_HEAD_INIT(StaticService, g->services);
132     AVAHI_LLIST_PREPEND(StaticServiceGroup, groups, groups, g);
133
134     return g;
135 }
136
137 static void static_service_free(StaticService *s) {
138     g_assert(s);
139     
140     AVAHI_LLIST_REMOVE(StaticService, services, s->group->services, s);
141
142     g_free(s->type);
143     g_free(s->host_name);
144     g_free(s->domain_name);
145
146     avahi_string_list_free(s->txt_records);
147     
148     g_free(s);
149 }
150
151 static void static_service_group_free(StaticServiceGroup *g) {
152     g_assert(g);
153
154     remove_static_service_group_from_server(g);
155
156     while (g->services)
157         static_service_free(g->services);
158
159     AVAHI_LLIST_REMOVE(StaticServiceGroup, groups, groups, g);
160
161     g_free(g->filename);
162     g_free(g->name);
163     g_free(g->chosen_name);
164     g_free(g);
165 }
166
167 static void entry_group_callback(AvahiServer *s, AvahiEntryGroup *eg, AvahiEntryGroupState state, gpointer userdata) {
168     StaticServiceGroup *g = userdata;
169     
170     g_assert(s);
171     g_assert(g);
172     
173     if (state == AVAHI_ENTRY_GROUP_COLLISION) {
174         gchar *n;
175
176         remove_static_service_group_from_server(g);
177
178         n = avahi_alternative_service_name(g->chosen_name);
179         g_free(g->chosen_name);
180         g->chosen_name = n;
181
182         avahi_log_notice("Service name conflict for \"%s\" (%s), retrying with \"%s\".", g->name, g->filename, g->chosen_name);
183
184         add_static_service_group_to_server(g);
185     } else if (state == AVAHI_ENTRY_GROUP_ESTABLISHED)
186         avahi_log_info("Service \"%s\" (%s) successfully established.", g->chosen_name, g->filename);
187 }
188
189 static void add_static_service_group_to_server(StaticServiceGroup *g) {
190     StaticService *s;
191
192     g_assert(g);
193     
194     if (g->entry_group)
195         return;
196     
197     if (g->chosen_name)
198         g_free(g->chosen_name);
199     
200     if (g->replace_wildcards)
201         g->chosen_name = replacestr(g->name, "%h", avahi_server_get_host_name(avahi_server));
202     else
203         g->chosen_name = g_strdup(g->name);
204     
205     g->entry_group = avahi_entry_group_new(avahi_server, entry_group_callback, g);
206     
207     for (s = g->services; s; s = s->services_next) {
208
209         if (avahi_server_add_service_strlst(
210                 avahi_server,
211                 g->entry_group,
212                 -1, AF_UNSPEC,
213                 s->type, g->chosen_name,
214                 s->domain_name, s->host_name, s->port,
215                 avahi_string_list_copy(s->txt_records)) < 0) {
216             avahi_log_error("Failed to add service '%s' of type '%s', ignoring service group (%s)", g->chosen_name, s->type, g->filename);
217             remove_static_service_group_from_server(g);
218             return;
219         }
220     }
221
222     avahi_entry_group_commit(g->entry_group);
223 }
224
225 static void remove_static_service_group_from_server(StaticServiceGroup *g) {
226     g_assert(g);
227
228     if (g->entry_group) {
229         avahi_entry_group_free(g->entry_group);
230         g->entry_group = NULL;
231     }
232 }
233
234 typedef enum {
235     XML_TAG_INVALID,
236     XML_TAG_SERVICE_GROUP,
237     XML_TAG_NAME,
238     XML_TAG_SERVICE,
239     XML_TAG_TYPE,
240     XML_TAG_DOMAIN_NAME,
241     XML_TAG_HOST_NAME,
242     XML_TAG_PORT,
243     XML_TAG_TXT_RECORD
244 } xml_tag_name;
245
246 struct xml_userdata {
247     StaticServiceGroup *group;
248     StaticService *service;
249     xml_tag_name current_tag;
250     gboolean failed;
251     gchar *buf;
252 };
253
254 static void XMLCALL xml_start(void *data, const char *el, const char *attr[]) {
255     struct xml_userdata *u = data;
256     
257     g_assert(u);
258
259     if (u->failed)
260         return;
261
262     if (u->current_tag == XML_TAG_INVALID && strcmp(el, "service-group") == 0) {
263
264         if (attr[0])
265             goto invalid_attr;
266
267         u->current_tag = XML_TAG_SERVICE_GROUP;
268     } else if (u->current_tag == XML_TAG_SERVICE_GROUP && strcmp(el, "name") == 0) {
269         u->current_tag = XML_TAG_NAME;
270
271         if (attr[0]) {
272             if (strcmp(attr[0], "replace-wildcards") == 0) 
273                 u->group->replace_wildcards = strcmp(attr[1], "yes") == 0;
274             else
275                 goto invalid_attr;
276         }
277
278         if (attr[2])
279             goto invalid_attr;
280         
281             
282         
283     } else if (u->current_tag == XML_TAG_SERVICE_GROUP && strcmp(el, "service") == 0) {
284         if (attr[0])
285             goto invalid_attr;
286
287         g_assert(!u->service);
288         u->service = static_service_new(u->group);
289
290         u->current_tag = XML_TAG_SERVICE;
291     } else if (u->current_tag == XML_TAG_SERVICE && strcmp(el, "type") == 0) {
292         if (attr[0])
293             goto invalid_attr;
294
295         u->current_tag = XML_TAG_TYPE;
296     } else if (u->current_tag == XML_TAG_SERVICE && strcmp(el, "domain-name") == 0) {
297         if (attr[0])
298             goto invalid_attr;
299         
300         u->current_tag = XML_TAG_DOMAIN_NAME;
301     } else if (u->current_tag == XML_TAG_SERVICE && strcmp(el, "host-name") == 0) {
302         if (attr[0])
303             goto invalid_attr;
304         
305         u->current_tag = XML_TAG_HOST_NAME;
306     } else if (u->current_tag == XML_TAG_SERVICE && strcmp(el, "port") == 0) {
307         if (attr[0])
308             goto invalid_attr;
309         
310         u->current_tag = XML_TAG_PORT;
311     } else if (u->current_tag == XML_TAG_SERVICE && strcmp(el, "txt-record") == 0) {
312         if (attr[0])
313             goto invalid_attr;
314         
315         u->current_tag = XML_TAG_TXT_RECORD;
316     } else {
317         avahi_log_error("%s: parse failure: didn't expect element <%s>.", u->group->filename, el);
318         u->failed = TRUE;
319     }
320
321     return;
322
323 invalid_attr:
324     avahi_log_error("%s: parse failure: invalid attribute for element <%s>.", u->group->filename, el);
325     u->failed = TRUE;
326     return;
327 }
328     
329 static void XMLCALL xml_end(void *data, const char *el) {
330     struct xml_userdata *u = data;
331     g_assert(u);
332
333     if (u->failed)
334         return;
335     
336     switch (u->current_tag) {
337         case XML_TAG_SERVICE_GROUP:
338
339             if (!u->group->name || !u->group->services) {
340                 avahi_log_error("%s: parse failure: service group incomplete.", u->group->filename);
341                 u->failed = TRUE;
342                 return;
343             }
344             
345             u->current_tag = XML_TAG_INVALID;
346             break;
347
348         case XML_TAG_SERVICE:
349
350             if (u->service->port == 0 || !u->service->type) {
351                 avahi_log_error("%s: parse failure: service incomplete.", u->group->filename);
352                 u->failed = TRUE;
353                 return;
354             }
355             
356             u->service = NULL;
357             u->current_tag = XML_TAG_SERVICE_GROUP;
358             break;
359
360         case XML_TAG_NAME:
361             u->current_tag = XML_TAG_SERVICE_GROUP;
362             break;
363
364         case XML_TAG_PORT: {
365             int p;
366             g_assert(u->service);
367             
368             p = u->buf ? atoi(u->buf) : 0;
369
370             if (p <= 0 || p > 0xFFFF) {
371                 avahi_log_error("%s: parse failure: invalid port specification \"%s\".", u->group->filename, u->buf);
372                 u->failed = TRUE;
373                 return;
374             }
375
376             u->service->port = (guint16) p;
377
378             u->current_tag = XML_TAG_SERVICE;
379             break;
380         }
381
382         case XML_TAG_TXT_RECORD: {
383             g_assert(u->service);
384             
385             u->service->txt_records = avahi_string_list_add(u->service->txt_records, u->buf ? u->buf : "");
386             u->current_tag = XML_TAG_SERVICE;
387             break;
388         }
389             
390         case XML_TAG_TYPE:
391         case XML_TAG_DOMAIN_NAME:
392         case XML_TAG_HOST_NAME:
393             u->current_tag = XML_TAG_SERVICE;
394             break;
395
396         case XML_TAG_INVALID:
397             ;
398     }
399
400     g_free(u->buf);
401     u->buf = NULL;
402 }
403
404 static gchar *append_cdata(gchar *t, const gchar *n, int length) {
405     gchar *r, *k;
406     
407     if (!length)
408         return t;
409
410     k = g_strndup(n, length);
411
412     if (t) {
413         r = g_strconcat(t, k, NULL);
414         g_free(k);
415         g_free(t);
416     } else
417         r = k;
418     
419     return r;
420 }
421
422 static void XMLCALL xml_cdata(void *data, const XML_Char *s, int len) {
423     struct xml_userdata *u = data;
424     g_assert(u);
425
426     if (u->failed)
427         return;
428
429     switch (u->current_tag) {
430         case XML_TAG_NAME:
431             u->group->name = append_cdata(u->group->name, s, len);
432             break;
433             
434         case XML_TAG_TYPE:
435             g_assert(u->service);
436             u->service->type = append_cdata(u->service->type, s, len);
437             break;
438
439         case XML_TAG_DOMAIN_NAME:
440             g_assert(u->service);
441             u->service->domain_name = append_cdata(u->service->domain_name, s, len);
442             break;
443
444         case XML_TAG_HOST_NAME:
445             g_assert(u->service);
446             u->service->host_name = append_cdata(u->service->host_name, s, len);
447             break;
448
449         case XML_TAG_PORT:
450         case XML_TAG_TXT_RECORD:
451             u->buf = append_cdata(u->buf, s, len);
452             break;
453
454         case XML_TAG_SERVICE_GROUP:
455         case XML_TAG_SERVICE:
456         case XML_TAG_INVALID:
457             ;
458     }
459 }
460
461 static gint static_service_group_load(StaticServiceGroup *g) {
462     XML_Parser parser = NULL;
463     gint fd = -1;
464     struct xml_userdata u;
465     gint r = -1;
466     struct stat st;
467     ssize_t n;
468
469     g_assert(g);
470
471     u.buf = NULL;
472     u.group = g;
473     u.service = NULL;
474     u.current_tag = XML_TAG_INVALID;
475     u.failed = FALSE;
476
477     /* Cleanup old data in this service group, if available */
478     remove_static_service_group_from_server(g);
479     while (g->services)
480         static_service_free(g->services);
481
482     g_free(g->name);
483     g_free(g->chosen_name);
484     g->name = g->chosen_name = NULL;
485     g->replace_wildcards = FALSE;
486     
487     if (!(parser = XML_ParserCreate(NULL))) {
488         avahi_log_error("XML_ParserCreate() failed.");
489         goto finish;
490     }
491
492     if ((fd = open(g->filename, O_RDONLY)) < 0) {
493         avahi_log_error("open(\"%s\", O_RDONLY): %s", g->filename, strerror(errno));
494         goto finish;
495     }
496
497     if (fstat(fd, &st) < 0) {
498         avahi_log_error("fstat(): %s", strerror(errno));
499         goto finish;
500     }
501
502     g->mtime = st.st_mtime;
503     
504     XML_SetUserData(parser, &u);
505
506     XML_SetElementHandler(parser, xml_start, xml_end);
507     XML_SetCharacterDataHandler(parser, xml_cdata);
508
509     do {
510         void *buffer;
511
512 #define BUFSIZE (10*1024)
513
514         if (!(buffer = XML_GetBuffer(parser, BUFSIZE))) {
515             avahi_log_error("XML_GetBuffer() failed.");
516             goto finish;
517         }
518
519         if ((n = read(fd, buffer, BUFSIZE)) < 0) {
520             avahi_log_error("read(): %s\n", strerror(errno));
521             goto finish;
522         }
523
524         if (!XML_ParseBuffer(parser, n, n == 0)) {
525             avahi_log_error("XML_ParseBuffer() failed at line %d: %s.\n", XML_GetCurrentLineNumber(parser), XML_ErrorString(XML_GetErrorCode(parser)));
526             goto finish;
527         }
528
529     } while (n != 0);
530
531     if (!u.failed)
532         r = 0;
533
534 finish:
535
536     if (fd >= 0)
537         close(fd);
538
539     if (parser)
540         XML_ParserFree(parser);
541
542     g_free(u.buf);
543
544     return r;
545 }
546
547 static void load_file(gchar *n) {
548     StaticServiceGroup *g;
549     g_assert(n);
550
551     for (g = groups; g; g = g->groups_next)
552         if (strcmp(g->filename, n) == 0)
553             return;
554
555     avahi_log_info("Loading service file %s", n);
556     
557     g = static_service_group_new(n);
558     if (static_service_group_load(g) < 0) {
559         avahi_log_error("Failed to load service group file %s, ignoring.", g->filename);
560         static_service_group_free(g);
561     }
562 }
563
564 void static_service_load(void) {
565     StaticServiceGroup *g, *n;
566     glob_t globbuf;
567     gchar **p;
568
569     for (g = groups; g; g = n) {
570         struct stat st;
571
572         n = g->groups_next;
573
574         if (stat(g->filename, &st) < 0) {
575
576             if (errno == ENOENT)
577                 avahi_log_info("Service group file %s vanished, removing services.", g->filename);
578             else
579                 avahi_log_warn("Failed to stat() file %s, ignoring: %s", g->filename, strerror(errno));
580             
581             static_service_group_free(g);
582         } else if (st.st_mtime != g->mtime) {
583             avahi_log_info("Service group file %s changed, reloading.", g->filename);
584             
585             if (static_service_group_load(g) < 0) {
586                 avahi_log_warn("Failed to load service group file %s, removing service.", g->filename);
587                 static_service_group_free(g);
588             }
589         }
590     }
591
592     memset(&globbuf, 0, sizeof(globbuf));
593     if (glob(AVAHI_SERVICE_DIRECTORY "/*.service", GLOB_ERR, NULL, &globbuf) != 0)
594         avahi_log_error("Failed to read service directory.");
595     else {
596         for (p = globbuf.gl_pathv; *p; p++)
597             load_file(*p);
598         
599         globfree(&globbuf);
600     }
601 }
602
603 void static_service_free_all(void) {
604     
605     while (groups)
606         static_service_group_free(groups);
607 }
608
609 void static_service_add_to_server(void) {
610     StaticServiceGroup *g;
611
612     for (g = groups; g; g = g->groups_next)
613         add_static_service_group_to_server(g);
614 }
615
616 void static_service_remove_from_server(void) {
617     StaticServiceGroup *g;
618
619     for (g = groups; g; g = g->groups_next)
620         remove_static_service_group_from_server(g);
621 }