GNUNET_GNS_lookup_zone (gns, "www.gnunet", zone, GNUNET_GNS_RECORD_A,
      GNUNET_YES, shorten_key, &process_ip_lookup_result, rq);
where "zone" and "shorten_key" are retrieved in the same way gnunet-gns does it.

static void
get_ip_from_hostname (struct GNUNET_SERVER_Client *client,
    const wchar_t *name, int af, GUID sc)
{
  struct request *rq;
  char *hostname;
  size_t strl;
  size_t namelen;
  uint32_t rtype;

  if (name)
    namelen = wcslen (name);
  else
    namelen = 0;
  if (namelen > 0)
    hostname = (char *) u16_to_u8 (name, namelen + 1, NULL, &strl);
  
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "W32 DNS resolver asked to look up %s for `%s'.\n",
              af == AF_INET ? "IPv4" : af == AF_INET6 ? "IPv6" : "anything",
              hostname);
  rq = GNUNET_malloc (sizeof (struct request));
  rq->sc = sc;
  rq->client = client;
  rq->af = af;
  if (rq->af != AF_INET && rq->af != AF_INET6)
    rq->af = AF_INET;
  if (namelen)
  {
    rq->name = GNUNET_malloc ((namelen + 1) * sizeof (wchar_t));
    memcpy (rq->name, name, (namelen + 1) * sizeof (wchar_t));
    rq->u8name = hostname;
  }

  if (IsEqualGUID (&SVCID_DNS_TYPE_A, &sc))
    rtype = GNUNET_GNS_RECORD_A;
  else if (IsEqualGUID (&SVCID_DNS_TYPE_NS, &sc))
    rtype = GNUNET_GNS_RECORD_NS;
  else if (IsEqualGUID (&SVCID_DNS_TYPE_CNAME, &sc))
    rtype = GNUNET_GNS_RECORD_CNAME;
  else if (IsEqualGUID (&SVCID_DNS_TYPE_SOA, &sc))
    rtype = GNUNET_GNS_RECORD_SOA;
  else if (IsEqualGUID (&SVCID_DNS_TYPE_PTR, &sc))
    rtype = GNUNET_GNS_RECORD_PTR;
  else if (IsEqualGUID (&SVCID_DNS_TYPE_MX, &sc))
    rtype = GNUNET_GNS_RECORD_MX;
  else if (IsEqualGUID (&SVCID_DNS_TYPE_TEXT, &sc))
    rtype = GNUNET_GNS_RECORD_TXT;
  else if (IsEqualGUID (&SVCID_DNS_TYPE_AAAA, &sc))
    rtype = GNUNET_GNS_RECORD_AAAA;
  else if (IsEqualGUID (&SVCID_DNS_TYPE_SRV, &sc))
    rtype = GNUNET_GNS_RECORD_SRV;
  else if (IsEqualGUID (&SVCID_INET_HOSTADDRBYNAME, &sc))
    rtype = GNUNET_GNS_RECORD_A;
  if (NULL != GNUNET_GNS_lookup_zone (gns, hostname, zone, rtype,
      GNUNET_YES, shorten_key, &process_ip_lookup_result, rq))
  {
    GNUNET_SERVER_client_keep (client);
  }
  else
  {
    if (namelen)
    {
      GNUNET_free (rq->name);
      free (rq->u8name);
    }
    GNUNET_free (rq);
  }
}


static void
handle_get (void *cls, struct GNUNET_SERVER_Client *client,
            const struct GNUNET_MessageHeader *message)
{
  uint16_t msize;
  const struct GNUNET_W32RESOLVER_GetMessage *msg;
  GUID sc;
  uint16_t size;
  uint64_t data4;
  int i;
  const wchar_t *hostname;
  int af;

  msize = ntohs (message->size);
  if (msize < sizeof (struct GNUNET_W32RESOLVER_GetMessage))
  {
    GNUNET_break (0);
    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
    return;
  }
  msg = (const struct GNUNET_W32RESOLVER_GetMessage *) message;
  size = msize - sizeof (struct GNUNET_W32RESOLVER_GetMessage);
  af = ntohl (msg->af);
  sc.Data1 = ntohl (msg->sc_data1);
  sc.Data2 = ntohs (msg->sc_data2);
  sc.Data3 = ntohs (msg->sc_data3);
  data4 = GNUNET_ntohll (msg->sc_data4);
  for (i = 0; i < 8; i++)
    sc.Data4[i] = 0xFF & (data4 >> ((7 - i) * 8));
  
  hostname = (const wchar_t *) &msg[1];
  if (hostname[size - 1] != L'\0')
  {
    GNUNET_break (0);
    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
    return;
  }
  get_ip_from_hostname (client, hostname, af, sc);
  GNUNET_SERVER_receive_done (client, GNUNET_OK);
  return;
}

static void
run (void *cls, struct GNUNET_SERVER_Handle *server,
     const struct GNUNET_CONFIGURATION_Handle *cfg)
{
  static const struct GNUNET_SERVER_MessageHandler handlers[] = {
    {&handle_get, NULL, GNUNET_MESSAGE_TYPE_W32RESOLVER_REQUEST, 0},
    {NULL, NULL, 0, 0}
  };

  char* keyfile;
  struct GNUNET_CRYPTO_RsaPrivateKey *key = NULL;
  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
  struct GNUNET_CRYPTO_ShortHashAsciiEncoded zonename;

  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
                                                           "ZONEKEY", &keyfile))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "No private key for root zone found, using default!\n");
    zone = NULL;
  }
  else
  {
    if (GNUNET_YES == GNUNET_DISK_file_test (keyfile))
    {
      key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
      GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
      GNUNET_CRYPTO_short_hash(&pkey,
                         sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
                         &user_zone);
      zone = &user_zone;
      GNUNET_CRYPTO_short_hash_to_enc (zone, &zonename);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Using zone: %s!\n", &zonename);
      GNUNET_CRYPTO_rsa_key_free(key);
    }
    GNUNET_free(keyfile);
  }

  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
                                                   "SHORTEN_ZONEKEY", &keyfile))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "No shorten key found!\n");
    shorten_key = NULL;
  }
  else
  {
    if (GNUNET_YES == GNUNET_DISK_file_test (keyfile))
    {
      shorten_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
    }
    GNUNET_free(keyfile);
  }

  gns = GNUNET_GNS_connect (cfg);
  if (gns == NULL)
    return;

  GNUNET_SERVER_add_handlers (server, handlers);
}