]> git.meshlink.io Git - catta/blob - avahi-compat-howl/address.c
CVE-2009-0758: Reflector creates packet storm on legacy unicast traffic
[catta] / avahi-compat-howl / 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 <assert.h>
27 #include <netdb.h>
28 #include <unistd.h>
29 #include <sys/socket.h>
30 #include <netinet/in.h>
31 #include <arpa/inet.h>
32 #include <sys/types.h>
33
34 #include <avahi-common/gccmacro.h>
35
36 #include "howl.h"
37 #include "warn.h"
38
39 sw_ipv4_address sw_ipv4_address_any(void) {
40     sw_ipv4_address a;
41
42     AVAHI_WARN_LINKAGE;
43
44     a.m_addr = htonl(INADDR_ANY);
45     return a;
46 }
47
48 sw_ipv4_address sw_ipv4_address_loopback(void) {
49     sw_ipv4_address a;
50
51     AVAHI_WARN_LINKAGE;
52
53     a.m_addr = htonl(INADDR_LOOPBACK);
54     return a;
55 }
56
57 sw_result sw_ipv4_address_init(sw_ipv4_address * self) {
58     assert(self);
59
60     AVAHI_WARN_LINKAGE;
61
62     self->m_addr = htonl(INADDR_ANY);
63     return SW_OKAY;
64 }
65
66 sw_result sw_ipv4_address_init_from_saddr(
67     sw_ipv4_address *self,
68     sw_saddr addr) {
69
70     assert(self);
71
72     AVAHI_WARN_LINKAGE;
73
74     self->m_addr = addr;
75     return SW_OKAY;
76 }
77
78 sw_result sw_ipv4_address_init_from_name(
79     sw_ipv4_address *self,
80     sw_const_string name) {
81
82     struct hostent *he;
83
84     assert(self);
85     assert(name);
86
87     AVAHI_WARN_LINKAGE;
88     
89     if (!(he = gethostbyname(name)))
90         return SW_E_UNKNOWN;
91     
92     self->m_addr = *(uint32_t*) he->h_addr;
93     return SW_OKAY;
94 }
95
96 sw_result sw_ipv4_address_init_from_address(
97     sw_ipv4_address *self,
98     sw_ipv4_address addr) {
99
100     assert(self);
101
102     AVAHI_WARN_LINKAGE;
103
104     self->m_addr = addr.m_addr;
105     return SW_OKAY;
106 }
107
108 sw_result sw_ipv4_address_init_from_this_host(sw_ipv4_address *self) {
109     struct sockaddr_in sa;
110     int fd;
111     socklen_t l = sizeof(sa);
112
113     assert(self);
114
115     AVAHI_WARN_LINKAGE;
116     
117     /* This is so fucked up ... */
118
119     memset(&sa, 0, sizeof(sa));
120     sa.sin_family = AF_INET;
121     sa.sin_addr.s_addr = inet_addr("192.168.1.1"); /* Ouch */
122     sa.sin_port = htons(5555);
123
124     if ((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0 ||
125         connect(fd, (struct sockaddr*) &sa, sizeof(sa)) < 0 ||
126         getsockname(fd, (struct sockaddr*) &sa, &l) < 0) {
127         if (fd >= 0)
128             close(fd);
129
130         perror("fuck");
131         return SW_E_UNKNOWN;
132     }
133
134     assert(l == sizeof(sa));
135     close(fd);
136
137     self->m_addr = sa.sin_addr.s_addr;
138     
139     return SW_OKAY;
140 }
141
142 sw_result sw_ipv4_address_fina(AVAHI_GCC_UNUSED sw_ipv4_address self) {
143
144     AVAHI_WARN_LINKAGE;
145
146     /* This is ridiculous ... */
147     
148     return SW_OKAY;
149 }
150
151 sw_bool sw_ipv4_address_is_any(sw_ipv4_address self) {
152     AVAHI_WARN_LINKAGE;
153     return self.m_addr == htonl(INADDR_ANY);
154 }
155
156 sw_saddr sw_ipv4_address_saddr(sw_ipv4_address self) {
157     AVAHI_WARN_LINKAGE;
158     return self.m_addr;
159 }
160
161 sw_string sw_ipv4_address_name(
162     sw_ipv4_address self,
163     sw_string name,
164     sw_uint32 len) {
165
166     assert(name);
167     assert(len > 0);
168
169     AVAHI_WARN_LINKAGE;
170
171     if (len < INET_ADDRSTRLEN)
172         return NULL;
173     
174     if (!(inet_ntop(AF_INET, &self.m_addr, name, len)))
175         return NULL;
176             
177     return name;
178 }
179
180 sw_result sw_ipv4_address_decompose(
181     sw_ipv4_address self,
182     sw_uint8 * a1,
183     sw_uint8 * a2,
184     sw_uint8 * a3,
185     sw_uint8 * a4) {
186
187     uint32_t a;
188
189     AVAHI_WARN_LINKAGE;
190     
191     a = ntohl(self.m_addr);
192     
193     assert(a1);
194     assert(a2);
195     assert(a3);
196     assert(a4);
197
198     *a1 = (uint8_t) (a >> 24);
199     *a2 = (uint8_t) (a >> 16);
200     *a3 = (uint8_t) (a >> 8);
201     *a4 = (uint8_t) (a);
202         
203     return SW_OKAY;
204 }
205
206 sw_bool sw_ipv4_address_equals(
207     sw_ipv4_address self,
208     sw_ipv4_address addr) {
209
210     AVAHI_WARN_LINKAGE;
211
212     return self.m_addr == addr.m_addr;
213 }
214