qa_avahi_resolver.cpp

00001 
00002 /***************************************************************************
00003  *  qa_avahi_resolver.cpp - QA for AvahiResolver
00004  *
00005  *  Created: Fri May 11 12:31:35 2007
00006  *  Copyright  2006-2007  Tim Niemueller [www.niemueller.de]
00007  *
00008  ****************************************************************************/
00009 
00010 /*  This program is free software; you can redistribute it and/or modify
00011  *  it under the terms of the GNU General Public License as published by
00012  *  the Free Software Foundation; either version 2 of the License, or
00013  *  (at your option) any later version. A runtime exception applies to
00014  *  this software (see LICENSE.GPL_WRE file mentioned below for details).
00015  *
00016  *  This program is distributed in the hope that it will be useful,
00017  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00018  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019  *  GNU Library General Public License for more details.
00020  *
00021  *  Read the full text in the LICENSE.GPL_WRE file in the doc directory.
00022  */
00023 
00024 /// @cond QA
00025 
00026 #include <netcomm/dns-sd/avahi_thread.h>
00027 #include <netcomm/dns-sd/avahi_resolver_handler.h>
00028 
00029 #include <core/exception.h>
00030 #include <utils/system/signal.h>
00031 #include <utils/system/argparser.h>
00032 
00033 #include <cstdio>
00034 #include <cstdlib>
00035 #include <arpa/inet.h>
00036 #include <netinet/in.h>
00037 
00038 using namespace fawkes;
00039 
00040 class QAAvahiResolverMain : public SignalHandler, public AvahiResolverHandler
00041 {
00042  public:
00043   QAAvahiResolverMain(ArgumentParser *argp)
00044   {
00045     this->argp = argp;
00046     at = new AvahiThread();
00047     wait_for_name = false;
00048     wait_for_addr = false;
00049   }
00050 
00051   ~QAAvahiResolverMain()
00052   {
00053     delete at;
00054   }
00055 
00056   virtual void handle_signal(int signum)
00057   {
00058     at->cancel();
00059   }
00060 
00061   void run()
00062   {
00063     printf("Starting AvahiThread\n");
00064     at->start();
00065 
00066     printf("Waiting until AvahiThread has been initialized\n");
00067     at->wait_initialized();
00068 
00069     wait_for_name = argp->has_arg("n");
00070     wait_for_addr = argp->has_arg("a");
00071 
00072     const char *tmp;
00073     if ( (tmp = argp->arg("n")) != NULL ) {
00074       printf("Calling name resolver\n");
00075       at->resolve_name(tmp, this);
00076     }
00077 
00078     if ( (tmp = argp->arg("a")) != NULL ) {
00079       printf("Calling address resolver\n");
00080       struct sockaddr_in saddr;
00081       if ( inet_pton(AF_INET, tmp, &(saddr.sin_addr)) >= 0 ) {
00082         at->resolve_address((struct sockaddr *)&saddr, sizeof(saddr), this);
00083       }
00084     }
00085 
00086     printf("Waiting for thread\n");
00087     at->join();
00088   }
00089   
00090   virtual void resolved_name(char *name, struct sockaddr *addr, socklen_t addrlen)
00091   {
00092     char addrp[INET_ADDRSTRLEN];
00093     struct sockaddr_in *in_addr = (struct sockaddr_in *)addr;
00094     if ( inet_ntop(AF_INET, &(in_addr->sin_addr), addrp, sizeof(addrp)) ) {
00095       printf("'%s' resolved to '%s'\n", name, addrp);
00096     } else {
00097       printf("'%s' resolved, but could not transform address to presentation form\n", name);
00098     }
00099 
00100     free(name);
00101     free(addr);
00102 
00103     wait_for_name = false;
00104     if ( ! wait_for_name && ! wait_for_addr )  at->cancel();
00105   }
00106 
00107 
00108   virtual void resolved_address(struct sockaddr_in *addr, socklen_t addrlen, char *name)
00109   {
00110     char addrp[INET_ADDRSTRLEN];
00111     struct sockaddr_in *in_addr = (struct sockaddr_in *)addr;
00112     if ( inet_ntop(AF_INET, &(in_addr->sin_addr), addrp, sizeof(addrp)) ) {
00113       printf("Address %s resolved to %s\n", addrp, name);
00114     } else {
00115       printf("Unknown address resolved to '%s'\n", name);
00116     }
00117 
00118     free(addr);
00119     free(name);
00120 
00121     wait_for_addr = false;
00122     if ( ! wait_for_name && ! wait_for_addr )  at->cancel();
00123   }
00124 
00125   virtual void name_resolution_failed(char *name)
00126   {
00127     printf("Could not resolve '%s'\n", name);
00128     free(name);
00129 
00130     wait_for_name = false;
00131     if ( ! wait_for_name && ! wait_for_addr )  at->cancel();
00132   }
00133 
00134 
00135   virtual void address_resolution_failed(struct sockaddr_in *addr, socklen_t addrlen)
00136   {
00137     free(addr);
00138 
00139     wait_for_addr = false;
00140     if ( ! wait_for_name && ! wait_for_addr )  at->cancel();
00141   }
00142 
00143 
00144  private:
00145   AvahiThread *at;
00146   ArgumentParser *argp;
00147 
00148   bool wait_for_name;
00149   bool wait_for_addr;
00150 };
00151 
00152 int
00153 main(int argc, char **argv)
00154 {
00155   ArgumentParser *argp = new ArgumentParser(argc, argv, "n:a:");
00156 
00157   if ( ! argp->has_arg("n") && ! argp->has_arg("a") ) {
00158     printf("Usage: %s [-n name] [-a address]\n\n", argv[0]);
00159     delete argp;
00160     return -1;
00161   }
00162 
00163   try {
00164     QAAvahiResolverMain m(argp);
00165     SignalManager::register_handler(SIGINT, &m);
00166 
00167     m.run();
00168 
00169   } catch (Exception &e) {
00170     e.print_trace();
00171   }
00172 
00173   SignalManager::finalize();
00174   delete argp;
00175 }
00176 
00177 /// @endcond

Generated on Tue Feb 22 13:31:27 2011 for Fawkes API by  doxygen 1.4.7