Ejemplo n.º 1
0
PCSTR
SrvPathGetFileName(
    PCSTR  pszPath
    )
{
    PCSTR  pszCursor     = pszPath;
    size_t sLen          = 0;
    CHAR   szBackSlash[] = { '\\', 0 };
    CHAR   szFwdSlash[]  = { '/',  0 };

    if (pszPath && (sLen = strlen(pszPath)))
    {
        pszCursor = pszPath + sLen - 1;

        while (!IsNullOrEmptyString(pszCursor) && (pszCursor != pszPath))
        {
            if ((*pszCursor == szBackSlash[0]) || (*pszCursor == szFwdSlash[0]))
            {
                pszCursor++;
                break;
            }

            pszCursor--;
        }
    }

    return pszCursor;
}
Ejemplo n.º 2
0
DWORD
VmDirSchemaAttrIdMapGetAttrId(
    PVDIR_SCHEMA_ATTR_ID_MAP    pAttrIdMap,
    PSTR                        pszAttrName,
    USHORT*                     pusAttrId
    )
{
    DWORD   dwError = 0;
    uintptr_t   pAttrId = 0;

    if (!pAttrIdMap || IsNullOrEmptyString(pszAttrName))
    {
        dwError = ERROR_INVALID_PARAMETER;
        BAIL_ON_VMDIR_ERROR(dwError);
    }

    dwError = LwRtlHashMapFindKey(pAttrIdMap->pStoredIds,
            (PVOID*)&pAttrId, pszAttrName);
    if (dwError)
    {
        dwError = LwRtlHashMapFindKey(pAttrIdMap->pNewIds,
                    (PVOID*)&pAttrId, pszAttrName);
    }
    BAIL_ON_VMDIR_ERROR(dwError);

    if (pusAttrId)
    {
        *pusAttrId = (USHORT)pAttrId;
    }

error:
    return dwError;
}
Ejemplo n.º 3
0
static
PVDIR_PAGED_SEARCH_RECORD
VmDirPagedSearchCacheFind(
    PCSTR pszCookie
    )
{
    DWORD dwError = 0;
    PLW_HASHTABLE_NODE pNode = NULL;
    PVDIR_PAGED_SEARCH_RECORD pSearchRecord = NULL;
    BOOLEAN bInLock = FALSE;

    if (IsNullOrEmptyString(pszCookie))
    {
        BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER);
    }

    VMDIR_LOCK_MUTEX(bInLock, gPagedSearchCache.mutex);
    dwError = LwRtlHashTableFindKey(
                    gPagedSearchCache.pHashTbl,
                    &pNode,
                    (PVOID)pszCookie);
    dwError = LwNtStatusToWin32Error(dwError);
    BAIL_ON_VMDIR_ERROR(dwError);

    pSearchRecord = LW_STRUCT_FROM_FIELD(pNode, VDIR_PAGED_SEARCH_RECORD, Node);
    _RefPagedSearchRecord(pSearchRecord);

cleanup:
    VMDIR_UNLOCK_MUTEX(bInLock, gPagedSearchCache.mutex);
    return pSearchRecord;
error:
    goto cleanup;
}
Ejemplo n.º 4
0
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;
}
Ejemplo n.º 5
0
DWORD
VmDirSimpleEntryDeleteAttribute(
    PCSTR   pszDN,
    PCSTR   pszAttr
    )
{
    DWORD   dwError = 0;
    size_t  dnlen = 0;
    size_t  attrlen = 0;
    VDIR_OPERATION  ldapOp = {0};

    if (IsNullOrEmptyString(pszDN) || IsNullOrEmptyString(pszAttr))
    {
        BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER);
    }

    dwError = VmDirInitStackOperation(
            &ldapOp,
            VDIR_OPERATION_TYPE_INTERNAL,
            LDAP_REQ_MODIFY,
            NULL);
    BAIL_ON_VMDIR_ERROR(dwError);

    dnlen = VmDirStringLenA(pszDN);
    attrlen = VmDirStringLenA(pszAttr);

    ldapOp.pBEIF = VmDirBackendSelect(NULL);
    ldapOp.reqDn.lberbv_val = (PSTR)pszDN;
    ldapOp.reqDn.lberbv_len = dnlen;

    ldapOp.request.modifyReq.dn.lberbv_val = ldapOp.reqDn.lberbv_val;
    ldapOp.request.modifyReq.dn.lberbv_len = ldapOp.reqDn.lberbv_len;

    dwError = VmDirAppendAMod(
            &ldapOp, MOD_OP_DELETE, pszAttr, attrlen, NULL, 0);
    BAIL_ON_VMDIR_ERROR(dwError);

    dwError = VmDirInternalModifyEntry(&ldapOp);
    BAIL_ON_VMDIR_ERROR(dwError);

cleanup:
    VmDirFreeOperationContent(&ldapOp);
    return dwError;

