src/libsystemd/sd-resolve/test-resolve.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2005-2008 Lennart Poettering
   7   Copyright 2014 Daniel Buch
   8
   9   systemd is free software; you can redistribute it and/or modify it
  10   under the terms of the GNU Lesser General Public License as published by
  11   the Free Software Foundation; either version 2.1 of the License, or
  12   (at your option) any later version.
  13
  14   systemd is distributed in the hope that it will be useful, but
  15   WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17   Lesser General Public License for more details.
  18
  19   You should have received a copy of the GNU Lesser General Public License
  20   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  21 ***/
  22
  23 #include <string.h>
  24 #include <sys/types.h>
  25 #include <sys/socket.h>
  26 #include <arpa/inet.h>
  27 #include <stdio.h>
  28 #include <netinet/in.h>
  29 #include <arpa/nameser.h>
  30 #include <resolv.h>
  31 #include <assert.h>
  32 #include <signal.h>
  33 #include <errno.h>
  34
  35 #include "socket-util.h"
  36 #include "sd-resolve.h"
  37 #include "resolve-util.h"
  38 #include "macro.h"
  39
  40 static int getaddrinfo_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
  41         const struct addrinfo *i;
  42
  43         assert(q);
  44
  45         if (ret != 0) {
  46                 log_error("getaddrinfo error: %s %i\n", gai_strerror(ret), ret);
  47                 return 0;
  48         }
  49
  50         for (i = ai; i; i = i->ai_next) {
  51                 _cleanup_free_ char *addr = NULL;
  52
  53                 assert_se(sockaddr_pretty(i->ai_addr, i->ai_addrlen, false, &addr) == 0);
  54                 puts(addr);
  55         }
  56
  57         printf("canonical name: %s\n", strna(ai->ai_canonname));
  58
  59         return 0;
  60 }
  61
  62 static int getnameinfo_handler(sd_resolve_query *q, int ret, const char *host, const char *serv, void *userdata) {
  63         assert(q);
  64
  65         if (ret != 0) {
  66                 log_error("getnameinfo error: %s %i\n", gai_strerror(ret), ret);
  67                 return 0;
  68         }
  69
  70         printf("Host: %s -- Serv: %s\n", strna(host), strna(serv));
  71         return 0;
  72 }
  73
  74 static int res_handler(sd_resolve_query *q, int ret, unsigned char *answer, void *userdata) {
  75         int qdcount, ancount, len;
  76         const unsigned char *pos = answer + sizeof(HEADER);
  77         unsigned char *end = answer + ret;
  78         HEADER *head = (HEADER *) answer;
  79         char name[256];
  80         assert(q);
  81
  82         if (ret < 0) {
  83                 log_error("res_query() error: %s %i\n", strerror(errno), errno);
  84                 return 0;
  85         }
  86
  87         if (ret == 0) {
  88                 log_error("No reply for SRV lookup\n");
  89                 return 0;
  90         }
  91
  92         qdcount = ntohs(head->qdcount);
  93         ancount = ntohs(head->ancount);
  94
  95         printf("%d answers for srv lookup:\n", ancount);
  96
  97         /* Ignore the questions */
  98         while (qdcount-- > 0 && (len = dn_expand(answer, end, pos, name, 255)) >= 0) {
  99                 assert(len >= 0);
 100                 pos += len + QFIXEDSZ;
 101         }
 102
 103         /* Parse the answers */
 104         while (ancount-- > 0 && (len = dn_expand(answer, end, pos, name, 255)) >= 0) {
 105                 /* Ignore the initial string */
 106                 uint16_t pref, weight, port;
 107                 assert(len >= 0);
 108                 pos += len;
 109                 /* Ignore type, ttl, class and dlen */
 110                 pos += 10;
 111
 112                 GETSHORT(pref, pos);
 113                 GETSHORT(weight, pos);
 114                 GETSHORT(port, pos);
 115                 len = dn_expand(answer, end, pos, name, 255);
 116                 printf("\tpreference: %2d weight: %2d port: %d host: %s\n",
 117                        pref, weight, port, name);
 118
 119                 pos += len;
 120         }
 121
 122         return 0;
 123 }
 124
 125 int main(int argc, char *argv[]) {
 126         _cleanup_resolve_query_unref_ sd_resolve_query *q1 = NULL, *q2 = NULL, *q3 = NULL;
 127         _cleanup_resolve_unref_ sd_resolve *resolve = NULL;
 128         int r = 0;
 129
 130         struct addrinfo hints = {
 131                 .ai_family = PF_UNSPEC,
 132                 .ai_socktype = SOCK_STREAM,
 133                 .ai_flags = AI_CANONNAME
 134         };
 135
 136         struct sockaddr_in sa = {
 137                 .sin_family = AF_INET,
 138                 .sin_port = htons(80)
 139         };
 140
 141         assert_se(sd_resolve_default(&resolve) >= 0);
 142
 143         /* Make a name -> address query */
 144         r = sd_resolve_getaddrinfo(resolve, &q1, argc >= 2 ? argv[1] : "www.heise.de", NULL, &hints, getaddrinfo_handler, NULL);
 145         if (r < 0)
 146                 log_error("sd_resolve_getaddrinfo(): %s\n", strerror(-r));
 147
 148         /* Make an address -> name query */
 149         sa.sin_addr.s_addr = inet_addr(argc >= 3 ? argv[2] : "193.99.144.71");
 150         r = sd_resolve_getnameinfo(resolve, &q2, (struct sockaddr*) &sa, sizeof(sa), 0, SD_RESOLVE_GET_BOTH, getnameinfo_handler, NULL);
 151         if (r < 0)
 152                 log_error("sd_resolve_getnameinfo(): %s\n", strerror(-r));
 153
 154         /* Make a res_query() call */
 155         r = sd_resolve_res_query(resolve, &q3, "_xmpp-client._tcp.gmail.com", C_IN, T_SRV, res_handler, NULL);
 156         if (r < 0)
 157                 log_error("sd_resolve_res_query(): %s\n", strerror(-r));
 158
 159         /* Wait until the three queries are completed */
 160         while (sd_resolve_query_is_done(q1) == 0 ||
 161                sd_resolve_query_is_done(q2) == 0 ||
 162                sd_resolve_query_is_done(q3) == 0) {
 163
 164                 r = sd_resolve_wait(resolve, (uint64_t) -1);
 165                 if (r < 0) {
 166                         log_error("sd_resolve_wait(): %s\n", strerror(-r));
 167                         assert_not_reached("sd_resolve_wait() failed");
 168                 }
 169         }
 170
 171         return 0;
 172 }