static VOID VmAfdMoveOldDbFile( VOID ) { DWORD dwError = 0; PSTR pszDbPath = NULL; PSTR pszDbOldPath = NULL; BOOLEAN bOldFileExists = FALSE; BOOLEAN bNewFieExists = FALSE; dwError = VmAfdAllocateStringA( VMAFD_CERT_DB, &pszDbPath ); BAIL_ON_VMAFD_ERROR (dwError); dwError = VmAfdAllocateStringA( VMAFD_OLD_CERT_DB, &pszDbOldPath ); BAIL_ON_VMAFD_ERROR(dwError); dwError = VmAfdFileExists(pszDbOldPath,&bOldFileExists); BAIL_ON_VMAFD_ERROR(dwError); dwError = VmAfdFileExists(pszDbPath, &bNewFieExists); BAIL_ON_VMAFD_ERROR(dwError); if (bOldFileExists && !bNewFieExists) { dwError = VmAfdCopyFile(pszDbOldPath, pszDbPath); BAIL_ON_VMAFD_ERROR(dwError); dwError = VmAfdDeleteFile(pszDbOldPath); BAIL_ON_VMAFD_ERROR(dwError); } cleanup: VMAFD_SAFE_FREE_STRINGA(pszDbOldPath); VMAFD_SAFE_FREE_STRINGA(pszDbPath); return; error: goto cleanup; }
static DWORD VmAfdGetDbPath( PSTR *ppszDbPath ) { DWORD dwError = 0; PSTR pszDbPath = NULL; VmAfdMoveOldDbFile(); dwError = VmAfdAllocateStringA( VMAFD_CERT_DB, &pszDbPath ); BAIL_ON_VMAFD_ERROR (dwError); *ppszDbPath = pszDbPath; cleanup: return dwError; error: if (ppszDbPath) { *ppszDbPath = NULL; } VMAFD_SAFE_FREE_STRINGA (pszDbPath); goto cleanup; }
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; }
static DWORD VmAfdCliLeaveVmDir( PVM_AFD_CLI_CONTEXT pContext ) { DWORD dwError = 0; PSTR pszAccount = NULL; PSTR pszPassword = NULL; if (!pContext) { dwError = ERROR_INVALID_PARAMETER; BAIL_ON_VMAFD_ERROR(dwError); } if (!pContext->pszUserName || !pContext->pszPassword) { dwError = VmAfdGetMachineAccountInfoA(NULL, &pszAccount, &pszPassword); } else { dwError = VmAfdAllocateStringA(pContext->pszUserName, &pszAccount); BAIL_ON_VMAFD_ERROR(dwError); dwError = VmAfdAllocateStringA(pContext->pszPassword, &pszPassword); } BAIL_ON_VMAFD_ERROR(dwError); dwError = VmAfdLeaveVmDirA(pContext->pszServerName, pszAccount, pszPassword, 0); BAIL_ON_VMAFD_ERROR(dwError); cleanup: VMAFD_SAFE_FREE_MEMORY(pszAccount); VMAFD_SAFE_FREE_MEMORY(pszPassword); return dwError; error: goto cleanup; }
DWORD VmAfWinCfgReadStringValue( PVMAF_CFG_KEY pKey, PCSTR pszSubkey, PCSTR pszName, PSTR* ppszValue ) { DWORD dwError = 0; CHAR szValue[VMAF_MAX_CONFIG_VALUE_BYTE_LENGTH] = {0}; DWORD dwszValueSize = sizeof(szValue); PSTR pszValue = NULL; dwError = RegGetValueA( pKey->hKey, pszSubkey, pszName, RRF_RT_REG_SZ, NULL, szValue, &dwszValueSize); BAIL_ON_VMAFD_ERROR_NO_LOG(dwError); dwError = VmAfdAllocateStringA(szValue, &pszValue); BAIL_ON_VMAFD_ERROR(dwError); *ppszValue = pszValue; cleanup: return dwError; error: *ppszValue = NULL; if (pszValue) { VmAfdFreeStringA(pszValue); } goto cleanup; }
DWORD VecsDbInitialize( PCSTR pszDbPath ) { DWORD dwError = 0; if (IsNullOrEmptyString(pszDbPath)) { dwError = ERROR_INVALID_PARAMETER; BAIL_ON_VECS_ERROR(dwError); } dwError = VecsDbDatabaseInitialize(pszDbPath); BAIL_ON_VECS_ERROR(dwError); dwError = VmAfdAllocateStringA(pszDbPath, &gVecsDbGlobals.pszDbPath); BAIL_ON_VECS_ERROR(dwError); error: return dwError; }
static DWORD _VmAfdJsonResultPasswordCB( PVOID pUserData, PCSTR pszKey, PVM_JSON_RESULT_VALUE pValue ) { DWORD dwError = 0; PSTR *ppszPassword = NULL; PSTR pszPassword = NULL; if (!pUserData || !pszKey || !pValue) { dwError = ERROR_INVALID_PARAMETER; BAIL_ON_VMAFD_ERROR(dwError); } if (!VmAfdStringCompareA("password", pszKey, TRUE)) { if (pValue->nType == JSON_RESULT_STRING) { dwError = VmAfdAllocateStringA(pValue->value.pszValue, &pszPassword); BAIL_ON_VMAFD_ERROR(dwError); ppszPassword = (PSTR *)pUserData; *ppszPassword = pszPassword; } } cleanup: return dwError; error: VMAFD_SAFE_FREE_MEMORY(pszPassword); goto cleanup; }
static DWORD VmAfdCliBeginOrEndUpgrade( PVM_AFD_CLI_CONTEXT pContext ) { DWORD dwError = 0; PSTR pszAccount = NULL; PSTR pszPassword = NULL; PSTR pszDomainName = NULL; BOOL bUsingIPC = FALSE; PVMAFD_SERVER pServer = NULL; if (!pContext) { dwError = ERROR_INVALID_PARAMETER; BAIL_ON_VMAFD_ERROR(dwError); } dwError = VmAfdGetDomainNameA(NULL,&pszDomainName); BAIL_ON_VMAFD_ERROR(dwError); if (IsNullOrEmptyString(pContext->pszServerName)) { bUsingIPC = TRUE; } if (bUsingIPC && !IsNullOrEmptyString(pContext->pszUserName)) { printf ("Getting heartbeat status of local system\n" "lightwave user-name will not be used\n" ); } if (!bUsingIPC) { //Factor domain name as well into this equation if(IsNullOrEmptyString(pContext->pszUserName)) { dwError = VmAfdGetMachineAccountInfoA(NULL, &pszAccount, &pszPassword); } else { if (VmAfdCaselessStrStrA(pContext->pszUserName, "@")) { dwError = VmAfdAllocateStringA(pContext->pszUserName, &pszAccount); } else { dwError = VmAfdAllocateStringPrintf( &pszAccount, "%s@%s", pContext->pszUserName, pszDomainName ); } BAIL_ON_VMAFD_ERROR(dwError); if (IsNullOrEmptyString(pContext->pszPassword)) { dwError = GetPassword(&pszPassword); } else { dwError = VmAfdAllocateStringA(pContext->pszPassword, &pszPassword); } BAIL_ON_VMAFD_ERROR(dwError); } } BAIL_ON_VMAFD_ERROR(dwError); dwError = VmAfdOpenServerA( pContext->pszServerName, pszAccount, pszPassword, &pServer ); BAIL_ON_VMAFD_ERROR(dwError); if (pContext->action == VM_AFD_ACTION_BEGIN_UPGRADE) { dwError = VmAfdBeginUpgrade(pServer); BAIL_ON_VMAFD_ERROR(dwError); printf ("Begin upgrade state is set\n"); } else if (pContext->action == VM_AFD_ACTION_END_UPGRADE) { dwError = VmAfdEndUpgrade(pServer); BAIL_ON_VMAFD_ERROR(dwError); printf ("End upgrade state is set\n"); } cleanup: VMAFD_SAFE_FREE_MEMORY(pszAccount); VMAFD_SAFE_FREE_MEMORY(pszPassword); VMAFD_SAFE_FREE_MEMORY(pszDomainName); if (pServer) { VmAfdCloseServer(pServer); } return dwError; error: goto cleanup; }
static DWORD VmAfdCliGetHeartbeatStatus( PVM_AFD_CLI_CONTEXT pContext ) { DWORD dwError = 0; PSTR pszAccount = NULL; PSTR pszPassword = NULL; PSTR pszDomainName = NULL; BOOL bUsingIPC = FALSE; PVMAFD_HB_STATUS_A pHeartbeatStatus = NULL; PVMAFD_SERVER pServer = NULL; if (!pContext) { dwError = ERROR_INVALID_PARAMETER; BAIL_ON_VMAFD_ERROR(dwError); } if (IsNullOrEmptyString(pContext->pszServerName)) { bUsingIPC = TRUE; } if (bUsingIPC && !IsNullOrEmptyString(pContext->pszUserName)) { printf ("Getting heartbeat status of local system\n" "lotus user-name will not be used\n" ); } if (!bUsingIPC) { //Factor domain name as well into this equation if(!pContext->pszUserName) { dwError = VmAfdGetMachineAccountInfoA(NULL, &pszAccount, &pszPassword); } else if (pContext->pszUserName && pContext->pszPassword) { dwError = VmAfdAllocateStringA(pContext->pszUserName, &pszAccount); BAIL_ON_VMAFD_ERROR(dwError); dwError = VmAfdAllocateStringA(pContext->pszPassword, &pszPassword); } else if (pContext->pszUserName && !pContext->pszPassword) { //getPassword } } BAIL_ON_VMAFD_ERROR(dwError); dwError = VmAfdOpenServerA( pContext->pszServerName, pszAccount, pszPassword, &pServer ); BAIL_ON_VMAFD_ERROR(dwError); dwError = VmAfdGetHeartbeatStatusA( pServer, &pHeartbeatStatus ); BAIL_ON_VMAFD_ERROR(dwError); printf ("Current Status of the machine is :\t%d\n",pHeartbeatStatus->bIsAlive); cleanup: VMAFD_SAFE_FREE_MEMORY(pszAccount); VMAFD_SAFE_FREE_MEMORY(pszPassword); VMAFD_SAFE_FREE_MEMORY(pszDomainName); return dwError; error: goto cleanup; }
DWORD VmAfWinCfgEnumKeys( PVMAF_CFG_CONNECTION pConnection, PVMAF_CFG_KEY pKey, PSTR **pppszKeyNames, PDWORD pdwKeyNameCount ) { DWORD dwError = 0; DWORD dwIndex = 0; DWORD dwCount = 0; PSTR pszKeyName = NULL; PSTR *ppszKeyNames = NULL; DWORD dwKeyNameSize = 0; while(1) { dwKeyNameSize = VMAF_REG_KEY_NAME_MAX_LENGTH; dwError = VmAfdAllocateMemory( dwKeyNameSize, (PVOID *)&pszKeyName ); BAIL_ON_VMAFD_ERROR(dwError); dwError = RegEnumKeyExA( (pKey ? pKey->hKey : NULL), dwCount, pszKeyName, &dwKeyNameSize, NULL, NULL, NULL, NULL ); if (dwError == ERROR_NO_MORE_ITEMS) { dwError = 0; break; } BAIL_ON_VMAFD_ERROR(dwError); dwCount++; VMAFD_SAFE_FREE_MEMORY(pszKeyName); } if (dwCount) { dwError = VmAfdAllocateMemory( sizeof(PSTR)*dwCount, (PVOID *)&ppszKeyNames ); BAIL_ON_VMAFD_ERROR(dwError); } for (; dwIndex < dwCount; ++dwIndex) { dwKeyNameSize = VMAF_REG_KEY_NAME_MAX_LENGTH; dwError = VmAfdAllocateMemory( dwKeyNameSize, (PVOID *)&pszKeyName ); BAIL_ON_VMAFD_ERROR(dwError); dwError = RegEnumKeyExA( (pKey ? pKey->hKey : NULL), dwIndex, pszKeyName, &dwKeyNameSize, NULL, NULL, NULL, NULL ); BAIL_ON_VMAFD_ERROR(dwError); dwError = VmAfdAllocateStringA( pszKeyName, &ppszKeyNames[dwIndex] ); BAIL_ON_VMAFD_ERROR(dwError); VMAFD_SAFE_FREE_MEMORY(pszKeyName); } *pppszKeyNames = ppszKeyNames; *pdwKeyNameCount = dwCount; cleanup: VMAFD_SAFE_FREE_MEMORY(pszKeyName); return dwError; error: if (pppszKeyNames) { *pppszKeyNames = NULL; } if (pdwKeyNameCount) { *pdwKeyNameCount = 0; } if (ppszKeyNames) { VmAfdFreeStringArrayA(ppszKeyNames); } goto cleanup; }
int main(int argc, char* argv[]) { DWORD dwError = 0; int retCode = 0; PSTR pszDomain = NULL; PSTR pszDomainName = NULL; PSTR pszUserName = NULL; PSTR pszPassword = NULL; PSTR pszPwdFile = NULL; PSTR pszSiteName = NULL; PSTR pszPartnerHostName = NULL; PSTR pszLotusServerName = NULL; PSTR pszPasswordBuf = NULL; FILE * fpPwdFile = NULL; PSTR pszPath = NULL; PSTR pszLogPathName = NULL; size_t dPwdLen = 0; BOOL bLogInitialized = FALSE; PCSTR pszErrorMsg = NULL; PSTR pszErrorDesc = NULL; PCSTR pszLocalhost = "localhost"; PSTR pszPnid = NULL; DNS_INIT_FLAG dnsInitFlag = DNS_NONE; #ifdef _WIN32 WSADATA wsaData = { 0 }; BOOLEAN bWsaStartup = FALSE; #endif #ifndef _WIN32 setlocale(LC_ALL, ""); #else dwError = WSAStartup(MAKEWORD(2, 2), &wsaData); BAIL_ON_VMAFD_ERROR(dwError); bWsaStartup = TRUE; #endif dwError = VmAfCfgInit(); BAIL_ON_VMAFD_ERROR(dwError); #ifndef _WIN32 dwError = VmAfdAllocateStringA(VMAFD_LOG_PATH, &pszLogPathName ); BAIL_ON_VMAFD_ERROR(dwError); #else dwError = VmAfdConfigGetString(VMAFD_SOFTWARE_KEY_PATH, VMAFD_LOGPATH_KEY_VALUE, &pszLogPathName); BAIL_ON_VMAFD_ERROR(dwError); #endif dwError = VmAfdAllocateStringAVsnprintf( &pszPath, "%s%s", pszLogPathName, "vdcpromo.log" ); BAIL_ON_VMAFD_ERROR(dwError); dwError = VmAfdLogInitialize(pszPath, 0, 0); BAIL_ON_VMAFD_ERROR(dwError); bLogInitialized = TRUE; dwError = VmAfdParseArgs(argc, argv, &pszDomain, &pszUserName, &pszPassword, &pszSiteName, &pszPartnerHostName, &pszLotusServerName, &pszPwdFile, &dnsInitFlag); if (dwError) { ShowUsage(); BAIL_ON_VMAFD_ERROR(dwError); } if (IsNullOrEmptyString(pszUserName)) { VmAfdLog(VMAFD_DEBUG_ANY, "Username parameter is not valid"); } else { VmAfdLog(VMAFD_DEBUG_ANY, "Username: \"%s\"", pszUserName); } if (!pszPwdFile && IsNullOrEmptyString(pszPassword)) { VmAfdLog(VMAFD_DEBUG_ANY, "Password parameter is not valid"); } if (IsNullOrEmptyString(pszDomain)) { VmAfdLog(VMAFD_DEBUG_ANY, "Domain parameter is not valid"); } else { VmAfdLog(VMAFD_DEBUG_ANY, "Domain: \"%s\"", pszDomain); } dwError = VmAfdAllocateMemory(VMAFD_MAX_PWD_LEN+1, (PVOID *)&pszPasswordBuf); BAIL_ON_VMAFD_ERROR(dwError); if (pszPassword == NULL && pszPwdFile != NULL) { dwError = VmAfdOpenFilePath(pszPwdFile, "rb", &fpPwdFile); if (dwError != ERROR_SUCCESS) { printf("vdcpromo: cannot open password file %s (%u)\n", pszPwdFile, dwError); dwError = ERROR_LOCAL_PASSWORDFILE_CANNOT_OPEN; BAIL_ON_VMAFD_ERROR(dwError); } if ( (dPwdLen = fread(pszPasswordBuf, 1, VMAFD_MAX_PWD_LEN, fpPwdFile)) == 0) { dwError = ERROR_LOCAL_PASSWORDFILE_CANNOT_READ; printf("vdcpromo: Could not read password file\n"); BAIL_ON_VMAFD_ERROR(dwError); } if (*pszPasswordBuf == '\0') { VmAfdLog(VMAFD_DEBUG_ANY, "password is empty"); dwError = ERROR_LOCAL_PASSWORD_EMPTY; BAIL_ON_VMAFD_ERROR(dwError); } } else if (pszPassword != NULL && pszPwdFile == NULL) { dwError = VmAfdStringCpyA(pszPasswordBuf, VMAFD_MAX_PWD_LEN, pszPassword); BAIL_ON_VMAFD_ERROR(dwError); } else //no password nor password-file, read password from stdin { VmAfdReadString("password: "******"Warning: failed to initialize DNS. Error [%d]\n", dwError); } else { fprintf(stdout, "Successfully initialized DNS.\n"); } BAIL_ON_VMAFD_ERROR(dwError); goto cleanup; } printf("Initializing Directory server instance ... \n"); fflush(stdout); dwError = VmAfdPromoteVmDirA( pszLotusServerName ? pszLotusServerName : pszLocalhost, pszDomain, pszUserName, pszPasswordBuf, pszSiteName, pszPartnerHostName); BAIL_ON_VMAFD_ERROR(dwError); printf("Directory host instance created successfully\n"); cleanup: VmAfCfgShutdown(); if (bLogInitialized) { VmAfdLogTerminate(); } #ifdef _WIN32 if (bWsaStartup != FALSE) { WSACleanup(); } #endif VMAFD_SAFE_FREE_MEMORY(pszPnid); VMAFD_SAFE_FREE_MEMORY(pszPasswordBuf); VMAFD_SAFE_FREE_MEMORY(pszPath); VMAFD_SAFE_FREE_MEMORY(pszLogPathName); VMAFD_SAFE_FREE_MEMORY(pszErrorDesc); VMAFD_SAFE_FREE_MEMORY(pszDomainName); return retCode; error: switch (dwError) { case ERROR_LOCAL_OPTION_UNKNOWN: retCode = 2; pszErrorMsg = "An unknown option was present on the command line."; break; case ERROR_LOCAL_OPTION_INVALID: retCode = 3; pszErrorMsg = "The options present on the command line are not valid."; break; case ERROR_LOCAL_PASSWORDFILE_CANNOT_OPEN: retCode = 4; pszErrorMsg = "Could not open password file.\nVerify the path is correct."; break; case ERROR_LOCAL_PASSWORDFILE_CANNOT_READ: retCode = 5; pszErrorMsg = "Problem reading password file.\nVerify contents of password file."; break; case ERROR_LOCAL_PASSWORD_EMPTY: retCode = 6; pszErrorMsg = "Invalid password; password cannot be empty."; break; case ERROR_CANNOT_CONNECT_VMAFD: retCode = 20; pszErrorMsg = "Could not connect to the local service VMware AFD.\nVerify VMware AFD is running."; break; case VMDIR_ERROR_CANNOT_CONNECT_VMDIR: retCode = 21; pszErrorMsg = "Could not connect to the local service VMware Directory Service.\nVerify VMware Directory Service is running."; break; case ERROR_INVALID_CONFIGURATION: retCode = 22; pszErrorMsg = "Configuration is not correct.\nFirst boot scripts need to be executed."; break; case VMDIR_ERROR_SERVER_DOWN: retCode = 23; pszErrorMsg = "Could not connect to VMware Directory Service via LDAP.\nVerify VMware Directory Service is running on the appropriate system and is reachable from this host."; break; case VMDIR_ERROR_USER_INVALID_CREDENTIAL: retCode = 24; pszErrorMsg = "Authentication to VMware Directory Service failed.\nVerify the username and password."; break; case ERROR_ACCESS_DENIED: retCode = 25; pszErrorMsg = "Authorization failed.\nVerify account has proper administrative privileges."; break; case VMDIR_ERROR_SCHEMA_NOT_COMPATIBLE: retCode = 26; pszErrorMsg = "Could not join to the remote service VMWare Directory Service.\nThe remote schema is incompatible with the local schema."; break; default: retCode = 1; } if (bLogInitialized) { if (pszErrorMsg == NULL) { VmAfdLog(VMAFD_DEBUG_ANY, "Vdcpromo failed. Error[%d]", dwError); } else { VmAfdLog(VMAFD_DEBUG_ANY, "Vdcpromo failed. Error[%d]\n%s", dwError, pszErrorMsg); } } if (pszErrorMsg == NULL) { if (!VmAfdGetErrorString(dwError, &pszErrorDesc)) { printf("Vdcpromo failed. Error %d: %s\n", dwError, pszErrorDesc); } else { printf("Vdcpromo failed. Error %d.\n", dwError); } } else { printf("Vdcpromo failed. Error[%d]\n%s\n", dwError, pszErrorMsg); } goto cleanup; }
static DWORD VmAfSrvCheckDC( PDNS_SERVER_INFO pServerInfo, PCSTR pszDomain, PCSTR pszUPN, PCSTR pszPassword, PSTR* ppszHostname, PSTR* ppszNetworkAddress ) { DWORD dwError = 0; PSTR pszHostname = NULL; PSTR pszNetworkAddress = NULL; PSTR pszDomainOther = NULL; LDAP* pLd = NULL; dwError = VmAfdLDAPConnect( pServerInfo->pszAddress, 0, pszUPN, pszPassword, &pLd); BAIL_ON_VMAFD_ERROR(dwError); dwError = VmAfdGetDefaultDomainName(pLd, &pszDomainOther); BAIL_ON_VMAFD_ERROR(dwError); if (VmAfdStringCompareA(pszDomain, pszDomainOther, FALSE) != 0) { dwError = ERROR_DC_NOT_FOUND; BAIL_ON_VMAFD_ERROR(dwError); } dwError = VmAfdAllocateStringA(pServerInfo->pszName, &pszHostname); BAIL_ON_VMAFD_ERROR(dwError); dwError = VmAfdAllocateStringA(pServerInfo->pszAddress, &pszNetworkAddress); BAIL_ON_VMAFD_ERROR(dwError); *ppszHostname = pszHostname; *ppszNetworkAddress = pszNetworkAddress; cleanup: if (pLd) { VmAfdLdapClose(pLd); } VMAFD_SAFE_FREE_MEMORY(pszDomainOther); return dwError; error: *ppszNetworkAddress = NULL; *ppszHostname = NULL; VMAFD_SAFE_FREE_MEMORY(pszHostname); VMAFD_SAFE_FREE_MEMORY(pszNetworkAddress); goto cleanup; }
/* * If pszServerName is in IP format, use it as Lotus Server Name. * If pszServerName is NOT "localhost" which means caller specify a name they prefer, use it as the Lotus Server Name. * * Otherwise, derive FQDN based on existing network naming configuration. * i.e. Call gethostname then perform forward+reverse lookup to derive the FQDN as Lotus Server Name. * The forward+reverse look up is for kerberos naming consistency between server (Lotus) and clients, which * could be Lotus or open sources, e.g. openldap. * However, this auto name resolution is error-prone as system could have multiple IF(s) defined and * we have no idea which IF we should pick to perform reverse lookup. * Thus, the best chance to get Kerberos working is - customer provides proper FQDN as Lotus Server Name. */ static DWORD VmAfSrvGetLotusServerName( PCSTR pszServerName, PSTR* ppOutServerName ) { DWORD dwError = 0; PSTR pszHostnameCanon = NULL; PSTR pszLocalHostName = NULL; PSTR pszFQDN = NULL; if ( !pszServerName || !ppOutServerName ) { dwError = ERROR_INVALID_PARAMETER; BAIL_ON_VMAFD_ERROR(dwError); } if ( VmAfdStringCompareA( pszServerName, "localhost", FALSE ) != 0 ) { // caller provides preferred Lotus Server Name or IP dwError = VmAfdAllocateStringA( pszServerName, &pszHostnameCanon ); BAIL_ON_VMAFD_ERROR(dwError); } else { // caller does NOT specify preferred Lotus Server Name, derives it ourselves. dwError = VmAfdGetHostName(&pszLocalHostName); BAIL_ON_VMAFD_ERROR(dwError); dwError = VmAfdGetCanonicalHostName(pszLocalHostName, &pszHostnameCanon); BAIL_ON_VMAFD_ERROR(dwError); } BAIL_ON_VMAFD_EMPTY_STRING(pszHostnameCanon, dwError); if (!VmAfdCheckIfIPV4AddressA(pszHostnameCanon) && !VmAfdCheckIfIPV6AddressA(pszHostnameCanon) && pszHostnameCanon[VmAfdStringLenA(pszHostnameCanon) - 1] != '.') { dwError = VmAfdAllocateStringPrintf( &pszFQDN, "%s.", pszHostnameCanon); BAIL_ON_VMAFD_ERROR(dwError); } else { pszFQDN = pszHostnameCanon; pszHostnameCanon = NULL; } *ppOutServerName = pszFQDN; VmAfdLog(VMAFD_DEBUG_ANY, "Lotus server name: (%s)", *ppOutServerName); cleanup: VMAFD_SAFE_FREE_MEMORY(pszHostnameCanon); return dwError; error: VMAFD_SAFE_FREE_MEMORY(pszFQDN); VmAfdLog(VMAFD_DEBUG_ANY, "%s failed (%s). Error(%u)", __FUNCTION__, pszServerName, dwError); goto cleanup; }
DWORD VmAfdGetDSERootAttribute( LDAP* pLotus, PSTR pszAttribute, PSTR* ppAttrValue ) { DWORD dwError = 0; // LDAP_SUCCESS PCHAR pDcFilter = "(objectClass=*)"; PCHAR pDcAttr[] = { pszAttribute, NULL }; PSTR pAttribute = NULL; BerElement* pBer = NULL; BerValue** ppValue = NULL; LDAPMessage* pSearchResult = NULL; LDAPMessage* pResults = NULL; dwError = ldap_search_ext_s( pLotus, "", LDAP_SCOPE_BASE, pDcFilter, pDcAttr, 0, NULL, NULL, NULL, 0, &pSearchResult); BAIL_ON_VMAFD_ERROR(dwError); if (ldap_count_entries(pLotus, pSearchResult) != 1) { dwError = ERROR_INVALID_STATE; BAIL_ON_VMAFD_ERROR(dwError); } pResults = ldap_first_entry(pLotus, pSearchResult); if (pResults == NULL) { ldap_get_option(pLotus, LDAP_OPT_ERROR_NUMBER, &dwError); BAIL_ON_VMAFD_ERROR(dwError); } pAttribute = ldap_first_attribute(pLotus,pResults,&pBer); if (pAttribute == NULL) { ldap_get_option(pLotus, LDAP_OPT_ERROR_NUMBER, &dwError); BAIL_ON_VMAFD_ERROR(dwError); } ppValue = ldap_get_values_len(pLotus, pResults, pAttribute); if (ppValue == NULL) { ldap_get_option(pLotus, LDAP_OPT_ERROR_NUMBER, &dwError); BAIL_ON_VMAFD_ERROR(dwError); } dwError = VmAfdAllocateStringA(ppValue[0]->bv_val, ppAttrValue); BAIL_ON_VMAFD_ERROR(dwError); cleanup: if (ppValue != NULL) { ldap_value_free_len(ppValue); } if (pAttribute != NULL) { ldap_memfree(pAttribute); } if (pBer != NULL) { ber_free(pBer,0); } if (pSearchResult != NULL) { ldap_msgfree(pSearchResult); } return dwError; error: *ppAttrValue = NULL; goto cleanup; }