error:
    goto cleanup;
}
Ejemplo n.º 6
0
DWORD
ADUSMBGetFile(
    PSTR  pszDomainName,
    PSTR  pszSourcePath,
    PSTR  pszDestPath
    )
{
    DWORD   dwError = MAC_AD_ERROR_SUCCESS;
    PSTR    pszFQSrcPath = NULL;
    PSTR    pszDCHostname = NULL;

    if (IsNullOrEmptyString(pszDomainName) ||
        IsNullOrEmptyString(pszSourcePath) ||
        IsNullOrEmptyString(pszDestPath))
    {
        dwError = MAC_AD_ERROR_INVALID_PARAMETER;
        BAIL_ON_MAC_ERROR(dwError);
    }

    dwError = GetPreferredDCAddress(
                    pszDomainName,
                    &pszDCHostname);
    BAIL_ON_MAC_ERROR(dwError);

    dwError = LwAllocateStringPrintf(
                    &pszFQSrcPath,
                    "//%s/sysvol/%s",
                    pszDCHostname,
                    *pszSourcePath == '/' ? pszSourcePath+1 : pszSourcePath);
    BAIL_ON_MAC_ERROR(dwError);

    LOG("Calling ADUCopyFileFromRemote(Src:%s, Dest:%s)", pszFQSrcPath, pszDestPath);

    dwError = ADUCopyFileFromRemote(pszFQSrcPath, pszDestPath);
    BAIL_ON_MAC_ERROR(dwError);

cleanup:

    LW_SAFE_FREE_STRING(pszFQSrcPath);
    LW_SAFE_FREE_STRING(pszDCHostname);

    return dwError;

error:

    goto cleanup;
}
Ejemplo n.º 7
0
DWORD
VmDirGetKrbMasterKey(
    PSTR        pszFQDN, // [in] FQDN
    PBYTE*      ppKeyBlob,
    DWORD*      pSize
)
{
    DWORD       dwError = 0;
    PBYTE       pRetMasterKey = NULL;

    if (IsNullOrEmptyString(pszFQDN)
        || !ppKeyBlob
        || !pSize
       )
    {
        dwError = VMDIR_ERROR_INVALID_PARAMETER;
        BAIL_ON_VMDIR_ERROR(dwError);
    }

    // Currently, we only support single krb realm.
    // Global cache gVmdirKrbGlobals is initialized during startup stage.

    if (VmDirStringCompareA( pszFQDN, VDIR_SAFE_STRING(gVmdirKrbGlobals.pszRealm), FALSE) != 0)
    {
        dwError = VMDIR_ERROR_INVALID_REALM;
        BAIL_ON_VMDIR_ERROR(dwError);
    }

    dwError = VmDirAllocateMemory(
                    gVmdirKrbGlobals.bervMasterKey.lberbv.bv_len,
                    (PVOID*)&pRetMasterKey
                    );
    BAIL_ON_VMDIR_ERROR(dwError);

    dwError = VmDirCopyMemory (
                    pRetMasterKey,
                    gVmdirKrbGlobals.bervMasterKey.lberbv.bv_len,
                    gVmdirKrbGlobals.bervMasterKey.lberbv.bv_val,
                    gVmdirKrbGlobals.bervMasterKey.lberbv.bv_len
                    );
    BAIL_ON_VMDIR_ERROR(dwError);

    *ppKeyBlob = pRetMasterKey;
    *pSize     = (DWORD) gVmdirKrbGlobals.bervMasterKey.lberbv.bv_len;
    pRetMasterKey = NULL;

cleanup:

    return dwError;

error:

    VMDIR_LOG_ERROR( LDAP_DEBUG_RPC, "VmDirGetKrbMasterKey failed. (%u)(%s)",
                                     dwError, VDIR_SAFE_STRING(pszFQDN));
    VMDIR_SAFE_FREE_MEMORY(pRetMasterKey);

    goto cleanup;

}
Ejemplo n.º 8
0
DWORD
LWNetDnsGetSrvRecordQuestion(
    OUT PSTR* ppszQuestion,
    IN PCSTR pszDomainName,
    IN OPTIONAL PCSTR pszSiteName,
    IN DWORD dwDsFlags
    )
{
    DWORD dwError = 0;
    PSTR question = NULL;
    PCSTR kind = "dc";
    PCSTR service = "_ldap";

    if (dwDsFlags & DS_PDC_REQUIRED)
    {
        kind = "pdc";
        service = "_ldap";
    }
    else if (dwDsFlags & DS_GC_SERVER_REQUIRED)
    {
        kind = "gc";
        service = "_ldap";
    }
    else if (dwDsFlags & DS_KDC_REQUIRED)
    {
        kind = "dc";
        service = "_kerberos";
    }
    else
    {
        kind = "dc";
        service = "_ldap";
    }

    if (IsNullOrEmptyString(pszSiteName))
    {
        dwError = LwAllocateStringPrintf(&question,
                                            "%s._tcp.%s._msdcs.%s",
                                            service, kind,
                                            pszDomainName);
        BAIL_ON_LWNET_ERROR(dwError);
    }
    else
    {
        dwError = LwAllocateStringPrintf(&question,
                                            "%s._tcp.%s._sites.%s._msdcs.%s",
                                            service, pszSiteName, kind,
                                            pszDomainName);
        BAIL_ON_LWNET_ERROR(dwError);
    }

error:
    if (dwError)
    {
        LWNET_SAFE_FREE_STRING(question);
    }
    *ppszQuestion = question;
    return dwError;
}
Ejemplo n.º 9
0
DWORD
LwCALockDN(
    PLWCA_POST_HANDLE   pHandle,
    PCSTR               pcszDN,
    PSTR                *ppszUuid
    )
{
    DWORD               dwError = 0;
    PSTR                pszUuid = NULL;
    ULONG               currTime = 0;
    DWORD               dwAttempt = 0;
    struct timespec     ts = {0};

    if (IsNullOrEmptyString(pcszDN) || !ppszUuid || !pHandle)
    {
        dwError = LWCA_ERROR_INVALID_PARAMETER;
        BAIL_ON_LWCA_ERROR(dwError);
    }

    dwError = LwCAUuidGenerate(&pszUuid);
    BAIL_ON_LWCA_ERROR(dwError);

    ts.tv_nsec = LWCA_LOCK_SLEEP_NS;

    while (dwAttempt < LWCA_LOCK_MAX_ATTEMPT)
    {
        dwError = _LwCAGetCurrentTime(&currTime);
        BAIL_ON_LWCA_ERROR(dwError);

        dwError = _LwCALockDNImpl(pHandle, pszUuid, currTime, pcszDN);
        if (dwError == LWCA_LOCK_APPLY_FAILED)
        {
            dwAttempt += 1;
            nanosleep(&ts, NULL);
            continue;
        }
        BAIL_ON_LWCA_ERROR(dwError);

        break;
    }
    if (dwAttempt >= LWCA_LOCK_MAX_ATTEMPT)
    {
        dwError = LWCA_LOCK_APPLY_FAILED;
        BAIL_ON_LWCA_ERROR(dwError);
    }

    *ppszUuid = pszUuid;

cleanup:
    return dwError;

error:
    LWCA_SAFE_FREE_STRINGA(pszUuid);
    if (ppszUuid)
    {
        *ppszUuid = NULL;
    }
    goto cleanup;
}
Ejemplo n.º 10
0
NTSTATUS
SrvGetTreeRelativePath(
    PWSTR  pwszOriginalPath,
    PWSTR* ppwszSpecificPath
    )
{
    NTSTATUS ntStatus        = STATUS_SUCCESS;
    wchar16_t wszBackSlash[] = { '\\', 0 };
    wchar16_t wszFwdSlash[]  = { '/',  0 };

    if ((*pwszOriginalPath != wszBackSlash[0]) &&
         (*pwszOriginalPath != wszFwdSlash[0]))
    {
        ntStatus = STATUS_INVALID_PARAMETER;
        BAIL_ON_NT_STATUS(ntStatus);
    }
    pwszOriginalPath++;

    // Skip the device name
    while (!IsNullOrEmptyString(pwszOriginalPath) &&
           (*pwszOriginalPath != wszBackSlash[0]) &&
           (*pwszOriginalPath != wszFwdSlash[0]))
    {
        pwszOriginalPath++;
    }

    if (IsNullOrEmptyString(pwszOriginalPath) ||
        ((*pwszOriginalPath != wszBackSlash[0]) &&
         (*pwszOriginalPath != wszFwdSlash[0])))
    {
        ntStatus = STATUS_INVALID_PARAMETER;
        BAIL_ON_NT_STATUS(ntStatus);
    }

    *ppwszSpecificPath = pwszOriginalPath;

cleanup:

    return ntStatus;

error:

    *ppwszSpecificPath = NULL;

    goto cleanup;
}
Ejemplo n.º 11
0
static
DWORD
VmwDeploySetupServerPartner(
    PVMW_IC_SETUP_PARAMS pParams
    )
{
    DWORD dwError = 0;
    PCSTR ppszServices[]=
    {
        VMW_DCERPC_SVC_NAME,
        VMW_VMDNS_SVC_NAME,
        VMW_VMAFD_SVC_NAME,
        VMW_DIR_SVC_NAME,
        VMW_VMCA_SVC_NAME
    };
    int iSvc = 0;

    VMW_DEPLOY_LOG_INFO("Setting up system as Infrastructure partner node");

    dwError = VmwDeployValidateHostname(pParams->pszHostname);
    BAIL_ON_DEPLOY_ERROR(dwError);

    dwError = VmwDeployValidatePartnerCredentials(
                    pParams->pszServer,
                    pParams->pszPassword,
                    pParams->pszDomainName);
    BAIL_ON_DEPLOY_ERROR(dwError);

    dwError = VmwDeployValidateSiteName(pParams->pszSite);
    BAIL_ON_DEPLOY_ERROR(dwError);

    if (!IsNullOrEmptyString(pParams->pszDNSForwarders))
    {
        dwError = VmwDeployValidateDNSForwarders(pParams->pszDNSForwarders);
        BAIL_ON_DEPLOY_ERROR(dwError);
    }

    for (; iSvc < sizeof(ppszServices)/sizeof(ppszServices[0]); iSvc++)
    {
        PCSTR pszService = ppszServices[iSvc];

        VMW_DEPLOY_LOG_INFO("Starting service [%s]", pszService);

        dwError = VmwDeployStartService(pszService);
        BAIL_ON_DEPLOY_ERROR(dwError);
    }

    dwError = VmwDeploySetupServerCommon(pParams);
    BAIL_ON_DEPLOY_ERROR(dwError);

cleanup:

    return dwError;

error:

    goto cleanup;
}
Ejemplo n.º 12
0
DWORD
VmAfWinCfgOpenRootKey(
    PVMAF_CFG_CONNECTION pConnection,
    PCSTR                pszKeyName,
    DWORD                dwOptions,
    DWORD                dwAccess,
    PVMAF_CFG_KEY*       ppKey
    )
{
    DWORD dwError = 0;
    PVMAF_CFG_KEY pKey = NULL;
    VMAF_CFG_KEY rootKey = {0};

    if (!pConnection || IsNullOrEmptyString(pszKeyName) || !ppKey)
    {
        dwError = ERROR_INVALID_PARAMETER;
        BAIL_ON_VMAFD_ERROR(dwError);
    }

    if (!strcmp(pszKeyName, "HKEY_LOCAL_MACHINE"))
    {
        rootKey.hKey = HKEY_LOCAL_MACHINE;
    }
    else
    {
        dwError = ERROR_NOT_SUPPORTED;
        BAIL_ON_VMAFD_ERROR(dwError);
    }

    dwError = VmAfWinCfgOpenKey(
                                  pConnection,
                                  &rootKey,
                                  NULL,
                                  dwOptions,
                                  dwAccess,
                                  &pKey);
    BAIL_ON_VMAFD_ERROR(dwError);

    *ppKey = pKey;

cleanup:

    return dwError;

error:

    if (ppKey)
    {
        *ppKey = NULL;
    }

//    if (pKey)
//    {
//        VmAfWinCfgCloseKey(pKey);
//    }

    goto cleanup;
}
Ejemplo n.º 13
0
DWORD
DJFixLoginConfigFile(
    PCSTR pszPath
    )
{
    DWORD ceError = ERROR_SUCCESS;
    PCSTR pszFilePath = NULL;
    PSTR pszTmpPath = NULL;
    PSTR pszFinalPath = NULL;
    BOOLEAN bFileExists = FALSE;
    FILE* fp = NULL;
    FILE* fp_new = NULL;
    DynamicArray lines;
    PSTR currentSystem = NULL;

    memset(&lines, 0, sizeof(lines));
    if (IsNullOrEmptyString(pszPath))
        pszFilePath = LOGIN_CONFIG_PATH;
    else
        pszFilePath = pszPath;

    GCE(ceError = CTGetFileTempPath(
                        pszFilePath,
                        &pszFinalPath,
                        &pszTmpPath));

    GCE(ceError = CTCheckFileExists(pszFinalPath, &bFileExists));

    if (!bFileExists)
        goto cleanup;

    GCE(ceError = CTOpenFile(pszFinalPath, "r", &fp));
    GCE(ceError = CTReadLines(fp, &lines));
    GCE(ceError = CTSafeCloseFile(&fp));

    GCE(ceError = GetAuthType(&lines, &currentSystem));
    if(!strcmp(currentSystem, "PAM_AUTH"))
        goto cleanup;

    GCE(ceError = SetAuthType(&lines, "PAM_AUTH"));

    GCE(ceError = CTOpenFile(pszTmpPath, "w", &fp_new));
    GCE(ceError = CTWriteLines(fp_new, &lines));
    GCE(ceError = CTSafeCloseFile(&fp_new));

    GCE(ceError = CTSafeReplaceFile(pszFilePath, pszTmpPath));

cleanup:
    CTSafeCloseFile(&fp);
    CTSafeCloseFile(&fp_new);

    CT_SAFE_FREE_STRING(currentSystem);
    CT_SAFE_FREE_STRING(pszTmpPath);
    CT_SAFE_FREE_STRING(pszFinalPath);
    CTFreeLines(&lines);

    return ceError;
}
Ejemplo n.º 14
0
DWORD
VmDirIndexCfgAcquire(
    PCSTR               pszAttrName,
    VDIR_INDEX_USAGE    usage,
    PVDIR_INDEX_CFG*    ppIndexCfg
    )
{
    DWORD   dwError = 0;
    BOOLEAN bInLock = FALSE;
    PVDIR_INDEX_CFG pIndexCfg = NULL;
    PVMDIR_MUTEX    pMutex = NULL;

    if (IsNullOrEmptyString(pszAttrName) || !ppIndexCfg)
    {
        dwError = VMDIR_ERROR_INVALID_PARAMETER;
        BAIL_ON_VMDIR_ERROR(dwError);
    }

    *ppIndexCfg = NULL;

    if (LwRtlHashMapFindKey(
            gVdirIndexGlobals.pIndexCfgMap, (PVOID*)&pIndexCfg, pszAttrName))
    {
        goto cleanup;
    }

    pMutex = pIndexCfg->mutex;
    VMDIR_LOCK_MUTEX(bInLock, pMutex);

    if (pIndexCfg->status == VDIR_INDEXING_SCHEDULED)
    {
        goto cleanup;
    }
    else if (pIndexCfg->status == VDIR_INDEXING_IN_PROGRESS &&
            usage == VDIR_INDEX_READ)
    {
        dwError = VMDIR_ERROR_UNWILLING_TO_PERFORM;
    }
    else if (pIndexCfg->status == VDIR_INDEXING_DISABLED ||
            pIndexCfg->status == VDIR_INDEXING_DELETED)
    {
        goto cleanup;
    }
    BAIL_ON_VMDIR_ERROR(dwError);

    pIndexCfg->usRefCnt++;
    *ppIndexCfg = pIndexCfg;

cleanup:
    VMDIR_UNLOCK_MUTEX(bInLock, pMutex);
    return dwError;

error:
    VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL,
            "%s failed, error (%d)", __FUNCTION__, dwError );

    goto cleanup;
}
Ejemplo n.º 15
0
DWORD
VmwDeployValidatePassword(
    PCSTR pszPassword
    )
{
    DWORD dwError = 0;
    size_t iCh = 0;
    size_t nUpper = 0;
    size_t nLower = 0;
    size_t nDigit = 0;
    size_t nSpecial = 0;
    size_t sLen = 0;

    VMW_DEPLOY_LOG_DEBUG("Validating password");

    if (IsNullOrEmptyString(pszPassword) || (sLen = strlen(pszPassword)) < 8)
    {
        dwError = ERROR_PASSWORD_RESTRICTION;
        BAIL_ON_DEPLOY_ERROR(dwError);
    }

    // We are looking for at least one upper case, one lower case, one digit and
    // one special case character. Added illegal chars check
    for (iCh = 0; iCh < sLen; iCh++)
    {
        int ch = pszPassword[iCh];

        if (isdigit(ch))
        {
            nDigit++;
        }
        else if (islower(ch))
        {
            nLower++;
        }
        else if (isupper(ch))
        {
            nUpper++;
        }
        else if (ispunct(ch))
        {
            nSpecial++;
        }
    }

    if (!nUpper || !nLower || !nDigit || !nSpecial)
    {
        VMW_DEPLOY_LOG_ERROR("Password complexity requirement not satisfied");

        dwError = ERROR_PASSWORD_RESTRICTION;
        BAIL_ON_DEPLOY_ERROR(dwError);
    }

error:

    return dwError;
}
Ejemplo n.º 16
0
DWORD
VmDirMetaDataCreate(
    USN                           localUsn,
    UINT64                        version,
    PCSTR                         pszOrigInvoId,
    PCSTR                         pszOrigTimeStamp,
    USN                           origUsn,
    PVMDIR_ATTRIBUTE_METADATA*    ppMetaData
    )
{
    DWORD    dwError = 0;
    PVMDIR_ATTRIBUTE_METADATA   pMetaData = NULL;

    if (!ppMetaData        ||
        IsNullOrEmptyString(pszOrigInvoId) ||
        IsNullOrEmptyString(pszOrigTimeStamp))
    {
        BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER);
    }

    dwError = VmDirAllocateMemory(sizeof(VMDIR_ATTRIBUTE_METADATA), (PVOID*) &pMetaData);
    BAIL_ON_VMDIR_ERROR(dwError);

    pMetaData->localUsn = localUsn;
    pMetaData->version = version;

    dwError = VmDirAllocateStringA(pszOrigInvoId, &pMetaData->pszOrigInvoId);
    BAIL_ON_VMDIR_ERROR(dwError);

    dwError = VmDirAllocateStringA(pszOrigTimeStamp, &pMetaData->pszOrigTime);
    BAIL_ON_VMDIR_ERROR(dwError);

    pMetaData->origUsn = origUsn;

    *ppMetaData = pMetaData;

