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