pegasus/src/Pegasus/Common/SystemWindows.cpp - diff

Return to SystemWindows.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/SystemWindows.cpp between version 1.40 and 1.85

version 1.40, 2004/07/19 08:46:23

version 1.85, 2008/12/01 17:49:57

Line 1

//%2003////////////////////////////////////////////////////////////////////////

//%LICENSE////////////////////////////////////////////////////////////////

// Licensed to The Open Group (TOG) under one or more contributor license

// Company, L. P., IBM Corp., The Open Group, Tivoli Systems.

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

// this work for additional information regarding copyright ownership.

// IBM Corp.; EMC Corporation, The Open Group.

// Each contributor licenses this file to you under the OpenPegasus Open

// Source License; you may not use this file except in compliance with the

// Permission is hereby granted, free of charge, to any person obtaining a copy

// License.

// of this software and associated documentation files (the "Software"), to

// deal in the Software without restriction, including without limitation the

// Permission is hereby granted, free of charge, to any person obtaining a

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// copy of this software and associated documentation files (the "Software"),

// sell copies of the Software, and to permit persons to whom the Software is

// to deal in the Software without restriction, including without limitation

// furnished to do so, subject to the following conditions:

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// and/or sell copies of the Software, and to permit persons to whom the

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// Software is furnished to do so, subject to the following conditions:

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// The above copyright notice and this permission notice shall be included

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// in all copies or substantial portions of the Software.

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

//==============================================================================

// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

// Author: Mike Brasher (mbrasher@bmc.com)

// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// Modified By: Sushma Fernandes (sushma_fernandes@hp.com)

//////////////////////////////////////////////////////////////////////////

// Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)

// Bapu Patil (bapu_patil@hp.com)

// Modified By: Dave Rosckes (rosckes@us.ibm.com)

// Terry Martin, Hewlett-Packard Company (terry.martin@hp.com)

// Amit K Arora, IBM (amita@in.ibm.com) for Bug#1428

//%/////////////////////////////////////////////////////////////////////////////

#include "System.h"

#include <windows.h>

#include "Network.h"

#ifndef _WINSOCKAPI_

#include "Mutex.h"

#include <winsock2.h>

#endif

#include <fcntl.h>

#include <sys/types.h>

#include <time.h>

Line 52

Line 44

#include <windows.h>

#include <process.h>

#include <lm.h>

#include <Pegasus/Common/Tracer.h>

#define SECURITY_WIN32

#include <security.h>

PEGASUS_NAMESPACE_BEGIN

#define ACCESS_EXISTS 0

#define PEGASUS_ACCESS_EXISTS 0

#define ACCESS_WRITE 2

#define PEGASUS_ACCESS_WRITE 2

#define ACCESS_READ 4

#define PEGASUS_ACCESS_READ 4

#define ACCESS_READ_AND_WRITE 6

#define PEGASUS_ACCESS_READ_AND_WRITE 6

#define PW_BUFF_LEN 65

Line 75

Line 71

milliseconds = milliseconds / 1000;

}

void System::getCurrentTimeUsec(Uint32& seconds, Uint32& microseconds)

{

FILETIME ft;

GetSystemTimeAsFileTime(&ft);

ULARGE_INTEGER largeInt = { ft.dwLowDateTime, ft.dwHighDateTime };

largeInt.QuadPart -= 0x19db1ded53e8000;

seconds = long(largeInt.QuadPart / (10000 * 1000));

microseconds = long((largeInt.QuadPart % (10000 * 1000)) / 10);

}

String System::getCurrentASCIITime()

