aboutsummaryrefslogtreecommitdiff
path: root/src/gns/gnunet-gns-helper-service-w32.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/gns/gnunet-gns-helper-service-w32.c')
-rw-r--r--src/gns/gnunet-gns-helper-service-w32.c944
1 files changed, 473 insertions, 471 deletions
diff --git a/src/gns/gnunet-gns-helper-service-w32.c b/src/gns/gnunet-gns-helper-service-w32.c
index 4eb965e24..4c4803556 100644
--- a/src/gns/gnunet-gns-helper-service-w32.c
+++ b/src/gns/gnunet-gns-helper-service-w32.c
@@ -11,12 +11,12 @@
11 WITHOUT ANY WARRANTY; without even the implied warranty of 11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details. 13 Affero General Public License for more details.
14 14
15 You should have received a copy of the GNU Affero General Public License 15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. 16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17 17
18 SPDX-License-Identifier: AGPL3.0-or-later 18 SPDX-License-Identifier: AGPL3.0-or-later
19*/ 19 */
20/** 20/**
21 * @file gnunet-gns-helper-service-w32.c 21 * @file gnunet-gns-helper-service-w32.c
22 * @brief an intermediary service to access distributed GNS 22 * @brief an intermediary service to access distributed GNS
@@ -35,7 +35,7 @@
35#include <nspapi.h> 35#include <nspapi.h>
36#include <unistr.h> 36#include <unistr.h>
37 37
38#define DEFINE_DNS_GUID(a,x) DEFINE_GUID(a, 0x00090035, 0x0000, x, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46) 38#define DEFINE_DNS_GUID(a, x) DEFINE_GUID(a, 0x00090035, 0x0000, x, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)
39DEFINE_DNS_GUID(SVCID_DNS_TYPE_A, 0x0001); 39DEFINE_DNS_GUID(SVCID_DNS_TYPE_A, 0x0001);
40DEFINE_DNS_GUID(SVCID_DNS_TYPE_NS, 0x0002); 40DEFINE_DNS_GUID(SVCID_DNS_TYPE_NS, 0x0002);
41DEFINE_DNS_GUID(SVCID_DNS_TYPE_CNAME, 0x0005); 41DEFINE_DNS_GUID(SVCID_DNS_TYPE_CNAME, 0x0005);
@@ -49,8 +49,7 @@ DEFINE_GUID(SVCID_HOSTNAME, 0x0002a800, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00,
49DEFINE_GUID(SVCID_INET_HOSTADDRBYNAME, 0x0002a803, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46); 49DEFINE_GUID(SVCID_INET_HOSTADDRBYNAME, 0x0002a803, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);
50 50
51 51
52struct request 52struct request {
53{
54 /** 53 /**
55 * We keep these in a doubly-linked list (for cleanup). 54 * We keep these in a doubly-linked list (for cleanup).
56 */ 55 */
@@ -120,83 +119,83 @@ static int got_egos;
120 * @param cls unused 119 * @param cls unused
121 */ 120 */
122static void 121static void
123do_shutdown (void *cls) 122do_shutdown(void *cls)
124{ 123{
125 struct request *rq; 124 struct request *rq;
126 125
127 if (NULL != id_op) 126 if (NULL != id_op)
128 { 127 {
129 GNUNET_IDENTITY_cancel (id_op); 128 GNUNET_IDENTITY_cancel(id_op);
130 id_op = NULL; 129 id_op = NULL;
131 } 130 }
132 if (NULL != identity) 131 if (NULL != identity)
133 { 132 {
134 GNUNET_IDENTITY_disconnect (identity); 133 GNUNET_IDENTITY_disconnect(identity);
135 identity = NULL; 134 identity = NULL;
136 } 135 }
137 while (NULL != (rq = rq_head)) 136 while (NULL != (rq = rq_head))
138 { 137 {
139 if (NULL != rq->lookup_request) 138 if (NULL != rq->lookup_request)
140 GNUNET_GNS_lookup_cancel (rq->lookup_request); 139 GNUNET_GNS_lookup_cancel(rq->lookup_request);
141 GNUNET_CONTAINER_DLL_remove (rq_head, 140 GNUNET_CONTAINER_DLL_remove(rq_head,
142 rq_tail, 141 rq_tail,
143 rq); 142 rq);
144 GNUNET_free_non_null (rq->name); 143 GNUNET_free_non_null(rq->name);
145 if (rq->u8name) 144 if (rq->u8name)
146 free (rq->u8name); 145 free(rq->u8name);
147 GNUNET_free (rq); 146 GNUNET_free(rq);
148 } 147 }
149 if (NULL != gns) 148 if (NULL != gns)
150 { 149 {
151 GNUNET_GNS_disconnect (gns); 150 GNUNET_GNS_disconnect(gns);
152 gns = NULL; 151 gns = NULL;
153 } 152 }
154} 153}
155 154
156 155
157#define MarshallPtr(ptr, base, type) \ 156#define MarshallPtr(ptr, base, type) \
158 if (ptr) \ 157 if (ptr) \
159 ptr = (type *) ((char *) ptr - (char *) base) 158 ptr = (type *) ((char *)ptr - (char *)base)
160 159
161 160
162void 161void
163MarshallWSAQUERYSETW (WSAQUERYSETW *qs, GUID *sc) 162MarshallWSAQUERYSETW(WSAQUERYSETW *qs, GUID *sc)
164{ 163{
165 MarshallPtr (qs->lpszServiceInstanceName, qs, wchar_t); 164 MarshallPtr(qs->lpszServiceInstanceName, qs, wchar_t);
166 MarshallPtr (qs->lpServiceClassId, qs, GUID); 165 MarshallPtr(qs->lpServiceClassId, qs, GUID);
167 MarshallPtr (qs->lpVersion, qs, WSAVERSION); 166 MarshallPtr(qs->lpVersion, qs, WSAVERSION);
168 MarshallPtr (qs->lpNSProviderId, qs, GUID); 167 MarshallPtr(qs->lpNSProviderId, qs, GUID);
169 MarshallPtr (qs->lpszContext, qs, wchar_t); 168 MarshallPtr(qs->lpszContext, qs, wchar_t);
170 MarshallPtr (qs->lpafpProtocols, qs, AFPROTOCOLS); 169 MarshallPtr(qs->lpafpProtocols, qs, AFPROTOCOLS);
171 MarshallPtr (qs->lpszQueryString, qs, wchar_t); 170 MarshallPtr(qs->lpszQueryString, qs, wchar_t);
172 for (int i = 0; i < qs->dwNumberOfCsAddrs; i++) 171 for (int i = 0; i < qs->dwNumberOfCsAddrs; i++)
173 { 172 {
174 MarshallPtr (qs->lpcsaBuffer[i].LocalAddr.lpSockaddr, qs, SOCKADDR); 173 MarshallPtr(qs->lpcsaBuffer[i].LocalAddr.lpSockaddr, qs, SOCKADDR);
175 MarshallPtr (qs->lpcsaBuffer[i].RemoteAddr.lpSockaddr, qs, SOCKADDR); 174 MarshallPtr(qs->lpcsaBuffer[i].RemoteAddr.lpSockaddr, qs, SOCKADDR);
176 } 175 }
177 MarshallPtr (qs->lpcsaBuffer, qs, CSADDR_INFO); 176 MarshallPtr(qs->lpcsaBuffer, qs, CSADDR_INFO);
178 if (IsEqualGUID (&SVCID_INET_HOSTADDRBYNAME, sc) && qs->lpBlob != NULL && qs->lpBlob->pBlobData != NULL) 177 if (IsEqualGUID(&SVCID_INET_HOSTADDRBYNAME, sc) && qs->lpBlob != NULL && qs->lpBlob->pBlobData != NULL)
179 { 178 {
180 struct hostent *he; 179 struct hostent *he;
181 180
182 he = (struct hostent *) qs->lpBlob->pBlobData; 181 he = (struct hostent *)qs->lpBlob->pBlobData;
183 for (int i = 0; he->h_aliases[i] != NULL; i++) 182 for (int i = 0; he->h_aliases[i] != NULL; i++)
184 MarshallPtr (he->h_aliases[i], he, char); 183 MarshallPtr(he->h_aliases[i], he, char);
185 MarshallPtr (he->h_aliases, he, char *); 184 MarshallPtr(he->h_aliases, he, char *);
186 MarshallPtr (he->h_name, he, char); 185 MarshallPtr(he->h_name, he, char);
187 for (int i = 0; he->h_addr_list[i] != NULL; i++) 186 for (int i = 0; he->h_addr_list[i] != NULL; i++)
188 MarshallPtr (he->h_addr_list[i], he, void); 187 MarshallPtr(he->h_addr_list[i], he, void);
189 MarshallPtr (he->h_addr_list, he, char *); 188 MarshallPtr(he->h_addr_list, he, char *);
190 MarshallPtr (qs->lpBlob->pBlobData, qs, void); 189 MarshallPtr(qs->lpBlob->pBlobData, qs, void);
191 } 190 }
192 MarshallPtr (qs->lpBlob, qs, BLOB); 191 MarshallPtr(qs->lpBlob, qs, BLOB);
193} 192}
194 193
195 194
196static void 195static void
197process_lookup_result (void *cls, 196process_lookup_result(void *cls,
198 uint32_t rd_count, 197 uint32_t rd_count,
199 const struct GNUNET_GNSRECORD_Data *rd) 198 const struct GNUNET_GNSRECORD_Data *rd)
200{ 199{
201 struct request *rq = cls; 200 struct request *rq = cls;
202 int i, j, csanum; 201 int i, j, csanum;
@@ -211,269 +210,272 @@ process_lookup_result (void *cls,
211 size_t blobsize = 0; 210 size_t blobsize = 0;
212 size_t blobaddrcount = 0; 211 size_t blobaddrcount = 0;
213 212
214 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 213 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
215 "Got lookup result with count %u for rq %p with client %p\n", 214 "Got lookup result with count %u for rq %p with client %p\n",
216 rd_count, 215 rd_count,
217 rq, 216 rq,
218 rq->client); 217 rq->client);
219 rq->lookup_request = NULL; 218 rq->lookup_request = NULL;
220 219
221 if (0 == rd_count) 220 if (0 == rd_count)
222 { 221 {
223 msgend_env = GNUNET_MQ_msg (msgend, GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE); 222 msgend_env = GNUNET_MQ_msg(msgend, GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE);
224 GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (rq->client), 223 GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(rq->client),
225 msgend_env); 224 msgend_env);
226 GNUNET_CONTAINER_DLL_remove (rq_head, 225 GNUNET_CONTAINER_DLL_remove(rq_head,
227 rq_tail, 226 rq_tail,
228 rq); 227 rq);
229 GNUNET_free_non_null (rq->name); 228 GNUNET_free_non_null(rq->name);
230 if (rq->u8name) 229 if (rq->u8name)
231 free (rq->u8name); 230 free(rq->u8name);
232 GNUNET_free (rq); 231 GNUNET_free(rq);
233 return; 232 return;
234 } 233 }
235 234
236 size = sizeof (struct GNUNET_W32RESOLVER_GetMessage) + sizeof (WSAQUERYSETW); 235 size = sizeof(struct GNUNET_W32RESOLVER_GetMessage) + sizeof(WSAQUERYSETW);
237 size += (wcslen (rq->name) + 1) * sizeof (wchar_t); 236 size += (wcslen(rq->name) + 1) * sizeof(wchar_t);
238 size += sizeof (GUID); 237 size += sizeof(GUID);
239 /* lpszComment ? a TXT record? */ 238 /* lpszComment ? a TXT record? */
240 size += sizeof (GUID); 239 size += sizeof(GUID);
241 /* lpszContext ? Not sure what it is */ 240 /* lpszContext ? Not sure what it is */
242 csanum = 0; 241 csanum = 0;
243 for (i = 0; i < rd_count; i++) 242 for (i = 0; i < rd_count; i++)
244 {
245 switch (rd[i].record_type)
246 { 243 {
247 case GNUNET_DNSPARSER_TYPE_A: 244 switch (rd[i].record_type)
248 if (rd[i].data_size != sizeof (struct in_addr)) 245 {
249 continue; 246 case GNUNET_DNSPARSER_TYPE_A:
250 size += sizeof (CSADDR_INFO) + sizeof (struct sockaddr_in) * 2; 247 if (rd[i].data_size != sizeof(struct in_addr))
251 csanum++; 248 continue;
252 break; 249 size += sizeof(CSADDR_INFO) + sizeof(struct sockaddr_in) * 2;
253 case GNUNET_DNSPARSER_TYPE_AAAA: 250 csanum++;
254 if (rd[i].data_size != sizeof (struct in6_addr)) 251 break;
255 continue; 252
256 size += sizeof (CSADDR_INFO) + sizeof (struct sockaddr_in6) * 2; 253 case GNUNET_DNSPARSER_TYPE_AAAA:
257 csanum++; 254 if (rd[i].data_size != sizeof(struct in6_addr))
258 break; 255 continue;
256 size += sizeof(CSADDR_INFO) + sizeof(struct sockaddr_in6) * 2;
257 csanum++;
258 break;
259 }
259 } 260 }
260 } 261 if (IsEqualGUID(&SVCID_INET_HOSTADDRBYNAME, &rq->sc))
261 if (IsEqualGUID (&SVCID_INET_HOSTADDRBYNAME, &rq->sc))
262 {
263 size += sizeof (BLOB);
264 blobsize += sizeof (struct hostent);
265 blobsize += strlen (rq->u8name) + 1;
266 blobsize += sizeof (void *); /* For aliases */
267 blobsize += sizeof (void *); /* For addresses */
268 for (i = 0; i < rd_count; i++)
269 { 262 {
270 if ((rq->af == AF_INET || rq->af == AF_UNSPEC) && rd[i].record_type == GNUNET_DNSPARSER_TYPE_A) 263 size += sizeof(BLOB);
271 { 264 blobsize += sizeof(struct hostent);
272 blobsize += sizeof (void *); 265 blobsize += strlen(rq->u8name) + 1;
273 blobsize += sizeof (struct in_addr); 266 blobsize += sizeof(void *); /* For aliases */
274 blobaddrcount++; 267 blobsize += sizeof(void *); /* For addresses */
275 } 268 for (i = 0; i < rd_count; i++)
276 else if (rq->af == AF_INET6 && rd[i].record_type == GNUNET_DNSPARSER_TYPE_AAAA) 269 {
277 { 270 if ((rq->af == AF_INET || rq->af == AF_UNSPEC) && rd[i].record_type == GNUNET_DNSPARSER_TYPE_A)
278 blobsize += sizeof (void *); 271 {
279 blobsize += sizeof (struct in6_addr); 272 blobsize += sizeof(void *);
280 blobaddrcount++; 273 blobsize += sizeof(struct in_addr);
281 } 274 blobaddrcount++;
275 }
276 else if (rq->af == AF_INET6 && rd[i].record_type == GNUNET_DNSPARSER_TYPE_AAAA)
277 {
278 blobsize += sizeof(void *);
279 blobsize += sizeof(struct in6_addr);
280 blobaddrcount++;
281 }
282 }
283 size += blobsize;
282 } 284 }
283 size += blobsize; 285 size_recalc = sizeof(struct GNUNET_W32RESOLVER_GetMessage) + sizeof(WSAQUERYSETW);
284 } 286 msg_env = GNUNET_MQ_msg_extra(msg,
285 size_recalc = sizeof (struct GNUNET_W32RESOLVER_GetMessage) + sizeof (WSAQUERYSETW); 287 size - sizeof(struct GNUNET_MessageHeader),
286 msg_env = GNUNET_MQ_msg_extra (msg, 288 GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE);
287 size - sizeof (struct GNUNET_MessageHeader), 289 msg->af = htonl(rq->af);
288 GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE); 290 msg->sc_data1 = htonl(rq->sc.Data1);
289 msg->af = htonl (rq->af); 291 msg->sc_data2 = htons(rq->sc.Data2);
290 msg->sc_data1 = htonl (rq->sc.Data1); 292 msg->sc_data3 = htons(rq->sc.Data3);
291 msg->sc_data2 = htons (rq->sc.Data2);
292 msg->sc_data3 = htons (rq->sc.Data3);
293 for (i = 0; i < 8; i++) 293 for (i = 0; i < 8; i++)
294 msg->sc_data4[i] = rq->sc.Data4[i]; 294 msg->sc_data4[i] = rq->sc.Data4[i];
295 qs = (WSAQUERYSETW *) &msg[1]; 295 qs = (WSAQUERYSETW *)&msg[1];
296 ptr = (char *) &qs[1]; 296 ptr = (char *)&qs[1];
297 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg)); 297 GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
298 qs->dwSize = sizeof (WSAQUERYSETW); 298 qs->dwSize = sizeof(WSAQUERYSETW);
299 qs->lpszServiceInstanceName = (wchar_t *) ptr; 299 qs->lpszServiceInstanceName = (wchar_t *)ptr;
300 ptr += (wcslen (rq->name) + 1) * sizeof (wchar_t); 300 ptr += (wcslen(rq->name) + 1) * sizeof(wchar_t);
301 size_recalc += (wcslen (rq->name) + 1) * sizeof (wchar_t); 301 size_recalc += (wcslen(rq->name) + 1) * sizeof(wchar_t);
302 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg)); 302 GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
303 wcscpy (qs->lpszServiceInstanceName, rq->name); 303 wcscpy(qs->lpszServiceInstanceName, rq->name);
304 qs->lpServiceClassId = (GUID *) ptr; 304 qs->lpServiceClassId = (GUID *)ptr;
305 ptr += sizeof (GUID); 305 ptr += sizeof(GUID);
306 size_recalc += sizeof (GUID); 306 size_recalc += sizeof(GUID);
307 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg)); 307 GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
308 GNUNET_memcpy (qs->lpServiceClassId, &rq->sc, sizeof (GUID)); 308 GNUNET_memcpy(qs->lpServiceClassId, &rq->sc, sizeof(GUID));
309 qs->lpVersion = NULL; 309 qs->lpVersion = NULL;
310 qs->dwNameSpace = NS_DNS; 310 qs->dwNameSpace = NS_DNS;
311 qs->lpNSProviderId = (GUID *) ptr; 311 qs->lpNSProviderId = (GUID *)ptr;
312 ptr += sizeof (GUID); 312 ptr += sizeof(GUID);
313 size_recalc += sizeof (GUID); 313 size_recalc += sizeof(GUID);
314 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg)); 314 GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
315 GNUNET_memcpy (qs->lpNSProviderId, &GNUNET_NAMESPACE_PROVIDER_DNS, sizeof (GUID)); 315 GNUNET_memcpy(qs->lpNSProviderId, &GNUNET_NAMESPACE_PROVIDER_DNS, sizeof(GUID));
316 qs->lpszContext = NULL; 316 qs->lpszContext = NULL;
317 qs->dwNumberOfProtocols = 0; 317 qs->dwNumberOfProtocols = 0;
318 qs->lpafpProtocols = NULL; 318 qs->lpafpProtocols = NULL;
319 /* Don't bother with this... */ 319 /* Don't bother with this... */
320 qs->lpszQueryString = NULL; 320 qs->lpszQueryString = NULL;
321 qs->dwNumberOfCsAddrs = rd_count; 321 qs->dwNumberOfCsAddrs = rd_count;
322 qs->lpcsaBuffer = (CSADDR_INFO *) ptr; 322 qs->lpcsaBuffer = (CSADDR_INFO *)ptr;
323 ptr += sizeof (CSADDR_INFO) * csanum; 323 ptr += sizeof(CSADDR_INFO) * csanum;
324 j = 0; 324 j = 0;
325 for (i = 0; i < rd_count; i++) 325 for (i = 0; i < rd_count; i++)
326 {
327 switch (rd[i].record_type)
328 { 326 {
329 case GNUNET_DNSPARSER_TYPE_A: 327 switch (rd[i].record_type)
330 if (rd[i].data_size != sizeof (struct in_addr)) 328 {
331 continue; 329 case GNUNET_DNSPARSER_TYPE_A:
332 qs->lpcsaBuffer[j].iSocketType = SOCK_STREAM; 330 if (rd[i].data_size != sizeof(struct in_addr))
333 qs->lpcsaBuffer[j].iProtocol = IPPROTO_TCP; 331 continue;
334 332 qs->lpcsaBuffer[j].iSocketType = SOCK_STREAM;
335 qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength = sizeof (struct sockaddr_in); 333 qs->lpcsaBuffer[j].iProtocol = IPPROTO_TCP;
336 qs->lpcsaBuffer[j].LocalAddr.lpSockaddr = (SOCKADDR *) ptr; 334
337 ptr += qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength; 335 qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength = sizeof(struct sockaddr_in);
338 memset (qs->lpcsaBuffer[j].LocalAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength); 336 qs->lpcsaBuffer[j].LocalAddr.lpSockaddr = (SOCKADDR *)ptr;
339 ((struct sockaddr_in *)qs->lpcsaBuffer[j].LocalAddr.lpSockaddr)->sin_family = AF_INET; 337 ptr += qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength;
340 338 memset(qs->lpcsaBuffer[j].LocalAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength);
341 qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength = sizeof (struct sockaddr_in); 339 ((struct sockaddr_in *)qs->lpcsaBuffer[j].LocalAddr.lpSockaddr)->sin_family = AF_INET;
342 qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr = (SOCKADDR *) ptr; 340
343 ptr += qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength; 341 qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength = sizeof(struct sockaddr_in);
344 memset (qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength); 342 qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr = (SOCKADDR *)ptr;
345 ((struct sockaddr_in *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin_family = AF_INET; 343 ptr += qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength;
346 ((struct sockaddr_in *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin_port = htonl (53); /* Don't ask why it's 53 */ 344 memset(qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength);
347 ((struct sockaddr_in *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin_addr = *(struct in_addr *) rd[i].data; 345 ((struct sockaddr_in *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin_family = AF_INET;
348 size_recalc += sizeof (CSADDR_INFO) + sizeof (struct sockaddr_in) * 2; 346 ((struct sockaddr_in *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin_port = htonl(53); /* Don't ask why it's 53 */
349 j++; 347 ((struct sockaddr_in *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin_addr = *(struct in_addr *)rd[i].data;
350 break; 348 size_recalc += sizeof(CSADDR_INFO) + sizeof(struct sockaddr_in) * 2;
351 case GNUNET_DNSPARSER_TYPE_AAAA: 349 j++;
352 if (rd[i].data_size != sizeof (struct in6_addr)) 350 break;
353 continue; 351
354 qs->lpcsaBuffer[j].iSocketType = SOCK_STREAM; 352 case GNUNET_DNSPARSER_TYPE_AAAA:
355 qs->lpcsaBuffer[j].iProtocol = IPPROTO_TCP; 353 if (rd[i].data_size != sizeof(struct in6_addr))
356 354 continue;
357 qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength = sizeof (struct sockaddr_in6); 355 qs->lpcsaBuffer[j].iSocketType = SOCK_STREAM;
358 qs->lpcsaBuffer[j].LocalAddr.lpSockaddr = (SOCKADDR *) ptr; 356 qs->lpcsaBuffer[j].iProtocol = IPPROTO_TCP;
359 ptr += qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength; 357
360 memset (qs->lpcsaBuffer[j].LocalAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength); 358 qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength = sizeof(struct sockaddr_in6);
361 ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].LocalAddr.lpSockaddr)->sin6_family = AF_INET6; 359 qs->lpcsaBuffer[j].LocalAddr.lpSockaddr = (SOCKADDR *)ptr;
362 360 ptr += qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength;
363 qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength = sizeof (struct sockaddr_in6); 361 memset(qs->lpcsaBuffer[j].LocalAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength);
364 qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr = (SOCKADDR *) ptr; 362 ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].LocalAddr.lpSockaddr)->sin6_family = AF_INET6;
365 ptr += qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength; 363
366 memset (qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength); 364 qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength = sizeof(struct sockaddr_in6);
367 ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin6_family = AF_INET6; 365 qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr = (SOCKADDR *)ptr;
368 ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin6_port = htonl (53); /* Don't ask why it's 53 */ 366 ptr += qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength;
369 ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin6_addr = *(struct in6_addr *) rd[i].data; 367 memset(qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength);
370 size_recalc += sizeof (CSADDR_INFO) + sizeof (struct sockaddr_in6) * 2; 368 ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin6_family = AF_INET6;
371 j++; 369 ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin6_port = htonl(53); /* Don't ask why it's 53 */
372 break; 370 ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin6_addr = *(struct in6_addr *)rd[i].data;
373 default: 371 size_recalc += sizeof(CSADDR_INFO) + sizeof(struct sockaddr_in6) * 2;
374 break; 372 j++;
373 break;
374
375 default:
376 break;
377 }
375 } 378 }
376 } 379 GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
377 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
378 qs->dwOutputFlags = 0; 380 qs->dwOutputFlags = 0;
379 if (IsEqualGUID (&SVCID_INET_HOSTADDRBYNAME, &rq->sc)) 381 if (IsEqualGUID(&SVCID_INET_HOSTADDRBYNAME, &rq->sc))
380 { 382 {
381 struct hostent *he; 383 struct hostent *he;
382 qs->lpBlob = (BLOB *) ptr; 384 qs->lpBlob = (BLOB *)ptr;
383 ptr += sizeof (BLOB); 385 ptr += sizeof(BLOB);
384 386
385 size_recalc += sizeof (BLOB); 387 size_recalc += sizeof(BLOB);
386 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg)); 388 GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
387 389
388 qs->lpBlob->cbSize = blobsize; 390 qs->lpBlob->cbSize = blobsize;
389 qs->lpBlob->pBlobData = (BYTE *) ptr; 391 qs->lpBlob->pBlobData = (BYTE *)ptr;
390 ptr += sizeof (struct hostent); 392 ptr += sizeof(struct hostent);
391 393
392 size_recalc += sizeof (struct hostent); 394 size_recalc += sizeof(struct hostent);
393 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg)); 395 GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
394 396
395 he = (struct hostent *) qs->lpBlob->pBlobData; 397 he = (struct hostent *)qs->lpBlob->pBlobData;
396 he->h_name = (char *) ptr; 398 he->h_name = (char *)ptr;
397 ptr += strlen (rq->u8name) + 1; 399 ptr += strlen(rq->u8name) + 1;
398 400
399 size_recalc += strlen (rq->u8name) + 1; 401 size_recalc += strlen(rq->u8name) + 1;
400 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg)); 402 GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
401 403
402 strcpy (he->h_name, rq->u8name); 404 strcpy(he->h_name, rq->u8name);
403 he->h_aliases = (char **) ptr; 405 he->h_aliases = (char **)ptr;
404 ptr += sizeof (void *); 406 ptr += sizeof(void *);
405 407
406 size_recalc += sizeof (void *); /* For aliases */ 408 size_recalc += sizeof(void *); /* For aliases */
407 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg)); 409 GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
408 410
409 he->h_aliases[0] = NULL; 411 he->h_aliases[0] = NULL;
410 he->h_addrtype = rq->af; 412 he->h_addrtype = rq->af;
411 he->h_length = rq->af == AF_INET || rq->af == AF_UNSPEC ? sizeof (struct in_addr) : sizeof (struct in6_addr); 413 he->h_length = rq->af == AF_INET || rq->af == AF_UNSPEC ? sizeof(struct in_addr) : sizeof(struct in6_addr);
412 he->h_addr_list = (char **) ptr; 414 he->h_addr_list = (char **)ptr;
413 ptr += sizeof (void *) * (blobaddrcount + 1); 415 ptr += sizeof(void *) * (blobaddrcount + 1);
414 416
415 size_recalc += sizeof (void *) * (blobaddrcount + 1); /* For addresses */ 417 size_recalc += sizeof(void *) * (blobaddrcount + 1); /* For addresses */
416 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg)); 418 GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
419
420 j = 0;
421 for (i = 0; i < rd_count; i++)
422 {
423 if ((rq->af == AF_INET || rq->af == AF_UNSPEC) &&
424 rd[i].record_type == GNUNET_DNSPARSER_TYPE_A)
425 {
426 he->h_addr_list[j] = (char *)ptr;
427 ptr += sizeof(struct in_addr);
428
429 size_recalc += sizeof(struct in_addr);
430 GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
431
432 GNUNET_memcpy(he->h_addr_list[j], rd[i].data, sizeof(struct in_addr));
433 j++;
434 }
435 else if (rq->af == AF_INET6 && rd[i].record_type == GNUNET_DNSPARSER_TYPE_AAAA)
436 {
437 he->h_addr_list[j] = (char *)ptr;
438 ptr += sizeof(struct in6_addr);
439
440 size_recalc += sizeof(struct in6_addr);
441 GNUNET_break(size_recalc == (size_t)((char *)ptr - (char *)msg));
442
443 GNUNET_memcpy(he->h_addr_list[j], rd[i].data, sizeof(struct in6_addr));
444 j++;
445 }
446 }
447 he->h_addr_list[j] = NULL;
448 }
449 msgend_env = GNUNET_MQ_msg(msgend, GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE);
417 450
418 j = 0; 451 if ((char *)ptr - (char *)msg != size || size_recalc != size || size_recalc != ((char *)ptr - (char *)msg))
419 for (i = 0; i < rd_count; i++)
420 { 452 {
421 if ((rq->af == AF_INET || rq->af == AF_UNSPEC) && 453 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
422 rd[i].record_type == GNUNET_DNSPARSER_TYPE_A) 454 "Error in WSAQUERYSETW size calc: expected %u, got %lu (recalc %u)\n",
423 { 455 size,
424 he->h_addr_list[j] = (char *) ptr; 456 (unsigned long)((char *)ptr - (char *)msg),
425 ptr += sizeof (struct in_addr); 457 size_recalc);
426
427 size_recalc += sizeof (struct in_addr);
428 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
429
430 GNUNET_memcpy (he->h_addr_list[j], rd[i].data, sizeof (struct in_addr));
431 j++;
432 }
433 else if (rq->af == AF_INET6 && rd[i].record_type == GNUNET_DNSPARSER_TYPE_AAAA)
434 {
435 he->h_addr_list[j] = (char *) ptr;
436 ptr += sizeof (struct in6_addr);
437
438 size_recalc += sizeof (struct in6_addr);
439 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
440
441 GNUNET_memcpy (he->h_addr_list[j], rd[i].data, sizeof (struct in6_addr));
442 j++;
443 }
444 } 458 }
445 he->h_addr_list[j] = NULL; 459 MarshallWSAQUERYSETW(qs, &rq->sc);
446 } 460 GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(rq->client),
447 msgend_env = GNUNET_MQ_msg (msgend, GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE); 461 msg_env);
448 462 GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(rq->client),
449 if ((char *) ptr - (char *) msg != size || size_recalc != size || size_recalc != ((char *) ptr - (char *) msg)) 463 msgend_env);
450 { 464 GNUNET_CONTAINER_DLL_remove(rq_head,
451 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 465 rq_tail,
452 "Error in WSAQUERYSETW size calc: expected %u, got %lu (recalc %u)\n", 466 rq);
453 size, 467 GNUNET_free_non_null(rq->name);
454 (unsigned long) ((char *) ptr - (char *) msg),
455 size_recalc);
456 }
457 MarshallWSAQUERYSETW (qs, &rq->sc);
458 GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (rq->client),
459 msg_env);
460 GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (rq->client),
461 msgend_env);
462 GNUNET_CONTAINER_DLL_remove (rq_head,
463 rq_tail,
464 rq);
465 GNUNET_free_non_null (rq->name);
466 if (rq->u8name) 468 if (rq->u8name)
467 free (rq->u8name); 469 free(rq->u8name);
468 GNUNET_free (rq); 470 GNUNET_free(rq);
469} 471}
470 472
471 473
472static void 474static void
473get_ip_from_hostname (struct GNUNET_SERVICE_Client *client, 475get_ip_from_hostname(struct GNUNET_SERVICE_Client *client,
474 const wchar_t *name, 476 const wchar_t *name,
475 int af, 477 int af,
476 GUID sc) 478 GUID sc)
477{ 479{
478 struct request *rq; 480 struct request *rq;
479 char *hostname; 481 char *hostname;
@@ -481,104 +483,104 @@ get_ip_from_hostname (struct GNUNET_SERVICE_Client *client,
481 size_t namelen; 483 size_t namelen;
482 uint32_t rtype; 484 uint32_t rtype;
483 485
484 if (IsEqualGUID (&SVCID_DNS_TYPE_A, &sc)) 486 if (IsEqualGUID(&SVCID_DNS_TYPE_A, &sc))
485 rtype = GNUNET_DNSPARSER_TYPE_A; 487 rtype = GNUNET_DNSPARSER_TYPE_A;
486 else if (IsEqualGUID (&SVCID_DNS_TYPE_NS, &sc)) 488 else if (IsEqualGUID(&SVCID_DNS_TYPE_NS, &sc))
487 rtype = GNUNET_DNSPARSER_TYPE_NS; 489 rtype = GNUNET_DNSPARSER_TYPE_NS;
488 else if (IsEqualGUID (&SVCID_DNS_TYPE_CNAME, &sc)) 490 else if (IsEqualGUID(&SVCID_DNS_TYPE_CNAME, &sc))
489 rtype = GNUNET_DNSPARSER_TYPE_CNAME; 491 rtype = GNUNET_DNSPARSER_TYPE_CNAME;
490 else if (IsEqualGUID (&SVCID_DNS_TYPE_SOA, &sc)) 492 else if (IsEqualGUID(&SVCID_DNS_TYPE_SOA, &sc))
491 rtype = GNUNET_DNSPARSER_TYPE_SOA; 493 rtype = GNUNET_DNSPARSER_TYPE_SOA;
492 else if (IsEqualGUID (&SVCID_DNS_TYPE_PTR, &sc)) 494 else if (IsEqualGUID(&SVCID_DNS_TYPE_PTR, &sc))
493 rtype = GNUNET_DNSPARSER_TYPE_PTR; 495 rtype = GNUNET_DNSPARSER_TYPE_PTR;
494 else if (IsEqualGUID (&SVCID_DNS_TYPE_MX, &sc)) 496 else if (IsEqualGUID(&SVCID_DNS_TYPE_MX, &sc))
495 rtype = GNUNET_DNSPARSER_TYPE_MX; 497 rtype = GNUNET_DNSPARSER_TYPE_MX;
496 else if (IsEqualGUID (&SVCID_DNS_TYPE_TEXT, &sc)) 498 else if (IsEqualGUID(&SVCID_DNS_TYPE_TEXT, &sc))
497 rtype = GNUNET_DNSPARSER_TYPE_TXT; 499 rtype = GNUNET_DNSPARSER_TYPE_TXT;
498 else if (IsEqualGUID (&SVCID_DNS_TYPE_AAAA, &sc)) 500 else if (IsEqualGUID(&SVCID_DNS_TYPE_AAAA, &sc))
499 rtype = GNUNET_DNSPARSER_TYPE_AAAA; 501 rtype = GNUNET_DNSPARSER_TYPE_AAAA;
500 else if (IsEqualGUID (&SVCID_DNS_TYPE_SRV, &sc)) 502 else if (IsEqualGUID(&SVCID_DNS_TYPE_SRV, &sc))
501 rtype = GNUNET_DNSPARSER_TYPE_SRV; 503 rtype = GNUNET_DNSPARSER_TYPE_SRV;
502 else if (IsEqualGUID (&SVCID_INET_HOSTADDRBYNAME, &sc)) 504 else if (IsEqualGUID(&SVCID_INET_HOSTADDRBYNAME, &sc))
503 rtype = GNUNET_DNSPARSER_TYPE_A; 505 rtype = GNUNET_DNSPARSER_TYPE_A;
504 else 506 else
505 { 507 {
506 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 508 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
507 "Unknown GUID: %08lX-%04X-%04X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\n", 509 "Unknown GUID: %08lX-%04X-%04X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\n",
508 sc.Data1, 510 sc.Data1,
509 sc.Data2, 511 sc.Data2,
510 sc.Data3, 512 sc.Data3,
511 sc.Data4[0], 513 sc.Data4[0],
512 sc.Data4[1], 514 sc.Data4[1],
513 sc.Data4[2], 515 sc.Data4[2],
514 sc.Data4[3], 516 sc.Data4[3],
515 sc.Data4[4], 517 sc.Data4[4],
516 sc.Data4[5], 518 sc.Data4[5],
517 sc.Data4[6], 519 sc.Data4[6],
518 sc.Data4[7]); 520 sc.Data4[7]);
519 GNUNET_SERVICE_client_drop (client); 521 GNUNET_SERVICE_client_drop(client);
520 return; 522 return;
521 } 523 }
522 524
523 if (name) 525 if (name)
524 namelen = wcslen (name); 526 namelen = wcslen(name);
525 else 527 else
526 namelen = 0; 528 namelen = 0;
527 if (namelen > 0) 529 if (namelen > 0)
528 hostname = (char *) u16_to_u8 (name, namelen + 1, NULL, &strl); 530 hostname = (char *)u16_to_u8(name, namelen + 1, NULL, &strl);
529 else 531 else
530 hostname = NULL; 532 hostname = NULL;
531 533
532 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 534 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
533 "W32 DNS resolver asked to look up %s for `%s'.\n", 535 "W32 DNS resolver asked to look up %s for `%s'.\n",
534 af == AF_INET ? "IPv4" : af == AF_INET6 ? "IPv6" : "anything", 536 af == AF_INET ? "IPv4" : af == AF_INET6 ? "IPv6" : "anything",
535 hostname); 537 hostname);
536 538
537 rq = GNUNET_new (struct request); 539 rq = GNUNET_new(struct request);
538 rq->sc = sc; 540 rq->sc = sc;
539 rq->client = client; 541 rq->client = client;
540 rq->af = af; 542 rq->af = af;
541 if (rq->af != AF_INET && rq->af != AF_INET6) 543 if (rq->af != AF_INET && rq->af != AF_INET6)
542 rq->af = AF_INET; 544 rq->af = AF_INET;
543 if (namelen) 545 if (namelen)
544 { 546 {
545 rq->name = GNUNET_malloc ((namelen + 1) * sizeof (wchar_t)); 547 rq->name = GNUNET_malloc((namelen + 1) * sizeof(wchar_t));
546 GNUNET_memcpy (rq->name, 548 GNUNET_memcpy(rq->name,
547 name, 549 name,
548 (namelen + 1) * sizeof (wchar_t)); 550 (namelen + 1) * sizeof(wchar_t));
549 rq->u8name = hostname; 551 rq->u8name = hostname;
550 } 552 }
551 553
552 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 554 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
553 "Launching a lookup for client %p with rq %p\n", 555 "Launching a lookup for client %p with rq %p\n",
554 client, 556 client,
555 rq); 557 rq);
556 rq->lookup_request = GNUNET_GNS_lookup (gns, 558 rq->lookup_request = GNUNET_GNS_lookup(gns,
557 hostname, 559 hostname,
558 &gns_master_pubkey, 560 &gns_master_pubkey,
559 rtype, 561 rtype,
560 GNUNET_NO /* Use DHT */, 562 GNUNET_NO /* Use DHT */,
561 &process_lookup_result, 563 &process_lookup_result,
562 rq); 564 rq);
563 if (NULL != rq->lookup_request) 565 if (NULL != rq->lookup_request)
564 { 566 {
565 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 567 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
566 "Lookup launched, waiting for a reply\n"); 568 "Lookup launched, waiting for a reply\n");
567 GNUNET_SERVICE_client_continue (client); 569 GNUNET_SERVICE_client_continue(client);
568 GNUNET_CONTAINER_DLL_insert (rq_head, 570 GNUNET_CONTAINER_DLL_insert(rq_head,
569 rq_tail, 571 rq_tail,
570 rq); 572 rq);
571 } 573 }
572 else 574 else
573 { 575 {
574 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 576 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
575 "Lookup was not launched, disconnecting the client\n"); 577 "Lookup was not launched, disconnecting the client\n");
576 GNUNET_free_non_null (rq->name); 578 GNUNET_free_non_null(rq->name);
577 if (rq->u8name) 579 if (rq->u8name)
578 free (rq->u8name); 580 free(rq->u8name);
579 GNUNET_free (rq); 581 GNUNET_free(rq);
580 GNUNET_SERVICE_client_drop (client); 582 GNUNET_SERVICE_client_drop(client);
581 } 583 }
582} 584}
583 585
584 586
@@ -590,25 +592,25 @@ get_ip_from_hostname (struct GNUNET_SERVICE_Client *client,
590 * @return #GNUNET_OK if @a msg is well-formed 592 * @return #GNUNET_OK if @a msg is well-formed
591 */ 593 */
592static int 594static int
593check_get (void *cls, 595check_get(void *cls,
594 const struct GNUNET_W32RESOLVER_GetMessage *msg) 596 const struct GNUNET_W32RESOLVER_GetMessage *msg)
595{ 597{
596 uint16_t size; 598 uint16_t size;
597 const wchar_t *hostname; 599 const wchar_t *hostname;
598 600
599 if (! got_egos) 601 if (!got_egos)
600 { 602 {
601 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 603 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
602 _("Not ready to process requests, lacking ego data\n")); 604 _("Not ready to process requests, lacking ego data\n"));
603 return GNUNET_SYSERR; 605 return GNUNET_SYSERR;
604 } 606 }
605 size = ntohs (msg->header.size) - sizeof (struct GNUNET_W32RESOLVER_GetMessage); 607 size = ntohs(msg->header.size) - sizeof(struct GNUNET_W32RESOLVER_GetMessage);
606 hostname = (const wchar_t *) &msg[1]; 608 hostname = (const wchar_t *)&msg[1];
607 if (hostname[size / 2 - 1] != L'\0') 609 if (hostname[size / 2 - 1] != L'\0')
608 { 610 {
609 GNUNET_break (0); 611 GNUNET_break(0);
610 return GNUNET_SYSERR; 612 return GNUNET_SYSERR;
611 } 613 }
612 return GNUNET_OK; 614 return GNUNET_OK;
613} 615}
614 616
@@ -620,8 +622,8 @@ check_get (void *cls,
620 * @param msg the actual message 622 * @param msg the actual message
621 */ 623 */
622static void 624static void
623handle_get (void *cls, 625handle_get(void *cls,
624 const struct GNUNET_W32RESOLVER_GetMessage *msg) 626 const struct GNUNET_W32RESOLVER_GetMessage *msg)
625{ 627{
626 struct GNUNET_SERVICE_Client *client = cls; 628 struct GNUNET_SERVICE_Client *client = cls;
627 GUID sc; 629 GUID sc;
@@ -629,50 +631,50 @@ handle_get (void *cls,
629 const wchar_t *hostname; 631 const wchar_t *hostname;
630 int af; 632 int af;
631 633
632 size = ntohs (msg->header.size) - sizeof (struct GNUNET_W32RESOLVER_GetMessage); 634 size = ntohs(msg->header.size) - sizeof(struct GNUNET_W32RESOLVER_GetMessage);
633 af = ntohl (msg->af); 635 af = ntohl(msg->af);
634 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 636 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
635 "Got NBO GUID: %08X-%04X-%04X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\n", 637 "Got NBO GUID: %08X-%04X-%04X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\n",
636 msg->sc_data1, 638 msg->sc_data1,
637 msg->sc_data2, 639 msg->sc_data2,
638 msg->sc_data3, 640 msg->sc_data3,
639 msg->sc_data4[0], 641 msg->sc_data4[0],
640 msg->sc_data4[1], 642 msg->sc_data4[1],
641 msg->sc_data4[2], 643 msg->sc_data4[2],
642 msg->sc_data4[3], 644 msg->sc_data4[3],
643 msg->sc_data4[4], 645 msg->sc_data4[4],
644 msg->sc_data4[5], 646 msg->sc_data4[5],
645 msg->sc_data4[6], 647 msg->sc_data4[6],
646 msg->sc_data4[7]); 648 msg->sc_data4[7]);
647 sc.Data1 = ntohl (msg->sc_data1); 649 sc.Data1 = ntohl(msg->sc_data1);
648 sc.Data2 = ntohs (msg->sc_data2); 650 sc.Data2 = ntohs(msg->sc_data2);
649 sc.Data3 = ntohs (msg->sc_data3); 651 sc.Data3 = ntohs(msg->sc_data3);
650 for (int i = 0; i < 8; i++) 652 for (int i = 0; i < 8; i++)
651 sc.Data4[i] = msg->sc_data4[i]; 653 sc.Data4[i] = msg->sc_data4[i];
652 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 654 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
653 "Got GUID: %08lX-%04X-%04X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\n", 655 "Got GUID: %08lX-%04X-%04X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\n",
654 sc.Data1, 656 sc.Data1,
655 sc.Data2, 657 sc.Data2,
656 sc.Data3, 658 sc.Data3,
657 sc.Data4[0], 659 sc.Data4[0],
658 sc.Data4[1], 660 sc.Data4[1],
659 sc.Data4[2], 661 sc.Data4[2],
660 sc.Data4[3], 662 sc.Data4[3],
661 sc.Data4[4], 663 sc.Data4[4],
662 sc.Data4[5], 664 sc.Data4[5],
663 sc.Data4[6], 665 sc.Data4[6],
664 sc.Data4[7]); 666 sc.Data4[7]);
665 hostname = (const wchar_t *) &msg[1]; 667 hostname = (const wchar_t *)&msg[1];
666 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 668 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
667 "Name of %u bytes (last word is 0x%0X): %*S\n", 669 "Name of %u bytes (last word is 0x%0X): %*S\n",
668 size, 670 size,
669 hostname[size / 2 - 2], 671 hostname[size / 2 - 2],
670 size / 2, 672 size / 2,
671 hostname); 673 hostname);
672 get_ip_from_hostname (client, 674 get_ip_from_hostname(client,
673 hostname, 675 hostname,
674 af, 676 af,
675 sc); 677 sc);
676} 678}
677 679
678 680
@@ -689,21 +691,21 @@ handle_get (void *cls,
689 * must thus no longer be used 691 * must thus no longer be used
690 */ 692 */
691static void 693static void
692identity_master_cb (void *cls, 694identity_master_cb(void *cls,
693 struct GNUNET_IDENTITY_Ego *ego, 695 struct GNUNET_IDENTITY_Ego *ego,
694 void **ctx, 696 void **ctx,
695 const char *name) 697 const char *name)
696{ 698{
697 id_op = NULL; 699 id_op = NULL;
698 if (NULL == ego) 700 if (NULL == ego)
699 { 701 {
700 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 702 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
701 _("Ego for `gns-master' not found, cannot perform lookup. Did you run gnunet-gns-import.sh?\n")); 703 _("Ego for `gns-master' not found, cannot perform lookup. Did you run gnunet-gns-import.sh?\n"));
702 GNUNET_SCHEDULER_shutdown (); 704 GNUNET_SCHEDULER_shutdown();
703 return; 705 return;
704 } 706 }
705 GNUNET_IDENTITY_ego_get_public_key (ego, 707 GNUNET_IDENTITY_ego_get_public_key(ego,
706 &gns_master_pubkey); 708 &gns_master_pubkey);
707 got_egos = 1; 709 got_egos = 1;
708} 710}
709 711
@@ -716,35 +718,35 @@ identity_master_cb (void *cls,
716 * @param service the initialized service 718 * @param service the initialized service
717 */ 719 */
718static void 720static void
719run (void *cls, 721run(void *cls,
720 const struct GNUNET_CONFIGURATION_Handle *cfg, 722 const struct GNUNET_CONFIGURATION_Handle *cfg,
721 struct GNUNET_SERVICE_Handle *service) 723 struct GNUNET_SERVICE_Handle *service)
722{ 724{
723 gns = GNUNET_GNS_connect (cfg); 725 gns = GNUNET_GNS_connect(cfg);
724 if (NULL == gns) 726 if (NULL == gns)
725 { 727 {
726 fprintf (stderr, 728 fprintf(stderr,
727 _("Failed to connect to GNS\n")); 729 _("Failed to connect to GNS\n"));
728 GNUNET_SCHEDULER_shutdown (); 730 GNUNET_SCHEDULER_shutdown();
729 return; 731 return;
730 } 732 }
731 GNUNET_SCHEDULER_add_shutdown (&do_shutdown, 733 GNUNET_SCHEDULER_add_shutdown(&do_shutdown,
732 NULL); 734 NULL);
733 identity = GNUNET_IDENTITY_connect (cfg, 735 identity = GNUNET_IDENTITY_connect(cfg,
734 NULL, 736 NULL,
735 NULL); 737 NULL);
736 if (NULL == identity) 738 if (NULL == identity)
737 { 739 {
738 fprintf (stderr, 740 fprintf(stderr,
739 _("Failed to connect to identity service\n")); 741 _("Failed to connect to identity service\n"));
740 GNUNET_SCHEDULER_shutdown (); 742 GNUNET_SCHEDULER_shutdown();
741 return; 743 return;
742 } 744 }
743 id_op = GNUNET_IDENTITY_get (identity, 745 id_op = GNUNET_IDENTITY_get(identity,
744 "gns-master", 746 "gns-master",
745 &identity_master_cb, 747 &identity_master_cb,
746 NULL); 748 NULL);
747 GNUNET_assert (NULL != id_op); 749 GNUNET_assert(NULL != id_op);
748} 750}
749 751
750 752
@@ -757,9 +759,9 @@ run (void *cls,
757 * @return @a client 759 * @return @a client
758 */ 760 */
759static void * 761static void *
760client_connect_cb (void *cls, 762client_connect_cb(void *cls,
761 struct GNUNET_SERVICE_Client *client, 763 struct GNUNET_SERVICE_Client *client,
762 struct GNUNET_MQ_Handle *mq) 764 struct GNUNET_MQ_Handle *mq)
763{ 765{
764 return client; 766 return client;
765} 767}
@@ -773,11 +775,11 @@ client_connect_cb (void *cls,
773 * @param internal_cls should be equal to @a c 775 * @param internal_cls should be equal to @a c
774 */ 776 */
775static void 777static void
776client_disconnect_cb (void *cls, 778client_disconnect_cb(void *cls,
777 struct GNUNET_SERVICE_Client *client, 779 struct GNUNET_SERVICE_Client *client,
778 void *internal_cls) 780 void *internal_cls)
779{ 781{
780 GNUNET_assert (internal_cls == client); 782 GNUNET_assert(internal_cls == client);
781} 783}
782 784
783 785
@@ -785,17 +787,17 @@ client_disconnect_cb (void *cls,
785 * Define "main" method using service macro. 787 * Define "main" method using service macro.
786 */ 788 */
787GNUNET_SERVICE_MAIN 789GNUNET_SERVICE_MAIN
788("gns-helper-service-w32", 790 ("gns-helper-service-w32",
789 GNUNET_SERVICE_OPTION_NONE, 791 GNUNET_SERVICE_OPTION_NONE,
790 &run, 792 &run,
791 &client_connect_cb, 793 &client_connect_cb,
792 &client_disconnect_cb, 794 &client_disconnect_cb,
793 NULL, 795 NULL,
794 GNUNET_MQ_hd_var_size (get, 796 GNUNET_MQ_hd_var_size(get,
795 GNUNET_MESSAGE_TYPE_W32RESOLVER_REQUEST, 797 GNUNET_MESSAGE_TYPE_W32RESOLVER_REQUEST,
796 struct GNUNET_W32RESOLVER_GetMessage, 798 struct GNUNET_W32RESOLVER_GetMessage,
797 NULL), 799 NULL),
798 GNUNET_MQ_handler_end()); 800 GNUNET_MQ_handler_end());
799 801
800 802
801/* end of gnunet-gns-helper-service-w32.c */ 803/* end of gnunet-gns-helper-service-w32.c */