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