git.meshlink.io Git - catta/blob - avahi-common/domain.c

   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 char *avahi_unescape_label(const char **name, char *dest, size_t size) {
  42     unsigned i = 0;
  43     char *d;
  44
  45     assert(dest);
  46     assert(size > 0);
  47     assert(name);
  48
  49     d = dest;
  50
  51     for (;;) {
  52         if (i >= size)
  53             return NULL;
  54
  55         if (**name == '.') {
  56             (*name)++;
  57             break;
  58         }
  59
  60         if (**name == 0)
  61             break;
  62
  63         if (**name == '\\') {
  64             /* Escaped character */
  65
  66             (*name) ++;
  67
  68             if (**name == 0)
  69                 /* Ending NUL */
  70                 return NULL;
  71
  72             else if (**name == '\\' || **name == '.') {
  73                 /* Escaped backslash or dot */
  74                 *(d++) = *((*name) ++);
  75                 i++;
  76             } else if (isdigit(**name)) {
  77                 int n;
  78
  79                 /* Escaped literal ASCII character */
  80
  81                 if (!isdigit(*(*name+1)) || !isdigit(*(*name+2)))
  82                     return NULL;
  83
  84                 n = ((uint8_t) (**name - '0') * 100) + ((uint8_t) (*(*name+1) - '0') * 10) + ((uint8_t) (*(*name +2) - '0'));
  85
  86                 if (n > 255 || n == 0)
  87                     return NULL;
  88
  89                 *(d++) = (char) n;
  90                 i++;
  91
  92                 (*name) += 3;
  93             } else
  94                 return NULL;
  95
  96         } else {
  97
  98             /* Normal character */
  99
 100             *(d++) = *((*name) ++);
 101             i++;
 102         }
 103     }
 104
 105     assert(i < size);
 106
 107     *d = 0;
 108
 109     if (!avahi_utf8_valid(dest))
 110         return NULL;
 111
 112     return dest;
 113 }
 114
 115 /* Escape "\" and ".", append \0 */
 116 char *avahi_escape_label(const char* src, size_t src_length, char **ret_name, size_t *ret_size) {
 117     char *r;
 118
 119     assert(src);
 120     assert(ret_name);
 121     assert(*ret_name);
 122     assert(ret_size);
 123     assert(*ret_size > 0);
 124
 125     r = *ret_name;
 126
 127     while (src_length > 0) {
 128         if (*src == '.' || *src == '\\') {
 129
 130             /* Dot or backslash */
 131
 132             if (*ret_size < 3)
 133                 return NULL;
 134
 135             *((*ret_name) ++) = '\\';
 136             *((*ret_name) ++) = *src;
 137             (*ret_size) -= 2;
 138
 139         } else if (
 140             *src == '_' ||
 141             *src == '-' ||
 142             (*src >= '0' && *src <= '9') ||
 143             (*src >= 'a' && *src <= 'z') ||
 144             (*src >= 'A' && *src <= 'Z')) {
 145
 146             /* Proper character */
 147
 148             if (*ret_size < 2)
 149                 return NULL;
 150
 151             *((*ret_name)++) = *src;
 152             (*ret_size) --;
 153
 154         } else {
 155
 156             /* Everything else */
 157
 158             if (*ret_size < 5)
 159                 return NULL;
 160
 161             *((*ret_name) ++) = '\\';
 162             *((*ret_name) ++) = '0' + (char)  ((uint8_t) *src / 100);
 163             *((*ret_name) ++) = '0' + (char) (((uint8_t) *src / 10) % 10);
 164             *((*ret_name) ++) = '0' + (char)  ((uint8_t) *src % 10);
 165
 166             (*ret_size) -= 4;
 167         }
 168
 169         src_length --;
 170         src++;
 171     }
 172
 173     **ret_name = 0;
 174
 175     return r;
 176 }
 177
 178 char *avahi_normalize_name(const char *s, char *ret_s, size_t size) {
 179     int empty = 1;
 180     char *r;
 181
 182     assert(s);
 183     assert(ret_s);
 184     assert(size > 0);
 185
 186     r = ret_s;
 187     *ret_s = 0;
 188
 189     while (*s) {
 190         char label[AVAHI_LABEL_MAX];
 191
 192         if (!(avahi_unescape_label(&s, label, sizeof(label))))
 193             return NULL;
 194
 195         if (label[0] == 0) {
 196
 197             if (*s == 0 && empty)
 198                 return ret_s;
 199
 200             return NULL;
 201         }
 202
 203         if (!empty) {
 204             if (size < 1)
 205                 return NULL;
 206
 207             *(r++) = '.';
 208             size--;
 209
 210         } else
 211             empty = 0;
 212
 213         avahi_escape_label(label, strlen(label), &r, &size);
 214     }
 215
 216     return ret_s;
 217 }
 218
 219 char *avahi_normalize_name_strdup(const char *s) {
 220     char t[AVAHI_DOMAIN_NAME_MAX];
 221     assert(s);
 222
 223     if (!(avahi_normalize_name(s, t, sizeof(t))))
 224         return NULL;
 225
 226     return avahi_strdup(t);
 227 }
 228
 229 int avahi_domain_equal(const char *a, const char *b) {
 230     assert(a);
 231     assert(b);
 232
 233     if (a == b)
 234         return 1;
 235
 236     for (;;) {
 237         char ca[AVAHI_LABEL_MAX], cb[AVAHI_LABEL_MAX], *r;
 238
 239         r = avahi_unescape_label(&a, ca, sizeof(ca));
 240         assert(r);
 241         r = avahi_unescape_label(&b, cb, sizeof(cb));
 242         assert(r);
 243
 244         if (strcasecmp(ca, cb))
 245             return 0;
 246
 247         if (!*a && !*b)
 248             return 1;
 249     }
 250
 251     return 1;
 252 }
 253
 254 int avahi_is_valid_service_type_generic(const char *t) {
 255     assert(t);
 256
 257     if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX || !*t)
 258         return 0;
 259
 260     do {
 261         char label[AVAHI_LABEL_MAX];
 262
 263         if (!(avahi_unescape_label(&t, label, sizeof(label))))
 264             return 0;
 265
 266         if (strlen(label) <= 2 || label[0] != '_')
 267             return 0;
 268
 269     } while (*t);
 270
 271     return 1;
 272 }
 273
 274 int avahi_is_valid_service_type_strict(const char *t) {
 275     char label[AVAHI_LABEL_MAX];
 276     assert(t);
 277
 278     if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX || !*t)
 279         return 0;
 280
 281     /* Application name */
 282
 283     if (!(avahi_unescape_label(&t, label, sizeof(label))))
 284         return 0;
 285
 286     if (strlen(label) <= 2 || label[0] != '_')
 287         return 0;
 288
 289     if (!*t)
 290         return 0;
 291
 292     /* _tcp or _udp boilerplate */
 293
 294     if (!(avahi_unescape_label(&t, label, sizeof(label))))
 295         return 0;
 296
 297     if (strcasecmp(label, "_tcp") && strcasecmp(label, "_udp"))
 298         return 0;
 299
 300     if (*t)
 301         return 0;
 302
 303     return 1;
 304 }
 305
 306 const char *avahi_get_type_from_subtype(const char *t) {
 307     char label[AVAHI_LABEL_MAX];
 308     const char *ret;
 309     assert(t);
 310
 311     if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX || !*t)
 312         return NULL;
 313
 314     /* Subtype name */
 315
 316     if (!(avahi_unescape_label(&t, label, sizeof(label))))
 317         return NULL;
 318
 319     if (strlen(label) <= 2 || label[0] != '_')
 320         return NULL;
 321
 322     if (!*t)
 323         return NULL;
 324
 325     /* String "_sub" */
 326
 327     if (!(avahi_unescape_label(&t, label, sizeof(label))))
 328         return NULL;
 329
 330     if (strcasecmp(label, "_sub"))
 331         return NULL;
 332
 333     if (!*t)
 334         return NULL;
 335
 336     ret = t;
 337
 338     /* Application name */
 339
 340     if (!(avahi_unescape_label(&t, label, sizeof(label))))
 341         return NULL;
 342
 343     if (strlen(label) <= 2 || label[0] != '_')
 344         return NULL;
 345
 346     if (!*t)
 347         return NULL;
 348
 349     /* _tcp or _udp boilerplate */
 350
 351     if (!(avahi_unescape_label(&t, label, sizeof(label))))
 352         return NULL;
 353
 354     if (strcasecmp(label, "_tcp") && strcasecmp(label, "_udp"))
 355         return NULL;
 356
 357     if (*t)
 358         return NULL;
 359
 360     return ret;
 361 }
 362
 363 int avahi_is_valid_service_subtype(const char *t) {
 364     assert(t);
 365
 366     return !!avahi_get_type_from_subtype(t);
 367 }
 368
 369 int avahi_is_valid_domain_name(const char *t) {
 370     int is_first = 1;
 371     assert(t);
 372
 373     if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX)
 374         return 0;
 375
 376     do {
 377         char label[AVAHI_LABEL_MAX];
 378
 379         if (!(avahi_unescape_label(&t, label, sizeof(label))))
 380             return 0;
 381
 382         /* Explicitly allow the root domain name */
 383         if (is_first && label[0] == 0 && *t == 0)
 384             return 1;
 385
 386         is_first = 0;
 387
 388         if (label[0] == 0)
 389             return 0;
 390
 391     } while (*t);
 392
 393     return 1;
 394 }
 395
 396 int avahi_is_valid_service_name(const char *t) {
 397     assert(t);
 398
 399     if (strlen(t) >= AVAHI_LABEL_MAX || !*t)
 400         return 0;
 401
 402     return 1;
 403 }
 404
 405 int avahi_is_valid_host_name(const char *t) {
 406     char label[AVAHI_LABEL_MAX];
 407     assert(t);
 408
 409     if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX || !*t)
 410         return 0;
 411
 412     if (!(avahi_unescape_label(&t, label, sizeof(label))))
 413         return 0;
 414
 415     if (strlen(label) < 1)
 416         return 0;
 417
 418     if (*t)
 419         return 0;
 420
 421     return 1;
 422 }
 423
 424 unsigned avahi_domain_hash(const char *s) {
 425     unsigned hash = 0;
 426
 427     while (*s) {
 428         char c[AVAHI_LABEL_MAX], *p, *r;
 429
 430         r = avahi_unescape_label(&s, c, sizeof(c));
 431         assert(r);
 432
 433         for (p = c; *p; p++)
 434             hash = 31 * hash + tolower(*p);
 435     }
 436
 437     return hash;
 438 }
 439
 440 int avahi_service_name_join(char *p, size_t size, const char *name, const char *type, const char *domain) {
 441     char escaped_name[AVAHI_LABEL_MAX*4];
 442     char normalized_type[AVAHI_DOMAIN_NAME_MAX];
 443     char normalized_domain[AVAHI_DOMAIN_NAME_MAX];
 444
 445     assert(p);
 446
 447     /* Validity checks */
 448
 449     if ((name && !avahi_is_valid_service_name(name)))
 450         return AVAHI_ERR_INVALID_SERVICE_NAME;
 451
 452     if (!avahi_is_valid_service_type_generic(type))
 453         return AVAHI_ERR_INVALID_SERVICE_TYPE;
 454
 455     if (!avahi_is_valid_domain_name(domain))
 456         return AVAHI_ERR_INVALID_DOMAIN_NAME;
 457
 458     /* Preparation */
 459
 460     if (name) {
 461         size_t l = sizeof(escaped_name);
 462         char *e = escaped_name, *r;
 463         r = avahi_escape_label(name, strlen(name), &e, &l);
 464         assert(r);
 465     }
 466
 467     if (!(avahi_normalize_name(type, normalized_type, sizeof(normalized_type))))
 468         return AVAHI_ERR_INVALID_SERVICE_TYPE;
 469
 470     if (!(avahi_normalize_name(domain, normalized_domain, sizeof(normalized_domain))))
 471         return AVAHI_ERR_INVALID_DOMAIN_NAME;
 472
 473     /* Concatenation */
 474
 475     snprintf(p, size, "%s%s%s.%s", name ? escaped_name : "", name ? "." : "", normalized_type, normalized_domain);
 476
 477     return AVAHI_OK;
 478 }
 479
 480 #ifndef HAVE_STRLCPY
 481
 482 static size_t strlcpy(char *dest, const char *src, size_t n) {
 483     assert(dest);
 484     assert(src);
 485
 486     if (n > 0) {
 487         strncpy(dest, src, n-1);
 488         dest[n-1] = 0;
 489     }
 490
 491     return strlen(src);
 492 }
 493
 494 #endif
 495
 496 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) {
 497     enum {
 498         NAME,
 499         TYPE,
 500         DOMAIN
 501     } state;
 502     int type_empty = 1, domain_empty = 1;
 503
 504     assert(p);
 505     assert(type);
 506     assert(type_size > 0);
 507     assert(domain);
 508     assert(domain_size > 0);
 509
 510     if (name) {
 511         assert(name_size > 0);
 512         *name = 0;
 513         state = NAME;
 514     } else
 515         state = TYPE;
 516
 517     *type = *domain = 0;
 518
 519     while (*p) {
 520         char buf[64];
 521
 522         if (!(avahi_unescape_label(&p, buf, sizeof(buf))))
 523             return -1;
 524
 525         switch (state) {
 526             case NAME:
 527                 strlcpy(name, buf, name_size);
 528                 state = TYPE;
 529                 break;
 530
 531             case TYPE:
 532
 533                 if (buf[0] == '_') {
 534
 535                     if (!type_empty) {
 536                         if (!type_size)
 537                             return AVAHI_ERR_NO_MEMORY;
 538
 539                         *(type++) = '.';
 540                         type_size --;
 541
 542                     } else
 543                         type_empty = 0;
 544
 545                     if (!(avahi_escape_label(buf, strlen(buf), &type, &type_size)))
 546                         return AVAHI_ERR_NO_MEMORY;
 547
 548                     break;
 549                 }
 550
 551                 state = DOMAIN;
 552                 /* fall through */
 553
 554             case DOMAIN:
 555
 556                 if (!domain_empty) {
 557                     if (!domain_size)
 558                         return AVAHI_ERR_NO_MEMORY;
 559
 560                     *(domain++) = '.';
 561                     domain_size --;
 562                 } else
 563                     domain_empty = 0;
 564
 565                 if (!(avahi_escape_label(buf, strlen(buf), &domain, &domain_size)))
 566                     return AVAHI_ERR_NO_MEMORY;
 567
 568                 break;
 569         }
 570     }
 571
 572     return 0;
 573 }
 574
 575 int avahi_is_valid_fqdn(const char *t) {
 576     char label[AVAHI_LABEL_MAX];
 577     char normalized[AVAHI_DOMAIN_NAME_MAX];
 578     const char *k = t;
 579     AvahiAddress a;
 580     assert(t);
 581
 582     if (strlen(t) >= AVAHI_DOMAIN_NAME_MAX)
 583         return 0;
 584
 585     if (!avahi_is_valid_domain_name(t))
 586         return 0;
 587
 588     /* Check if there are at least two labels*/
 589     if (!(avahi_unescape_label(&k, label, sizeof(label))))
 590         return 0;
 591
 592     if (label[0] == 0 || !k)
 593         return 0;
 594
 595     if (!(avahi_unescape_label(&k, label, sizeof(label))))
 596         return 0;
 597
 598     if (label[0] == 0 || !k)
 599         return 0;
 600
 601     /* Make sure that the name is not an IP address */
 602     if (!(avahi_normalize_name(t, normalized, sizeof(normalized))))
 603         return 0;
 604
 605     if (avahi_address_parse(normalized, AVAHI_PROTO_UNSPEC, &a))
 606         return 0;
 607
 608     return 1;
 609 }