1 karl 1.37 //%2006////////////////////////////////////////////////////////////////////////
|
2 mike 1.6 //
|
3 karl 1.23 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
|
6 karl 1.19 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.23 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
|
9 karl 1.25 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 karl 1.37 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
|
13 mike 1.6 //
14 // Permission is hereby granted, free of charge, to any person obtaining a copy
|
15 kumpf 1.11 // of this software and associated documentation files (the "Software"), to
16 // deal in the Software without restriction, including without limitation the
17 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
18 mike 1.6 // sell copies of the Software, and to permit persons to whom the Software is
19 // furnished to do so, subject to the following conditions:
|
20 karl 1.23 //
|
21 kumpf 1.11 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
|
22 mike 1.6 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
23 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
|
24 kumpf 1.11 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
25 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
27 mike 1.6 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30 //==============================================================================
31 //
32 //%/////////////////////////////////////////////////////////////////////////////
|
33 mike 1.8
|
34 sage 1.12 #if defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
|
35 r.kieninger 1.21 #include <Pegasus/Common/Config.h>
36 #endif
|
37 sage 1.12
|
38 mike 1.8 #include <fstream>
|
39 kumpf 1.13 #include <cctype> // for tolower()
|
40 kumpf 1.14 #include <cstring>
|
41 mike 1.6 #include "System.h"
|
42 r.kieninger 1.21 #include "Socket.h"
|
43 mike 1.39 #include "Network.h"
|
44 kumpf 1.10 #include <Pegasus/Common/PegasusVersion.h>
|
45 mateus.baur 1.50 #include <Pegasus/Common/FileSystem.h>
|
46 dave.sudlik 1.52 #include <Pegasus/Common/HostAddress.h>
47 #include <Pegasus/Common/Array.h>
|
48 kumpf 1.10
|
49 mike 1.6 #if defined(PEGASUS_OS_TYPE_WINDOWS)
50 # include "SystemWindows.cpp"
|
51 kumpf 1.41 #elif defined(PEGASUS_OS_TYPE_UNIX) || defined(PEGASUS_OS_VMS)
|
52 mike 1.40 # include "SystemPOSIX.cpp"
|
53 mike 1.6 #else
54 # error "Unsupported platform"
55 #endif
|
56 mike 1.8
57 PEGASUS_USING_STD;
58
59 PEGASUS_NAMESPACE_BEGIN
60
|
61 kumpf 1.20 Boolean System::bindVerbose = false;
62
|
63 mike 1.8 Boolean System::copyFile(const char* fromPath, const char* toPath)
64 {
|
65 ramnath 1.9 ifstream is(fromPath PEGASUS_IOS_BINARY);
|
66 mateus.baur 1.50 fstream os(toPath, ios::out PEGASUS_OR_IOS_BINARY);
|
67 mike 1.8
68 char c;
69
70 while (is.get(c))
71 {
|
72 kumpf 1.44 if (!os.put(c))
73 return false;
|
74 mike 1.8 }
75
|
76 mateus.baur 1.50 FileSystem::syncWithDirectoryUpdates(os);
|
77 kumpf 1.42 return is.eof();
|
78 kumpf 1.13 }
79
|
80 kumpf 1.44 static const Uint8 _toLowerTable[256] =
|
81 mike 1.32 {
82 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
83 0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
84 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
85 0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
86 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
87 0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
88 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
89 0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
90 0x40,0x61,0x62,0x63,0x64,0x65,0x66,0x67,
91 0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
92 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,
93 0x78,0x79,0x7A,0x5B,0x5C,0x5D,0x5E,0x5F,
94 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,
95 0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
96 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,
97 0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
98 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
99 0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
100 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,
101 0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
102 mike 1.32 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,
103 0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
104 0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,
105 0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
106 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,
107 0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
108 0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,
109 0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
110 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,
111 0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
112 0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,
113 0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF,
114 };
115
|
116 kumpf 1.13 Sint32 System::strcasecmp(const char* s1, const char* s2)
117 {
|
118 mike 1.32 // Note: this is faster than glibc strcasecmp().
119
120 Uint8* p = (Uint8*)s1;
121 Uint8* q = (Uint8*)s2;
122 int r;
123
124 for (;;)
|
125 kumpf 1.13 {
|
126 kumpf 1.44 if ((r = _toLowerTable[p[0]] - _toLowerTable[q[0]]) || !p[0] ||
127 (r = _toLowerTable[p[1]] - _toLowerTable[q[1]]) || !p[1] ||
128 (r = _toLowerTable[p[2]] - _toLowerTable[q[2]]) || !p[2] ||
129 (r = _toLowerTable[p[3]] - _toLowerTable[q[3]]) || !p[3])
130 break;
|
131 kumpf 1.13
|
132 kumpf 1.44 p += 4;
133 q += 4;
|
134 kumpf 1.13 }
135
|
136 mike 1.32 return r;
|
137 mike 1.8 }
138
|
139 tony 1.15 // Return the just the file name from the path into basename
140 char *System::extract_file_name(const char *fullpath, char *basename)
141 {
|
142 kumpf 1.44 if (fullpath == NULL)
143 {
144 basename[0] = '\0';
145 return basename;
146 }
|
147 kumpf 1.31
|
148 kumpf 1.44 for (const char* p = fullpath + strlen(fullpath) - 1; p >= fullpath; p--)
149 {
150 if (*p == '\\' || *p == '/')
151 {
152 strcpy(basename, p+1);
153 return basename;
154 }
155 }
156
157 strcpy(basename, fullpath);
158 return basename;
|
159 tony 1.15 }
160
161 // Return the just the path to the file name into dirname
162 char *System::extract_file_path(const char *fullpath, char *dirname)
163 {
|
164 kumpf 1.44 char *p;
165 char buff[4096];
166 if (fullpath == NULL)
167 {
168 dirname[0] = '\0';
169 return dirname;
170 }
171 strncpy(buff, fullpath, sizeof(buff)-1);
172 buff[sizeof(buff)-1] = '\0';
173 for (p = buff + strlen(buff); p >= buff; p--)
|
174 tony 1.15 {
|
175 kumpf 1.44 if (*p == '\\' || *p == '/')
|
176 tony 1.15 {
177 strncpy(dirname, buff, p+1 - buff);
178 dirname[p+1 - buff] = '\0';
179 return dirname;
180 }
181 }
|
182 kumpf 1.44 strcpy(dirname, fullpath);
183 return dirname;
|
184 tony 1.15 }
185
|
186 dave.sudlik 1.52 Boolean System::getHostIP(const String &hostName, int *af, String &hostIP)
|
187 marek 1.24 {
|
188 dave.sudlik 1.52 #ifdef PEGASUS_ENABLE_IPV6
189 struct addrinfo *info, hints;
190 memset (&hints, 0, sizeof(struct addrinfo));
191
192 // Check for valid IPV4 address, if found return ipv4 address
193 *af = AF_INET;
194 hints.ai_family = *af;
195 hints.ai_protocol = IPPROTO_TCP;
196 hints.ai_socktype = SOCK_STREAM;
|
197 dmitry.mikulin 1.59 if (!getAddrInfo(hostName.getCString(), 0, &hints, &info))
|
198 dave.sudlik 1.52 {
199 char ipAddress[PEGASUS_INET_ADDRSTR_LEN];
200 HostAddress::convertBinaryToText(info->ai_family,
|
201 kumpf 1.54 &(reinterpret_cast<struct sockaddr_in*>(info->ai_addr))->sin_addr,
202 ipAddress,
|
203 dave.sudlik 1.52 PEGASUS_INET_ADDRSTR_LEN);
204 hostIP = ipAddress;
205 freeaddrinfo(info);
206 return true;
207 }
208
209 // Check for valid IPV6 Address.
210 *af = AF_INET6;
211 hints.ai_family = *af;
212 hints.ai_protocol = IPPROTO_TCP;
213 hints.ai_socktype = SOCK_STREAM;
|
214 dmitry.mikulin 1.59 if (!getAddrInfo(hostName.getCString(), 0, &hints, &info))
|
215 dave.sudlik 1.52 {
216 char ipAddress[PEGASUS_INET6_ADDRSTR_LEN];
217 HostAddress::convertBinaryToText(info->ai_family,
|
218 kumpf 1.54 &(reinterpret_cast<struct sockaddr_in6*>(info->ai_addr))->sin6_addr,
219 ipAddress,
|
220 dave.sudlik 1.52 PEGASUS_INET6_ADDRSTR_LEN);
221 hostIP = ipAddress;
222 freeaddrinfo(info);
223 return true;
224 }
225
226 return false;
227 #else
228 *af = AF_INET;
|
229 kumpf 1.36 struct hostent* hostEntry;
230 struct in_addr inaddr;
231 String ipAddress;
232 CString hostNameCString = hostName.getCString();
233 const char* hostNamePtr = hostNameCString;
234
235 char hostEntryBuffer[8192];
236 struct hostent hostEntryStruct;
|
237 dmitry.mikulin 1.59 hostEntry = getHostByName(hostNamePtr, &hostEntryStruct,
238 hostEntryBuffer, sizeof (hostEntryBuffer));
|
239 kumpf 1.36
240 if (hostEntry)
|
241 marek 1.24 {
|
242 kumpf 1.36 ::memcpy( &inaddr, hostEntry->h_addr,4);
|
243 marek 1.24 ipAddress = ::inet_ntoa( inaddr );
|
244 dmitry.mikulin 1.59 hostIP = ipAddress;
245 return true;
|
246 marek 1.24 }
|
247 dmitry.mikulin 1.59 return false;
|
248 dave.sudlik 1.52 #endif
|
249 marek 1.24 }
|
250 r.kieninger 1.21
|
251 venkat.puvvada 1.56
252 #ifdef PEGASUS_ENABLE_IPV6
253 Boolean System::isIPv6StackActive()
254 {
255 SocketHandle ip6Socket;
256 if ((ip6Socket = Socket::createSocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP))
257 == PEGASUS_INVALID_SOCKET)
258 {
259 if (getSocketError() == PEGASUS_INVALID_ADDRESS_FAMILY)
260 {
261 return false;
262 }
263 }
264 else
265 {
266 Socket::close(ip6Socket);
267 }
268
269 return true;
270 }
271 #endif
272 venkat.puvvada 1.56
|
273 r.kieninger 1.21 // ------------------------------------------------------------------------
274 // Convert a hostname into a a single host unique integer representation
275 // ------------------------------------------------------------------------
|
276 dave.sudlik 1.52 Boolean System::_acquireIP(const char* hostname, int *af, void *dst)
277 {
278 #ifdef PEGASUS_ENABLE_IPV6
279 String ipAddress;
280 if(getHostIP(hostname, af, ipAddress))
|
281 dmitry.mikulin 1.59 {
|
282 dave.sudlik 1.52 HostAddress::convertTextToBinary(*af, ipAddress.getCString(), dst);
283 return true;
284 }
285 return false;
286 #else
287 *af = AF_INET;
|
288 kumpf 1.44 Uint32 ip = 0xFFFFFFFF;
289 if (!hostname) return 0xFFFFFFFF;
|
290 r.kieninger 1.21
|
291 dave.sudlik 1.22 ////////////////////////////////////////////////////////////////////////////////
292 // This code used to check if the first character of "hostname" was alphabetic
|
293 kumpf 1.44 // to indicate hostname instead of IP address. But RFC 1123, section 2.1,
294 // relaxed this requirement to alphabetic character *or* digit. So bug 1462
295 // changed the flow here to call inet_addr first to check for a valid IP
296 // address in dotted decimal notation. If it's not a valid IP address, then
297 // try to validate it as a hostname.
298 // RFC 1123 states: The host SHOULD check the string syntactically for a
299 // dotted-decimal number before looking it up in the Domain Name System.
|
300 dave.sudlik 1.22 // Hence the call to inet_addr() first.
301 ////////////////////////////////////////////////////////////////////////////////
302
|
303 kumpf 1.44 Uint32 tmp_addr = inet_addr((char *) hostname);
|
304 kumpf 1.36 struct hostent* hostEntry;
|
305 r.kieninger 1.21
|
306 dave.sudlik 1.22 // Note: 0xFFFFFFFF is actually a valid IP address (255.255.255.255).
307 // A better solution would be to use inet_aton() or equivalent, as
308 // inet_addr() is now considered "obsolete".
309
310 if (tmp_addr == 0xFFFFFFFF) // if hostname is not an IP address
|
311 kumpf 1.36 {
312 char hostEntryBuffer[8192];
313 struct hostent hostEntryStruct;
|
314 dmitry.mikulin 1.59 hostEntry = getHostByName(hostname, &hostEntryStruct,
315 hostEntryBuffer, sizeof (hostEntryBuffer));
|
316 kumpf 1.36
317 if (!hostEntry)
|
318 kumpf 1.44 {
|
319 dave.sudlik 1.52 // error, couldn't resolve the ip
320 memcpy(dst, &ip, sizeof (Uint32));
321 return false;
|
322 kumpf 1.44 }
323 unsigned char ip_part1,ip_part2,ip_part3,ip_part4;
324
325 ip_part1 = hostEntry->h_addr[0];
326 ip_part2 = hostEntry->h_addr[1];
327 ip_part3 = hostEntry->h_addr[2];
328 ip_part4 = hostEntry->h_addr[3];
329 ip = ip_part1;
330 ip = (ip << 8) + ip_part2;
331 ip = (ip << 8) + ip_part3;
332 ip = (ip << 8) + ip_part4;
333 }
|
334 dave.sudlik 1.22 else // else hostname *is* a dotted-decimal IP address
|
335 kumpf 1.44 {
336 // resolve hostaddr to a real host entry
337 // casting to (const char *) as (char *) will work as (void *) too,
338 // those it fits all platforms
|
339 ms.aruran 1.45 char hostEntryBuffer[8192];
340 struct hostent hostEntryStruct;
|
341 dmitry.mikulin 1.59 hostEntry =
342 getHostByAddr((const char*) &tmp_addr, sizeof(tmp_addr), AF_INET,
343 &hostEntryStruct, hostEntryBuffer, sizeof (hostEntryBuffer));
|
344 ms.aruran 1.45
|
345 kumpf 1.44 if (hostEntry == 0)
346 {
347 // error, couldn't resolve the ip
|
348 dave.sudlik 1.52 memcpy(dst, &ip, sizeof (Uint32));
349 return false;
|
350 kumpf 1.44 }
351 else
352 {
353 unsigned char ip_part1,ip_part2,ip_part3,ip_part4;
|
354 r.kieninger 1.21
|
355 kumpf 1.44 ip_part1 = hostEntry->h_addr[0];
356 ip_part2 = hostEntry->h_addr[1];
357 ip_part3 = hostEntry->h_addr[2];
358 ip_part4 = hostEntry->h_addr[3];
359 ip = ip_part1;
360 ip = (ip << 8) + ip_part2;
361 ip = (ip << 8) + ip_part3;
362 ip = (ip << 8) + ip_part4;
363 }
364 }
|
365 dave.sudlik 1.52 memcpy(dst, &ip, sizeof (Uint32));
|
366 carolann.graves 1.29
367 return true;
|
368 dave.sudlik 1.52 #endif
|
369 carolann.graves 1.29 }
370
|
371 kumpf 1.44 Boolean System::resolveHostNameAtDNS(
372 const char* hostname,
373 Uint32* resolvedNameIP)
|
374 marek 1.43 {
|
375 dmitry.mikulin 1.59 struct hostent* hostEntry;
376
|
377 marek 1.43 // ask the DNS for hostname resolution to IP address
378 // this can mean a time delay for as long as the DNS
|
379 kumpf 1.44 // takes to answer
380 char hostEntryBuffer[8192];
381 struct hostent hostEntryStruct;
|
382 dmitry.mikulin 1.59 hostEntry = getHostByName(hostname, &hostEntryStruct,
383 hostEntryBuffer, sizeof (hostEntryBuffer));
|
384 marek 1.43
385 if (hostEntry == 0)
386 {
387 // error, couldn't resolve the hostname to an ip address
388 return false;
|
389 kumpf 1.44 }
390 else
|
391 marek 1.43 {
392 unsigned char ip_part1,ip_part2,ip_part3,ip_part4;
393 ip_part1 = hostEntry->h_addr[0];
394 ip_part2 = hostEntry->h_addr[1];
395 ip_part3 = hostEntry->h_addr[2];
396 ip_part4 = hostEntry->h_addr[3];
397 *resolvedNameIP = ip_part1;
398 *resolvedNameIP = (*resolvedNameIP << 8) + ip_part2;
399 *resolvedNameIP = (*resolvedNameIP << 8) + ip_part3;
400 *resolvedNameIP = (*resolvedNameIP << 8) + ip_part4;
401 }
402 return true;
403 }
404
405 Boolean System::resolveIPAtDNS(Uint32 ip_addr, Uint32 * resolvedIP)
406 {
|
407 kumpf 1.44 struct hostent *entry;
|
408 marek 1.43
|
409 dmitry.mikulin 1.59 entry = getHostByAddr((const char *) &ip_addr, sizeof(ip_addr), AF_INET);
|
410 ouyang.jian 1.51
|
411 kumpf 1.44 if (entry == 0)
412 {
413 // error, couldn't resolve the ip
414 return false;
415 }
416 else
417 {
418 unsigned char ip_part1,ip_part2,ip_part3,ip_part4;
419 ip_part1 = entry->h_addr[0];
420 ip_part2 = entry->h_addr[1];
421 ip_part3 = entry->h_addr[2];
422 ip_part4 = entry->h_addr[3];
423 *resolvedIP = ip_part1;
424 *resolvedIP = (*resolvedIP << 8) + ip_part2;
425 *resolvedIP = (*resolvedIP << 8) + ip_part3;
426 *resolvedIP = (*resolvedIP << 8) + ip_part4;
427 }
428 return true;
|
429 marek 1.43 }
430
431
|
432 dave.sudlik 1.52 Boolean System::isLoopBack(int af, void *binIPAddress)
433 {
434 #ifdef PEGASUS_ENABLE_IPV6
435 struct in6_addr ip6 = PEGASUS_IPV6_LOOPBACK_INIT;
436 #endif
437 Uint32 ip4 = PEGASUS_IPV4_LOOPBACK_INIT;
438 switch (af)
439 {
440 #ifdef PEGASUS_ENABLE_IPV6
441 case AF_INET6:
442 return !memcmp(&ip6, binIPAddress, sizeof (ip6));
443 #endif
444 case AF_INET:
445 Uint32 n = ntohl( *(Uint32*)binIPAddress);
446 return !memcmp(&ip4, &n, sizeof (ip4));
447 }
448
449 return false;
450 }
451
|
452 marek 1.43 Boolean System::isLocalHost(const String &hostName)
453 {
|
454 dave.sudlik 1.52 // Get all ip addresses on the node and compare them with the given hostname.
455 #ifdef PEGASUS_ENABLE_IPV6
456 CString csName = hostName.getCString();
|
457 dave.sudlik 1.53 struct addrinfo hints, *res1, *res2, *res1root, *res2root;
|
458 dave.sudlik 1.52 char localHostName[PEGASUS_MAXHOSTNAMELEN];
459 gethostname(localHostName, PEGASUS_MAXHOSTNAMELEN);
460 Boolean isLocal = false;
461
462 memset(&hints, 0, sizeof(hints));
463 hints.ai_family = AF_INET;
464 hints.ai_socktype = SOCK_STREAM;
465 hints.ai_protocol = IPPROTO_TCP;
|
466 dave.sudlik 1.53 res1root = res2root = 0;
|
467 dmitry.mikulin 1.59 getAddrInfo(csName, 0, &hints, &res1root);
468 getAddrInfo(localHostName, 0, &hints, &res2root);
|
469 dave.sudlik 1.52
|
470 dave.sudlik 1.53 res1 = res1root;
|
471 dave.sudlik 1.52 while (res1 && !isLocal)
472 {
473 if (isLoopBack(AF_INET,
|
474 kumpf 1.54 &(reinterpret_cast<struct sockaddr_in*>(res1->ai_addr))->sin_addr))
|
475 dave.sudlik 1.52 {
476 isLocal = true;
477 break;
478 }
479
|
480 dave.sudlik 1.53 res2 = res2root;
481 while (res2)
|
482 dave.sudlik 1.52 {
|
483 kumpf 1.54 if (!memcmp(
484 &(reinterpret_cast<struct sockaddr_in*>(res1->ai_addr))->
485 sin_addr,
486 &(reinterpret_cast<struct sockaddr_in*>(res2->ai_addr))->
487 sin_addr,
488 sizeof (struct in_addr)))
|
489 dave.sudlik 1.52 {
490 isLocal = true;
491 break;
492 }
|
493 dave.sudlik 1.53 res2 = res2->ai_next;
|
494 dave.sudlik 1.52 }
495 res1 = res1->ai_next;
496 }
|
497 dave.sudlik 1.53 freeaddrinfo(res1root);
498 freeaddrinfo(res2root);
|
499 dave.sudlik 1.52 if (isLocal)
500 {
501 return true;
502 }
503
504 hints.ai_family = AF_INET6;
|
505 dave.sudlik 1.53 res1root = res2root = 0;
|
506 dmitry.mikulin 1.59 getAddrInfo(csName, 0, &hints, &res1root);
507 getAddrInfo(localHostName, 0, &hints, &res2root);
|
508 dave.sudlik 1.53
509 res1 = res1root;
|
510 dave.sudlik 1.52 while (res1 && !isLocal)
511 {
|
512 kumpf 1.54 if (isLoopBack(
513 AF_INET6,
514 &(reinterpret_cast<struct sockaddr_in6*>(res1->ai_addr))->
515 sin6_addr))
|
516 dave.sudlik 1.52 {
517 isLocal = true;
518 break;
519 }
520
|
521 dave.sudlik 1.53 res2 = res2root;
522 while (res2)
|
523 dave.sudlik 1.52 {
|
524 kumpf 1.54 if (!memcmp(
525 &(reinterpret_cast<struct sockaddr_in6*>(res1->ai_addr))->
526 sin6_addr,
527 &(reinterpret_cast<struct sockaddr_in6*>(res2->ai_addr))->
528 sin6_addr,
529 sizeof (struct in6_addr)))
|
530 dave.sudlik 1.52 {
531 isLocal = true;
532 break;
533 }
|
534 dave.sudlik 1.53 res2 = res2->ai_next;
|
535 dave.sudlik 1.52 }
536 res1 = res1->ai_next;
537 }
|
538 dave.sudlik 1.53 freeaddrinfo(res1root);
539 freeaddrinfo(res2root);
|
540 dave.sudlik 1.52
541 return isLocal;
542 #else
543
|
544 marek 1.43 // differentiate between a dotted IP address given
545 // and a real hostname given
546 CString csName = hostName.getCString();
|
547 marek 1.46 char cc_hostname[PEGASUS_MAXHOSTNAMELEN];
548 strcpy(cc_hostname, (const char*) csName);
|
549 marek 1.43 Uint32 tmp_addr = 0xFFFFFFFF;
550 Boolean hostNameIsIPNotation;
551
552 // Note: Platforms already supporting the inet_aton()
553 // should define their platform here,
554 // as this is the superior way to work
|
555 kumpf 1.54 #if defined(PEGASUS_OS_LINUX) || \
556 defined(PEGASUS_OS_AIX) || \
|
557 ouyang.jian 1.55 defined(PEGASUS_OS_HPUX) || \
|
558 carson.hovey 1.60 defined(PEGASUS_OS_PASE) || \
559 defined(PEGASUS_OS_VMS)
|
560 kumpf 1.44
|
561 marek 1.43 struct in_addr inaddr;
562 // if inet_aton failed(return=0),
563 // we do not have a valip IP address (x.x.x.x)
564 int atonSuccess = inet_aton(cc_hostname, &inaddr);
565 if (atonSuccess == 0) hostNameIsIPNotation = false;
566 else
567 {
568 hostNameIsIPNotation = true;
569 tmp_addr = inaddr.s_addr;
570 }
571 #else
572 // Note: 0xFFFFFFFF is actually a valid IP address (255.255.255.255).
573 // A better solution would be to use inet_aton() or equivalent, as
574 // inet_addr() is now considered "obsolete".
575 // Note: inet_aton() not yet supported on all Pegasus platforms
|
576 kumpf 1.44 tmp_addr = inet_addr((char *) cc_hostname);
|
577 marek 1.43 if (tmp_addr == 0xFFFFFFFF) hostNameIsIPNotation = false;
578 else hostNameIsIPNotation = true;
579 #endif
|
580 kumpf 1.44
|
581 marek 1.43 if (!hostNameIsIPNotation) // if hostname is not an IP address
|
582 kumpf 1.44 {
|
583 marek 1.43 // localhost ?
584 if (String::equalNoCase(hostName,String("localhost"))) return true;
|
585 marek 1.46 char localHostName[PEGASUS_MAXHOSTNAMELEN];
|
586 marek 1.47 CString cstringLocalHostName = System::getHostName().getCString();
|
587 marek 1.46 strcpy(localHostName, (const char*) cstringLocalHostName);
|
588 marek 1.43 // given hostname equals what system returns as local hostname ?
589 if (String::equalNoCase(hostName,localHostName)) return true;
590 Uint32 hostIP;
591 // bail out if hostname unresolveable
592 if (!System::resolveHostNameAtDNS(cc_hostname, &hostIP)) return false;
593 // lets see if the IP is defined on one of the network interfaces
594 // this can help us avoid another call to DNS
595 if (System::isIpOnNetworkInterface(hostIP)) return true;
596 // need to check if the local hosts name is possibly
597 // registered at the DNS with the IP address equal resolvedNameIP
598 Uint32 localHostIP;
|
599 kumpf 1.44 if (!System::resolveHostNameAtDNS(localHostName, &localHostIP))
600 return false;
|
601 marek 1.43 if (localHostIP == hostIP) return true;
|
602 kumpf 1.44 }
603 else
|
604 marek 1.43 { // hostname is an IP address
605 // 127.0.0.1 is always the loopback
606 // inet_addr returns network byte order
607 if (tmp_addr == htonl(0x7F000001)) return true;
608 // IP defined on a local AF_INET network interface
609 if (System::isIpOnNetworkInterface(tmp_addr)) return true;
610 // out of luck so far, lets ask the DNS what our IP is
611 // and check against what we got
612 Uint32 localHostIP;
|
613 kumpf 1.44 if (!System::resolveHostNameAtDNS(
614 (const char*) System::getHostName().getCString(), &localHostIP))
615 return false;
|
616 marek 1.43 if (localHostIP == tmp_addr) return true;
617 // not yet, sometimes resolving the IP address we got against the DNS
618 // can solve the problem
|
619 kumpf 1.44 // casting to (const char *) as (char *) will work as (void *) too,
620 // those it fits all platforms
|
621 marek 1.43 Uint32 hostIP;
622 if (!System::resolveIPAtDNS(tmp_addr, &hostIP)) return false;
623 if (hostIP == localHostIP) return true;
624 }
625 return false;
|
626 dave.sudlik 1.52 #endif
|
627 marek 1.43 }
628
|
629 dmitry.mikulin 1.59 struct hostent* System::getHostByName(
630 const char* name,
631 struct hostent* he,
632 char* buf,
633 size_t len)
634 {
635 int hostEntryErrno = 0;
636 struct hostent* hostEntry = 0;
637 unsigned int maxTries = 5;
638
639 do
640 {
641 #if defined(PEGASUS_OS_LINUX)
642 gethostbyname_r(name,
643 he,
644 buf,
645 len,
646 &hostEntry,
647 &hostEntryErrno);
648 #elif defined(PEGASUS_OS_SOLARIS)
649 hostEntry = gethostbyname_r((char *)name,
650 dmitry.mikulin 1.59 he,
651 buf,
652 len,
653 &hostEntryErrno);
654 #elif defined(PEGASUS_OS_ZOS)
655 char hostName[PEGASUS_MAXHOSTNAMELEN + 1];
656 if (String::equalNoCase("localhost", String(name)))
657 {
658 gethostname(hostName, PEGASUS_MAXHOSTNAMELEN);
659 hostName[sizeof(hostName) - 1] = 0;
660 hostEntry = gethostbyname(hostName);
661 }
662 else
663 {
664 hostEntry = gethostbyname((char *)name);
665 }
666 hostEntryErrno = h_errno;
667 #else
668 hostEntry = gethostbyname((char *)name);
669 hostEntryErrno = h_errno;
670 #endif
671 dmitry.mikulin 1.59 } while (hostEntry == 0 && hostEntryErrno == TRY_AGAIN &&
672 maxTries-- > 0);
673
674 return hostEntry;
675 }
676
677 struct hostent* System::getHostByAddr(
678 const char *addr,
679 int len,
680 int type,
681 struct hostent* he,
682 char* buf,
683 size_t buflen)
684 {
685 int hostEntryErrno = 0;
686 struct hostent* hostEntry = 0;
687 unsigned int maxTries = 5;
688
689 do
690 {
691 #if defined(PEGASUS_OS_LINUX)
692 dmitry.mikulin 1.59 gethostbyaddr_r(addr,
693 len,
694 type,
695 he,
696 buf,
697 buflen,
698 &hostEntry,
699 &hostEntryErrno);
700 #elif defined(PEGASUS_OS_SOLARIS)
701 char hostEntryBuffer[8192];
702 struct hostent hostEntryStruct;
703
704 hostEntry = gethostbyaddr_r(addr,
705 len,
706 type,
707 he,
708 buf,
709 buflen,
710 &hostEntryErrno);
711 #else
712 hostEntry = gethostbyaddr(addr,
713 dmitry.mikulin 1.59 len,
714 type);
715 hostEntryErrno = h_errno;
716 #endif
717 } while (hostEntry == 0 && hostEntryErrno == TRY_AGAIN &&
718 maxTries-- > 0);
719
720 return hostEntry;
721 }
722
|
723 dmitry.mikulin 1.61 #if defined(PEGASUS_OS_ZOS) || \
724 defined(PEGASUS_OS_VMS) || \
725 defined(PEGASUS_ENABLE_IPV6)
726
|
727 dmitry.mikulin 1.59 int System::getAddrInfo(
728 const char *hostname,
729 const char *servname,
730 const struct addrinfo *hints,
731 struct addrinfo **res)
732 {
733 int rc = 0;
734 unsigned int maxTries = 5;
735
736 while ((rc = getaddrinfo(hostname,
737 servname,
738 hints,
739 res)) == EAI_AGAIN &&
740 maxTries-- > 0)
741 ;
742 return rc;
743 }
744
745 int System::getNameInfo(
746 const struct sockaddr *sa,
747 size_t salen,
748 dmitry.mikulin 1.59 char *host,
749 size_t hostlen,
750 char *serv,
751 size_t servlen,
752 int flags)
753 {
754 int rc = 0;
755 unsigned int maxTries = 5;
756
757 while ((rc = getnameinfo(sa,
758 salen,
759 host,
760 hostlen,
761 serv,
762 servlen,
763 flags)) == EAI_AGAIN &&
764 maxTries-- > 0)
765 ;
766 return rc;
767 }
768
|
769 dmitry.mikulin 1.61 #endif
|
770 dmitry.mikulin 1.59
|
771 tony 1.17 // System ID constants for Logger::put and Logger::trace
772 const String System::CIMLISTENER = "cimlistener"; // Listener systme ID
773
|
774 mike 1.8 PEGASUS_NAMESPACE_END
|
Return to
System.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common