static DWORD VmDnsSockPosixSetDescriptorNonBlocking( int fd ) { DWORD dwError = 0; int flags = 0; if ((flags = fcntl(fd, F_GETFL, 0)) < 0) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_POSIX_SOCK_ERROR(dwError); } flags |= O_NONBLOCK; if ((flags = fcntl(fd, F_SETFL, flags)) < 0) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_POSIX_SOCK_ERROR(dwError); } error: return dwError; }
DWORD LWNetSrvStartNetBiosThread( VOID) { DWORD dwError = 0; pthread_t thread; pthread_attr_t attrib; gpNbCtx->udpTimeout = LWNetConfigIsNetBiosUdpTimeout(); dwError = LwErrnoToWin32Error(pthread_attr_init(&attrib)); BAIL_ON_LWNET_ERROR(dwError); dwError = LwErrnoToWin32Error(pthread_attr_setdetachstate( &attrib, PTHREAD_CREATE_DETACHED)); BAIL_ON_LWNET_ERROR(dwError); dwError = LwErrnoToWin32Error(pthread_create(&thread, &attrib, LWNetSrvStartNetBiosThreadRoutine, (void *) gpNbCtx)); BAIL_ON_LWNET_ERROR(dwError); cleanup: return dwError; error: goto cleanup; }
DWORD VmwDeployWriteToFile( PCSTR pszContent, PCSTR pszDirPath, PCSTR pszFilename ) { DWORD dwError = 0; PSTR pszPath = NULL; FILE* fp = NULL; size_t nWritten = 0; size_t nToWrite = 0; if (IsNullOrEmptyString(pszContent) || IsNullOrEmptyString(pszDirPath) || IsNullOrEmptyString(pszFilename)) { dwError = ERROR_INVALID_PARAMETER; BAIL_ON_DEPLOY_ERROR(dwError); } dwError = VmwDeployAllocateStringPrintf( &pszPath, "%s/%s", pszDirPath, pszFilename); BAIL_ON_DEPLOY_ERROR(dwError); if ((fp = fopen(pszPath, "w")) == NULL) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_DEPLOY_ERROR(dwError); } nToWrite = strlen(pszContent); nWritten = fwrite(pszContent, 1, nToWrite, fp); if (nWritten != nToWrite) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_DEPLOY_ERROR(dwError); } cleanup: if (fp) { fclose(fp); } if (pszPath) { VmwDeployFreeMemory(pszPath); } return dwError; error: goto cleanup; }
DWORD VmAfdWriteDataImpl( PVM_AFD_CONNECTION pConnection, PBYTE pRequest, DWORD dwRequestSize ) { DWORD dwError = 0; DWORD dwBytesWritten = 0; DWORD dwTotalBytesWritten = 0; PBYTE pRequestCursor = pRequest; DWORD dwActualRequestSize = dwRequestSize; do { dwBytesWritten = write(pConnection->fd, (PVOID)&dwRequestSize, sizeof (DWORD)); }while (dwBytesWritten == -1 && errno == EINTR); if (dwBytesWritten < sizeof (DWORD)) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_VMAFD_ERROR (dwError); } dwBytesWritten = 0; while (dwRequestSize > 0) { DWORD dwBytesToWrite = VMAFD_IPC_PACKET_SIZE<dwRequestSize?VMAFD_IPC_PACKET_SIZE:dwRequestSize; do { dwBytesWritten = write(pConnection->fd,pRequestCursor,dwBytesToWrite); }while (dwBytesWritten == -1 && errno == EINTR); if (dwBytesWritten < 0) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_VMAFD_ERROR(dwError); } dwTotalBytesWritten += dwBytesWritten; pRequestCursor += dwBytesWritten; dwRequestSize -= dwBytesWritten; } if (dwActualRequestSize != dwTotalBytesWritten){ dwError = ERROR_IO_INCOMPLETE; BAIL_ON_VMAFD_ERROR(dwError); } cleanup: return dwError; error: goto cleanup; }
DWORD VmAfdOpenServerConnectionImpl( PVM_AFD_CONNECTION *ppConnection ) { DWORD dwError = 0; int socket_fd = -1, on = 1; struct sockaddr_un address = {0}; PVM_AFD_CONNECTION pConnection = NULL; socket_fd = socket(PF_UNIX,SOCK_STREAM, 0); if (socket_fd < 0){ dwError = LwErrnoToWin32Error(errno); BAIL_ON_VMAFD_ERROR(dwError); } if( setsockopt( socket_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) ) < 0){ dwError = LwErrnoToWin32Error(errno); BAIL_ON_VMAFD_ERROR(dwError); } unlink (SOCKET_FILE_PATH); address.sun_family = AF_UNIX; snprintf (address.sun_path, sizeof(SOCKET_FILE_PATH), SOCKET_FILE_PATH); if (bind (socket_fd, (struct sockaddr *)&address, sizeof(struct sockaddr_un)) < 0){ dwError = LwErrnoToWin32Error(errno); BAIL_ON_VMAFD_ERROR(dwError); } if (listen (socket_fd, 5) < 0){ dwError = LwErrnoToWin32Error(errno); BAIL_ON_VMAFD_ERROR(dwError); } dwError = VmAfdAllocateMemory(sizeof(VM_AFD_CONNECTION), (PVOID *)&pConnection); BAIL_ON_VMAFD_ERROR(dwError); pConnection->fd = socket_fd; *ppConnection = pConnection; cleanup: return dwError; error: if (ppConnection != NULL){ *ppConnection = NULL; } if (socket_fd >=0 ){ close (socket_fd); } VMAFD_SAFE_FREE_MEMORY (pConnection); goto cleanup; }
DWORD VmAfdOpenClientConnectionImpl( PVM_AFD_CONNECTION *ppConnection ) { DWORD dwError = 0; int socket_fd = 0; struct sockaddr_un address; PVM_AFD_CONNECTION pConnection = NULL; socket_fd = socket (PF_UNIX, SOCK_STREAM, 0); if (socket_fd < 0){ dwError = LwErrnoToWin32Error(errno); BAIL_ON_VMAFD_ERROR(dwError); } memset (&address, 0, sizeof(struct sockaddr_un)); address.sun_family = AF_UNIX; snprintf (address.sun_path, sizeof(SOCKET_FILE_PATH), SOCKET_FILE_PATH); if (connect(socket_fd, (struct sockaddr *) &address, sizeof(struct sockaddr_un)) <0) { if (errno == ENOENT || errno == ECONNREFUSED) { dwError = ERROR_CANNOT_CONNECT_VMAFD; } else if (errno == EACCES) { dwError = ERROR_ACCESS_DENIED; } else { dwError = LwErrnoToWin32Error (errno); } BAIL_ON_VMAFD_ERROR(dwError); } dwError = VmAfdAllocateMemory (sizeof(VM_AFD_CONNECTION),(PVOID *)&pConnection); BAIL_ON_VMAFD_ERROR(dwError); pConnection->fd = socket_fd; *ppConnection = pConnection; cleanup: return dwError; error: if (ppConnection != NULL){ *ppConnection = NULL; } if (socket_fd >= 0){ close (socket_fd); } VMAFD_SAFE_FREE_MEMORY(pConnection); goto cleanup; }
DWORD VmDnsSockPosixSetTimeOut( PVM_SOCKET pSocket, DWORD dwTimeOut ) { DWORD dwError = 0; BOOLEAN bLocked = FALSE; if (!pSocket) { dwError = ERROR_INVALID_PARAMETER; BAIL_ON_POSIX_SOCK_ERROR(dwError); } if (dwTimeOut) { struct timeval tv = {0}; dwError = VmDnsLockMutex(pSocket->pMutex); BAIL_ON_POSIX_SOCK_ERROR(dwError); bLocked = TRUE; tv.tv_sec = dwTimeOut; if (setsockopt(pSocket->fd, SOL_SOCKET, SO_RCVTIMEO,&tv,sizeof(tv)) < 0) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_POSIX_SOCK_ERROR(dwError); } if (setsockopt(pSocket->fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) < 0) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_POSIX_SOCK_ERROR(dwError); } } cleanup: if (bLocked) { VmDnsUnlockMutex(pSocket->pMutex); } return dwError; error: goto cleanup; }
DWORD VmAfdGenRandomImpl ( PDWORD pdwRandomNumber ) { DWORD dwError = 0; FILE *fpUrandom = NULL; DWORD dwRandomNumber = 0; DWORD dwBytesRead = 0; fpUrandom = fopen("/dev/urandom", "r"); if (!fpUrandom) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_VMAFD_ERROR (dwError); } dwBytesRead = fread( (VOID *)&dwRandomNumber, sizeof (DWORD), 1, fpUrandom ); if (dwBytesRead < sizeof (DWORD) && !feof (fpUrandom) ) { dwError = LwErrnoToWin32Error (ferror(fpUrandom)); BAIL_ON_VMAFD_ERROR (dwError); } *pdwRandomNumber = dwRandomNumber; cleanup: if (fpUrandom) { fclose(fpUrandom); } return dwError; error: *pdwRandomNumber = 0; goto cleanup; }
static DWORD VmDnsSockPosixEventQueueRearm_inlock( PVM_SOCK_EVENT_QUEUE pQueue, BOOL bOneShot, PVM_SOCKET pSocket ) { DWORD dwError = 0; struct epoll_event event = {0}; event.data.ptr = pSocket; event.events = EPOLLIN; if (bOneShot) { event.events = event.events | EPOLLONESHOT; } if (pSocket->bInEventQueue == TRUE && epoll_ctl(pQueue->epollFd, EPOLL_CTL_MOD, pSocket->fd, &event) < 0) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_POSIX_SOCK_ERROR(dwError); } error: return dwError; }
DWORD VmDnsRpcServerStartListen( VOID ) { DWORD dwError = 0; int status = 0; status = dcethread_create( &gVmdnsGlobals.pRPCServerThread, NULL, VmDnsListenRpcServer, NULL); #ifndef _WIN32 dwError = LwErrnoToWin32Error(status); #else dwError = status; #endif BAIL_ON_VMDNS_ERROR(dwError); while (!VmDnsRpcCheckServerIsActive()) { // Wait for RPC Server to come up. } error: return dwError; }
static DWORD ReadPassword( PSTR* ppszPassword ) { DWORD dwError = ERROR_SUCCESS; struct termios orig, nonecho; sigset_t sig, osig; CHAR szPassword[33] = ""; PSTR pszPassword = NULL; fprintf(stdout, "Password: "******"\n")] = '\0'; if (IsNullOrEmptyString(szPassword)) { dwError = ERROR_PASSWORD_RESTRICTION; BAIL_ON_VMAFD_ERROR(dwError); } dwError = VmAfdAllocateStringA(szPassword, &pszPassword); BAIL_ON_VMAFD_ERROR(dwError); *ppszPassword = pszPassword; cleanup: tcsetattr(0, TCSANOW, &orig); sigprocmask(SIG_SETMASK,&osig,NULL); return dwError; error: *ppszPassword = NULL; goto cleanup; }
DWORD VmwDeployGetHostname( PSTR* ppszHostname ) { DWORD dwError = 0; CHAR szHostname[HOST_NAME_MAX + 1] = ""; PSTR pszHostname = NULL; if (gethostname(szHostname, sizeof(szHostname)-1) < 0) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_DEPLOY_ERROR(dwError); } dwError = VmwDeployAllocateStringA(szHostname, &pszHostname); BAIL_ON_DEPLOY_ERROR(dwError); *ppszHostname = pszHostname; cleanup: return dwError; error: *ppszHostname = NULL; goto cleanup; }
static DWORD LwSmControlLock( VOID ) { DWORD dwError = ERROR_SUCCESS; struct flock lock = {0}; lock.l_type = F_WRLCK; lock.l_whence = SEEK_SET; lock.l_start = 0; lock.l_len = 0; lock.l_pid = getpid(); if ((gState.ControlLock = open(CONTROL_LOCK, O_WRONLY | O_CREAT | O_TRUNC, 0200)) < 0) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_ERROR(dwError); } if (fcntl(gState.ControlLock, F_SETFD, FD_CLOEXEC) < 0) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_ERROR(dwError); } if (fcntl(gState.ControlLock, F_SETLK, &lock) < 0) { switch(errno) { case EACCES: case EAGAIN: dwError = ERROR_SERVICE_ALREADY_RUNNING; break; default: dwError = LwErrnoToWin32Error(errno); break; } BAIL_ON_ERROR(dwError); } error: return dwError; }
static DWORD GetPassword( PSTR *ppszPassword ) { CHAR pszPasswordBuff[100] = {0}; PSTR pszPassword = NULL; DWORD dwError = 0; struct termios tp, save; fflush(stdout); tcgetattr(0, &tp) ; memcpy (&save, &tp, sizeof (struct termios)); save.c_lflag &= ~ECHO; /* ECHO off, other bits unchanged */ tcsetattr(0, TCSANOW, &save); if (!fgets(pszPasswordBuff, 100, stdin) && ferror(stdin)) { dwError = LwErrnoToWin32Error(ferror(stdin)); BAIL_ON_VMAFD_ERROR (dwError); } if (pszPasswordBuff[strlen(pszPasswordBuff)-1] == '\n') { pszPasswordBuff[strlen(pszPasswordBuff)-1] = '\0'; } dwError = VmAfdAllocateStringPrintf( &pszPassword, "%s", pszPasswordBuff ); BAIL_ON_VMAFD_ERROR (dwError); *ppszPassword = pszPassword; cleanup: tcsetattr(0, TCSANOW, &tp); fflush (stdin); return dwError; error: if (ppszPassword) { *ppszPassword = NULL; } VMAFD_SAFE_FREE_MEMORY (pszPassword); goto cleanup; }
static DWORD VmDnsSockPosixAcceptConnection( PVM_SOCKET pListener, PVM_SOCKET* ppSocket ) { DWORD dwError = 0; PVM_SOCKET pSocket = NULL; int fd = -1; dwError = VmDnsAllocateMemory(sizeof(*pSocket), (PVOID*)&pSocket); BAIL_ON_POSIX_SOCK_ERROR(dwError); pSocket->refCount = 1; dwError = VmDnsAllocateMutex(&pSocket->pMutex); BAIL_ON_POSIX_SOCK_ERROR(dwError); pSocket->protocol = pListener->protocol; pSocket->type = VM_SOCK_TYPE_SERVER; fd = accept(pListener->fd, &pSocket->addr, &pSocket->addrLen); if (fd < 0) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_POSIX_SOCK_ERROR(dwError); } pSocket->fd = fd; pSocket->pAddr = &pSocket->addr; *ppSocket = pSocket; cleanup: return dwError; error: *ppSocket = NULL; if (pSocket) { VmDnsSockPosixFreeSocket(pSocket); } if (fd >= 0) { close(fd); } goto cleanup; }
static DWORD GetError( VOID ) { #if defined _WIN32 return GetLastError(); #else return LwErrnoToWin32Error(errno); #endif }
static DWORD VmDirNotifyLikewiseServiceManager( VOID ) { DWORD dwError = ERROR_SUCCESS; PCSTR pszSmNotify = NULL; int ret = 0; int notifyFd = -1; char notifyCode = 0; // interact with likewise service manager (start/stop control) if ((pszSmNotify = getenv("LIKEWISE_SM_NOTIFY")) != NULL) { notifyFd = atoi(pszSmNotify); do { ret = write(notifyFd, ¬ifyCode, sizeof(notifyCode)); } while (ret != sizeof(notifyCode) && errno == EINTR); if (ret < 0) { #define BUFFER_SIZE 1024 char buffer[BUFFER_SIZE]= {0}; int errorNumber = errno; VmDirStringErrorA( buffer, BUFFER_SIZE, errorNumber ); VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL, "Could not notify service manager: %s (%i)", buffer, errorNumber); dwError = LwErrnoToWin32Error(errno); BAIL_ON_VMDIR_ERROR(dwError); #undef BUFFER_SIZE } } error: if(notifyFd != -1) { close(notifyFd); } return dwError; }
static DWORD VMCASrvCreateDirSyncParams( DWORD dwInterval, PVMCA_DIR_SYNC_PARAMS* ppSyncInfo ) { DWORD dwError = 0; PVMCA_DIR_SYNC_PARAMS pSyncInfo = NULL; dwError = VMCAAllocateMemory( sizeof(VMCA_DIR_SYNC_PARAMS), (PVOID*)&pSyncInfo); BAIL_ON_VMCA_ERROR(dwError); pSyncInfo->refCount = 1; dwError = pthread_mutex_init(&pSyncInfo->mutex, NULL); if (dwError) { #ifndef _WIN32 dwError = LwErrnoToWin32Error(dwError); #endif BAIL_ON_VMCA_ERROR(dwError); } pSyncInfo->pMutex = &pSyncInfo->mutex; pSyncInfo->dwSyncIntervalSecs = dwInterval; *ppSyncInfo = pSyncInfo; cleanup: return dwError; error: *ppSyncInfo = NULL; if (pSyncInfo) { VMCASrvReleaseDirSyncParams(pSyncInfo); } goto cleanup; }
DWORD VmLinuxWaitOnEvent( VMNETEVENT_FD FD, PFN_VMNETEVENT_CALLBACK pCallback, pthread_t* pEventThread ) { DWORD dwError = 0; PVMNETEVENT_DATA pData = NULL; pthread_t eventWorkerThread; if (!pEventThread) { dwError = ERROR_INVALID_PARAMETER; BAIL_ON_VMNETEVENT_ERROR(dwError); } dwError = VmAfdAllocateMemory( sizeof(VMNETEVENT_DATA), (PVOID*)&pData ); BAIL_ON_VMNETEVENT_ERROR(dwError); pData->eventFd = FD; pData->pfnCallBack = pCallback; dwError = pthread_create( &eventWorkerThread, NULL, VmLinuxWaitOnEventWorker, (PVOID)pData ); if (dwError) { dwError = LwErrnoToWin32Error(dwError); BAIL_ON_VMNETEVENT_ERROR(dwError); } *pEventThread = eventWorkerThread; cleanup: return dwError; error: goto cleanup; }
static DWORD VmDnsSockPosixSetReuseAddress( int fd ) { DWORD dwError = 0; int on = 1; if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_POSIX_SOCK_ERROR(dwError); } error: return dwError; }
DWORD VmLinuxOpenConnection( DWORD dwEventType, PVMNETEVENT_FD pFD ) { DWORD dwError = 0; int netLinkFd = -1; if (!pFD) { dwError = ERROR_INVALID_PARAMETER; BAIL_ON_VMNETEVENT_ERROR(dwError); } netLinkFd = socket( AF_NETLINK, SOCK_RAW, NETLINK_ROUTE); if(netLinkFd < 0) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_VMAFD_ERROR(dwError); } pFD->dwNetlinkFD = netLinkFd; cleanup: return dwError; error: if (pFD) { pFD->dwNetlinkFD = -1; } if (netLinkFd>=0) { close(netLinkFd); } goto cleanup; }
static DWORD VmDnsSockPosixEventQueueDelete_inlock( PVM_SOCK_EVENT_QUEUE pQueue, PVM_SOCKET pSocket ) { DWORD dwError = 0; struct epoll_event event = {0}; if (pSocket->bInEventQueue == TRUE && epoll_ctl(pQueue->epollFd, EPOLL_CTL_DEL, pSocket->fd, &event) < 0) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_POSIX_SOCK_ERROR(dwError); } pSocket->bInEventQueue = FALSE; VmDnsSockPosixReleaseSocket(pSocket); error: return dwError; }
static DWORD GetHostname( OUT PSTR* ppszHostname ) { DWORD dwError = 0; CHAR buffer[1024] = { 0 }; PSTR dot = NULL; PSTR pszHostname = NULL; if (gethostname(buffer, sizeof(buffer) - 1) == -1) { dwError = LwErrnoToWin32Error(errno); assert(dwError); GOTO_CLEANUP(); } dot = strchr(buffer, '.'); if (dot) { *dot = 0; } dwError = LwAllocateString(buffer, &pszHostname); GOTO_CLEANUP_ON_WINERROR(dwError); cleanup: if (dwError) { LW_SAFE_FREE_STRING(pszHostname); } *ppszHostname = pszHostname; return dwError; }
DWORD VmAfdAcceptConnectionImpl( PVM_AFD_CONNECTION pConnection, PVM_AFD_CONNECTION *ppConnection ) { DWORD dwError = 0; PVM_AFD_CONNECTION pTempConnection = NULL; int connection_fd = 0; struct sockaddr_un address = {0}; socklen_t address_length = 0; connection_fd = accept(pConnection->fd,(struct sockaddr *)&address, &address_length); if (connection_fd < 0){ dwError = LwErrnoToWin32Error(errno); BAIL_ON_VMAFD_ERROR(dwError); } dwError = VmAfdAllocateMemory(sizeof(VM_AFD_CONNECTION),(PVOID *)&pTempConnection); BAIL_ON_VMAFD_ERROR(dwError); pTempConnection->fd = connection_fd; *ppConnection = pTempConnection; cleanup: return dwError; error: if (pTempConnection){ VMAFD_SAFE_FREE_MEMORY(pTempConnection); } if (ppConnection){ *ppConnection = NULL; } if (connection_fd >= 0){ close (connection_fd); } goto cleanup; }
DWORD EventLogGetHostName( PSTR* ppszHostName ) { DWORD dwError = ERROR_SUCCESS; char hostBuf[HOST_NAME_MAX]; DWORD dwBufLen = sizeof(hostBuf) - 1; PSTR pszHostName = NULL; if (gethostname(hostBuf, dwBufLen) < 0) { dwError = LwErrnoToWin32Error(errno); } dwError = EventLogAllocateStringA(hostBuf, &pszHostName); BAIL_ON_VMEVENT_ERROR(dwError); *ppszHostName = pszHostName; error: return dwError; }
DWORD VmAfdInitializeSecurityContextImpl( PVM_AFD_CONNECTION pConnection, PVM_AFD_SECURITY_CONTEXT *ppSecurityContext ) { DWORD dwError = 0; struct ucred credentials = {0}; int credLength = sizeof (struct ucred); PVM_AFD_SECURITY_CONTEXT pSecurityContext = NULL; if ((getsockopt ( pConnection->fd, SOL_SOCKET, SO_PEERCRED, &credentials, &credLength)) < 0){ dwError = LwErrnoToWin32Error (errno); BAIL_ON_VMAFD_ERROR (dwError); } dwError = VmAfdAllocateMemory( sizeof (VM_AFD_SECURITY_CONTEXT), (PVOID *)&pSecurityContext); BAIL_ON_VMAFD_ERROR (dwError); pSecurityContext->uid = credentials.uid; *ppSecurityContext = pSecurityContext; cleanup: return dwError; error: if (ppSecurityContext != NULL){ *ppSecurityContext = NULL; } if (pSecurityContext){ VmAfdFreeSecurityContext(pSecurityContext); } goto cleanup; }
DWORD DirectoryAddObject( HANDLE hDirectory, PWSTR pwszObjectDN, DIRECTORY_MOD attributes[] ) { DWORD dwError = 0; PDIRECTORY_CONTEXT pContext = (PDIRECTORY_CONTEXT)hDirectory; PWSTR pwszBase = NULL; DWORD dwScope = 0; wchar_t wszFilterFmt[] = L"%ws='%ws'"; size_t sDnLen = 0; DWORD dwFilterLen = 0; PWSTR pwszFilter = NULL; WCHAR wszAttrDn[] = DIRECTORY_ATTR_DISTINGUISHED_NAME; WCHAR wszAttrObjectClass[] = DIRECTORY_ATTR_OBJECT_CLASS; PDIRECTORY_ENTRY pEntries = NULL; PDIRECTORY_ENTRY pEntry = NULL; DWORD dwNumEntries = 0; DWORD dwObjectClass = 0; PWSTR wszAttributes[] = { wszAttrDn, wszAttrObjectClass, NULL }; if (!pContext || !pContext->pProvider) { dwError = LW_ERROR_INVALID_PARAMETER; BAIL_ON_DIRECTORY_ERROR(dwError); } dwError = LwWc16sLen(pwszObjectDN, &sDnLen); BAIL_ON_DIRECTORY_ERROR(dwError); dwFilterLen = ((sizeof(wszFilterFmt)/sizeof(wszFilterFmt[0])) - 1) + sizeof(wszAttrDn) + (sizeof(WCHAR) * sDnLen); dwError = DirectoryAllocateMemory(dwFilterLen, OUT_PPVOID(&pwszFilter)); BAIL_ON_DIRECTORY_ERROR(dwError); if (sw16printfw(pwszFilter, dwFilterLen, wszFilterFmt, wszAttrDn, pwszObjectDN) < 0) { dwError = LwErrnoToWin32Error(errno); BAIL_ON_DIRECTORY_ERROR(dwError); } dwError = DirectorySearch(hDirectory, pwszBase, dwScope, pwszFilter, wszAttributes, FALSE, &pEntries, &dwNumEntries); BAIL_ON_DIRECTORY_ERROR(dwError); if (dwNumEntries == 1) { pEntry = &(pEntries[0]); dwError = DirectoryGetEntryAttrValueByName( pEntry, wszAttrObjectClass, DIRECTORY_ATTR_TYPE_INTEGER, &dwObjectClass); BAIL_ON_DIRECTORY_ERROR(dwError); switch (dwObjectClass) { case DIR_OBJECT_CLASS_USER: dwError = ERROR_USER_EXISTS; break; case DIR_OBJECT_CLASS_LOCAL_GROUP: dwError = ERROR_ALIAS_EXISTS; break; default: dwError = ERROR_ALREADY_EXISTS; break; } BAIL_ON_DIRECTORY_ERROR(dwError); } else if (dwNumEntries > 1) { dwError = LW_ERROR_SAM_DATABASE_ERROR; BAIL_ON_DIRECTORY_ERROR(dwError); } dwError = pContext->pProvider->pProviderFnTbl->pfnDirectoryAdd( pContext->hBindHandle, pwszObjectDN, attributes); error: if (pEntries) { DirectoryFreeEntries(pEntries, dwNumEntries); } DIRECTORY_FREE_MEMORY(pwszFilter); return dwError; }
DWORD VmAfdInitRootFlushThread( PVMAFD_THREAD* ppThread ) { DWORD dwError = 0; PVMAFD_THREAD pThread = NULL; VmAfdLog(VMAFD_DEBUG_ANY, "Starting Roots Flush Thread, %s", __FUNCTION__); dwError = VmAfdAllocateMemory( sizeof(VMAFD_THREAD), (PVOID*)&pThread); BAIL_ON_VMAFD_ERROR(dwError); dwError = pthread_mutex_init(&pThread->thrData.mutex, NULL); if (dwError) { #ifndef _WIN32 dwError = LwErrnoToWin32Error(dwError); #endif BAIL_ON_VMAFD_ERROR(dwError); } pThread->thrData.pMutex = &pThread->thrData.mutex; dwError = pthread_cond_init(&pThread->thrData.cond, NULL); if (dwError) { #ifndef _WIN32 dwError = LwErrnoToWin32Error(dwError); #endif BAIL_ON_VMAFD_ERROR(dwError); } pThread->thrData.pCond = &pThread->thrData.cond; dwError = pthread_create( &pThread->thread, NULL, &VmAfdFlushTrustedRoots, (PVOID)&pThread->thrData); if (dwError) { #ifndef _WIN32 dwError = LwErrnoToWin32Error(dwError); #endif BAIL_ON_VMAFD_ERROR(dwError); } pThread->pThread = &pThread->thread; *ppThread = pThread; VmAfdLog(VMAFD_DEBUG_ANY, "Started Roots Flush Thread successfully, %s", __FUNCTION__); cleanup: return dwError; error: *ppThread = NULL; if (pThread) { VmAfdShutdownRootFlushThread(pThread); } goto cleanup; }
static DWORD VmAfdSrvWriteRootToDisk( PCSTR pszCertificate, PCSTR pszCAPath, PCSTR pszFilename ) { DWORD dwError = 0; LONG maxIndex = -1; PSTR pszPath = NULL; PSTR pszAlias = NULL; FILE* pFile = NULL; size_t len = 0; size_t bytesToWrite = 0; BOOLEAN bCertOnDisk = FALSE; PCSTR pszCursor = NULL; dwError = VmAfdFindFileIndex(pszCAPath, pszFilename, &maxIndex); if (dwError != ERROR_FILE_NOT_FOUND) { BAIL_ON_VMAFD_ERROR(dwError); dwError = VecsComputeCertAliasA((PSTR)pszCertificate, &pszAlias); BAIL_ON_VMAFD_ERROR(dwError); dwError = VmAfdCheckCertOnDisk( pszAlias, pszCAPath, pszFilename, maxIndex, &bCertOnDisk); BAIL_ON_VMAFD_ERROR(dwError); if (bCertOnDisk) { goto cleanup; } } dwError = VmAfdAllocateStringPrintf( &pszPath, "%s%s%s.%ld", pszCAPath, VMAFD_PATH_SEPARATOR_STR, pszFilename, maxIndex+1); BAIL_ON_VMAFD_ERROR(dwError); dwError = VmAfdOpenFilePath(pszPath, "w", &pFile); BAIL_ON_VMAFD_ERROR(dwError); len = strlen(pszCertificate); bytesToWrite = len; pszCursor = pszCertificate; while (bytesToWrite > 0) { size_t bytesWritten = 0; if ((bytesWritten = fwrite(pszCursor, 1, len, pFile)) == 0) { #ifndef _WIN32 dwError = LwErrnoToWin32Error(errno); #else dwError = GetLastError(); #endif BAIL_ON_VMAFD_ERROR(dwError); } pszCursor += bytesWritten; bytesToWrite -= bytesWritten; } cleanup: if (pFile) { fclose(pFile); } VMAFD_SAFE_FREE_MEMORY(pszPath); VMAFD_SAFE_FREE_MEMORY(pszAlias); return dwError; error: goto cleanup; }
VOID LwSmTableNotifyEntryStateChanged( PSM_TABLE_ENTRY pEntry, LW_SERVICE_STATE state ) { DWORD error = ERROR_SUCCESS; BOOLEAN bLocked = FALSE; PSM_LINK pLink = NULL; PSM_LINK pNext = NULL; PSM_ENTRY_NOTIFY pNotify = NULL; PSTR pServiceName = NULL; time_t now = 0; LOCK(bLocked, pEntry->pLock); for (pLink = LwSmLinkBegin(&pEntry->waiters); LwSmLinkValid(&pEntry->waiters, pLink); pLink = pNext) { pNext = LwSmLinkNext(pLink); pNotify = STRUCT_FROM_MEMBER(pLink, SM_ENTRY_NOTIFY, link); LwSmLinkRemove(pLink); pNotify->pfnNotifyEntryStateChange(state, pNotify->pData); LwFreeMemory(pNotify); } pthread_cond_broadcast(pEntry->pEvent); if (state == LW_SERVICE_STATE_DEAD && gState.bWatchdog) { now = time(NULL); if (now == (time_t) -1) { error = LwErrnoToWin32Error(errno); BAIL_ON_ERROR(error); } error = LwWc16sToMbs(pEntry->pInfo->pwszName, &pServiceName); BAIL_ON_ERROR(error); if (pEntry->StartAttempts >= 1 && (now - pEntry->LastRestartPeriod) > RESTART_PERIOD) { pEntry->StartAttempts = 1; pEntry->LastRestartPeriod = now; } if (pEntry->StartAttempts > 0 && pEntry->StartAttempts < RESTART_LIMIT) { pEntry->StartAttempts++; pEntry->dwRefCount++; SM_LOG_WARNING( "Restarting dead service: %s (attempt %u/%u)", pServiceName, (unsigned int) pEntry->StartAttempts, (unsigned int) RESTART_LIMIT); error = LwNtStatusToWin32Error(LwRtlQueueWorkItem(gpPool, LwSmTableWatchdog, pEntry, 0)); if (error) { pEntry->dwRefCount--; } BAIL_ON_ERROR(error); } else if (pEntry->StartAttempts >= 1) { SM_LOG_ERROR( "Service died: %s (restarted %u times in %lu seconds)", pServiceName, (unsigned int) pEntry->StartAttempts, (unsigned long) (now - pEntry->LastRestartPeriod)); } else { SM_LOG_ERROR( "Service failed to start: %s", pServiceName); } } error: UNLOCK(bLocked, pEntry->pLock); LW_SAFE_FREE_MEMORY(pServiceName); }