]> git.meshlink.io Git - catta/blob - avahi-common/address.c
Complete AVAHI_LOOKUP_NO_ADDRESS fix
[catta] / 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 }