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