/src/avahi/avahi-common/domain.c

Source (jump to first uncovered line)
/***
  This file is part of avahi.

  avahi is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as
  published by the Free Software Foundation; either version 2.1 of the
  License, or (at your option) any later version.

  avahi is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
  Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with avahi; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  USA.
***/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <assert.h>

#include "domain.h"
#include "malloc.h"
#include "error.h"
#include "address.h"
#include "utf8.h"

/* Read the first label from string *name, unescape "\" and write it to dest */
char *avahi_unescape_label(const char **name, char *dest, size_t size) {
    unsigned i = 0;
    char *d;

    assert(dest);
    assert(size > 0);
    assert(name);

    d = dest;

    for (;;) {
        if (i >= size)
            return NULL;

        if (**name == '.') {
            (*name)++;
            break;
        }

        if (**name == 0)
            break;

        if (**name == '\\') {
            /* Escaped character */

            (*name) ++;

            if (**name == 0)
                /* Ending NUL */
                return NULL;

            else if (**name == '\\' || **name == '.') {
                /* Escaped backslash or dot */
                *(d++) = *((*name) ++);
                i++;
            } else if (isdigit(**name)) {
                int n;

                /* Escaped literal ASCII character */

                if (!isdigit(*(*name+1)) || !isdigit(*(*name+2)))
                    return NULL;

                n = ((uint8_t) (**name - '0') * 100) + ((uint8_t) (*(*name+1) - '0') * 10) + ((uint8_t) (*(*name +2) - '0'));

                if (n > 255 || n == 0)
                    return NULL;

                *(d++) = (char) n;
                i++;

                (*name) += 3;
            } else
                return NULL;

        } else {

            /* Normal character */

            *(d++) = *((*name) ++);
            i++;
        }
    }

    assert(i < size);

    *d = 0;

    if (!avahi_utf8_valid(dest))
        return NULL;

    return dest;
}

/* Escape "\" and ".", append \0 */
char *avahi_escape_label(const char* src, size_t src_length, char **ret_name, size_t *ret_size) {
    char *r;

    assert(src);
    assert(ret_name);
    assert(*ret_name);
    assert(ret_size);
    assert(*ret_size > 0);

    r = *ret_name;

    while (src_length > 0) {
        if (*src == '.' || *src == '\\') {

            /* Dot or backslash */

            if (*ret_size < 3)
                return NULL;

            *((*ret_name) ++) = '\\';
            *((*ret_name) ++) = *src;
            (*ret_size) -= 2;

        } else if (
            *src == '_' ||
            *src == '-' ||
            (*src >= '0' && *src <= '9') ||
            (*src >= 'a' && *src <= 'z') ||
            (*src >= 'A' && *src <= 'Z')) {

            /* Proper character */

            if (*ret_size < 2)
                return NULL;

            *((*ret_name)++) = *src;
            (*ret_size) --;

        } else {

            /* Everything else */

            if (*ret_size < 5)
                return NULL;

            *((*ret_name) ++) = '\\';
            *((*ret_name) ++) = '0' + (char)  ((uint8_t) *src / 100);
            *((*ret_name) ++) = '0' + (char) (((uint8_t) *src / 10) % 10);
            *((*ret_name) ++) = '0' + (char)  ((uint8_t) *src % 10);

            (*ret_size) -= 4;
        }

        src_length --;
        src++;
    }

    **ret_name = 0;

    return r;
}

char *avahi_normalize_name(const char *s, char *ret_s, size_t size) {
    int empty = 1;
    char *r;

    assert(s);
    assert(ret_s);
    assert(size > 0);

    r = ret_s;
    *ret_s = 0;

    while (*s) {
        char label[AVAHI_LABEL_MAX];

        if (!(avahi_unescape_label(&s, label, sizeof(label))))
            return NULL;

        if (label[0] == 0) {

            if (*s == 0 && empty)
                return ret_s;

            return NULL;
        }

        if (!empty) {
            if (size < 2)
                return NULL;

            *(r++) = '.';
            size--;

        } else
            empty = 0;

        if (!(avahi_escape_label(label, strlen(label), &r, &size)))
            return NULL;
    }

    return ret_s;
}

