00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include <netcomm/utils/resolver.h>
00025 #include <netcomm/utils/resolver_thread.h>
00026 #include <core/exceptions/system.h>
00027 #include <core/threading/mutex_locker.h>
00028 #include <utils/system/hostinfo.h>
00029
00030 #include <sys/types.h>
00031 #include <arpa/inet.h>
00032 #include <netdb.h>
00033 #include <netinet/in.h>
00034 #include <cstring>
00035 #include <cstdlib>
00036 #include <cstdio>
00037
00038 namespace fawkes {
00039 #if 0
00040 }
00041 #endif
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088 NetworkNameResolver::NetworkNameResolver(AvahiThread *avahi_thread)
00089 {
00090 addr2name_cache.clear();
00091 name2addr_cache.clear();
00092 __cache_timeout = 30;
00093
00094 resolver_thread = new NetworkNameResolverThread(this, avahi_thread);
00095 resolver_thread->start();
00096
00097 usleep(0);
00098
00099 __host_info = new HostInfo();
00100 }
00101
00102
00103
00104 NetworkNameResolver::~NetworkNameResolver()
00105 {
00106 flush_cache();
00107 resolver_thread->cancel();
00108 resolver_thread->join();
00109 delete resolver_thread;
00110 delete __host_info;
00111 }
00112
00113
00114
00115
00116
00117
00118
00119 void
00120 NetworkNameResolver::set_cache_timeout(unsigned int sec)
00121 {
00122 __cache_timeout = sec;
00123 }
00124
00125
00126
00127
00128
00129 unsigned int
00130 NetworkNameResolver::cache_timeout()
00131 {
00132 return __cache_timeout;
00133 }
00134
00135
00136
00137
00138
00139 void
00140 NetworkNameResolver::flush_cache()
00141 {
00142 addr2name_cache.lock();
00143 while ( ! addr2name_cache.empty() ) {
00144 a2ncit = addr2name_cache.begin();
00145 free((*a2ncit).second.first);
00146 addr2name_cache.erase(a2ncit);
00147 }
00148 addr2name_cache.unlock();
00149 name2addr_cache.lock();
00150 while ( ! name2addr_cache.empty() ) {
00151 n2acit = name2addr_cache.begin();
00152 char *name = (*n2acit).first;
00153 free((*n2acit).second.first);
00154 name2addr_cache.erase(n2acit);
00155 free(name);
00156 }
00157 name2addr_cache.unlock();
00158 __host_info->update();
00159
00160
00161
00162
00163
00164
00165
00166
00167 }
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181 bool
00182 NetworkNameResolver::resolve_name(const char *name,
00183 struct sockaddr **addr, socklen_t *addrlen)
00184 {
00185 name2addr_cache.lock();
00186
00187 if ( name2addr_cache.find( (char *)name ) != name2addr_cache.end() ) {
00188
00189 std::pair<struct sockaddr *, time_t> &nrec = name2addr_cache[(char *)name];
00190 if ( nrec.second <= time(NULL) ) {
00191
00192 resolver_thread->resolve_name(name);
00193 }
00194 *addr = nrec.first;
00195 *addrlen = sizeof(struct sockaddr_in);
00196 name2addr_cache.unlock();
00197 return true;
00198 } else {
00199 name2addr_cache.unlock();
00200 resolver_thread->resolve_name(name);
00201 return false;
00202 }
00203 }
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217 bool
00218 NetworkNameResolver::resolve_name_blocking(const char *name,
00219 struct sockaddr **addr, socklen_t *addrlen)
00220 {
00221 if ( resolve_name(name, addr, addrlen) ) {
00222 return true;
00223 } else {
00224 struct sockaddr *_addr;
00225 socklen_t _addrlen;
00226 if ( resolver_thread->resolve_name_immediately(name, &_addr, &_addrlen) ) {
00227 name_resolved(strdup(name), _addr, _addrlen);
00228 *addr = _addr;
00229 *addrlen = _addrlen;
00230 return true;
00231 } else {
00232 return false;
00233 }
00234 }
00235 }
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248 bool
00249 NetworkNameResolver::resolve_address(struct sockaddr *addr, socklen_t addr_len, std::string &name)
00250 {
00251 addr2name_cache.lock();
00252 struct sockaddr_in *saddr = (struct sockaddr_in *)addr;
00253
00254 if ( addr2name_cache.find( saddr->sin_addr.s_addr ) != addr2name_cache.end() ) {
00255
00256 std::pair<char *, time_t> &nrec = addr2name_cache[saddr->sin_addr.s_addr];
00257 name = nrec.first;
00258 if ( nrec.second <= time(NULL) ) {
00259
00260 addr2name_cache.unlock();
00261 resolver_thread->resolve_address(addr, addr_len);
00262 } else {
00263 addr2name_cache.unlock();
00264 }
00265 } else {
00266 char tmp[INET_ADDRSTRLEN];
00267 if ( inet_ntop(AF_INET, &(saddr->sin_addr), tmp, sizeof(tmp)) ) {
00268 char *n = strdup(tmp);
00269
00270 addr2name_cache[saddr->sin_addr.s_addr] = std::pair<char *, time_t>(n, time(NULL) + __cache_timeout);
00271 name = n;
00272 addr2name_cache.unlock();
00273 } else {
00274 addr2name_cache.unlock();
00275 return false;
00276 }
00277
00278 resolver_thread->resolve_address(addr, addr_len);
00279 }
00280
00281 return true;
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297 }
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309 void
00310 NetworkNameResolver::name_resolved(char *name, struct sockaddr *addr,
00311 socklen_t addrlen)
00312 {
00313 name2addr_cache.lock();
00314 if ( (n2acit = name2addr_cache.find( name )) != name2addr_cache.end() ) {
00315
00316 char *n = (*n2acit).first;
00317 free((*n2acit).second.first);
00318 name2addr_cache.erase(n2acit);
00319 free(n);
00320 }
00321 name2addr_cache[name] = std::pair<struct sockaddr *, time_t>(addr, time(NULL) + __cache_timeout);
00322 name2addr_cache.unlock();
00323 }
00324
00325
00326 void
00327 NetworkNameResolver::addr_resolved(struct sockaddr *addr,
00328 socklen_t addrlen,
00329 char *name, bool namefound)
00330 {
00331 addr2name_cache.lock();
00332 struct sockaddr_in *saddr = (struct sockaddr_in *)addr;
00333 if (namefound) {
00334 if ((a2ncit = addr2name_cache.find( saddr->sin_addr.s_addr )) != addr2name_cache.end() ) {
00335
00336 free(a2ncit->second.first);
00337 addr2name_cache.erase(a2ncit);
00338 addr2name_cache[saddr->sin_addr.s_addr] = std::pair<char *, time_t>(name, time(NULL) + __cache_timeout);
00339 } else {
00340 free(name);
00341 }
00342 } else {
00343 if ((a2ncit = addr2name_cache.find( saddr->sin_addr.s_addr )) == addr2name_cache.end() ) {
00344 addr2name_cache[saddr->sin_addr.s_addr] = std::pair<char *, time_t>(name, 0);
00345 } else {
00346 free(name);
00347 }
00348 }
00349 free(addr);
00350 addr2name_cache.unlock();
00351 }
00352
00353
00354 void
00355 NetworkNameResolver::name_resolution_failed(char *name)
00356 {
00357 free(name);
00358 }
00359
00360
00361 void
00362 NetworkNameResolver::address_resolution_failed(struct sockaddr *addr,
00363 socklen_t addrlen)
00364 {
00365 free(addr);
00366 }
00367
00368
00369
00370
00371
00372 const char *
00373 NetworkNameResolver::hostname()
00374 {
00375 return __host_info->name();
00376 }
00377
00378
00379
00380
00381
00382 const char *
00383 NetworkNameResolver::short_hostname()
00384 {
00385 return __host_info->short_name();
00386 }
00387
00388 }