WINGs/host.c

   1 /*
   2  *  WINGs WMHost function library
   3  *
   4  *  Copyright (c) 1999 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
  23 #include <unistd.h>
  24 #include <string.h>
  25 #include <netdb.h>
  26 #include <sys/socket.h>
  27 #include <netinet/in.h>
  28 #include <arpa/inet.h>
  29
  30 #include "WUtil.h"
  31
  32
  33 typedef struct W_Host {
  34     char   *name;
  35
  36     WMBag  *names;
  37     WMBag  *addresses;
  38
  39     int    refCount;
  40 } W_Host;
  41
  42
  43 static WMHashTable *hostCache = NULL;
  44 static Bool hostCacheEnabled = True;
  45
  46
  47 /* Max hostname length (RFC  1123) */
  48 #define W_MAXHOSTNAMELEN        255
  49
  50
  51 static WMHost*
  52 getHostFromCache(char *name)
  53 {
  54     if (!hostCache)
  55         return NULL;
  56
  57     return WMHashGet(hostCache, name);
  58 }
  59
  60
  61 static WMHost*
  62 getHostWithHostEntry(struct hostent *host, char *name)
  63 {
  64     WMHost *hPtr;
  65     struct in_addr in;
  66     int i;
  67
  68     hPtr = (WMHost*)wmalloc(sizeof(WMHost));
  69     memset(hPtr, 0, sizeof(WMHost));
  70
  71     hPtr->names = WMCreateBag(1);
  72     hPtr->addresses = WMCreateBag(1);
  73
  74     WMPutInBag(hPtr->names, wstrdup(host->h_name));
  75
  76     for (i=0; host->h_aliases[i]!=NULL; i++) {
  77         WMPutInBag(hPtr->names, wstrdup(host->h_aliases[i]));
  78     }
  79
  80     for (i=0; host->h_addr_list[i]!=NULL; i++) {
  81         memcpy((void*)&in.s_addr, (const void*)host->h_addr_list[i],
  82                host->h_length);
  83         WMPutInBag(hPtr->addresses, wstrdup(inet_ntoa(in)));
  84     }
  85
  86     hPtr->refCount = 1;
  87
  88     if (hostCacheEnabled) {
  89         if (!hostCache)
  90             hostCache = WMCreateHashTable(WMStringPointerHashCallbacks);
  91         hPtr->name = wstrdup(name);
  92         wassertr(WMHashInsert(hostCache, hPtr->name, hPtr)==NULL);
  93         hPtr->refCount++;
  94     }
  95
  96     return hPtr;
  97 }
  98
  99
 100 WMHost*
 101 WMGetCurrentHost()
 102 {
 103     char name[W_MAXHOSTNAMELEN+1];
 104
 105     if (gethostname(name, W_MAXHOSTNAMELEN) < 0) {
 106         wsyserror("Cannot get current host name");
 107         return NULL;
 108     }
 109
 110     name[W_MAXHOSTNAMELEN] = '\0';
 111
 112     return WMGetHostWithName(name);
 113 }
 114
 115
 116 WMHost*
 117 WMGetHostWithName(char* name)
 118 {
 119     struct hostent *host;
 120     WMHost *hPtr;
 121
 122     if (name == NULL) {
 123         wwarning("NULL host name in 'WMGetHostWithName()'");
 124         return NULL;
 125     }
 126
 127     if (hostCacheEnabled) {
 128         if ((hPtr = getHostFromCache(name)) != NULL) {
 129             WMRetainHost(hPtr);
 130             return hPtr;
 131         }
 132     }
 133
 134     host = gethostbyname(name);
 135     if (host == NULL) {
 136         return NULL;
 137     }
 138
 139     hPtr = getHostWithHostEntry(host, name);
 140
 141     return hPtr;
 142 }
 143
 144
 145 WMHost*
 146 WMGetHostWithAddress(char* address)
 147 {
 148     struct hostent *host;
 149     struct in_addr in;
 150     WMHost *hPtr;
 151
 152     if (address == NULL) {
 153         wwarning("NULL address in 'WMGetHostWithAddress()'");
 154         return NULL;
 155     }
 156
 157     if (hostCacheEnabled) {
 158         if ((hPtr = getHostFromCache(address)) != NULL) {
 159             WMRetainHost(hPtr);
 160             return hPtr;
 161         }
 162     }
 163
 164 #ifndef HAVE_INET_ATON
 165     if ((in.s_addr = inet_addr(address)) == INADDR_NONE)
 166         return NULL;
 167 #else
 168     if (inet_aton(address, &in.s_addr) == 0)
 169         return NULL;
 170 #endif
 171
 172     host = gethostbyaddr((char*)&in, sizeof(in), AF_INET);
 173     if (host == NULL) {
 174         return NULL;
 175     }
 176
 177     hPtr = getHostWithHostEntry(host, address);
 178
 179     return hPtr;
 180 }
 181
 182
 183 WMHost*
 184 WMRetainHost(WMHost *hPtr)
 185 {
 186     hPtr->refCount++;
 187     return hPtr;
 188 }
 189
 190
 191 void
 192 WMReleaseHost(WMHost *hPtr)
 193 {
 194     int i;
 195
 196     hPtr->refCount--;
 197
 198     if (hPtr->refCount > 0)
 199         return;
 200
 201     for (i=0; i<WMGetBagItemCount(hPtr->names); i++)
 202         wfree(WMGetFromBag(hPtr->names, i));
 203     for (i=0; i<WMGetBagItemCount(hPtr->addresses); i++)
 204         wfree(WMGetFromBag(hPtr->addresses, i));
 205
 206     WMFreeBag(hPtr->names);
 207     WMFreeBag(hPtr->addresses);
 208
 209     if (hPtr->name) {
 210         WMHashRemove(hostCache, hPtr->name);
 211         wfree(hPtr->name);
 212     }
 213
 214     wfree(hPtr);
 215 }
 216
 217
 218 void
 219 WMSetHostCacheEnabled(Bool flag)
 220 {
 221     hostCacheEnabled = flag;
 222 }
 223
 224
 225 Bool
 226 WMIsHostCacheEnabled()
 227 {
 228     return hostCacheEnabled;
 229 }
 230
 231
 232 void
 233 WMFlushHostCache()
 234 {
 235     if (hostCache && WMCountHashTable(hostCache)>0) {
 236         WMBag *hostBag = WMCreateBag(WMCountHashTable(hostCache));
 237         WMHashEnumerator enumer = WMEnumerateHashTable(hostCache);
 238         WMHost *hPtr;
 239         int i;
 240
 241         while ((hPtr = WMNextHashEnumeratorItem(&enumer))) {
 242             /* we can't release the host here, because we can't change the
 243              * hash while using the enumerator functions. */
 244             WMPutInBag(hostBag, hPtr);
 245         }
 246         for (i=0; i<WMGetBagItemCount(hostBag); i++)
 247             WMReleaseHost(WMGetFromBag(hostBag, i));
 248         WMFreeBag(hostBag);
 249         WMResetHashTable(hostCache);
 250     }
 251 }
 252
 253
 254 Bool
 255 WMIsHostEqualToHost(WMHost* hPtr, WMHost* aPtr)
 256 {
 257     int i, j;
 258     char *adr1, *adr2;
 259
 260     wassertrv(hPtr!=NULL && aPtr!=NULL, False);
 261
 262     if (hPtr == aPtr)
 263         return True;
 264
 265     for (i=0; i<WMGetBagItemCount(aPtr->addresses); i++) {
 266         adr1 = WMGetFromBag(aPtr->addresses, i);
 267         for (j=0; j<WMGetBagItemCount(hPtr->addresses); j++) {
 268             adr2 = WMGetFromBag(hPtr->addresses, j);
 269             if (strcmp(adr1, adr2)==0)
 270                 return True;
 271         }
 272     }
 273
 274     return False;
 275 }
 276
 277
 278 char*
 279 WMGetHostName(WMHost *hPtr)
 280 {
 281     return (WMGetBagItemCount(hPtr->names) > 0 ?
 282             WMGetFromBag(hPtr->names, 0) : NULL);
 283     /*return WMGetFromBag(hPtr->names, 0);*/
 284 }
 285
 286
 287 WMBag*
 288 WMGetHostNames(WMHost *hPtr)
 289 {
 290     return hPtr->names;
 291 }
 292
 293
 294 char*
 295 WMGetHostAddress(WMHost *hPtr)
 296 {
 297     return (WMGetBagItemCount(hPtr->addresses) > 0 ?
 298             WMGetFromBag(hPtr->addresses, 0) : NULL);
 299 }
 300
 301
 302 WMBag*
 303 WMGetHostAddresses(WMHost *hPtr)
 304 {
 305     return hPtr->addresses;
 306 }
 307
 308
 309
 310