char *avahi_normalize_name_strdup(const char *s) {
    char t[AVAHI_DOMAIN_NAME_MAX];
    assert(s);

    if (!(avahi_normalize_name(s, t, sizeof(t))))
        return NULL;

    return avahi_strdup(t);
}

int avahi_domain_equal(const char *a, const char *b) {
    assert(a);
    assert(b);

    if (a == b)
        return 1;

    for (;;) {
        char ca[AVAHI_LABEL_MAX], cb[AVAHI_LABEL_MAX], *r;

        r = avahi_unescape_label(&a, ca, sizeof(ca));
        assert(r);
        r = avahi_unescape_label(&b, cb, sizeof(cb));
        assert(r);

        if (strcasecmp(ca, cb))
            return 0;

        if (!*a && !*b)
            return 1;
    }

    return 1;
}

int avahi_is_valid_service_type_generic(const char *t) {
    assert(t);

    if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX || !*t)
        return 0;

    do {
        char label[AVAHI_LABEL_MAX];

        if (!(avahi_unescape_label(&t, label, sizeof(label))))
            return 0;

        if (strlen(label) <= 2 || label[0] != '_')
            return 0;

    } while (*t);

    return 1;
}

int avahi_is_valid_service_type_strict(const char *t) {
    char label[AVAHI_LABEL_MAX];
    assert(t);

    if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX || !*t)
        return 0;

    /* Application name */

    if (!(avahi_unescape_label(&t, label, sizeof(label))))
        return 0;

    if (strlen(label) <= 2 || label[0] != '_')
        return 0;

    if (!*t)
        return 0;

    /* _tcp or _udp boilerplate */

    if (!(avahi_unescape_label(&t, label, sizeof(label))))
        return 0;

    if (strcasecmp(label, "_tcp") && strcasecmp(label, "_udp"))
        return 0;

    if (*t)
        return 0;

    return 1;
}

const char *avahi_get_type_from_subtype(const char *t) {
    char label[AVAHI_LABEL_MAX];
    const char *ret;
    assert(t);

    if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX || !*t)
        return NULL;

    /* Subtype name */

    if (!(avahi_unescape_label(&t, label, sizeof(label))))
        return NULL;

    if (strlen(label) <= 2 || label[0] != '_')
        return NULL;

    if (!*t)
        return NULL;

    /* String "_sub" */

    if (!(avahi_unescape_label(&t, label, sizeof(label))))
        return NULL;

    if (strcasecmp(label, "_sub"))
        return NULL;

    if (!*t)
        return NULL;

    ret = t;

    /* Application name */

    if (!(avahi_unescape_label(&t, label, sizeof(label))))
        return NULL;

    if (strlen(label) <= 2 || label[0] != '_')
        return NULL;

    if (!*t)
        return NULL;

    /* _tcp or _udp boilerplate */

    if (!(avahi_unescape_label(&t, label, sizeof(label))))
        return NULL;

    if (strcasecmp(label, "_tcp") && strcasecmp(label, "_udp"))
        return NULL;

    if (*t)
        return NULL;

    return ret;
}

int avahi_is_valid_service_subtype(const char *t) {
    assert(t);

    return !!avahi_get_type_from_subtype(t);
}

int avahi_is_valid_domain_name(const char *t) {
    int is_first = 1;
    assert(t);

    if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX)
        return 0;

    do {
        char label[AVAHI_LABEL_MAX];

        if (!(avahi_unescape_label(&t, label, sizeof(label))))
            return 0;

        /* Explicitly allow the root domain name */
        if (is_first && label[0] == 0 && *t == 0)
            return 1;

        is_first = 0;

        if (label[0] == 0)
            return 0;

    } while (*t);

    return 1;
}

int avahi_is_valid_service_name(const char *t) {
    assert(t);

    if (strlen(t) >= AVAHI_LABEL_MAX || !*t || !avahi_utf8_valid(t))
        return 0;

    return 1;
}

int avahi_is_valid_host_name(const char *t) {
    char label[AVAHI_LABEL_MAX];
    assert(t);

    if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX || !*t)
        return 0;

    if (!(avahi_unescape_label(&t, label, sizeof(label))))
        return 0;

    if (strlen(label) < 1)
        return 0;

    if (*t)
        return 0;

    return 1;
}