cleanup:
    return dwError;

error:
    VmDirFreeMetaData(pMetaData);
    VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError);
    goto cleanup;
}
Ejemplo n.º 17
0
static
DWORD
VmDirValidateUserCreateParamsW(
    PVMDIR_USER_CREATE_PARAMS_W pCreateParams
    )
{
    DWORD dwError = 0;

    if (!pCreateParams ||
        IsNullOrEmptyString(pCreateParams->pwszAccount) ||
        IsNullOrEmptyString(pCreateParams->pwszFirstname) ||
        IsNullOrEmptyString(pCreateParams->pwszLastname) ||
        IsNullOrEmptyString(pCreateParams->pwszPassword))
    {
        dwError = ERROR_INVALID_PARAMETER;
    }

    return dwError;
}
Ejemplo n.º 18
0
DWORD
VmDirConfigSetDefaultSiteandLduGuid(
    PCSTR pszDefaultSiteGuid,
    PCSTR pszDefaultLduGuid
    )
#ifndef _WIN32
{
    DWORD   dwError = 0;

    if (IsNullOrEmptyString(pszDefaultSiteGuid) || IsNullOrEmptyString(pszDefaultLduGuid))
    {
        dwError = ERROR_INVALID_PARAMETER;
        BAIL_ON_VMDIR_ERROR(dwError);
    }

    dwError = RegUtilSetValue(
                NULL,
                HKEY_THIS_MACHINE,
                VMDIR_CONFIG_PARAMETER_KEY_PATH,
                NULL,
                VMDIR_REG_KEY_SITE_GUID,
                REG_SZ,
                (PVOID)pszDefaultSiteGuid,
                VmDirStringLenA(pszDefaultSiteGuid)+1);
    BAIL_ON_VMDIR_ERROR(dwError);

    dwError = RegUtilSetValue(
                NULL,
                HKEY_THIS_MACHINE,
                VMDIR_CONFIG_PARAMETER_KEY_PATH,
                NULL,
                VMDIR_REG_KEY_LDU_GUID,
                REG_SZ,
                (PVOID)pszDefaultLduGuid,
                VmDirStringLenA(pszDefaultLduGuid)+1);
    BAIL_ON_VMDIR_ERROR(dwError);

cleanup:
    return dwError;
error:
    VmDirLog(LDAP_DEBUG_ANY, "VmDirConfigSetDefaultSiteandLduGuid failed with error (%u)", dwError);
    goto cleanup;
}
Ejemplo n.º 19
0
DWORD
LWSetConfigValueBySectionName(
    PCFGSECTION pSectionList,
    PCSTR pszSectionName,
    PCSTR pszName,
    PCSTR pszValue
    )
{
    DWORD dwError = 0;
    PCFGSECTION pSection = NULL;

    if (IsNullOrEmptyString(pszSectionName) ||
        IsNullOrEmptyString(pszName)) {
        dwError = MAC_AD_ERROR_INVALID_PARAMETER;
        BAIL_ON_MAC_ERROR(dwError);
    }

    while (pSectionList) {
        if (!strcmp(pSectionList->pszName, pszSectionName)) {
            pSection = pSectionList;
            break;
        }
        pSectionList = pSectionList->pNext;
    }

    if (!pSection) {
        dwError = MAC_AD_ERROR_INVALID_RECORD_TYPE;
        goto error;
    }

    dwError = LWSetConfigValueBySection(pSection,
                                        pszName,
                                        pszValue);
    BAIL_ON_MAC_ERROR(dwError);

cleanup:

    return dwError;

error:

    goto cleanup;
}
Ejemplo n.º 20
0
DWORD
VmDirSchemaAttrIdMapAddNewAttr(
    PVDIR_SCHEMA_ATTR_ID_MAP    pAttrIdMap,
    PSTR                        pszAttrName,
    USHORT                      usAttrId    // optional
    )
{
    DWORD   dwError = 0;
    PSTR    pszKey = 0;

    if (!pAttrIdMap || IsNullOrEmptyString(pszAttrName))
    {
        dwError = ERROR_INVALID_PARAMETER;
        BAIL_ON_VMDIR_ERROR(dwError);
    }

    if (VmDirSchemaAttrIdMapGetAttrId(pAttrIdMap, pszAttrName, NULL) == 0)
    {
        dwError = ERROR_ALREADY_EXISTS;
        BAIL_ON_VMDIR_ERROR(dwError);
    }

    dwError = VmDirAllocateStringA(pszAttrName, &pszKey);
    BAIL_ON_VMDIR_ERROR(dwError);

    if (usAttrId)
    {
        dwError = LwRtlHashMapInsert(pAttrIdMap->pNewIds,
                pszKey, (PVOID)(uintptr_t)usAttrId, NULL);
        BAIL_ON_VMDIR_ERROR(dwError);

        if (usAttrId >= pAttrIdMap->usNextId)
        {
            pAttrIdMap->usNextId = usAttrId + 1;
        }
    }
    else
    {
        dwError = LwRtlHashMapInsert(pAttrIdMap->pNewIds,
                pszKey, (PVOID)(uintptr_t)pAttrIdMap->usNextId, NULL);
        BAIL_ON_VMDIR_ERROR(dwError);

        pAttrIdMap->usNextId++;
    }

cleanup:
    return dwError;

error:
    VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL,
            "%s failed, error (%d)", __FUNCTION__, dwError );

    VMDIR_SAFE_FREE_MEMORY(pszKey);
    goto cleanup;
}
Ejemplo n.º 21
0
int
main(
    int argc,
    char* argv[]
    )
{
    DWORD dwError = 0;
    handle_t bindingHandle = 0;
    HANDLE hEventLog = 0;
    PSTR pszBindingString = NULL;

    DWORD eventTableCategoryId = (DWORD) -1;

    PSTR pszFilename = NULL;
    
    evt_init_logging_to_file(LOG_LEVEL_VERBOSE, "");

    dwError = ParseArgs(argc, argv, &pszFilename, &eventTableCategoryId);
    BAIL_ON_EVT_ERROR(dwError);

    if (IsNullOrEmptyString(pszFilename)) {
       EVT_LOG_ERROR("No path to the file containing events was specified.");
       ShowUsage();
       BAIL_ON_EVT_ERROR((dwError = EINVAL));
    }

    TRY
    {
	dwError = LWIOpenEventLog(&bindingHandle, &hEventLog, &pszBindingString, "127.0.0.1", "127.0.0.1");
	BAIL_ON_EVT_ERROR(dwError);

        dwError = ParseAndAddEvents(bindingHandle, hEventLog, pszFilename, eventTableCategoryId, AddEventRecord);
        BAIL_ON_EVT_ERROR(dwError);

    }
    CATCH_ALL
    {
        exc_get_status (THIS_CATCH, &dwError);
        EVT_LOG_ERROR("Unexpected error . Error code [%d]\n", dwError);
        BAIL_ON_EVT_ERROR(dwError);
    }
    ENDTRY;


  error:

    if (bindingHandle && hEventLog && pszBindingString)
	LWICloseEventLog(bindingHandle, hEventLog, pszBindingString);
        
    if(dwError != 0) {
	EVT_LOG_ERROR("Failed to import events. Error code [%d]\n", dwError);
    }

    return dwError;
}
Ejemplo n.º 22
0
DWORD
CTMatchProgramToPID(
    PCSTR pszProgramName,
    pid_t    pid
    )
{
    DWORD ceError = ERROR_SUCCESS;
    CHAR szBuf[PATH_MAX+1];
    FILE* pFile = NULL;

#if defined(__LWI_DARWIN__) || defined(__LWI_FREEBSD__)
    sprintf(szBuf, "ps -p %d -o command= | grep %s", pid, pszProgramName);
#elif defined(__LWI_SOLARIS__) || defined(__LWI_HP_UX__) || defined(__LWI_AIX__)
    sprintf(szBuf, "PS=ps; [ -x /bin/ps ] && PS=/bin/ps; UNIX95=1 $PS -p %ld -o comm= | grep %s", (long)pid, pszProgramName);
#else
    sprintf(szBuf, "UNIX95=1 ps -p %ld -o cmd= | grep %s", (long)pid, pszProgramName);
#endif

    pFile = popen(szBuf, "r");
    if (pFile == NULL) {
        ceError = LwMapErrnoToLwError(errno);
        BAIL_ON_CENTERIS_ERROR(ceError);
    }

    /* Assume that we won't find the process we are looking for */
    ceError = ERROR_PROC_NOT_FOUND;

    while (TRUE) {

        if (NULL == fgets(szBuf, PATH_MAX, pFile)) {
            if (feof(pFile)) {
                break;
            } else {
                ceError = LwMapErrnoToLwError(errno);
                BAIL_ON_CENTERIS_ERROR(ceError);
            }
        }

        CTStripWhitespace(szBuf);
        if (!IsNullOrEmptyString(szBuf)) {
            /* Well what do you know, it was found! */
            ceError = ERROR_SUCCESS;
            break;
        }

    }

error:

    if (pFile)
        pclose(pFile);

    return ceError;
}
Ejemplo n.º 23
0
DWORD
VMCAGetCRLInfoPrivate(
    PSTR pszFileName,
    time_t *ptmLastUpdate,
    time_t *ptmNextUpdate,
    DWORD  *pdwCRLNumber)
{
    DWORD dwError = 0;
    X509_CRL *pCrl = NULL;
    ASN1_TIME *pLastUpdate = NULL;
    ASN1_TIME *pNextUpdate = NULL;
    ASN1_INTEGER *pCrlNumber = NULL;
    long nCrlNum = 0;

    if (   (IsNullOrEmptyString(pszFileName))
        || (ptmNextUpdate == NULL)
        || (ptmLastUpdate == NULL)
        || (pdwCRLNumber == NULL)
        ) {
        dwError = ERROR_INVALID_PARAMETER;
        BAIL_ON_ERROR(dwError);
    }

    dwError = VMCAFileToCRL(pszFileName, &pCrl);
    BAIL_ON_ERROR(dwError);

    pLastUpdate = X509_CRL_get_lastUpdate(pCrl);
    pNextUpdate = X509_CRL_get_nextUpdate(pCrl);

    pCrlNumber = ASN1_INTEGER_new();
    if(pCrlNumber == NULL) {
        dwError = VMCA_OUT_MEMORY_ERR;
        BAIL_ON_ERROR(dwError);
    }
    pCrlNumber = X509_CRL_get_ext_d2i(pCrl, NID_crl_number, 0,0);
    nCrlNum = ASN1_INTEGER_get(pCrlNumber);
    *pdwCRLNumber = nCrlNum;

    dwError =  VMCAASN1ToTimeT(pLastUpdate,ptmLastUpdate);
    BAIL_ON_ERROR(dwError);

    dwError =  VMCAASN1ToTimeT(pNextUpdate,ptmNextUpdate);
    BAIL_ON_ERROR(dwError);


cleanup:
    if(pCrlNumber){
        ASN1_INTEGER_free(pCrlNumber);
    }
    VMCACrlFree(pCrl);
    return dwError;
error :
    goto cleanup;
}
Ejemplo n.º 24
0
DWORD
DNSOpen(
    PCSTR   pszNameServer,
    DWORD   dwType,
    PHANDLE phDNSServer
    )
{
    DWORD  dwError = 0;
    HANDLE hDNSServer = (HANDLE)NULL;

    if (IsNullOrEmptyString(pszNameServer))
    {
        dwError = LWDNS_ERROR_INVALID_PARAMETER;
        BAIL_ON_LWDNS_ERROR(dwError);
    }

    switch (dwType)
    {
        case DNS_TCP:

            dwError = DNSTCPOpen(
                            pszNameServer,
                            &hDNSServer
                            );

            break;

        case DNS_UDP:

            dwError = DNSUDPOpen(
                            pszNameServer,
                            &hDNSServer
                            );

            break;

        default:

            dwError = LWDNS_ERROR_INVALID_PARAMETER;
    }
    BAIL_ON_LWDNS_ERROR(dwError);

    *phDNSServer = hDNSServer;

cleanup:

    return dwError;

error:

    *phDNSServer = (HANDLE)NULL;

    goto cleanup;
}
Ejemplo n.º 25
0
DWORD
VmAfdModifyOwner(
          PVECS_SERV_STORE pStore,
          PCWSTR pszUserName,
          PVMAFD_SECURITY_DESCRIPTOR pSecurityDescriptor
          )
{
    DWORD dwError = 0;
    PVM_AFD_SECURITY_CONTEXT pSecurityContext = NULL;
    PVM_AFD_SECURITY_CONTEXT pSecurityContextToClean = NULL;

    if (IsNullOrEmptyString (pszUserName) ||
        !pSecurityDescriptor ||
        !pStore
       )
    {
        dwError = ERROR_INVALID_PARAMETER;
        BAIL_ON_VMAFD_ERROR (dwError);
    }

    dwError = VmAfdAllocateContextFromName (
                                    pszUserName,
                                    &pSecurityContext
                                    );
    BAIL_ON_VMAFD_ERROR (dwError);

    pSecurityContextToClean = pSecurityContext;

    dwError = VmAfdCheckOwnerShip (
                                  pStore,
                                  pSecurityContext
                                  );

    if (dwError == 0)
    {
        goto cleanup;
    }
    dwError = 0;

    pSecurityContextToClean = pSecurityDescriptor->pOwnerSecurityContext;

    pSecurityDescriptor->pOwnerSecurityContext = pSecurityContext;

cleanup:
    if (pSecurityContextToClean)
    {
        VmAfdFreeSecurityContext (pSecurityContextToClean);
    }

    return dwError;

error:
    goto cleanup;
}
Ejemplo n.º 26
0
DWORD
VmDnsCacheLoadZoneFromStore(
    PVMDNS_CACHE_CONTEXT    pContext,
    PCSTR                   pZoneName
    )
{
    DWORD dwError = 0;
    PVMDNS_RECORD_LIST pList = NULL;
    PVMDNS_ZONE_OBJECT pZoneObject = NULL;
    BOOL bLocked = FALSE;
    PVMDNS_PROPERTY_LIST pPropertyList = NULL;

    if (IsNullOrEmptyString(pZoneName))
    {
        dwError = ERROR_INVALID_PARAMETER;
        BAIL_ON_VMDNS_ERROR(dwError);
    }

    VmDnsLockWrite(pContext->pLock);
    bLocked = TRUE;

    dwError = VmDnsStoreGetProperties(pZoneName, &pPropertyList);
    if (dwError && dwError != ERROR_NOT_FOUND)
    {
        BAIL_ON_VMDNS_ERROR(dwError);
    }

    dwError = VmDnsStoreGetRecords(pZoneName, pZoneName, &pList);
    if (dwError && dwError != ERROR_NOT_FOUND)
    {
        BAIL_ON_VMDNS_ERROR(dwError);
    }

    dwError = VmDnsZoneCreateFromRecordList(pZoneName, pList, pPropertyList, &pZoneObject);
    BAIL_ON_VMDNS_ERROR(dwError);

    VmDnsZoneListAddZone(pContext->pZoneList, pZoneObject);
    BAIL_ON_VMDNS_ERROR(dwError);

cleanup:
    if (bLocked)
    {
        VmDnsUnlockWrite(pContext->pLock);
    }

    VmDnsRecordListRelease(pList);
    VmDnsPropertyListRelease(pPropertyList);
    VmDnsZoneObjectRelease(pZoneObject);

    return dwError;

error:
    goto cleanup;
}
Ejemplo n.º 27
0
DWORD
DJUnjoinDomain(
    PCSTR pszUsername,
    PCSTR pszPassword
    )
{
    DWORD dwError = 0;
    LWException *exc = NULL; 
    JoinProcessOptions options;

    DJZeroJoinProcessOptions(&options);
    options.joiningDomain = FALSE;

    if (!IsNullOrEmptyString(pszUsername))
    {
        LW_CLEANUP_CTERR(&exc, CTStrdup(pszUsername, &options.username));
    }

    if (!IsNullOrEmptyString(pszPassword))
    {
        LW_CLEANUP_CTERR(&exc, CTStrdup(pszPassword, &options.password));
    }

    LW_CLEANUP_CTERR(&exc, DJGetComputerName(&options.computerName));

    LW_TRY(&exc, DJInitModuleStates(&options, &LW_EXC));

    LW_TRY(&exc, DJRunJoinProcess(&options, &LW_EXC));

cleanup:

    DJFreeJoinProcessOptions(&options);

    if (!LW_IS_OK(exc))
    {
        dwError = exc->code;
        LWHandle(&exc);
    }

    return dwError;
}
Ejemplo n.º 28
0
static
DWORD
_VmDirSimpleEntryCreateInBEWithGuid(
    PVDIR_BACKEND_INTERFACE pBE,
    PVDIR_SCHEMA_CTX        pSchemaCtx,
    PSTR*                   ppszEntryInitializer,
    PSTR                    pszDN,
    ENTRYID                 ulEntryId,
    PSTR                    pszGuid /* Optional */
    )
{
    DWORD                   dwError = 0;
    VDIR_OPERATION          ldapOp = {0};

    dwError = VmDirInitStackOperation( &ldapOp,
                                       VDIR_OPERATION_TYPE_INTERNAL,
                                       LDAP_REQ_ADD,
                                       pSchemaCtx );
    BAIL_ON_VMDIR_ERROR(dwError);

    ldapOp.pBEIF = pBE;
    assert(ldapOp.pBEIF);

    ldapOp.reqDn.lberbv.bv_val = pszDN;
    ldapOp.reqDn.lberbv.bv_len = VmDirStringLenA(pszDN);

    dwError = AttrListToEntry(
            pSchemaCtx,
            pszDN,
            ppszEntryInitializer,
            ldapOp.request.addReq.pEntry);
    BAIL_ON_VMDIR_ERROR(dwError);

    ldapOp.request.addReq.pEntry->eId = ulEntryId;

    if (!IsNullOrEmptyString(pszGuid))
    {
        dwError = VmDirAllocateStringA(pszGuid, &ldapOp.request.addReq.pEntry->pszGuid);
        BAIL_ON_VMDIR_ERROR(dwError);
    }

    dwError = VmDirInternalAddEntry(&ldapOp);
    BAIL_ON_VMDIR_ERROR(dwError);

cleanup:
    VmDirFreeOperationContent(&ldapOp);

    return dwError;

error:

    goto cleanup;
}
Ejemplo n.º 29
0
DWORD
VmwDeployValidateSiteName(
    PCSTR pszSite
    )
{
    DWORD dwError = 0;
    BOOLEAN bHasSpecialChars = FALSE;

    VMW_DEPLOY_LOG_DEBUG(
            "Validating site name [%s]",
            VMW_DEPLOY_SAFE_LOG_STRING(pszSite));

    if (!IsNullOrEmptyString(pszSite))
    {
        PCSTR pszCursor = pszSite;

        while (*pszCursor && !bHasSpecialChars)
        {
            switch (*pszCursor)
            {
                case '!':
                case '@':
                case '#':
                case '$':
                case '%':
                case '^':
                case '&':
                case '*':
                case '[':
                case ']':
                     bHasSpecialChars = TRUE;
                     break;
                default:
                     pszCursor++;
                     break;
            }
        }
    }

    if (bHasSpecialChars)
    {
        VMW_DEPLOY_LOG_ERROR(
                "Site name [%s] has invalid characters",
                VMW_DEPLOY_SAFE_LOG_STRING(pszSite));

        dwError = ERROR_INVALID_PARAMETER;
        BAIL_ON_DEPLOY_ERROR(dwError);
    }

error:

    return dwError;
}
Ejemplo n.º 30
0
Archivo: repo.c Proyecto: jreypo/tdnf
uint32_t
TDNFGetGPGCheck(
    PTDNF pTdnf,
    const char* pszRepo,
    int* pnGPGCheck,
    char** ppszUrlGPGKey
    )
{
    uint32_t dwError = 0;
    PTDNF_REPO_DATA pRepo = NULL;
    int nGPGCheck = 0;
    char* pszUrlGPGKey = NULL;

    if(!pTdnf || !ppszUrlGPGKey || IsNullOrEmptyString(pszRepo))
    {
        dwError = ERROR_TDNF_INVALID_PARAMETER;
        BAIL_ON_TDNF_ERROR(dwError);
    }
    if(!pTdnf->pArgs->nNoGPGCheck)
    {
        dwError = TDNFGetRepoById(pTdnf, pszRepo, &pRepo);
        if(dwError == ERROR_TDNF_NO_DATA)
        {
            dwError = 0;
        }
        BAIL_ON_TDNF_ERROR(dwError);
        if(pRepo)
        {
            nGPGCheck = pRepo->nGPGCheck;
            if(nGPGCheck)
            {
                dwError = TDNFAllocateString(
                             pRepo->pszUrlGPGKey,
                             &pszUrlGPGKey);
                BAIL_ON_TDNF_ERROR(dwError);
            }
        }
    }

    *pnGPGCheck = nGPGCheck;
    *ppszUrlGPGKey = pszUrlGPGKey;

cleanup:
    return dwError;

error:
    if(ppszUrlGPGKey)
    {
        *ppszUrlGPGKey = NULL;
    }
    TDNF_SAFE_FREE_MEMORY(pszUrlGPGKey);
    goto cleanup;
}