/***
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 "avahi-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 < 1)
return NULL;
*(r++) = '.';
size--;
} else
empty = 0;
avahi_escape_label(label, strlen(label), &r, &size);
}
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)
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;
assert(p);
assert(type);
assert(type_size > 0);
assert(domain);
assert(domain_size > 0);
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;
}
}
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;
}