unsigned avahi_domain_hash(const char *s) {
    unsigned hash = 0;

    while (*s) {
        char c[AVAHI_LABEL_MAX], *p, *r;

        r = avahi_unescape_label(&s, c, sizeof(c));
        assert(r);

        for (p = c; *p; p++)
            hash = 31 * hash + tolower(*p);
    }

    return hash;
}

int avahi_service_name_join(char *p, size_t size, const char *name, const char *type, const char *domain) {
    char escaped_name[AVAHI_LABEL_MAX*4];
    char normalized_type[AVAHI_DOMAIN_NAME_MAX];
    char normalized_domain[AVAHI_DOMAIN_NAME_MAX];

    assert(p);

    /* Validity checks */

    if ((name && !avahi_is_valid_service_name(name)))
        return AVAHI_ERR_INVALID_SERVICE_NAME;

    if (!avahi_is_valid_service_type_generic(type))
        return AVAHI_ERR_INVALID_SERVICE_TYPE;

    if (!avahi_is_valid_domain_name(domain))
        return AVAHI_ERR_INVALID_DOMAIN_NAME;

    /* Preparation */

    if (name) {
        size_t l = sizeof(escaped_name);
        char *e = escaped_name, *r;
        r = avahi_escape_label(name, strlen(name), &e, &l);
        assert(r);
    }

    if (!(avahi_normalize_name(type, normalized_type, sizeof(normalized_type))))
        return AVAHI_ERR_INVALID_SERVICE_TYPE;

    if (!(avahi_normalize_name(domain, normalized_domain, sizeof(normalized_domain))))
        return AVAHI_ERR_INVALID_DOMAIN_NAME;

    /* Concatenation */

    snprintf(p, size, "%s%s%s.%s", name ? escaped_name : "", name ? "." : "", normalized_type, normalized_domain);

    return AVAHI_OK;
}

#ifndef HAVE_STRLCPY

static size_t strlcpy(char *dest, const char *src, size_t n) {
    assert(dest);
    assert(src);

    if (n > 0) {
        strncpy(dest, src, n-1);
        dest[n-1] = 0;
    }

    return strlen(src);
}

#endif

int avahi_service_name_split(const char *p, char *name, size_t name_size, char *type, size_t type_size, char *domain, size_t domain_size) {
    enum {
        NAME,
        TYPE,
        DOMAIN
    } state;
    int type_empty = 1, domain_empty = 1;
    char *oname, *otype, *odomain;

    assert(p);
    assert(type);
    assert(type_size > 0);
    assert(domain);
    assert(domain_size > 0);

    oname = name;
    otype = type;
    odomain = domain;

    if (name) {
        assert(name_size > 0);
        *name = 0;
        state = NAME;
    } else
        state = TYPE;

    *type = *domain = 0;

    while (*p) {
        char buf[64];

        if (!(avahi_unescape_label(&p, buf, sizeof(buf))))
            return -1;

        switch (state) {
            case NAME:
                strlcpy(name, buf, name_size);
                state = TYPE;
                break;

            case TYPE:

                if (buf[0] == '_') {

                    if (!type_empty) {
                        if (!type_size)
                            return AVAHI_ERR_NO_MEMORY;

                        *(type++) = '.';
                        type_size --;

                    } else
                        type_empty = 0;

                    if (!(avahi_escape_label(buf, strlen(buf), &type, &type_size)))
                        return AVAHI_ERR_NO_MEMORY;

                    break;
                }

                state = DOMAIN;
                /* fall through */

            case DOMAIN:

                if (!domain_empty) {
                    if (!domain_size)
                        return AVAHI_ERR_NO_MEMORY;

                    *(domain++) = '.';
                    domain_size --;
                } else
                    domain_empty = 0;

                if (!(avahi_escape_label(buf, strlen(buf), &domain, &domain_size)))
                    return AVAHI_ERR_NO_MEMORY;

                break;
        }
    }

    if ((oname && !avahi_is_valid_service_name(oname)))
        return AVAHI_ERR_INVALID_SERVICE_NAME;

    if (!avahi_is_valid_service_type_strict(otype) && !avahi_is_valid_service_subtype(otype))
        return AVAHI_ERR_INVALID_SERVICE_TYPE;

    if (!avahi_is_valid_domain_name(odomain))
        return AVAHI_ERR_INVALID_DOMAIN_NAME;

    return 0;
}