{

char tmpbuf[128];

Line 93

Line 99

Boolean System::exists(const char* path)

{

return _access(path, ACCESS_EXISTS) == 0;

return _access(path, PEGASUS_ACCESS_EXISTS) == 0;

}

Boolean System::canRead(const char* path)

{

return _access(path, ACCESS_READ) == 0;

return _access(path, PEGASUS_ACCESS_READ) == 0;

}

Boolean System::canWrite(const char* path)

{

return _access(path, ACCESS_WRITE) == 0;

return _access(path, PEGASUS_ACCESS_WRITE) == 0;

}

Boolean System::getCurrentDirectory(char* path, Uint32 size)

Line 154

Line 160

Boolean System::renameFile(const char* oldPath, const char* newPath)

{

return rename(oldPath, newPath) == 0;

if (exists(oldPath))

}

DynamicLibraryHandle System::loadDynamicLibrary(const char* fileName)

{

return DynamicLibraryHandle(LoadLibrary(fileName));

}

void System::unloadDynamicLibrary(DynamicLibraryHandle libraryHandle)

{

FreeLibrary(HINSTANCE(libraryHandle));

}

String System::dynamicLoadError(void) {

return String();

}

DynamicSymbolHandle System::loadDynamicSymbol(

DynamicLibraryHandle libraryHandle,

const char* symbolName)

{

return DynamicSymbolHandle(GetProcAddress(

(HINSTANCE)libraryHandle, symbolName));

}

String System::getHostName()

{

static char hostname[PEGASUS_MAXHOSTNAMELEN];

if (!*hostname)

gethostname(hostname, sizeof(hostname));

return hostname;

}

String System::getFullyQualifiedHostName ()

{

static char FQHostName[PEGASUS_MAXHOSTNAMELEN];

if (!*FQHostName)

{

String hostname = getHostName();

struct hostent* hostEnt;

hostEnt = gethostbyname((const char *)hostname.getCString());

if (hostEnt == NULL)

{

return String::EMPTY;

removeFile(newPath);

}

strcpy(FQHostName, hostEnt->h_name);

return rename(oldPath, newPath) == 0;

}

return FQHostName;

}

String System::getSystemCreationClassName ()

Line 223

Line 181

struct servent *serv;

// Get wbem-local port from /etc/services

// Get the port number.

if ( (serv = getservbyname(serviceName, TCP)) != NULL )

{

localPort = serv->s_port;

localPort = ntohs(serv->s_port);

}

else

{

Line 317

Line 275

String System::getEffectiveUserName()

{

#if (_MSC_VER >= 1300) || defined(PEGASUS_WINDOWS_SDK_HOME)

//Bug 3076 fix

wchar_t fullUserName[UNLEN+1];

DWORD userNameSize = sizeof(fullUserName)/sizeof(fullUserName[0]);

wchar_t computerName[MAX_COMPUTERNAME_LENGTH+1];

DWORD computerNameSize = sizeof(computerName)/sizeof(computerName[0]);

wchar_t userName[UNLEN+1];

wchar_t userDomain[UNLEN+1];

String userId;

if (!GetUserNameExW(NameSamCompatible, fullUserName, &userNameSize))

{

return String();

}

wchar_t* index = wcschr(fullUserName, '\\');

*index = 0;

wcscpy(userDomain, fullUserName);

wcscpy(userName, index + 1);

//The above function will return the system name as the domain if

//the user is not on a real domain. Strip this out so that the rest of

//our windows user functions work. What if the system name and the domain

//name are the same?

GetComputerNameW(computerName, &computerNameSize);

if (wcscmp(computerName, userDomain) != 0)

{

//userId.append(userDomain);

Uint32 n = (Uint32)wcslen(userDomain);

for (unsigned long i = 0; i < n; i++)

{

userId.append(Char16(userDomain[i]));

}

userId.append("\\");

//userId.append(userName);

n = (Uint32)wcslen(userName);

for (unsigned long i = 0; i < n; i++)

{

userId.append(Char16(userName[i]));

}

else

{

//userId.append(userName);

Uint32 n = (Uint32)wcslen(userName);

for (unsigned long i = 0; i < n; i++)

{

userId.append(Char16(userName[i]));

}

return userId;

#else //original getEffectiveUserName function

int retcode = 0;

// UNLEN (256) is the limit, not including null

char pUserName[256+1] = {0};

wchar_t pUserName[256+1] = {0};

DWORD nSize = sizeof(pUserName);

DWORD nSize = sizeof(pUserName)/sizeof(pUserName[0]);

retcode = GetUserName(pUserName, &nSize);

retcode = GetUserNameW(pUserName, &nSize);

if (retcode == 0)

{

// zero is failure

return String();

}

String userId;

Uint32 n = wcslen(pUserName);

for (unsigned long i = 0; i < n; i++)

{

userId.append(Char16(pUserName[i]));

}

return String(pUserName);

return userId;

#endif

}

String System::encryptPassword(const char* password, const char* salt)

Line 340

Line 364

char pcSalt[3] = {0};

strncpy(pcSalt, salt, 2);

dwByteCount = strlen(password);

dwByteCount = (DWORD)strlen(password);

memcpy(pbBuffer, password, dwByteCount);

for (DWORD i=0; (i<dwByteCount) || (i>=PW_BUFF_LEN); i++)

(i%2 == 0) ? pbBuffer[i] ^= pcSalt[1] : pbBuffer[i] ^= pcSalt[0];

Line 348

Line 372

return String(pcSalt) + String((char *)pbBuffer);

}

String processUserName;

Mutex processUserNameMut;

Boolean System::isSystemUser(const char* userName)

{

//ATTN: Implement this method to verify if user is vaild on the local system

if (processUserName.size() == 0)

// This is used in User Manager

{

// Lock and recheck the processUserName length in case two threads

// enter this block simultaneously

AutoMutex mut(processUserNameMut);

if (processUserName.size() == 0)

{

processUserName = getEffectiveUserName();

}

if (processUserName == userName)

{

return true;

}

Boolean System::isPrivilegedUser(const String userName)

Boolean isSystemUser = false;

char mUserName[UNLEN+1];

char mDomainName[UNLEN+1];

char tUserName[UNLEN+1];

wchar_t wUserName[UNLEN+1];

wchar_t wDomainName[UNLEN+1];

char* pbs;

bool usingDomain = false;

LPBYTE pComputerName=NULL;

DWORD dwLevel = 1;

LPUSER_INFO_1 pUserInfo = NULL;

NET_API_STATUS nStatus = NULL;

// Make a copy of the specified username, it cannot be used directly

// because it's declared as const and strchr() may modify the string.

strncpy(tUserName, userName, sizeof(tUserName) - 1);

tUserName[sizeof(tUserName)- 1] = '\0';

//separate the domain and user name if both are present.

if (NULL != (pbs = strchr(tUserName, '\\')))

{

*pbs = '\0';

strcpy(mDomainName, tUserName);

strcpy(mUserName, pbs+1);

usingDomain = true;

}

else if ((NULL != (pbs = (strchr(tUserName, '@')))) ||

(NULL != (pbs = (strchr(tUserName, '.')))))

{

*pbs = '\0';

strcpy(mDomainName, pbs+1);

strcpy(mUserName, tUserName);

usingDomain = true;

}

else

{

// ATTN: Implement this method to verify if user executing the current

strcpy(mDomainName, ".");

// command is a priviliged user, when user name is not passed as

strcpy(mUserName, tUserName);

// as argument. If user name is passed the function checks

}

// whether the given user is a priviliged user.

// This is used in cimuser CLI and CIMOperationRequestAuthorizer

//convert domain name to unicode

return true;

if (!MultiByteToWideChar(

CP_ACP, 0, mDomainName, -1, wDomainName,

(int)(strlen(mDomainName) + 1)))

{

return false;

}

//convert username to unicode

if (!MultiByteToWideChar(

CP_ACP, 0, mUserName, -1, wUserName, (int)(strlen(mUserName) + 1)))

{

return false;

}

if (usingDomain)

{

//get domain controller

DWORD rc = NetGetDCName(NULL, wDomainName, &pComputerName);

if (rc == NERR_Success)

{

// this is automatically prefixed with "\\"

wcscpy(wDomainName, (LPWSTR) pComputerName);

}

else

{

// failover

// ATTN: This is commented out until there is resolution on

// Bugzilla 2236. -hns 2/2005

// This needs to be more thoroughly tested when we uncomment it out.

PDOMAIN_CONTROLLER_INFO DomainControllerInfo = NULL;

//this function does not take wide strings

rc = DsGetDcName(NULL,

mDomainName,

NULL,

//not sure what flags we want here

DS_DIRECTORY_SERVICE_REQUIRED,

&DomainControllerInfo);

if (rc == ERROR_SUCCESS && DomainControllerInfo)

{

strcpy(mDomainName, DomainControllerInfo->DomainName);

NetApiBufferFree(DomainControllerInfo);

if (!MultiByteToWideChar(

CP_ACP, 0, mDomainName, -1, wDomainName,

strlen(mDomainName) + 1))

{

return false;

}

//get user info

nStatus = NetUserGetInfo(wDomainName,

wUserName,

dwLevel,

(LPBYTE *)&pUserInfo);

if (nStatus == NERR_Success)

{

isSystemUser = true;

}

if (pComputerName != NULL)

{

NetApiBufferFree(pComputerName);

}

if (pUserInfo != NULL)

{

NetApiBufferFree(pUserInfo);

}

return isSystemUser;

}

Boolean System::isPrivilegedUser(const String& userName)

{

Boolean isPrivileged = false;

char mUserName[UNLEN+1];

char mDomainName[UNLEN+1];

wchar_t wUserName[UNLEN+1];

wchar_t wDomainName[UNLEN+1];

char* pbs;

char userStr[UNLEN+1];

bool usingDomain = false;

LPBYTE pComputerName=NULL;

DWORD dwLevel = 1;

LPUSER_INFO_1 pUserInfo = NULL;

NET_API_STATUS nStatus = NULL;

//get the username in the correct format

strcpy(userStr, (const char*)userName.getCString());

//separate the domain and user name if both are present.

if (NULL != (pbs = strchr(userStr, '\\')))

{

*pbs = '\0';

strcpy(mDomainName, userStr);

strcpy(mUserName, pbs+1);

usingDomain = true;

}

else if ((NULL != (pbs = (strchr(userStr, '@')))) ||

(NULL != (pbs = (strchr(userStr, '.')))))

{

*pbs = '\0';

strcpy(mDomainName, pbs+1);

strcpy(mUserName, userStr);

usingDomain = true;

}

else

{

strcpy(mDomainName, ".");

strcpy(mUserName, userStr);

}

//convert domain name to unicode

if (!MultiByteToWideChar(

CP_ACP, 0, mDomainName, -1, wDomainName,

(int)(strlen(mDomainName) + 1)))

{

return false;

}

//convert username to unicode

if (!MultiByteToWideChar(

CP_ACP, 0, mUserName, -1, wUserName, (int)(strlen(mUserName) + 1)))

{

return false;

}

if (usingDomain)

{

//get domain controller

DWORD rc = NetGetDCName(NULL, wDomainName, &pComputerName);

if (rc == NERR_Success)

{

// this is automatically prefixed with "\\"

wcscpy(wDomainName, (LPWSTR) pComputerName);

}

else

{

// failover

// ATTN: This is commented out until there is resolution on

// Bugzilla 2236. -hns 2/2005

// This needs to be more thoroughly tested when we uncomment it out.

PDOMAIN_CONTROLLER_INFO DomainControllerInfo = NULL;

//this function does not take wide strings

rc = DsGetDcName(NULL,

mDomainName,

NULL,

// not sure what flags we want here

DS_DIRECTORY_SERVICE_REQUIRED,

&DomainControllerInfo);

if (rc == ERROR_SUCCESS && DomainControllerInfo)

{

strcpy(mDomainName, DomainControllerInfo->DomainName);

NetApiBufferFree(DomainControllerInfo);

if (!MultiByteToWideChar(

CP_ACP, 0, mDomainName, -1, wDomainName,

strlen(mDomainName) + 1))

{

return false;

}

//get privileges

nStatus = NetUserGetInfo(wDomainName,

wUserName,

dwLevel,

(LPBYTE *)&pUserInfo);

if ((nStatus == NERR_Success) &&

(pUserInfo != NULL) &&

(pUserInfo->usri1_priv == USER_PRIV_ADMIN))

{

isPrivileged = true;

}

if (pComputerName != NULL)

{

NetApiBufferFree(pComputerName);

}

if (pUserInfo != NULL)

{

NetApiBufferFree(pUserInfo);

}

return isPrivileged;

}

String System::getPrivilegedUserName()

Line 370

Line 654

// ATTN-NB-03-20000304: Implement better way to get the privileged

// user on the system.

return (String("Administrator"));

return String("Administrator");

}

Boolean System::isGroupMember(const char* userName, const char* groupName)

Line 384

Line 668

DWORD dwEntriesRead = 0;

DWORD dwTotalEntries = 0;

NET_API_STATUS nStatus;

wchar_t wcUserName[UNLEN+1];

wchar_t wcGroupName[UNLEN+1];

//Convert user name to unicode

if (!MultiByteToWideChar(CP_ACP,0,userName, -1, wcUserName,

strlen(userName)+1))

{

return false;

}

//Convert group name to unicode

if (!MultiByteToWideChar(CP_ACP, 0, groupName, -1, wcGroupName,

strlen(groupName)+1))

{

return false;

}

// Call the NetUserGetLocalGroups function

Line 394

Line 693

// function should also return the names of the local

// groups in which the user is indirectly a member.

nStatus = NetUserGetLocalGroups(NULL,

nStatus = NetUserGetLocalGroups(

(LPCWSTR)userName,

NULL,

(LPCWSTR)wcUserName,

dwLevel,

dwFlags,

(LPBYTE *) &pBuf,

Line 423

Line 723

// Compare the user's group name to groupName.

if ( strcmp ((char *)pTmpBuf->lgrui0_name, groupName) == 0 )

if (wcscmp(pTmpBuf->lgrui0_name, wcGroupName) == 0)

{

// User is a member of the group.

retVal = true;

Line 457

Line 758

// Call the NetUserGetGroups function, specifying level 0.

nStatus = NetUserGetGroups(NULL,

nStatus = NetUserGetGroups(

(LPCWSTR)userName,

NULL,

(LPCWSTR)wcUserName,

dwLevel,

(LPBYTE*)&pBuf,

dwPrefMaxLen,

&dwEntriesRead,

&dwTotalEntries);

// If the call succeeds,

Line 484

Line 787

// Compare the user's group name to groupName.

if ( strcmp ((char *)pTmpBuf->grui0_name, groupName) == 0 )

if (wcscmp(pTmpBuf->grui0_name, wcGroupName) == 0)

{

// User is a member of the group.

retVal = true;

Line 507

Line 810

return retVal;

}

Boolean System::lookupUserId(

const char* userName,

PEGASUS_UID_T& uid,

PEGASUS_GID_T& gid)

{

// ATTN: Implement this method to look up the specified user

return false;

}

Boolean System::changeUserContext_SingleThreaded(

const char* userName,

const PEGASUS_UID_T& uid,

const PEGASUS_GID_T& gid)

{

// ATTN: Implement this method to change the process user context to the

// specified user

return false;

}

Uint32 System::getPID()

{

return _getpid();

Line 516

Line 838

const char* path,

size_t newSize)

{

int fd = open(path, O_RDWR);

if (fd == -1)

Boolean rv = false;

return false;

int fd = open(path, O_RDWR);

if (fd != -1)

if (chsize(fd, newSize) != 0)

{

return false;

if (chsize(fd, (long)newSize) == 0)

{

rv = true;

}

close(fd);

return true;

}

return rv;

}

// Is absolute path?

Line 539

Line 865

path_slash[_MAX_PATH-1] = '\0';

for(p = path_slash; p < path_slash + strlen(path_slash); p++)

if (*p == '/') *p = '\\';

if (*p == '/')

*p = '\\';

return (strcasecmp(_fullpath( full, path_slash, _MAX_PATH ), path_slash) == 0) ? true : false;

return (strcasecmp(

_fullpath(full, path_slash, _MAX_PATH), path_slash) == 0);

}

// Changes file permissions on the given file.

Line 551

Line 879

return true;

}

void System::openlog(const String ident)

Boolean System::verifyFileOwnership(const char* path)

{

return;

// ATTN: Implement this to check that the owner of the specified file is

// the same as the effective user for this process.

return true;

}

void System::syslog(Uint32 severity, const char *data)

void System::syslog(const String& ident, Uint32 severity, const char* message)

{

return;

// Not implemented

}

void System::openlog(const char *ident, int logopt, int facility)

{

// Not implemented

}

void System::closelog()

{

return;

// Not implemented

}

// System ID constants for Logger::put and Logger::trace

const String System::CIMSERVER = "cimserver"; // Server system ID

// check if a given IP address is defined on the local network interfaces

Boolean System::isIpOnNetworkInterface(Uint32 inIP)

{

SOCKET sock;

int interfaces = 0;

int errcode;

if ( SOCKET_ERROR != ( sock = WSASocket(AF_INET,

SOCK_RAW, 0, NULL, 0, 0) ) )

{

unsigned long *bytes_returned=0;

char *output_buf = (char *)calloc(1, 256);

int buf_size = 256;

if ( 0 == (errcode = WSAIoctl(sock,

SIO_ADDRESS_LIST_QUERY,

NULL,

output_buf,

256,

bytes_returned,

NULL,

NULL)) )

{

SOCKET_ADDRESS_LIST *addr_list;

SOCKET_ADDRESS *addr;

Uint32 ip;

struct sockaddr_in *sin;

addr_list = (SOCKET_ADDRESS_LIST *)output_buf;

addr = addr_list->Address;

sin = (struct sockaddr_in *)addr->lpSockaddr;

for ( ; interfaces < addr_list->iAddressCount; interfaces++)

{

ip = sin->sin_addr.s_addr;

addr++;

sin = (struct sockaddr_in *)addr->lpSockaddr;

if (ip == inIP)

{

free(output_buf);

closesocket(sock);

return true;

}

else

{

free(output_buf);

return false;

}

free(output_buf);

closesocket(sock);

}

return false;

}

#ifdef PEGASUS_ENABLE_IPV6

void _getInterfaceAddrs(Array<String> &ips, int af)

{

SOCKET sock;

if (INVALID_SOCKET != (sock = WSASocket(af, SOCK_RAW,

0, NULL, 0, 0)))

{

DWORD bytesReturned;

char buf[2048];

int interfaces = 0;

char str[PEGASUS_INET6_ADDRSTR_LEN];

void *p;

if (0 == WSAIoctl(sock, SIO_ADDRESS_LIST_QUERY, NULL, 0,

buf, 2048, &bytesReturned, NULL,

NULL))

{

SOCKET_ADDRESS_LIST *addr_list;

SOCKET_ADDRESS *addr;

struct sockaddr *sin;

addr_list = (SOCKET_ADDRESS_LIST *)buf;

addr = addr_list->Address;

for (sin = (struct sockaddr *) addr->lpSockaddr ;

interfaces < addr_list->iAddressCount;

interfaces++)

{

if (af == AF_INET)

{

p = &((struct sockaddr_in*)sin)->sin_addr;

}

else

{

p = &((struct sockaddr_in6*)sin)->sin6_addr;

}

// Don't gather loopback addrs

if (!System::isLoopBack(af, p))

{

HostAddress::convertBinaryToText(af, p, str, sizeof(str));

ips.append(str);

}

addr++;

sin = (struct sockaddr*)addr->lpSockaddr;

}

#endif

Array<String> System::getInterfaceAddrs()

{

Array<String> ips;

#ifdef PEGASUS_ENABLE_IPV6

_getInterfaceAddrs(ips, AF_INET);

_getInterfaceAddrs(ips, AF_INET6);

#endif

return ips;

}

String System::getErrorMSG_NLS(int errorCode,int errorCode2)

{

LPVOID winErrorMsg = NULL;

if (FormatMessage(

FORMAT_MESSAGE_ALLOCATE_BUFFER |

FORMAT_MESSAGE_FROM_SYSTEM |

FORMAT_MESSAGE_IGNORE_INSERTS,

NULL,

errorCode,

MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

(LPTSTR)&winErrorMsg,

NULL))

{

MessageLoaderParms parms(

"Common.System.ERROR_MESSAGE.STANDARD",

"$0 (error code $1)",(char*)winErrorMsg,errorCode);

LocalFree(winErrorMsg);

return MessageLoader::getMessage(parms);

}

MessageLoaderParms parms(

"Common.System.ERROR_MESSAGE.STANDARD",

"$0 (error code $1)","",errorCode);

return MessageLoader::getMessage(parms);

}

String System::getErrorMSG(int errorCode,int errorCode2)

{

String buffer;

LPVOID winErrorMsg = NULL;

char strErrorCode[32];

sprintf(strErrorCode, "%d", errorCode);

if (FormatMessage(

FORMAT_MESSAGE_ALLOCATE_BUFFER |

FORMAT_MESSAGE_FROM_SYSTEM |

FORMAT_MESSAGE_IGNORE_INSERTS,

NULL,

errorCode,

MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

(LPTSTR)&winErrorMsg,

NULL))

{

buffer.append((char*)winErrorMsg);

LocalFree(winErrorMsg);

}

buffer.append(" (error code ");

buffer.append(strErrorCode);

buffer.append(")");

return buffer;

}

///////////////////////////////////////////////////////////////////////////////

// AutoFileLock class

///////////////////////////////////////////////////////////////////////////////

AutoFileLock::AutoFileLock(const char* fileName)

{

// Repeat createFile, if there is a sharing violation.

{

_hFile = CreateFile (fileName, GENERIC_READ | GENERIC_WRITE, 0, NULL,

OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

}while ((GetLastError() == ERROR_SHARING_VIOLATION));

// If this conditon succeeds, There is an error opening the file. Hence

// returning from here as Lock can not be acquired.

if((_hFile == INVALID_HANDLE_VALUE)

&& (GetLastError() != ERROR_ALREADY_EXISTS)

&& (GetLastError() != ERROR_SUCCESS))

{

PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL1,

"AutoFileLock: Failed to open lock file '%s', error code %d.",

fileName, GetLastError()));

return;

}

OVERLAPPED l={0,0,0,0,0};

if(LockFileEx(_hFile,LOCKFILE_EXCLUSIVE_LOCK, 0, 0, 0, &l) == 0)

{

PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL1,

"AutoFileLock: Failed to Acquire lock on file %s, error code %d.",

fileName, GetLastError()));

CloseHandle(_hFile);

_hFile = INVALID_HANDLE_VALUE;

}

AutoFileLock::~AutoFileLock()

{

if(_hFile != INVALID_HANDLE_VALUE)

{

OVERLAPPED l={0,0,0,0,0};

if(UnlockFileEx (_hFile, 0, 0, 0, &l) == 0)

{

PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL2,

"AutoFileLock: Failed to unlock file, error code %d.",

GetLastError()));

}

CloseHandle(_hFile);

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.40
changed lines
	Added in v.1.85

No CVS admin address has been configured