WINGs/host.c

   1 /*
   2  *  WINGs WMHost function library
   3  *
   4  *  Copyright (c) 1999-2001 Dan Pascu
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21
  22 #include "../src/config.h"
  23
  24 #include "wconfig.h"
  25
  26 #include <unistd.h>
  27 #include <string.h>
  28 #include <netdb.h>
  29 #include <sys/socket.h>
  30 #include <netinet/in.h>
  31 #include <arpa/inet.h>
  32
  33 #include "WUtil.h"
  34
  35
  36 /* For Solaris */
  37 #ifndef INADDR_NONE
  38 # define INADDR_NONE  (-1)
  39 #endif
  40
  41 /* Max hostname length (RFC  1123) */
  42 #define W_MAXHOSTNAMELEN        255
  43
  44
  45 typedef struct W_Host {
  46     char   *name;
  47
  48     WMArray  *names;
  49     WMArray  *addresses;
  50
  51     int    refCount;
  52 } W_Host;
  53
  54
  55 static WMHashTable *hostCache = NULL;
  56
  57 static Bool hostCacheEnabled = True;
  58
  59
  60
  61 static WMHost*
  62 getHostFromCache(char *name)
  63 {
  64     if (!hostCache)
  65         return NULL;
  66
  67     return WMHashGet(hostCache, name);
  68 }
  69
  70
  71 static WMHost*
  72 getHostWithHostEntry(struct hostent *host, char *name)
  73 {
  74     WMHost *hPtr;
  75     struct in_addr in;
  76     int i;
  77
  78     hPtr = (WMHost*)wmalloc(sizeof(WMHost));
  79     memset(hPtr, 0, sizeof(WMHost));
  80
  81     hPtr->names = WMCreateArrayWithDestructor(1, wfree);
  82     hPtr->addresses = WMCreateArrayWithDestructor(1, wfree);
  83
  84     WMAddToArray(hPtr->names, wstrdup(host->h_name));
  85
  86     for (i=0; host->h_aliases[i]!=NULL; i++) {
  87         WMAddToArray(hPtr->names, wstrdup(host->h_aliases[i]));
  88     }
  89
  90     for (i=0; host->h_addr_list[i]!=NULL; i++) {
  91         memcpy((void*)&in.s_addr, (const void*)host->h_addr_list[i],
  92                host->h_length);
  93         WMAddToArray(hPtr->addresses, wstrdup(inet_ntoa(in)));
  94     }
  95
  96     hPtr->refCount = 1;
  97
  98     if (hostCacheEnabled) {
  99         if (!hostCache)
 100             hostCache = WMCreateHashTable(WMStringPointerHashCallbacks);
 101         hPtr->name = wstrdup(name);
 102         wassertr(WMHashInsert(hostCache, hPtr->name, hPtr)==NULL);
 103         hPtr->refCount++;
 104     }
 105
 106     return hPtr;
 107 }
 108
 109
 110 WMHost*
 111 WMGetCurrentHost()
 112 {
 113     char name[W_MAXHOSTNAMELEN+1];
 114
 115     if (gethostname(name, W_MAXHOSTNAMELEN) < 0) {
 116         wsyserror(_("Cannot get current host name"));
 117         return NULL;
 118     }
 119
 120     name[W_MAXHOSTNAMELEN] = 0;
 121
 122     return WMGetHostWithName(name);
 123 }
 124
 125
 126 WMHost*
 127 WMGetHostWithName(char *name)
 128 {
 129     struct hostent *host;
 130     WMHost *hPtr;
 131
 132     wassertrv(name!=NULL, NULL);
 133
 134     if (hostCacheEnabled) {
 135         if ((hPtr = getHostFromCache(name)) != NULL) {
 136             WMRetainHost(hPtr);
 137             return hPtr;
 138         }
 139     }
 140
 141     host = gethostbyname(name);
 142     if (host == NULL) {
 143         return NULL;
 144     }
 145
 146     hPtr = getHostWithHostEntry(host, name);
 147
 148     return hPtr;
 149 }
 150
 151
 152 WMHost*
 153 WMGetHostWithAddress(char *address)
 154 {
 155     struct hostent *host;
 156     struct in_addr in;
 157     WMHost *hPtr;
 158
 159     wassertrv(address!=NULL, NULL);
 160
 161     if (hostCacheEnabled) {
 162         if ((hPtr = getHostFromCache(address)) != NULL) {
 163             WMRetainHost(hPtr);
 164             return hPtr;
 165         }
 166     }
 167
 168 #ifndef HAVE_INET_ATON
 169     if ((in.s_addr = inet_addr(address)) == INADDR_NONE)
 170         return NULL;
 171 #else
 172     if (inet_aton(address, &in) == 0)
 173         return NULL;
 174 #endif
 175
 176     host = gethostbyaddr((char*)&in, sizeof(in), AF_INET);
 177     if (host == NULL) {
 178         return NULL;
 179     }
 180
 181     hPtr = getHostWithHostEntry(host, address);
 182
 183     return hPtr;
 184 }
 185
 186
 187 WMHost*
 188 WMRetainHost(WMHost *hPtr)
 189 {
 190     hPtr->refCount++;
 191     return hPtr;
 192 }
 193
 194
 195 void
 196 WMReleaseHost(WMHost *hPtr)
 197 {
 198     hPtr->refCount--;
 199
 200     if (hPtr->refCount > 0)
 201         return;
 202
 203     WMFreeArray(hPtr->names);
 204     WMFreeArray(hPtr->addresses);
 205
 206     if (hPtr->name) {
 207         WMHashRemove(hostCache, hPtr->name);
 208         wfree(hPtr->name);
 209     }
 210
 211     wfree(hPtr);
 212 }
 213
 214
 215 void
 216 WMSetHostCacheEnabled(Bool flag)
 217 {
 218     hostCacheEnabled = flag;
 219 }
 220
 221
 222 Bool
 223 WMIsHostCacheEnabled()
 224 {
 225     return hostCacheEnabled;
 226 }
 227
 228
 229 void
 230 WMFlushHostCache()
 231 {
 232     if (hostCache && WMCountHashTable(hostCache)>0) {
 233         WMArray *hostArray = WMCreateArray(WMCountHashTable(hostCache));
 234         WMHashEnumerator enumer = WMEnumerateHashTable(hostCache);
 235         WMHost *hPtr;
 236         int i;
 237
 238         while ((hPtr = WMNextHashEnumeratorItem(&enumer))) {
 239             /* we can't release the host here, because we can't change the
 240              * hash while using the enumerator functions. */
 241             WMAddToArray(hostArray, hPtr);
 242         }
 243         for (i=0; i<WMGetArrayItemCount(hostArray); i++)
 244             WMReleaseHost(WMGetFromArray(hostArray, i));
 245         WMFreeArray(hostArray);
 246         WMResetHashTable(hostCache);
 247     }
 248 }
 249
 250
 251 static int
 252 matchAddress(void *item, void *cdata)
 253 {
 254     return (strcmp((char*) item, (char*) cdata)==0);
 255 }
 256
 257
 258 Bool
 259 WMIsHostEqualToHost(WMHost* hPtr, WMHost* aPtr)
 260 {
 261     char *adr;
 262     int i;
 263
 264     wassertrv(hPtr!=NULL && aPtr!=NULL, False);
 265
 266     if (hPtr == aPtr)
 267         return True;
 268
 269     for (i=0; i<WMGetArrayItemCount(aPtr->addresses); i++) {
 270         adr = WMGetFromArray(aPtr->addresses, i);
 271         if (WMFindInArray(hPtr->addresses, matchAddress, adr) != WANotFound) {
 272             return True;
 273         }
 274     }
 275
 276     return False;
 277 }
 278
 279
 280 char*
 281 WMGetHostName(WMHost *hPtr)
 282 {
 283     return (WMGetArrayItemCount(hPtr->names) > 0 ?
 284             WMGetFromArray(hPtr->names, 0) : NULL);
 285     /*return WMGetFromArray(hPtr->names, 0);*/
 286 }
 287
 288
 289 WMArray*
 290 WMGetHostNames(WMHost *hPtr)
 291 {
 292     return hPtr->names;
 293 }
 294
 295
 296 char*
 297 WMGetHostAddress(WMHost *hPtr)
 298 {
 299     return (WMGetArrayItemCount(hPtr->addresses) > 0 ?
 300             WMGetFromArray(hPtr->addresses, 0) : NULL);
 301 }
 302
 303
 304 WMArray*
 305 WMGetHostAddresses(WMHost *hPtr)
 306 {
 307     return hPtr->addresses;
 308 }
 309
 310
 311
 312