int avahi_is_valid_fqdn(const char *t) {
    char label[AVAHI_LABEL_MAX];
    char normalized[AVAHI_DOMAIN_NAME_MAX];
    const char *k = t;
    AvahiAddress a;
    assert(t);

    if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX)
        return 0;

    if (!avahi_is_valid_domain_name(t))
        return 0;

    /* Check if there are at least two labels*/
    if (!(avahi_unescape_label(&k, label, sizeof(label))))
        return 0;

    if (label[0] == 0 || !k)
        return 0;

    if (!(avahi_unescape_label(&k, label, sizeof(label))))
        return 0;

    if (label[0] == 0 || !k)
        return 0;

    /* Make sure that the name is not an IP address */
    if (!(avahi_normalize_name(t, normalized, sizeof(normalized))))
        return 0;

    if (avahi_address_parse(normalized, AVAHI_PROTO_UNSPEC, &a))
        return 0;

    return 1;
}

Coverage Report

Created: 2024-06-25 06:24

Line	Count	Source (jump to first uncovered line)
1		/***
2		This file is part of avahi.
3
4		avahi is free software; you can redistribute it and/or modify it
5		under the terms of the GNU Lesser General Public License as
6		published by the Free Software Foundation; either version 2.1 of the
7		License, or (at your option) any later version.
8
9		avahi is distributed in the hope that it will be useful, but WITHOUT
10		ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11		or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
12		Public License for more details.
13
14		You should have received a copy of the GNU Lesser General Public
15		License along with avahi; if not, write to the Free Software
16		Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
17		USA.
18		***/
19
20		#ifdef HAVE_CONFIG_H
21		#include <config.h>
22		#endif
23
24		#include <string.h>
25		#include <unistd.h>
26		#include <fcntl.h>
27		#include <errno.h>
28		#include <limits.h>
29		#include <stdio.h>
30		#include <ctype.h>
31		#include <stdlib.h>
32		#include <assert.h>
33
34		#include "domain.h"
35		#include "malloc.h"
36		#include "error.h"
37		#include "address.h"
38		#include "utf8.h"
39
40		/* Read the first label from string name, unescape "\" and write it to dest /
41	1.64M	char avahi_unescape_label(const char name, char dest, size_t size) {
42	1.64M	unsigned i = 0;
43	1.64M	char *d;
44
45	1.64M	assert(dest);
46	1.64M	assert(size > 0);
47	1.64M	assert(name);
48
49	1.64M	d = dest;
50
51	10.4M	for (;;) {
52	10.4M	if (i >= size)
53	61	return NULL;
54
55	10.4M	if (**name == '.') {
56	1.25M	(*name)++;
57	1.25M	break;
58	1.25M	}
59
60	9.17M	if (**name == 0)
61	392k	break;
62
63	8.78M	if (**name == '\\') {
64		/* Escaped character */
65
66	4.05M	(*name) ++;
67
68	4.05M	if (**name == 0)
69		/* Ending NUL */
70	71	return NULL;
71
72	4.05M	else if (name == '\\' \|\| name == '.') {
73		/* Escaped backslash or dot */
74	431k	(d++) = ((*name) ++);
75	431k	i++;
76	3.62M	} else if (isdigit(**name)) {
77	3.62M	int n;
78
79		/* Escaped literal ASCII character */
80
81	3.62M	if (!isdigit((name+1)) \|\| !isdigit((name+2)))
82	42	return NULL;
83
84	3.62M	n = ((uint8_t) (*name - '0') 100) + ((uint8_t) ((name+1) - '0') * 10) + ((uint8_t) ((name +2) - '0'));
85
86	3.62M	if (n > 255 \|\| n == 0)
87	128	return NULL;
88
89	3.62M	*(d++) = (char) n;
90	3.62M	i++;
91
92	3.62M	(*name) += 3;
93	3.62M	} else
94	253	return NULL;
95
96	4.72M	} else {
97
98		/* Normal character */
99
100	4.72M	(d++) = ((*name) ++);
101	4.72M	i++;
102	4.72M	}
103	8.78M	}
104
105	1.64M	assert(i < size);
106
107	1.64M	*d = 0;
108
109	1.64M	if (!avahi_utf8_valid(dest))
110	872	return NULL;
111
112	1.64M	return dest;
113	1.64M	}
114
115		/* Escape "\" and ".", append \0 */
116	336k	char avahi_escape_label(const char src, size_t src_length, char *ret_name, size_t ret_size) {
117	336k	char *r;
118
119	336k	assert(src);
120	336k	assert(ret_name);
121	336k	assert(*ret_name);
122	336k	assert(ret_size);
123	336k	assert(*ret_size > 0);
124
125	336k	r = *ret_name;
126
127	2.67M	while (src_length > 0) {
128	2.33M	if (src == '.' \|\| src == '\\') {
129
130		/* Dot or backslash */
131
132	107k	if (*ret_size < 3)
133	13	return NULL;
134
135	107k	((ret_name) ++) = '\\';
136	107k	((ret_name) ++) = *src;
137	107k	(*ret_size) -= 2;
138
139	2.23M	} else if (
140	2.23M	*src == '_' \|\|
141	2.23M	*src == '-' \|\|
142	2.23M	(src >= '0' && src <= '9') \|\|
143	2.23M	(src >= 'a' && src <= 'z') \|\|
144	2.23M	(src >= 'A' && src <= 'Z')) {
145
146		/* Proper character */
147
148	1.28M	if (*ret_size < 2)
149	16	return NULL;
150
151	1.28M	((ret_name)++) = *src;
152	1.28M	(*ret_size) --;
153
154	1.28M	} else {
155
156		/* Everything else */
157
158	948k	if (*ret_size < 5)
159	53	return NULL;
160
161	948k	((ret_name) ++) = '\\';
162	948k	((ret_name) ++) = '0' + (char) ((uint8_t) *src / 100);
163	948k	((ret_name) ++) = '0' + (char) (((uint8_t) *src / 10) % 10);
164	948k	((ret_name) ++) = '0' + (char) ((uint8_t) *src % 10);
165
166	948k	(*ret_size) -= 4;
167	948k	}
168
169	2.33M	src_length --;
170	2.33M	src++;
171	2.33M	}
172
173	336k	**ret_name = 0;
174
175	336k	return r;
176	336k	}
177
178	165k	char avahi_normalize_name(const char s, char *ret_s, size_t size) {
179	165k	int empty = 1;
180	165k	char *r;
181
182	165k	assert(s);
183	165k	assert(ret_s);
184	165k	assert(size > 0);
185
186	165k	r = ret_s;
187	165k	*ret_s = 0;
188
189	313k	while (*s) {
190	148k	char label[AVAHI_LABEL_MAX];
191
192	148k	if (!(avahi_unescape_label(&s, label, sizeof(label))))
193	389	return NULL;
194
195	147k	if (label[0] == 0) {
196
197	22	if (*s == 0 && empty)
198	1	return ret_s;
199
200	21	return NULL;
201	22	}
202
203	147k	if (!empty) {
204	133k	if (size < 2)
205	3	return NULL;
206
207	133k	*(r++) = '.';
208	133k	size--;
209
210	133k	} else
211	14.5k	empty = 0;
212
213	147k	if (!(avahi_escape_label(label, strlen(label), &r, &size)))
214	31	return NULL;
215	147k	}
216
217	164k	return ret_s;
218	165k	}
219
220	162k	char avahi_normalize_name_strdup(const char s) {
221	162k	char t[AVAHI_DOMAIN_NAME_MAX];
222	162k	assert(s);
223
224	162k	if (!(avahi_normalize_name(s, t, sizeof(t))))
225	434	return NULL;
226
227	161k	return avahi_strdup(t);
228	162k	}
229
230	324k	int avahi_domain_equal(const char a, const char b) {
231	324k	assert(a);
232	324k	assert(b);
233
234	324k	if (a == b)
235	0	return 1;
236
237	343k	for (;;) {
238	343k	char ca[AVAHI_LABEL_MAX], cb[AVAHI_LABEL_MAX], *r;
239
240	343k	r = avahi_unescape_label(&a, ca, sizeof(ca));
241	343k	assert(r);
242	343k	r = avahi_unescape_label(&b, cb, sizeof(cb));
243	343k	assert(r);
244
245	343k	if (strcasecmp(ca, cb))
246	318k	return 0;
247
248	24.6k	if (!a && !b)
249	5.44k	return 1;
250	24.6k	}
251
252	0	return 1;
253	324k	}
254
255	2.26k	int avahi_is_valid_service_type_generic(const char *t) {
256	2.26k	assert(t);
257
258	2.26k	if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX \|\| !*t)
259	44	return 0;
260
261	5.32k	do {
262	5.32k	char label[AVAHI_LABEL_MAX];
263
264	5.32k	if (!(avahi_unescape_label(&t, label, sizeof(label))))
265	123	return 0;
266
267	5.20k	if (strlen(label) <= 2 \|\| label[0] != '_')
268	665	return 0;
269
270	5.20k	} while (*t);
271
272	1.43k	return 1;
273	2.22k	}
274
275	8.07k	int avahi_is_valid_service_type_strict(const char *t) {
276	8.07k	char label[AVAHI_LABEL_MAX];
277	8.07k	assert(t);
278
279	8.07k	if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX \|\| !*t)
280	1.40k	return 0;
281
282		/* Application name */
283
284	6.67k	if (!(avahi_unescape_label(&t, label, sizeof(label))))
285	101	return 0;
286
287	6.56k	if (strlen(label) <= 2 \|\| label[0] != '_')
288	877	return 0;
289
290	5.69k	if (!*t)
291	1.19k	return 0;
292
293		/* _tcp or _udp boilerplate */
294
295	4.49k	if (!(avahi_unescape_label(&t, label, sizeof(label))))
296	11	return 0;
297
298	4.48k	if (strcasecmp(label, "_tcp") && strcasecmp(label, "_udp"))
299	3.23k	return 0;
300
301	1.25k	if (*t)
302	365	return 0;
303
304	885	return 1;
305	1.25k	}
306
307	7.19k	const char avahi_get_type_from_subtype(const char t) {
308	7.19k	char label[AVAHI_LABEL_MAX];
309	7.19k	const char *ret;
310	7.19k	assert(t);
311
312	7.19k	if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX \|\| !*t)
313	1.40k	return NULL;
314
315		/* Subtype name */
316
317	5.78k	if (!(avahi_unescape_label(&t, label, sizeof(label))))
318	101	return NULL;
319
320	5.68k	if (strlen(label) <= 2 \|\| label[0] != '_')
321	877	return NULL;
322
323	4.80k	if (!*t)
324	1.19k	return NULL;
325
326		/* String "_sub" */
327
328	3.61k	if (!(avahi_unescape_label(&t, label, sizeof(label))))
329	11	return NULL;
330
331	3.60k	if (strcasecmp(label, "_sub"))
332	1.62k	return NULL;
333
334	1.97k	if (!*t)
335	351	return NULL;
336
337	1.62k	ret = t;
338
339		/* Application name */
340
341	1.62k	if (!(avahi_unescape_label(&t, label, sizeof(label))))
342	3	return NULL;
343
344	1.62k	if (strlen(label) <= 2 \|\| label[0] != '_')
345	246	return NULL;
346
347	1.37k	if (!*t)
348	213	return NULL;
349
350		/* _tcp or _udp boilerplate */
351
352	1.16k	if (!(avahi_unescape_label(&t, label, sizeof(label))))
353	2	return NULL;
354
355	1.16k	if (strcasecmp(label, "_tcp") && strcasecmp(label, "_udp"))
356	316	return NULL;
357
358	846	if (*t)
359	394	return NULL;
360
361	452	return ret;
362	846	}
363
364	7.19k	int avahi_is_valid_service_subtype(const char *t) {
365	7.19k	assert(t);
366
367	7.19k	return !!avahi_get_type_from_subtype(t);
368	7.19k	}
369
370	177k	int avahi_is_valid_domain_name(const char *t) {
371	177k	int is_first = 1;
372	177k	assert(t);
373
374	177k	if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX)
375	42	return 0;
376
377	346k	do {
378	346k	char label[AVAHI_LABEL_MAX];
379
380	346k	if (!(avahi_unescape_label(&t, label, sizeof(label))))
381	484	return 0;
382
383		/* Explicitly allow the root domain name */
384	346k	if (is_first && label[0] == 0 && *t == 0)
385	156k	return 1;
386
387	190k	is_first = 0;
388
389	190k	if (label[0] == 0)
390	44	return 0;
391
392	190k	} while (*t);
393
394	20.7k	return 1;
395	177k	}
396
397	6.94k	int avahi_is_valid_service_name(const char *t) {
398	6.94k	assert(t);
399
400	6.94k	if (strlen(t) >= AVAHI_LABEL_MAX \|\| !*t \|\| !avahi_utf8_valid(t))
401	1.06k	return 0;
402
403	5.88k	return 1;
404	6.94k	}
405
406	2.26k	int avahi_is_valid_host_name(const char *t) {
407	2.26k	char label[AVAHI_LABEL_MAX];
408	2.26k	assert(t);
409
410	2.26k	if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX \|\| !*t)
411	88	return 0;
412
413	2.17k	if (!(avahi_unescape_label(&t, label, sizeof(label))))
414	202	return 0;
415
416	1.97k	if (strlen(label) < 1)
417	28	return 0;
418
419	1.94k	if (*t)
420	760	return 0;
421
422	1.18k	return 1;
423	1.94k	}
424
425	611	unsigned avahi_domain_hash(const char *s) {
426	611	unsigned hash = 0;
427
428	10.6k	while (*s) {
429	10.0k	char c[AVAHI_LABEL_MAX], p, r;
430
431	10.0k	r = avahi_unescape_label(&s, c, sizeof(c));
432	10.0k	assert(r);
433
434	23.1k	for (p = c; *p; p++)
435	13.1k	hash = 31 * hash + tolower(*p);
436	10.0k	}
437
438	611	return hash;
439	611	}
440
441	1.33k	int avahi_service_name_join(char p, size_t size, const char name, const char type, const char domain) {
442	1.33k	char escaped_name[AVAHI_LABEL_MAX*4];
443	1.33k	char normalized_type[AVAHI_DOMAIN_NAME_MAX];
444	1.33k	char normalized_domain[AVAHI_DOMAIN_NAME_MAX];
445
446	1.33k	assert(p);
447
448		/* Validity checks */
449
450	1.33k	if ((name && !avahi_is_valid_service_name(name)))
451	0	return AVAHI_ERR_INVALID_SERVICE_NAME;
452
453	1.33k	if (!avahi_is_valid_service_type_generic(type))
454	0	return AVAHI_ERR_INVALID_SERVICE_TYPE;
455
456	1.33k	if (!avahi_is_valid_domain_name(domain))
457	0	return AVAHI_ERR_INVALID_DOMAIN_NAME;
458
459		/* Preparation */
460
461	1.33k	if (name) {
462	524	size_t l = sizeof(escaped_name);
463	524	char e = escaped_name, r;
464	524	r = avahi_escape_label(name, strlen(name), &e, &l);
465	524	assert(r);
466	524	}
467
468	1.33k	if (!(avahi_normalize_name(type, normalized_type, sizeof(normalized_type))))
469	0	return AVAHI_ERR_INVALID_SERVICE_TYPE;
470
471	1.33k	if (!(avahi_normalize_name(domain, normalized_domain, sizeof(normalized_domain))))
472	0	return AVAHI_ERR_INVALID_DOMAIN_NAME;
473
474		/* Concatenation */
475
476	1.33k	snprintf(p, size, "%s%s%s.%s", name ? escaped_name : "", name ? "." : "", normalized_type, normalized_domain);
477
478	1.33k	return AVAHI_OK;
479	1.33k	}
480
481		#ifndef HAVE_STRLCPY
482
483	3.28k	static size_t strlcpy(char dest, const char src, size_t n) {
484	3.28k	assert(dest);
485	3.28k	assert(src);
486
487	3.28k	if (n > 0) {
488	3.28k	strncpy(dest, src, n-1);
489	3.28k	dest[n-1] = 0;
490	3.28k	}
491
492	3.28k	return strlen(src);
493	3.28k	}
494
495		#endif
496
497	7.72k	int avahi_service_name_split(const char p, char name, size_t name_size, char type, size_t type_size, char domain, size_t domain_size) {
498	7.72k	enum {
499	7.72k	NAME,
500	7.72k	TYPE,
501	7.72k	DOMAIN
502	7.72k	} state;
503	7.72k	int type_empty = 1, domain_empty = 1;
504	7.72k	char oname, otype, *odomain;
505
506	7.72k	assert(p);
507	7.72k	assert(type);
508	7.72k	assert(type_size > 0);
509	7.72k	assert(domain);
510	7.72k	assert(domain_size > 0);
511
512	7.72k	oname = name;
513	7.72k	otype = type;
514	7.72k	odomain = domain;
515
516	7.72k	if (name) {
517	3.86k	assert(name_size > 0);
518	3.86k	*name = 0;
519	3.86k	state = NAME;
520	3.86k	} else
521	3.86k	state = TYPE;
522
523	7.72k	type = domain = 0;
524
525	31.1k	while (*p) {
526	23.4k	char buf[64];
527
528	23.4k	if (!(avahi_unescape_label(&p, buf, sizeof(buf))))
529	0	return -1;
530
531	23.4k	switch (state) {
532	3.28k	case NAME:
533	3.28k	strlcpy(name, buf, name_size);
534	3.28k	state = TYPE;
535	3.28k	break;
536
537	16.6k	case TYPE:
538
539	16.6k	if (buf[0] == '_') {
540
541	14.6k	if (!type_empty) {
542	8.85k	if (!type_size)
543	0	return AVAHI_ERR_NO_MEMORY;
544
545	8.85k	*(type++) = '.';
546	8.85k	type_size --;
547
548	8.85k	} else
549	5.78k	type_empty = 0;
550
551	14.6k	if (!(avahi_escape_label(buf, strlen(buf), &type, &type_size)))
552	0	return AVAHI_ERR_NO_MEMORY;
553
554	14.6k	break;
555	14.6k	}
556
557	2.04k	state = DOMAIN;
558		/* fall through */
559
560	5.50k	case DOMAIN:
561
562	5.50k	if (!domain_empty) {
563	3.45k	if (!domain_size)
564	0	return AVAHI_ERR_NO_MEMORY;
565
566	3.45k	*(domain++) = '.';
567	3.45k	domain_size --;
568	3.45k	} else
569	2.04k	domain_empty = 0;
570
571	5.50k	if (!(avahi_escape_label(buf, strlen(buf), &domain, &domain_size)))
572	0	return AVAHI_ERR_NO_MEMORY;
573
574	5.50k	break;
575	23.4k	}
576	23.4k	}
577
578	7.72k	if ((oname && !avahi_is_valid_service_name(oname)))
579	584	return AVAHI_ERR_INVALID_SERVICE_NAME;
580
581	7.14k	if (!avahi_is_valid_service_type_strict(otype) && !avahi_is_valid_service_subtype(otype))
582	5.81k	return AVAHI_ERR_INVALID_SERVICE_TYPE;
583
584	1.33k	if (!avahi_is_valid_domain_name(odomain))
585	0	return AVAHI_ERR_INVALID_DOMAIN_NAME;
586
587	1.33k	return 0;
588	1.33k	}
589
590	933	int avahi_is_valid_fqdn(const char *t) {
591	933	char label[AVAHI_LABEL_MAX];
592	933	char normalized[AVAHI_DOMAIN_NAME_MAX];
593	933	const char *k = t;
594	933	AvahiAddress a;
595	933	assert(t);
596
597	933	if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX)
598	42	return 0;
599
600	891	if (!avahi_is_valid_domain_name(t))
601	211	return 0;
602
603		/* Check if there are at least two labels*/
604	680	if (!(avahi_unescape_label(&k, label, sizeof(label))))
605	0	return 0;
606
607	680	if (label[0] == 0 \|\| !k)
608	3	return 0;
609
610	677	if (!(avahi_unescape_label(&k, label, sizeof(label))))
611	0	return 0;
612
613	677	if (label[0] == 0 \|\| !k)
614	394	return 0;
615
616		/* Make sure that the name is not an IP address */
617	283	if (!(avahi_normalize_name(t, normalized, sizeof(normalized))))
618	10	return 0;
619
620	273	if (avahi_address_parse(normalized, AVAHI_PROTO_UNSPEC, &a))
621	1	return 0;
622
623	272	return 1;
624	273	}