git.meshlink.io Git - catta/blob - avahi-common/address.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/types.h>
  27 #include <sys/socket.h>
  28 #include <arpa/inet.h>
  29 #include <string.h>
  30 #include <assert.h>
  31
  32 #include "address.h"
  33 #include "malloc.h"
  34
  35 size_t avahi_address_get_size(const AvahiAddress *a) {
  36     assert(a);
  37
  38     if (a->proto == AVAHI_PROTO_INET)
  39         return 4;
  40     else if (a->proto == AVAHI_PROTO_INET6)
  41         return 16;
  42
  43     return 0;
  44 }
  45
  46 int avahi_address_cmp(const AvahiAddress *a, const AvahiAddress *b) {
  47     assert(a);
  48     assert(b);
  49
  50     if (a->proto != b->proto)
  51         return -1;
  52
  53     return memcmp(a->data.data, b->data.data, avahi_address_get_size(a));
  54 }
  55
  56 char *avahi_address_snprint(char *s, size_t length, const AvahiAddress *a) {
  57     assert(s);
  58     assert(length);
  59     assert(a);
  60
  61     return (char*) inet_ntop(avahi_proto_to_af(a->proto), a->data.data, s, length);
  62 }
  63
  64 char* avahi_reverse_lookup_name_ipv4(const AvahiIPv4Address *a) {
  65     uint32_t n = ntohl(a->address);
  66     assert(a);
  67
  68     return avahi_strdup_printf("%u.%u.%u.%u.in-addr.arpa", n & 0xFF, (n >> 8) & 0xFF, (n >> 16) & 0xFF, n >> 24);
  69 }
  70
  71 static char *reverse_lookup_name_ipv6(const AvahiIPv6Address *a, const char *suffix) {
  72
  73     return avahi_strdup_printf("%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%s",
  74                            a->address[15] & 0xF,
  75                            a->address[15] >> 4,
  76                            a->address[14] & 0xF,
  77                            a->address[14] >> 4,
  78                            a->address[13] & 0xF,
  79                            a->address[13] >> 4,
  80                            a->address[12] & 0xF,
  81                            a->address[12] >> 4,
  82                            a->address[11] & 0xF,
  83                            a->address[11] >> 4,
  84                            a->address[10] & 0xF,
  85                            a->address[10] >> 4,
  86                            a->address[9] & 0xF,
  87                            a->address[9] >> 4,
  88                            a->address[8] & 0xF,
  89                            a->address[8] >> 4,
  90                            a->address[7] & 0xF,
  91                            a->address[7] >> 4,
  92                            a->address[6] & 0xF,
  93                            a->address[6] >> 4,
  94                            a->address[5] & 0xF,
  95                            a->address[5] >> 4,
  96                            a->address[4] & 0xF,
  97                            a->address[4] >> 4,
  98                            a->address[3] & 0xF,
  99                            a->address[3] >> 4,
 100                            a->address[2] & 0xF,
 101                            a->address[2] >> 4,
 102                            a->address[1] & 0xF,
 103                            a->address[1] >> 4,
 104                            a->address[0] & 0xF,
 105                            a->address[0] >> 4,
 106                            suffix);
 107 }
 108
 109 char *avahi_reverse_lookup_name_ipv6_arpa(const AvahiIPv6Address *a) {
 110     return reverse_lookup_name_ipv6(a, "ip6.arpa");
 111 }
 112
 113 char *avahi_reverse_lookup_name_ipv6_int(const AvahiIPv6Address *a) {
 114     return reverse_lookup_name_ipv6(a, "ip6.int");
 115 }
 116
 117 AvahiAddress *avahi_address_parse(const char *s, AvahiProtocol proto, AvahiAddress *ret_addr) {
 118     assert(ret_addr);
 119     assert(s);
 120
 121     if (proto == AVAHI_PROTO_UNSPEC) {
 122         if (inet_pton(AF_INET, s, ret_addr->data.data) <= 0) {
 123             if (inet_pton(AF_INET6, s, ret_addr->data.data) <= 0)
 124                 return NULL;
 125             else
 126                 ret_addr->proto = AVAHI_PROTO_INET6;
 127         } else
 128             ret_addr->proto = AVAHI_PROTO_INET;
 129     } else {
 130         if (inet_pton(avahi_proto_to_af(proto), s, ret_addr->data.data) <= 0)
 131             return NULL;
 132
 133         ret_addr->proto = proto;
 134     }
 135
 136     return ret_addr;
 137 }
 138
 139 AvahiAddress *avahi_address_from_sockaddr(const struct sockaddr* sa, AvahiAddress *ret_addr) {
 140     assert(sa);
 141     assert(ret_addr);
 142
 143     assert(sa->sa_family == AF_INET || sa->sa_family == AF_INET6);
 144
 145     ret_addr->proto = avahi_af_to_proto(sa->sa_family);
 146
 147     if (sa->sa_family == AF_INET)
 148         memcpy(&ret_addr->data.ipv4, &((const struct sockaddr_in*) sa)->sin_addr, sizeof(ret_addr->data.ipv4));
 149     else
 150         memcpy(&ret_addr->data.ipv6, &((const struct sockaddr_in6*) sa)->sin6_addr, sizeof(ret_addr->data.ipv6));
 151
 152     return ret_addr;
 153 }
 154
 155 uint16_t avahi_port_from_sockaddr(const struct sockaddr* sa) {
 156     assert(sa);
 157
 158     assert(sa->sa_family == AF_INET || sa->sa_family == AF_INET6);
 159
 160     if (sa->sa_family == AF_INET)
 161         return ntohs(((const struct sockaddr_in*) sa)->sin_port);
 162     else
 163         return ntohs(((const struct sockaddr_in6*) sa)->sin6_port);
 164 }
 165
 166 int avahi_address_is_ipv4_in_ipv6(const AvahiAddress *a) {
 167
 168     static const uint8_t ipv4_in_ipv6[] = {
 169         0x00, 0x00, 0x00, 0x00,
 170         0x00, 0x00, 0x00, 0x00,
 171         0xFF, 0xFF, 0xFF, 0xFF
 172     };
 173
 174     assert(a);
 175
 176     if (a->proto != AVAHI_PROTO_INET6)
 177         return 0;
 178
 179     return memcmp(a->data.ipv6.address, ipv4_in_ipv6, sizeof(ipv4_in_ipv6)) == 0;
 180 }
 181
 182 int avahi_proto_to_af(AvahiProtocol proto) {
 183     if (proto == AVAHI_PROTO_INET)
 184         return AF_INET;
 185     if (proto == AVAHI_PROTO_INET6)
 186         return AF_INET6;
 187
 188     assert(proto == AVAHI_PROTO_UNSPEC);
 189     return AF_UNSPEC;
 190 }
 191
 192 AvahiProtocol avahi_af_to_proto(int af) {
 193     if (af == AF_INET)
 194         return AVAHI_PROTO_INET;
 195     if (af == AF_INET6)
 196         return AVAHI_PROTO_INET6;
 197
 198     assert(af == AF_UNSPEC);
 199     return AVAHI_PROTO_UNSPEC;
 200 }
 201
 202 const char* avahi_proto_to_string(AvahiProtocol proto) {
 203     if (proto == AVAHI_PROTO_INET)
 204         return "IPv4";
 205     if (proto == AVAHI_PROTO_INET6)
 206         return "IPv6";
 207
 208     assert(proto == AVAHI_PROTO_UNSPEC);
 209     return "UNSPEC";
 210 }