2 This file is part of GNUnet.
3 (C) 2012 Christian Grothoff (and other contributing authors)
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 3, or (at your
8 option) any later version.
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.
21 * @file gnunet-gns-helper-service-w32.c
22 * @brief an intermediary service to access distributed GNS
23 * @author Christian Grothoff
28 #include <gnunet_util_lib.h>
29 #include <gnunet_dnsparser_lib.h>
30 #include <gnunet_namestore_service.h>
31 #include <gnunet_gns_service.h>
32 #include "gnunet_w32nsp_lib.h"
33 #include "w32resolver.h"
37 #define DEFINE_DNS_GUID(a,x) DEFINE_GUID(a, 0x00090035, 0x0000, x, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)
38 DEFINE_DNS_GUID(SVCID_DNS_TYPE_A, 0x0001);
39 DEFINE_DNS_GUID(SVCID_DNS_TYPE_NS, 0x0002);
40 DEFINE_DNS_GUID(SVCID_DNS_TYPE_CNAME, 0x0005);
41 DEFINE_DNS_GUID(SVCID_DNS_TYPE_SOA, 0x0006);
42 DEFINE_DNS_GUID(SVCID_DNS_TYPE_PTR, 0x000c);
43 DEFINE_DNS_GUID(SVCID_DNS_TYPE_MX, 0x000f);
44 DEFINE_DNS_GUID(SVCID_DNS_TYPE_TEXT, 0x0010);
45 DEFINE_DNS_GUID(SVCID_DNS_TYPE_AAAA, 0x001c);
46 DEFINE_DNS_GUID(SVCID_DNS_TYPE_SRV, 0x0021);
47 DEFINE_GUID(SVCID_HOSTNAME, 0x0002a800, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);
48 DEFINE_GUID(SVCID_INET_HOSTADDRBYNAME, 0x0002a803, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);
52 struct GNUNET_SERVER_Client *client;
60 * Handle to GNS service.
62 static struct GNUNET_GNS_Handle *gns;
64 static struct GNUNET_CRYPTO_EccPublicSignKey *zone = NULL;
65 static struct GNUNET_HashCode user_zone;
66 struct GNUNET_CRYPTO_EccPrivateKey *shorten_key = NULL;
70 * Task run on shutdown. Cleans up everything.
73 * @param tc scheduler context
76 do_shutdown (void *cls,
77 const struct GNUNET_SCHEDULER_TaskContext *tc)
81 GNUNET_GNS_disconnect (gns);
87 * Context for transmitting replies to clients.
89 struct TransmitCallbackContext
93 * We keep these in a doubly-linked list (for cleanup).
95 struct TransmitCallbackContext *next;
98 * We keep these in a doubly-linked list (for cleanup).
100 struct TransmitCallbackContext *prev;
103 * The message that we're asked to transmit.
105 struct GNUNET_MessageHeader *msg;
108 * Handle for the transmission request.
110 struct GNUNET_SERVER_TransmitHandle *th;
116 * Head of the doubly-linked list (for cleanup).
118 static struct TransmitCallbackContext *tcc_head;
121 * Tail of the doubly-linked list (for cleanup).
123 static struct TransmitCallbackContext *tcc_tail;
126 * Have we already cleaned up the TCCs and are hence no longer
127 * willing (or able) to transmit anything to anyone?
129 static int cleaning_done;
133 * Function called to notify a client about the socket
134 * begin ready to queue more data. "buf" will be
135 * NULL and "size" zero if the socket was closed for
136 * writing in the meantime.
139 * @param size number of bytes available in buf
140 * @param buf where the callee should write the message
141 * @return number of bytes written to buf
144 transmit_callback (void *cls, size_t size, void *buf)
146 struct TransmitCallbackContext *tcc = cls;
150 GNUNET_CONTAINER_DLL_remove (tcc_head, tcc_tail, tcc);
151 msize = ntohs (tcc->msg->size);
154 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
155 _("Transmission to client failed!\n"));
156 GNUNET_free (tcc->msg);
160 GNUNET_assert (size >= msize);
161 memcpy (buf, tcc->msg, msize);
162 GNUNET_free (tcc->msg);
169 * Transmit the given message to the client.
171 * @param client target of the message
172 * @param msg message to transmit, will be freed!
175 transmit (struct GNUNET_SERVER_Client *client,
176 struct GNUNET_MessageHeader *msg)
178 struct TransmitCallbackContext *tcc;
180 if (GNUNET_YES == cleaning_done)
182 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
183 _("Shutdown in progress, aborting transmission.\n"));
187 tcc = GNUNET_malloc (sizeof (struct TransmitCallbackContext));
191 GNUNET_SERVER_notify_transmit_ready (client,
193 GNUNET_TIME_UNIT_FOREVER_REL,
194 &transmit_callback, tcc)))
201 GNUNET_CONTAINER_DLL_insert (tcc_head, tcc_tail, tcc);
205 #define MarshallPtr(ptr, base, type) \
207 ptr = (type *) ((char *) ptr - (char *) base)
211 MarshallWSAQUERYSETW (WSAQUERYSETW *qs, GUID *sc)
214 MarshallPtr (qs->lpszServiceInstanceName, qs, wchar_t);
215 MarshallPtr (qs->lpServiceClassId, qs, GUID);
216 MarshallPtr (qs->lpVersion, qs, WSAVERSION);
217 MarshallPtr (qs->lpNSProviderId, qs, GUID);
218 MarshallPtr (qs->lpszContext, qs, wchar_t);
219 MarshallPtr (qs->lpafpProtocols, qs, AFPROTOCOLS);
220 MarshallPtr (qs->lpszQueryString, qs, wchar_t);
221 for (i = 0; i < qs->dwNumberOfCsAddrs; i++)
223 MarshallPtr (qs->lpcsaBuffer[i].LocalAddr.lpSockaddr, qs, SOCKADDR);
224 MarshallPtr (qs->lpcsaBuffer[i].RemoteAddr.lpSockaddr, qs, SOCKADDR);
226 MarshallPtr (qs->lpcsaBuffer, qs, CSADDR_INFO);
227 if (IsEqualGUID (&SVCID_INET_HOSTADDRBYNAME, sc) && qs->lpBlob != NULL && qs->lpBlob->pBlobData != NULL)
230 he = (struct hostent *) qs->lpBlob->pBlobData;
231 for (i = 0; he->h_aliases[i] != NULL; i++)
232 MarshallPtr (he->h_aliases[i], he, char);
233 MarshallPtr (he->h_aliases, he, char *);
234 MarshallPtr (he->h_name, he, char);
235 for (i = 0; he->h_addr_list[i] != NULL; i++)
236 MarshallPtr (he->h_addr_list[i], he, void);
237 MarshallPtr (he->h_addr_list, he, char *);
238 MarshallPtr (qs->lpBlob->pBlobData, qs, void);
240 MarshallPtr (qs->lpBlob, qs, BLOB);
245 process_ip_lookup_result (void* cls,
247 const struct GNUNET_NAMESTORE_RecordData *rd)
250 struct request *rq = (struct request *) cls;
251 struct GNUNET_W32RESOLVER_GetMessage *msg;
252 struct GNUNET_MessageHeader *msgend;
258 size_t blobaddrcount = 0;
260 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
261 "Got lookup result with count %u for rq %p with client %p\n",
262 rd_count, rq, rq->client);
266 size = sizeof (struct GNUNET_MessageHeader);
267 msg = GNUNET_malloc (size);
268 msg->header.size = htons (size);
269 msg->header.type = htons (GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE);
270 transmit (rq->client, &msg->header);
274 size = sizeof (struct GNUNET_W32RESOLVER_GetMessage) + sizeof (WSAQUERYSETW);
275 size += (wcslen (rq->name) + 1) * sizeof (wchar_t);
276 size += sizeof (GUID);
277 /* lpszComment ? a TXT record? */
278 size += sizeof (GUID);
279 /* lpszContext ? Not sure what it is */
281 for (i = 0; i < rd_count; i++)
283 switch (rd[i].record_type)
285 case GNUNET_DNSPARSER_TYPE_A:
286 if (rd[i].data_size != sizeof (struct in_addr))
288 size += sizeof (CSADDR_INFO) + sizeof (struct sockaddr_in) * 2;
291 case GNUNET_DNSPARSER_TYPE_AAAA:
292 if (rd[i].data_size != sizeof (struct in6_addr))
294 size += sizeof (CSADDR_INFO) + sizeof (struct sockaddr_in6) * 2;
299 if (IsEqualGUID (&SVCID_INET_HOSTADDRBYNAME, &rq->sc))
301 size += sizeof (BLOB);
302 blobsize += sizeof (struct hostent);
303 blobsize += strlen (rq->u8name) + 1;
304 blobsize += sizeof (void *); /* For aliases */
305 blobsize += sizeof (void *); /* For addresses */
306 for (i = 0; i < rd_count; i++)
308 if ((rq->af == AF_INET || rq->af == AF_UNSPEC) && rd[i].record_type == GNUNET_DNSPARSER_TYPE_A)
310 blobsize += sizeof (void *);
311 blobsize += sizeof (struct in_addr);
314 else if (rq->af == AF_INET6 && rd[i].record_type == GNUNET_DNSPARSER_TYPE_AAAA)
316 blobsize += sizeof (void *);
317 blobsize += sizeof (struct in6_addr);
323 size += sizeof (struct GNUNET_MessageHeader);
324 size_recalc = sizeof (struct GNUNET_W32RESOLVER_GetMessage) + sizeof (WSAQUERYSETW);
325 msg = GNUNET_malloc (size);
326 msg->header.size = htons (size - sizeof (struct GNUNET_MessageHeader));
327 msg->header.type = htons (GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE);
328 msg->af = htonl (rq->af);
329 msg->sc_data1 = htonl (rq->sc.Data1);
330 msg->sc_data2 = htons (rq->sc.Data2);
331 msg->sc_data3 = htons (rq->sc.Data3);
333 for (i = 0; i < 8; i++)
334 msg->sc_data4 |= rq->sc.Data4[i] << ((7 - i) * 8);
335 msg->sc_data4 = GNUNET_htonll (msg->sc_data4);
336 qs = (WSAQUERYSETW *) &msg[1];
337 ptr = (char *) &qs[1];
338 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
339 qs->dwSize = sizeof (WSAQUERYSETW);
340 qs->lpszServiceInstanceName = (wchar_t *) ptr;
341 ptr += (wcslen (rq->name) + 1) * sizeof (wchar_t);
342 size_recalc += (wcslen (rq->name) + 1) * sizeof (wchar_t);
343 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
344 wcscpy (qs->lpszServiceInstanceName, rq->name);
345 qs->lpServiceClassId = (GUID *) ptr;
346 ptr += sizeof (GUID);
347 size_recalc += sizeof (GUID);
348 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
349 memcpy (qs->lpServiceClassId, &rq->sc, sizeof (GUID));
350 qs->lpVersion = NULL;
351 qs->dwNameSpace = NS_DNS;
352 qs->lpNSProviderId = (GUID *) ptr;
353 ptr += sizeof (GUID);
354 size_recalc += sizeof (GUID);
355 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
356 memcpy (qs->lpNSProviderId, &GNUNET_NAMESPACE_PROVIDER_DNS, sizeof (GUID));
357 qs->lpszContext = NULL;
358 qs->dwNumberOfProtocols = 0;
359 qs->lpafpProtocols = NULL;
360 /* Don't bother with this... */
361 qs->lpszQueryString = NULL;
362 qs->dwNumberOfCsAddrs = rd_count;
363 qs->lpcsaBuffer = (CSADDR_INFO *) ptr;
364 ptr += sizeof (CSADDR_INFO) * csanum;
366 for (i = 0; i < rd_count; i++)
368 switch (rd[i].record_type)
370 case GNUNET_DNSPARSER_TYPE_A:
371 if (rd[i].data_size != sizeof (struct in_addr))
373 qs->lpcsaBuffer[j].iSocketType = SOCK_STREAM;
374 qs->lpcsaBuffer[j].iProtocol = IPPROTO_TCP;
376 qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength = sizeof (struct sockaddr_in);
377 qs->lpcsaBuffer[j].LocalAddr.lpSockaddr = (SOCKADDR *) ptr;
378 ptr += qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength;
379 memset (qs->lpcsaBuffer[j].LocalAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength);
380 ((struct sockaddr_in *)qs->lpcsaBuffer[j].LocalAddr.lpSockaddr)->sin_family = AF_INET;
382 qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength = sizeof (struct sockaddr_in);
383 qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr = (SOCKADDR *) ptr;
384 ptr += qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength;
385 memset (qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength);
386 ((struct sockaddr_in *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin_family = AF_INET;
387 ((struct sockaddr_in *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin_port = htonl (53); /* Don't ask why it's 53 */
388 ((struct sockaddr_in *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin_addr = *(struct in_addr *) rd[i].data;
389 size_recalc += sizeof (CSADDR_INFO) + sizeof (struct sockaddr_in) * 2;
392 case GNUNET_DNSPARSER_TYPE_AAAA:
393 if (rd[i].data_size != sizeof (struct in6_addr))
395 qs->lpcsaBuffer[j].iSocketType = SOCK_STREAM;
396 qs->lpcsaBuffer[j].iProtocol = IPPROTO_TCP;
398 qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength = sizeof (struct sockaddr_in6);
399 qs->lpcsaBuffer[j].LocalAddr.lpSockaddr = (SOCKADDR *) ptr;
400 ptr += qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength;
401 memset (qs->lpcsaBuffer[j].LocalAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].LocalAddr.iSockaddrLength);
402 ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].LocalAddr.lpSockaddr)->sin6_family = AF_INET6;
404 qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength = sizeof (struct sockaddr_in6);
405 qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr = (SOCKADDR *) ptr;
406 ptr += qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength;
407 memset (qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr, 0, qs->lpcsaBuffer[j].RemoteAddr.iSockaddrLength);
408 ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin6_family = AF_INET6;
409 ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin6_port = htonl (53); /* Don't ask why it's 53 */
410 ((struct sockaddr_in6 *)qs->lpcsaBuffer[j].RemoteAddr.lpSockaddr)->sin6_addr = *(struct in6_addr *) rd[i].data;
411 size_recalc += sizeof (CSADDR_INFO) + sizeof (struct sockaddr_in6) * 2;
418 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
419 qs->dwOutputFlags = 0;
420 if (IsEqualGUID (&SVCID_INET_HOSTADDRBYNAME, &rq->sc))
423 qs->lpBlob = (BLOB *) ptr;
424 ptr += sizeof (BLOB);
426 size_recalc += sizeof (BLOB);
427 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
429 qs->lpBlob->cbSize = blobsize;
430 qs->lpBlob->pBlobData = (BYTE *) ptr;
431 ptr += sizeof (struct hostent);
433 size_recalc += sizeof (struct hostent);
434 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
436 he = (struct hostent *) qs->lpBlob->pBlobData;
437 he->h_name = (char *) ptr;
438 ptr += strlen (rq->u8name) + 1;
440 size_recalc += strlen (rq->u8name) + 1;
441 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
443 strcpy (he->h_name, rq->u8name);
444 he->h_aliases = (char **) ptr;
445 ptr += sizeof (void *);
447 size_recalc += sizeof (void *); /* For aliases */
448 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
450 he->h_aliases[0] = NULL;
451 he->h_addrtype = rq->af;
452 he->h_length = rq->af == AF_INET || rq->af == AF_UNSPEC ? sizeof (struct in_addr) : sizeof (struct in6_addr);
453 he->h_addr_list = (char **) ptr;
454 ptr += sizeof (void *) * (blobaddrcount + 1);
456 size_recalc += sizeof (void *) * (blobaddrcount + 1); /* For addresses */
457 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
460 for (i = 0; i < rd_count; i++)
462 if ((rq->af == AF_INET || rq->af == AF_UNSPEC) &&
463 rd[i].record_type == GNUNET_DNSPARSER_TYPE_A)
465 he->h_addr_list[j] = (char *) ptr;
466 ptr += sizeof (struct in_addr);
468 size_recalc += sizeof (struct in_addr);
469 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
471 memcpy (he->h_addr_list[j], rd[i].data, sizeof (struct in_addr));
474 else if (rq->af == AF_INET6 && rd[i].record_type == GNUNET_DNSPARSER_TYPE_AAAA)
476 he->h_addr_list[j] = (char *) ptr;
477 ptr += sizeof (struct in6_addr);
479 size_recalc += sizeof (struct in6_addr);
480 GNUNET_break (size_recalc == (size_t) ((char *) ptr - (char *) msg));
482 memcpy (he->h_addr_list[j], rd[i].data, sizeof (struct in6_addr));
486 he->h_addr_list[j] = NULL;
488 msgend = (struct GNUNET_MessageHeader *) ptr;
489 ptr += sizeof (struct GNUNET_MessageHeader);
490 size_recalc += sizeof (struct GNUNET_MessageHeader);
492 msgend->type = htons (GNUNET_MESSAGE_TYPE_W32RESOLVER_RESPONSE);
493 msgend->size = htons (sizeof (struct GNUNET_MessageHeader));
495 if ((char *) ptr - (char *) msg != size || size_recalc != size || size_recalc != ((char *) ptr - (char *) msg))
497 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error in WSAQUERYSETW size calc: expected %lu, got %lu (recalc %lu)\n", size, (unsigned long) ((char *) ptr - (char *) msg), size_recalc);
499 MarshallWSAQUERYSETW (qs, &rq->sc);
500 transmit (rq->client, &msg->header);
505 get_ip_from_hostname (struct GNUNET_SERVER_Client *client,
506 const wchar_t *name, int af, GUID sc)
514 if (IsEqualGUID (&SVCID_DNS_TYPE_A, &sc))
515 rtype = GNUNET_DNSPARSER_TYPE_A;
516 else if (IsEqualGUID (&SVCID_DNS_TYPE_NS, &sc))
517 rtype = GNUNET_DNSPARSER_TYPE_NS;
518 else if (IsEqualGUID (&SVCID_DNS_TYPE_CNAME, &sc))
519 rtype = GNUNET_DNSPARSER_TYPE_CNAME;
520 else if (IsEqualGUID (&SVCID_DNS_TYPE_SOA, &sc))
521 rtype = GNUNET_DNSPARSER_TYPE_SOA;
522 else if (IsEqualGUID (&SVCID_DNS_TYPE_PTR, &sc))
523 rtype = GNUNET_DNSPARSER_TYPE_PTR;
524 else if (IsEqualGUID (&SVCID_DNS_TYPE_MX, &sc))
525 rtype = GNUNET_DNSPARSER_TYPE_MX;
526 else if (IsEqualGUID (&SVCID_DNS_TYPE_TEXT, &sc))
527 rtype = GNUNET_DNSPARSER_TYPE_TXT;
528 else if (IsEqualGUID (&SVCID_DNS_TYPE_AAAA, &sc))
529 rtype = GNUNET_DNSPARSER_TYPE_AAAA;
530 else if (IsEqualGUID (&SVCID_DNS_TYPE_SRV, &sc))
531 rtype = GNUNET_DNSPARSER_TYPE_SRV;
532 else if (IsEqualGUID (&SVCID_INET_HOSTADDRBYNAME, &sc))
533 rtype = GNUNET_DNSPARSER_TYPE_A;
536 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
537 "Unknown GUID: %08X-%04X-%04X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\n",
538 sc.Data1, sc.Data2, sc.Data3, sc.Data4[0], sc.Data4[1], sc.Data4[2],
539 sc.Data4[3], sc.Data4[4], sc.Data4[5], sc.Data4[6], sc.Data4[7]);
540 GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
545 namelen = wcslen (name);
549 hostname = (char *) u16_to_u8 (name, namelen + 1, NULL, &strl);
551 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
552 "W32 DNS resolver asked to look up %s for `%s'.\n",
553 af == AF_INET ? "IPv4" : af == AF_INET6 ? "IPv6" : "anything",
555 rq = GNUNET_malloc (sizeof (struct request));
559 if (rq->af != AF_INET && rq->af != AF_INET6)
563 rq->name = GNUNET_malloc ((namelen + 1) * sizeof (wchar_t));
564 memcpy (rq->name, name, (namelen + 1) * sizeof (wchar_t));
565 rq->u8name = hostname;
568 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
569 "Launching a lookup for client %p with rq %p\n",
572 if (NULL != GNUNET_GNS_lookup (gns, hostname, zone, rtype,
573 GNUNET_YES, shorten_key, &process_ip_lookup_result, rq))
575 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
576 "Lookup launched, waiting for a reply\n");
577 GNUNET_SERVER_receive_done (client, GNUNET_OK);
581 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
582 "Lookup was not, disconnecting the client\n");
585 GNUNET_free (rq->name);
589 GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
595 * Handle GET-message.
598 * @param client identification of the client
599 * @param message the actual message
602 handle_get (void *cls, struct GNUNET_SERVER_Client *client,
603 const struct GNUNET_MessageHeader *message)
606 const struct GNUNET_W32RESOLVER_GetMessage *msg;
611 const wchar_t *hostname;
614 msize = ntohs (message->size);
615 if (msize < sizeof (struct GNUNET_W32RESOLVER_GetMessage))
618 GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
621 msg = (const struct GNUNET_W32RESOLVER_GetMessage *) message;
622 size = msize - sizeof (struct GNUNET_W32RESOLVER_GetMessage);
623 af = ntohl (msg->af);
624 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got NBO GUID: %08X-%04X-%04X-%016llX\n",
625 msg->sc_data1, msg->sc_data2, msg->sc_data3, msg->sc_data4);
626 sc.Data1 = ntohl (msg->sc_data1);
627 sc.Data2 = ntohs (msg->sc_data2);
628 sc.Data3 = ntohs (msg->sc_data3);
629 data4 = GNUNET_ntohll (msg->sc_data4);
630 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got GUID: %08X-%04X-%04X-%016llX\n",
631 sc.Data1, sc.Data2, sc.Data3, data4);
632 for (i = 0; i < 8; i++)
633 sc.Data4[i] = 0xFF & (data4 >> ((7 - i) * 8));
635 hostname = (const wchar_t *) &msg[1];
636 if (hostname[size - 1] != L'\0')
638 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "name of length %u, not 0-terminated: %*S\n",
639 size, size, hostname);
641 GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
644 get_ip_from_hostname (client, hostname, af, sc);
649 * Start up gns-helper-w32 service.
652 * @param server the initialized server
653 * @param cfg configuration to use
656 run (void *cls, struct GNUNET_SERVER_Handle *server,
657 const struct GNUNET_CONFIGURATION_Handle *cfg)
659 static const struct GNUNET_SERVER_MessageHandler handlers[] = {
660 {&handle_get, NULL, GNUNET_MESSAGE_TYPE_W32RESOLVER_REQUEST, 0},
665 struct GNUNET_CRYPTO_EccPrivateKey *key = NULL;
666 struct GNUNET_CRYPTO_EccPublicSignKey pkey;
667 struct GNUNET_CRYPTO_HashAsciiEncoded zonename;
669 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
670 "ZONEKEY", &keyfile))
672 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
673 "No private key for root zone found, using default!\n");
678 if (GNUNET_YES == GNUNET_DISK_file_test (keyfile))
680 key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
681 GNUNET_CRYPTO_ecc_key_get_public_for_signature (key, &pkey);
682 GNUNET_CRYPTO_hash (&pkey, sizeof(struct GNUNET_CRYPTO_EccPublicSignKey),
684 GNUNET_CRYPTO_hash_to_enc (&user_zone, &zonename);
685 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
686 "Using zone: %s!\n", &zonename);
689 GNUNET_free(keyfile);
692 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
693 "SHORTEN_ZONEKEY", &keyfile))
695 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
696 "No shorten key found!\n");
701 if (GNUNET_YES == GNUNET_DISK_file_test (keyfile))
703 shorten_key = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
705 GNUNET_free(keyfile);
708 gns = GNUNET_GNS_connect (cfg);
712 GNUNET_SERVER_add_handlers (server, handlers);
713 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &do_shutdown,
720 * The main function for gns-helper-w32.
722 * @param argc number of arguments from the command line
723 * @param argv command line arguments
724 * @return 0 ok, 1 on error
727 main (int argc, char *const *argv)
733 GNUNET_SERVICE_run (argc, argv, "gns-helper-service-w32", GNUNET_SERVICE_OPTION_NONE,
734 &run, NULL)) ? 0 : 1;
739 /* end of gnunet-gns-helper-service-w32.c */