git.meshlink.io Git - catta/blob - avahi-utils/avahi-resolve-host-name.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 <stdlib.h>
  27 #include <stdio.h>
  28 #include <getopt.h>
  29 #include <assert.h>
  30 #include <string.h>
  31 #include <sys/types.h>
  32 #include <sys/socket.h>
  33 #include <net/if.h>
  34 #include <locale.h>
  35
  36 #include <avahi-common/simple-watch.h>
  37 #include <avahi-common/error.h>
  38 #include <avahi-common/malloc.h>
  39 #include <avahi-common/domain.h>
  40 #include <avahi-common/llist.h>
  41 #include <avahi-client/client.h>
  42 #include <avahi-client/lookup.h>
  43
  44 #include "sigint.h"
  45
  46 #ifdef HAVE_GDBM
  47 #include "stdb.h"
  48 #endif
  49
  50 typedef enum {
  51     COMMAND_HELP,
  52     COMMAND_VERSION,
  53     COMMAND_RESOLVE_HOST_NAME,
  54     COMMAND_RESOLVE_ADDRESS
  55 } Command;
  56
  57 typedef struct Config {
  58     int verbose;
  59     Command command;
  60     AvahiProtocol proto;
  61 } Config;
  62
  63 static AvahiSimplePoll *simple_poll = NULL;
  64 static AvahiClient *client = NULL;
  65
  66 static int n_resolving = 0;
  67
  68 static void host_name_resolver_callback(
  69     AvahiHostNameResolver *r,
  70     AVAHI_GCC_UNUSED AvahiIfIndex interface,
  71     AVAHI_GCC_UNUSED AvahiProtocol protocol,
  72     AvahiResolverEvent event,
  73     const char *name,
  74     const AvahiAddress *a,
  75     AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
  76     AVAHI_GCC_UNUSED void *userdata) {
  77
  78     assert(r);
  79
  80     switch (event) {
  81         case AVAHI_RESOLVER_FOUND: {
  82             char address[AVAHI_ADDRESS_STR_MAX];
  83
  84             avahi_address_snprint(address, sizeof(address), a);
  85
  86             printf("%s\t%s\n", name, address);
  87
  88             break;
  89         }
  90
  91         case AVAHI_RESOLVER_FAILURE:
  92
  93             fprintf(stderr, "Failed to resolve host name '%s': %s\n", name, avahi_strerror(avahi_client_errno(client)));
  94             break;
  95     }
  96
  97
  98     avahi_host_name_resolver_free(r);
  99
 100     assert(n_resolving > 0);
 101     n_resolving--;
 102
 103     if (n_resolving <= 0)
 104         avahi_simple_poll_quit(simple_poll);
 105 }
 106
 107 static void address_resolver_callback(
 108     AvahiAddressResolver *r,
 109     AVAHI_GCC_UNUSED AvahiIfIndex interface,
 110     AVAHI_GCC_UNUSED AvahiProtocol protocol,
 111     AvahiResolverEvent event,
 112     const AvahiAddress *a,
 113     const char *name,
 114     AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
 115     AVAHI_GCC_UNUSED void *userdata) {
 116
 117     char address[AVAHI_ADDRESS_STR_MAX];
 118     assert(r);
 119
 120     avahi_address_snprint(address, sizeof(address), a);
 121
 122     switch (event) {
 123         case AVAHI_RESOLVER_FOUND:
 124
 125             printf("%s\t%s\n", address, name);
 126             break;
 127
 128         case AVAHI_RESOLVER_FAILURE:
 129
 130             fprintf(stderr, "Failed to resolve address '%s': %s\n", address, avahi_strerror(avahi_client_errno(client)));
 131             break;
 132     }
 133
 134
 135     avahi_address_resolver_free(r);
 136
 137     assert(n_resolving > 0);
 138     n_resolving--;
 139
 140     if (n_resolving <= 0)
 141         avahi_simple_poll_quit(simple_poll);
 142 }
 143
 144 static void client_callback(AvahiClient *c, AvahiClientState state, AVAHI_GCC_UNUSED void * userdata) {
 145     switch (state) {
 146         case AVAHI_CLIENT_FAILURE:
 147             fprintf(stderr, "Client failure, exiting: %s\n", avahi_strerror(avahi_client_errno(c)));
 148             avahi_simple_poll_quit(simple_poll);
 149             break;
 150
 151         case AVAHI_CLIENT_S_REGISTERING:
 152         case AVAHI_CLIENT_S_RUNNING:
 153         case AVAHI_CLIENT_S_COLLISION:
 154         case AVAHI_CLIENT_CONNECTING:
 155             ;
 156     }
 157 }
 158
 159 static void help(FILE *f, const char *argv0) {
 160     fprintf(f,
 161             "%s [options] %s <name ...>\n"
 162             "%s [options] %s <address ... >\n\n"
 163             "    -h --help            Show this help\n"
 164             "    -V --version         Show version\n"
 165             "    -n --name            Resolve host name\n"
 166             "    -a --address         Resolve address\n"
 167             "    -v --verbose         Enable verbose mode\n"
 168             "    -6                   Lookup IPv6 address\n"
 169             "    -4                   Lookup IPv4 address\n"
 170             ,
 171             argv0, strstr(argv0, "address") ? "-n" : "[-n]",
 172             argv0, strstr(argv0, "address") ? "[-a]" : "-a");
 173 }
 174
 175 static int parse_command_line(Config *c, int argc, char *argv[]) {
 176     int o;
 177
 178     static const struct option long_options[] = {
 179         { "help",           no_argument,       NULL, 'h' },
 180         { "version",        no_argument,       NULL, 'V' },
 181         { "name",           no_argument,       NULL, 'n' },
 182         { "address",        no_argument,       NULL, 'a' },
 183         { "verbose",        no_argument,       NULL, 'v' },
 184         { NULL, 0, NULL, 0 }
 185     };
 186
 187     assert(c);
 188
 189     c->command = strstr(argv[0], "address") ? COMMAND_RESOLVE_ADDRESS : COMMAND_RESOLVE_HOST_NAME;
 190     c->proto = AVAHI_PROTO_UNSPEC;
 191     c->verbose = 0;
 192
 193     opterr = 0;
 194     while ((o = getopt_long(argc, argv, "hVnav46", long_options, NULL)) >= 0) {
 195
 196         switch(o) {
 197             case 'h':
 198                 c->command = COMMAND_HELP;
 199                 break;
 200             case 'V':
 201                 c->command = COMMAND_VERSION;
 202                 break;
 203             case 'n':
 204                 c->command = COMMAND_RESOLVE_HOST_NAME;
 205                 break;
 206             case 'a':
 207                 c->command = COMMAND_RESOLVE_ADDRESS;
 208                 break;
 209             case 'v':
 210                 c->verbose = 1;
 211                 break;
 212             case '4':
 213                 c->proto = AVAHI_PROTO_INET;
 214                 break;
 215             case '6':
 216                 c->proto = AVAHI_PROTO_INET6;
 217                 break;
 218             default:
 219                 fprintf(stderr, "Invalid command line argument: %c\n", o);
 220                 return -1;
 221         }
 222     }
 223
 224     if (c->command == COMMAND_RESOLVE_ADDRESS || c->command == COMMAND_RESOLVE_HOST_NAME) {
 225         if (optind >= argc) {
 226             fprintf(stderr, "Too few arguments\n");
 227             return -1;
 228         }
 229     }
 230
 231     return 0;
 232 }
 233
 234 int main(int argc, char *argv[]) {
 235     int ret = 1, error;
 236     Config config;
 237     const char *argv0;
 238
 239     if ((argv0 = strrchr(argv[0], '/')))
 240         argv0++;
 241     else
 242         argv0 = argv[0];
 243
 244     if (parse_command_line(&config, argc, argv) < 0)
 245         goto fail;
 246
 247     switch (config.command) {
 248         case COMMAND_HELP:
 249             help(stdout, argv0);
 250             ret = 0;
 251             break;
 252
 253         case COMMAND_VERSION:
 254             printf("%s "PACKAGE_VERSION"\n", argv0);
 255             ret = 0;
 256             break;
 257
 258         case COMMAND_RESOLVE_HOST_NAME:
 259         case COMMAND_RESOLVE_ADDRESS: {
 260             int i;
 261
 262             if (!(simple_poll = avahi_simple_poll_new())) {
 263                 fprintf(stderr, "Failed to create simple poll object.\n");
 264                 goto fail;
 265             }
 266
 267             if (sigint_install(simple_poll) < 0)
 268                 goto fail;
 269
 270             if (!(client = avahi_client_new(avahi_simple_poll_get(simple_poll), 0, client_callback, NULL, &error))) {
 271                 fprintf(stderr, "Failed to create client object: %s\n", avahi_strerror(error));
 272                 goto fail;
 273             }
 274
 275             if (config.verbose) {
 276                 const char *version, *hn;
 277
 278                 if (!(version = avahi_client_get_version_string(client))) {
 279                     fprintf(stderr, "Failed to query version string: %s\n", avahi_strerror(avahi_client_errno(client)));
 280                     goto fail;
 281                 }
 282
 283                 if (!(hn = avahi_client_get_host_name_fqdn(client))) {
 284                     fprintf(stderr, "Failed to query host name: %s\n", avahi_strerror(avahi_client_errno(client)));
 285                     goto fail;
 286                 }
 287
 288                 fprintf(stderr, "Server version: %s; Host name: %s\n", version, hn);
 289             }
 290
 291             n_resolving = 0;
 292
 293             for (i = optind; i < argc; i++) {
 294
 295                 if (config.command == COMMAND_RESOLVE_HOST_NAME) {
 296
 297                     if (!(avahi_host_name_resolver_new(client, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, argv[i], config.proto, 0, host_name_resolver_callback, NULL))) {
 298                         fprintf(stderr, "Failed to create host name resolver: %s\n", avahi_strerror(avahi_client_errno(client)));
 299                         goto fail;
 300                     }
 301
 302                 } else {
 303                     AvahiAddress a;
 304
 305                     assert(config.command == COMMAND_RESOLVE_ADDRESS);
 306
 307                     if (!avahi_address_parse(argv[i], AVAHI_PROTO_UNSPEC, &a)) {
 308                         fprintf(stderr, "Failed to parse address '%s'\n", argv[i]);
 309                         goto fail;
 310                     }
 311
 312                     if (!(avahi_address_resolver_new(client, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, &a, 0, address_resolver_callback, NULL))) {
 313                         fprintf(stderr, "Failed to create address resolver: %s\n", avahi_strerror(avahi_client_errno(client)));
 314                         goto fail;
 315                     }
 316                 }
 317
 318                 n_resolving++;
 319             }
 320
 321             avahi_simple_poll_loop(simple_poll);
 322             ret = 0;
 323             break;
 324         }
 325     }
 326
 327
 328 fail:
 329
 330     if (client)
 331         avahi_client_free(client);
 332
 333     sigint_uninstall();
 334
 335     if (simple_poll)
 336         avahi_simple_poll_free(simple_poll);
 337
 338     return ret;
 339 }