//--------------------------------------------------------------------------- // // // Microsoft Windows // Copyright (C) Microsoft Corporation, 1992 - 1997 // // File: cdsobj.cxx // // Contents: Microsoft ADs LDAP Provider DSObject // // // History: 02-20-97 yihsins Created. // //---------------------------------------------------------------------------- #include "ldapc.hxx" #pragma hdrstop // //Hard Coded Support for RootDSE object // LPWSTR SpecialSyntaxesTable[] = { LDAP_OPATT_CURRENT_TIME_W, LDAP_OPATT_SUBSCHEMA_SUBENTRY_W, LDAP_OPATT_SERVER_NAME_W, LDAP_OPATT_NAMING_CONTEXTS_W, LDAP_OPATT_DEFAULT_NAMING_CONTEXT_W, LDAP_OPATT_SCHEMA_NAMING_CONTEXT_W, LDAP_OPATT_CONFIG_NAMING_CONTEXT_W, LDAP_OPATT_ROOT_DOMAIN_NAMING_CONTEXT_W, LDAP_OPATT_SUPPORTED_CONTROL_W, LDAP_OPATT_SUPPORTED_LDAP_VERSION_W, L"lowestUncommittedUSN", L"allowedAttributesEffective", L"supportedExtension", L"altServer", NULL }; HRESULT ComputeAttributeBufferSize( PADS_ATTR_INFO pAdsAttributes, DWORD dwNumAttributes, PDWORD pdwSize, PDWORD pdwNumValues ); LPBYTE CopyAttributeName( PADS_ATTR_INFO pThisAdsSrcAttribute, PADS_ATTR_INFO pThisAdsTargAttribute, LPBYTE pDataBuffer ); HRESULT ADsSetObjectAttributes( ADS_LDP *ld, LPTSTR pszLDAPServer, LPTSTR pszLDAPDn, CCredentials Credentials, DWORD dwPort, SECURITY_INFORMATION seInfo, PADS_ATTR_INFO pAttributeEntries, DWORD dwNumAttributes, DWORD *pdwNumAttributesModified ) { HRESULT hr = S_OK; DWORD i = 0; DWORD j = 0; PADS_ATTR_INFO pThisAttribute = NULL; LDAPOBJECTARRAY ldapObjectArray; DWORD dwSyntaxId = 0; LDAPMod **aMods = NULL; LDAPModW *aModsBuffer = NULL; DWORD dwNumAttributesReturn = 0; BOOL fNTSecDescriptor = FALSE; int ldaperr = 0; DWORD dwOptions = 0; DWORD dwSecDescType = ADSI_LDAPC_SECDESC_NONE; BOOL fModifyDone = FALSE; BYTE berValue[8]; memset(berValue, 0, 8); berValue[0] = 0x30; // Start sequence tag berValue[1] = 0x03; // Length in bytes of following berValue[2] = 0x02; // Actual value this and next 2 berValue[3] = 0x01; berValue[4] = (BYTE)((ULONG)seInfo); LDAPControl SeInfoControl = { LDAP_SERVER_SD_FLAGS_OID_W, { 5, (PCHAR) berValue }, TRUE }; LDAPControl ModifyControl = { LDAP_SERVER_PERMISSIVE_MODIFY_OID_W, { 0, NULL }, FALSE }; PLDAPControl ServerControls[2] = { &SeInfoControl, NULL }; PLDAPControl ServerControlsOnlyModify[2] = { &ModifyControl, NULL }; PLDAPControl ServerControlsAll[3] = { &SeInfoControl, &ModifyControl, NULL }; BOOL fServerIsAD = FALSE; *pdwNumAttributesModified = 0; // // Allocate memory to send the modify request // aMods = (LDAPModW **) AllocADsMem((dwNumAttributes+1) * sizeof(LDAPModW*)); if ( aMods == NULL ) { hr = E_OUTOFMEMORY; BAIL_ON_FAILURE(hr); } aModsBuffer = (LDAPModW *) AllocADsMem( dwNumAttributes * sizeof(LDAPModW)); if ( aModsBuffer == NULL ) { hr = E_OUTOFMEMORY; BAIL_ON_FAILURE(hr); } // // Format the modify request // for (i = 0; i < dwNumAttributes; i++) { BOOL fGenTime = FALSE; LDAPOBJECTARRAY_INIT(ldapObjectArray); pThisAttribute = pAttributeEntries + i; if (!fNTSecDescriptor && _wcsicmp(L"ntSecurityDescriptor", pThisAttribute->pszAttrName) == 0) { { // we need to use appropriate controls if the operation // is modify the security descriptor. Specifically we do // not want to use any control if the operation is a clear // and default to whatever the server deems fit. if (pThisAttribute->dwControlCode != ADS_ATTR_CLEAR) { fNTSecDescriptor = TRUE; } } } if (pThisAttribute->dwControlCode != ADS_ATTR_CLEAR) { // // If this is a time attribute, see if it is GenTime or // UTCTime and set the syntax the flag appropriately // if (pThisAttribute->dwADsType == ADSTYPE_UTC_TIME) { hr = LdapGetSyntaxOfAttributeOnServer( pszLDAPServer, pThisAttribute->pszAttrName, &dwSyntaxId, Credentials, dwPort ); if (SUCCEEDED(hr) && (dwSyntaxId == LDAPTYPE_GENERALIZEDTIME)) { // // Use GenTime conversion // fGenTime = TRUE; } } } switch (pThisAttribute->dwControlCode) { case ADS_ATTR_UPDATE: hr = AdsTypeToLdapTypeCopyConstruct( pThisAttribute->pADsValues, pThisAttribute->dwNumValues, &ldapObjectArray, &dwSyntaxId, fGenTime ); BAIL_ON_FAILURE(hr); aMods[i] = &aModsBuffer[i]; aModsBuffer[i].mod_type = pThisAttribute->pszAttrName; if ( ldapObjectArray.fIsString ) { aModsBuffer[i].mod_values = (TCHAR **) ldapObjectArray.pLdapObjects; } else { aModsBuffer[i].mod_bvalues = (struct berval **) ldapObjectArray.pLdapObjects; aModsBuffer[i].mod_op = LDAP_MOD_BVALUES; } aModsBuffer[i].mod_op |= LDAP_MOD_REPLACE; dwNumAttributesReturn++; break; case ADS_ATTR_APPEND: hr = AdsTypeToLdapTypeCopyConstruct( pThisAttribute->pADsValues, pThisAttribute->dwNumValues, &ldapObjectArray, &dwSyntaxId, fGenTime ); BAIL_ON_FAILURE(hr); aMods[i] = &aModsBuffer[i]; aModsBuffer[i].mod_type = pThisAttribute->pszAttrName; if ( ldapObjectArray.fIsString ) { aModsBuffer[i].mod_values = (TCHAR **) ldapObjectArray.pLdapObjects; } else { aModsBuffer[i].mod_bvalues = (struct berval **) ldapObjectArray.pLdapObjects; aModsBuffer[i].mod_op = LDAP_MOD_BVALUES; } aModsBuffer[i].mod_op |= LDAP_MOD_ADD; dwNumAttributesReturn++; break; case ADS_ATTR_CLEAR: aMods[i] = &aModsBuffer[i]; aModsBuffer[i].mod_type = pThisAttribute->pszAttrName; aModsBuffer[i].mod_bvalues = NULL; aModsBuffer[i].mod_op |= LDAP_MOD_DELETE; dwNumAttributesReturn++; break; case ADS_ATTR_DELETE: hr = AdsTypeToLdapTypeCopyConstruct( pThisAttribute->pADsValues, pThisAttribute->dwNumValues, &ldapObjectArray, &dwSyntaxId, fGenTime ); BAIL_ON_FAILURE(hr); aMods[i] = &aModsBuffer[i]; aModsBuffer[i].mod_type = pThisAttribute->pszAttrName; if ( ldapObjectArray.fIsString ) { aModsBuffer[i].mod_values = (TCHAR **) ldapObjectArray.pLdapObjects; } else { aModsBuffer[i].mod_bvalues = (struct berval **) ldapObjectArray.pLdapObjects; aModsBuffer[i].mod_op = LDAP_MOD_BVALUES; } aModsBuffer[i].mod_op |= LDAP_MOD_DELETE; dwNumAttributesReturn++; break; default: // // ignore this attribute and move on // break; } } // // Find out if server is AD. // hr = ReadServerSupportsIsADControl( pszLDAPServer, &fServerIsAD, Credentials, dwPort ); if (FAILED(hr)) { // // Assume it is not AD and continue, there is no // good reason for this to fail on AD. // fServerIsAD = FALSE; } // // Modify the object with appropriate call // if (fNTSecDescriptor) { // // Check if we are V3 // ldaperr = ldap_get_option( ld->LdapHandle, LDAP_OPT_VERSION, &dwOptions ); // // check supported controls and set accordingly // if (ldaperr == LDAP_SUCCESS && (dwOptions == LDAP_VERSION3)) { // // Read the security descriptor type if applicable // hr = ReadSecurityDescriptorControlType( pszLDAPServer, &dwSecDescType, Credentials, dwPort ); if (SUCCEEDED(hr) && (dwSecDescType == ADSI_LDAPC_SECDESC_NT)) { hr = LdapModifyExtS( ld, pszLDAPDn, aMods, fServerIsAD ? (PLDAPControl *) &ServerControlsAll : (PLDAPControl *) &ServerControls, NULL ); fModifyDone = TRUE; } } // If Read Version succeeded } // // Perform a simple modify - only if fModifyDone is false // if (!fModifyDone) { if (fServerIsAD) { // // Need to send the OID that allows delete on empty attributes // without sending an error - for clients that have gotten used // to bad practices. // hr = LdapModifyExtS( ld, pszLDAPDn, aMods, (PLDAPControl *)&ServerControlsOnlyModify, NULL ); } else { // // Regular calls from most folks not using AD. // hr = LdapModifyS( ld, pszLDAPDn, aMods ); } } BAIL_ON_FAILURE(hr); *pdwNumAttributesModified = dwNumAttributesReturn; error: if ( aModsBuffer ) { for ( j = 0; j < i; j++ ) { if ( aModsBuffer[j].mod_op & LDAP_MOD_BVALUES ) { if ( aModsBuffer[j].mod_bvalues ) { for ( DWORD k = 0; aModsBuffer[j].mod_bvalues[k]; k++ ) FreeADsMem( aModsBuffer[j].mod_bvalues[k] ); FreeADsMem( aModsBuffer[j].mod_bvalues ); } } else if ( aModsBuffer[j].mod_values ) { for ( DWORD k = 0; aModsBuffer[j].mod_values[k]; k++ ) FreeADsMem( aModsBuffer[j].mod_values[k] ); FreeADsMem( aModsBuffer[j].mod_values ); } } FreeADsMem( aModsBuffer ); } if ( aMods ) FreeADsMem( aMods ); return hr; } HRESULT ADsGetObjectAttributes( ADS_LDP *ld, LPTSTR pszLDAPServer, LPTSTR pszLDAPDn, CCredentials Credentials, DWORD dwPort, SECURITY_INFORMATION seInfo, LPWSTR *pAttributeNames, DWORD dwNumberAttributes, PADS_ATTR_INFO *ppAttributeEntries, DWORD * pdwNumAttributesReturned ) { HRESULT hr = S_OK; DWORD i = 0; DWORD j = 0; LPWSTR *aStrings = NULL; LDAPMessage *res = NULL; LDAPMessage *entry = NULL; void *ptr; DWORD dwNumberOfEntries = 0; LPTSTR pszAttrName = NULL; LDAPOBJECTARRAY ldapObjectArray; PADSVALUE pAdsDestValues = NULL; DWORD dwNumAdsValues = 0; DWORD dwAdsType = 0; DWORD dwSyntaxId = 0; PADS_ATTR_INFO pAdsAttributes = NULL; PADS_ATTR_INFO pThisAttributeDef = NULL; LPBYTE pAttributeBuffer = NULL; DWORD dwAttrCount = 0; DWORD dwMemSize = 0; DWORD dwTotalValues = 0; DWORD dwNumValues = 0; LPBYTE pValueBuffer = NULL; LPBYTE pDataBuffer = NULL; PADS_ATTR_INFO pAttrEntry = NULL; PADSVALUE pAttrValue = NULL; PADS_ATTR_INFO pThisAdsSrcAttribute = NULL; PADS_ATTR_INFO pThisAdsTargAttribute = NULL; PADSVALUE pThisAdsSrcValue = NULL; PADSVALUE pThisAdsTargValue = NULL; *ppAttributeEntries = NULL; *pdwNumAttributesReturned = 0; DWORD ldaperr = 0; DWORD dwOptions = 0; BOOLEAN getSecDesc = FALSE; DWORD dwSecDescType = ADSI_LDAPC_SECDESC_NONE; BOOLEAN fSearchDone = FALSE; BYTE berValue[8]; memset(berValue, 0, 8); berValue[0] = 0x30; // Start sequence tag berValue[1] = 0x03; // Length in bytes of following berValue[2] = 0x02; // Actual value this and next 2 berValue[3] = 0x01; berValue[4] = (BYTE)((ULONG)seInfo); LDAPControl SeInfoControl = { LDAP_SERVER_SD_FLAGS_OID_W, { 5, (PCHAR) berValue }, TRUE }; PLDAPControl ServerControls[2] = { &SeInfoControl, NULL }; LDAPOBJECTARRAY_INIT(ldapObjectArray); if (dwNumberAttributes != (DWORD)-1) { if ( dwNumberAttributes == 0 ) return S_OK; // // Package attributes // aStrings = (LPWSTR *) AllocADsMem( sizeof(LPTSTR) * (dwNumberAttributes + 1)); if ( aStrings == NULL ) { hr = E_OUTOFMEMORY; BAIL_ON_FAILURE(hr); } for ( i = 0; i < dwNumberAttributes; i++) { aStrings[i] = pAttributeNames[i]; if (!getSecDesc && _wcsicmp(L"ntSecurityDescriptor", pAttributeNames[i]) == 0) { // we need go to get the security descriptor getSecDesc = TRUE; } } } else { // // If all attributes are requested, we will mark as read // security descriptor also. Further down, the decision to // use or not use a control is made. // getSecDesc = TRUE; } // // Read the DS Object // // modified from LdapSearchS to LdapSearchExtS to get all attributes // including SecurityDescriptor by one call if (getSecDesc) { ldaperr = ldap_get_option( ld->LdapHandle, LDAP_OPT_VERSION, &dwOptions ); if (dwOptions == LDAP_VERSION3) { // // Read the security descriptor type if applicable // hr = ReadSecurityDescriptorControlType( pszLDAPServer, &dwSecDescType, Credentials, dwPort ); // // If we could no get the control information for whatever reason, // just try the SearchS. // if (SUCCEEDED(hr) && (dwSecDescType == ADSI_LDAPC_SECDESC_NT)) { hr = LdapSearchExtS( ld, pszLDAPDn, LDAP_SCOPE_BASE, TEXT("(objectClass=*)"), aStrings, 0, (PLDAPControl *)&ServerControls, NULL, NULL, 10000, &res ); fSearchDone = TRUE; } } } // // Perform just a LdapSearchS if the flag indicates that // no search has been done. We do not try a second search // if the first tone failed (saves packets on the wire). // if (!fSearchDone) { hr = LdapSearchS( ld, pszLDAPDn, LDAP_SCOPE_BASE, TEXT("(objectClass=*)"), aStrings, 0, &res ); fSearchDone = TRUE; BAIL_ON_FAILURE(hr); } // // Should only contain one entry // if ( LdapCountEntries( ld, res ) == 0 ) goto error; hr = LdapFirstEntry( ld, res, &entry ); BAIL_ON_FAILURE(hr); // // Compute the number of attributes in the // read buffer. // hr = LdapFirstAttribute( ld, entry, &ptr, &pszAttrName ); BAIL_ON_FAILURE(hr); while ( pszAttrName != NULL ) { dwNumberOfEntries++; LdapAttributeFree( pszAttrName ); pszAttrName = NULL; hr = LdapNextAttribute( ld, entry, ptr, &pszAttrName ); if (FAILED(hr)) break; // error occurred, ignore the rest of the attributes } // // Allocate an attribute buffer which is as large as the // number of attributes present // // // Note that pADsAttributes is inited to Null if (dwNumberOfEntries != 0) { pAdsAttributes = (PADS_ATTR_INFO)AllocADsMem( sizeof(ADS_ATTR_INFO) * dwNumberOfEntries ); if (!pAdsAttributes) { hr = E_OUTOFMEMORY; BAIL_ON_FAILURE(hr); } } dwAttrCount = 0; ptr = NULL; hr = LdapFirstAttribute( ld, entry, &ptr, &pszAttrName ); while ( SUCCEEDED(hr) && ( pszAttrName != NULL ) && ( dwAttrCount < dwNumberOfEntries ) ) { // // Get the syntax of the attribute. Force only // if we know that the this is not the RootDSE // as RootDSE attributes are not in schema. // hr = LdapGetSyntaxOfAttributeOnServer( pszLDAPServer, pszAttrName, &dwSyntaxId, Credentials, dwPort, pszLDAPDn ? TRUE : FALSE ); // // If it failed with errorcode 0x8000500D which is // E_ADS_PROPERTY_NOT_FOUND, // see if it is one of the RootDSE syntaxes, // if so set Syntax to ADSTYPE_CASE_IGNORE_STRING // if (hr == E_ADS_PROPERTY_NOT_FOUND) { // // search the hardcoded table to see if it is a known entry // BOOLEAN valFound = FALSE; DWORD ctr = 0; while (SpecialSyntaxesTable[ctr] && !valFound) { if (!_wcsicmp(pszAttrName, SpecialSyntaxesTable[ctr])) { dwSyntaxId = ADSTYPE_CASE_IGNORE_STRING; hr = S_OK; valFound = TRUE; } ctr++; } }else { if (!_wcsicmp(pszAttrName, L"ntSecurityDescriptor")) { dwSyntaxId = LDAPTYPE_SECURITY_DESCRIPTOR; } } if ( hr == E_ADS_PROPERTY_NOT_FOUND ) { // // We will default to provider specific // dwSyntaxId = LDAPTYPE_UNKNOWN; } else if (FAILED(hr)) { // // Some other failure so skip attribute // goto NextAttr; } // // Get the values of the current attribute // hr = UnMarshallLDAPToLDAPSynID( pszAttrName, ld, entry, dwSyntaxId, &ldapObjectArray ); if ( FAILED(hr)) goto NextAttr; hr = LdapTypeToAdsTypeCopyConstruct( ldapObjectArray, dwSyntaxId, &pAdsDestValues, &dwNumAdsValues, &dwAdsType ); if (FAILED(hr)) goto NextAttr; pThisAttributeDef = pAdsAttributes + dwAttrCount; pThisAttributeDef->pszAttrName = AllocADsStr(pszAttrName); if ( !pThisAttributeDef->pszAttrName ) { hr = E_OUTOFMEMORY; BAIL_ON_FAILURE(hr); } pThisAttributeDef->pADsValues = pAdsDestValues; if ( pThisAttributeDef->dwNumValues = ldapObjectArray.dwCount ) pThisAttributeDef->dwADsType = pAdsDestValues[0].dwType; dwAttrCount++; NextAttr: if ( pszAttrName ) { LdapAttributeFree( pszAttrName ); pszAttrName = NULL; } if ( ldapObjectArray.pLdapObjects ) { if ( ldapObjectArray.fIsString ) LdapValueFree( (TCHAR **) ldapObjectArray.pLdapObjects ); else LdapValueFreeLen( (struct berval **) ldapObjectArray.pLdapObjects ); LDAPOBJECTARRAY_INIT(ldapObjectArray); } if ( hr == E_OUTOFMEMORY ) // break on serious error break; hr = LdapNextAttribute( ld, entry, ptr, &pszAttrName ); } BAIL_ON_FAILURE(hr); if ( dwAttrCount == 0 ) goto error; // // Now package this data into a single contiguous buffer // hr = ComputeAttributeBufferSize( pAdsAttributes, dwAttrCount, &dwMemSize, &dwTotalValues ); BAIL_ON_FAILURE(hr); pAttributeBuffer = (LPBYTE) AllocADsMem( dwMemSize ); if (!pAttributeBuffer) { hr = E_OUTOFMEMORY; BAIL_ON_FAILURE(hr); } pValueBuffer = pAttributeBuffer + dwAttrCount * (sizeof(ADS_ATTR_INFO)); pDataBuffer = pValueBuffer + dwTotalValues * sizeof(ADSVALUE); pAttrEntry = (PADS_ATTR_INFO) pAttributeBuffer; pAttrValue = (PADSVALUE) pValueBuffer; for (i = 0; i < dwAttrCount; i++) { pThisAdsSrcAttribute = pAdsAttributes + i; pThisAdsTargAttribute = pAttrEntry + i; dwNumValues = pThisAdsSrcAttribute->dwNumValues; pThisAdsTargAttribute->dwNumValues = dwNumValues; pThisAdsTargAttribute->dwADsType = pThisAdsSrcAttribute->dwADsType; pThisAdsTargAttribute->pADsValues = pAttrValue; pThisAdsSrcValue = pThisAdsSrcAttribute->pADsValues; pThisAdsTargValue = pAttrValue; if (!pDataBuffer) { BAIL_ON_FAILURE(hr = E_OUTOFMEMORY); } for ( j = 0; j < dwNumValues; j++) { pDataBuffer = AdsTypeCopy( pThisAdsSrcValue, pThisAdsTargValue, pDataBuffer ); pAttrValue++; pThisAdsTargValue = pAttrValue; pThisAdsSrcValue++; } if (!pDataBuffer) { BAIL_ON_FAILURE(hr = E_OUTOFMEMORY); } pDataBuffer = CopyAttributeName( pThisAdsSrcAttribute, pThisAdsTargAttribute, pDataBuffer ); } hr = S_OK; error: if ( aStrings ) FreeADsMem( aStrings ); if ( res ) LdapMsgFree( res ); // // Clean up the header based Ods structures // if ( pAdsAttributes ) { for (i = 0; i < dwAttrCount; i++) { pThisAttributeDef = pAdsAttributes + i; FreeADsStr( pThisAttributeDef->pszAttrName ); AdsTypeFreeAdsObjects( pThisAttributeDef->pADsValues, pThisAttributeDef->dwNumValues ); } FreeADsMem( pAdsAttributes ); } if (FAILED(hr)) { if ( pAttributeBuffer ) FreeADsMem(pAttributeBuffer); *ppAttributeEntries = NULL; *pdwNumAttributesReturned = 0; } else { *ppAttributeEntries = (PADS_ATTR_INFO)pAttributeBuffer; *pdwNumAttributesReturned = dwAttrCount; } return hr; } HRESULT ADsCreateDSObjectExt( ADS_LDP *ld, LPTSTR ADsPath, LPWSTR pszRDNName, PADS_ATTR_INFO pAttributeEntries, DWORD dwNumAttributes, SECURITY_INFORMATION seInfo, BOOL fSecDesc ) { HRESULT hr = S_OK; LPTSTR pszAbsoluteName = NULL; TCHAR *pszLDAPServer = NULL; LPWSTR pszLDAPDn = NULL; DWORD dwSyntaxId = 0; DWORD dwPort = 0; DWORD i = 0; DWORD j = 0; PADS_ATTR_INFO pThisAttribute = NULL; LDAPOBJECTARRAY ldapObjectArray; LDAPMod **aMods = NULL; LDAPModW *aModsBuffer = NULL; BYTE berValue[8]; memset(berValue, 0, 8); berValue[0] = 0x30; // Start sequence tag berValue[1] = 0x03; // Length in bytes of following berValue[2] = 0x02; // Actual value this and next 2 berValue[3] = 0x01; berValue[4] = (BYTE)((ULONG)seInfo); LDAPControl SeInfoControl = { LDAP_SERVER_SD_FLAGS_OID_W, { 5, (PCHAR) berValue }, TRUE }; PLDAPControl ServerControls[2] = { &SeInfoControl, NULL }; // // Get the LDAP path of the object to create // hr = BuildADsPathFromParent( ADsPath, pszRDNName, &pszAbsoluteName ); BAIL_ON_FAILURE(hr); hr = BuildLDAPPathFromADsPath2( pszAbsoluteName, &pszLDAPServer, &pszLDAPDn, &dwPort ); BAIL_ON_FAILURE(hr); // // Allocate memory to store the add request // aMods = (LDAPModW **) AllocADsMem((dwNumAttributes+1) * sizeof(LDAPModW*)); if ( aMods == NULL ) { hr = E_OUTOFMEMORY; BAIL_ON_FAILURE(hr); } aModsBuffer = (LDAPModW *) AllocADsMem( dwNumAttributes * sizeof(LDAPModW)); if ( aModsBuffer == NULL ) { hr = E_OUTOFMEMORY; BAIL_ON_FAILURE(hr); } // // Format the add request // for (i = 0; i < dwNumAttributes; i++) { BOOL fGenTime = FALSE; LDAPOBJECTARRAY_INIT(ldapObjectArray); pThisAttribute = pAttributeEntries + i; if (pThisAttribute->dwControlCode != ADS_ATTR_CLEAR) { // // If this is a time attribute, see if it is GenTime or // UTCTime and set the syntax the flag appropriately // if (pThisAttribute->dwADsType == ADSTYPE_UTC_TIME) { hr = LdapGetSyntaxOfAttributeOnServer( pszLDAPServer, pThisAttribute->pszAttrName, &dwSyntaxId, (*ld->pCredentials), ld->PortNumber ); if (SUCCEEDED(hr) && (dwSyntaxId == LDAPTYPE_GENERALIZEDTIME)) { // // Use GenTime conversion // fGenTime = TRUE; } } } hr = AdsTypeToLdapTypeCopyConstruct( pThisAttribute->pADsValues, pThisAttribute->dwNumValues, &ldapObjectArray, &dwSyntaxId, fGenTime ); BAIL_ON_FAILURE(hr); aMods[i] = &aModsBuffer[i]; aModsBuffer[i].mod_type = pThisAttribute->pszAttrName; if ( ldapObjectArray.fIsString ) { aModsBuffer[i].mod_values = (TCHAR **) ldapObjectArray.pLdapObjects; } else { aModsBuffer[i].mod_bvalues = (struct berval **) ldapObjectArray.pLdapObjects; aModsBuffer[i].mod_op = LDAP_MOD_BVALUES; } aModsBuffer[i].mod_op |= LDAP_MOD_REPLACE; } if (fSecDesc) { hr = LdapAddExtS( ld, pszLDAPDn, aMods, (PLDAPControl *)&ServerControls, NULL ); } else { // // Now, send the add request // hr = LdapAddS( ld, pszLDAPDn, aMods ); } BAIL_ON_FAILURE(hr); error: if ( pszAbsoluteName ) { FreeADsStr( pszAbsoluteName ); } if ( pszLDAPServer ) { FreeADsStr( pszLDAPServer ); } if (pszLDAPDn) { FreeADsStr( pszLDAPDn); } if ( aModsBuffer ) { for ( j = 0; j < i; j++ ) { if ( aModsBuffer[j].mod_op & LDAP_MOD_BVALUES ) { if ( aModsBuffer[j].mod_bvalues ) { for ( DWORD k = 0; aModsBuffer[j].mod_bvalues[k]; k++ ) FreeADsMem( aModsBuffer[j].mod_bvalues[k] ); FreeADsMem( aModsBuffer[j].mod_bvalues ); } } else if ( aModsBuffer[j].mod_values ) { for ( DWORD k = 0; aModsBuffer[j].mod_values[k]; k++ ) FreeADsMem( aModsBuffer[j].mod_values[k] ); FreeADsMem( aModsBuffer[j].mod_values ); } } FreeADsMem( aModsBuffer ); } if ( aMods ) FreeADsMem( aMods ); return hr; } HRESULT ADsCreateDSObject( ADS_LDP *ld, LPTSTR ADsPath, LPWSTR pszRDNName, PADS_ATTR_INFO pAttributeEntries, DWORD dwNumAttributes ) { RRETURN ( ADsCreateDSObjectExt( ld, ADsPath, pszRDNName, pAttributeEntries, dwNumAttributes, 0, // for seInfo since it is ignored FALSE ) ); } HRESULT ADsDeleteDSObject( ADS_LDP *ld, LPTSTR ADsPath, LPWSTR pszRDNName ) { HRESULT hr = S_OK; LPTSTR pszAbsoluteName = NULL; TCHAR *pszLDAPServer = NULL; LPWSTR pszLDAPDn = NULL; DWORD dwPort = 0; // // Get the LDAP path of the object to delete // hr = BuildADsPathFromParent( ADsPath, pszRDNName, &pszAbsoluteName ); BAIL_ON_FAILURE(hr); hr = BuildLDAPPathFromADsPath2( pszAbsoluteName, &pszLDAPServer, &pszLDAPDn, &dwPort ); BAIL_ON_FAILURE(hr); // // Now, send the delete request // hr = LdapDeleteS( ld, pszLDAPDn ); BAIL_ON_FAILURE(hr); error: if ( pszAbsoluteName ) { FreeADsStr( pszAbsoluteName ); } if ( pszLDAPServer ) { FreeADsStr( pszLDAPServer ); } if (pszLDAPDn) { FreeADsStr(pszLDAPDn); } return hr; } HRESULT ComputeAttributeBufferSize( PADS_ATTR_INFO pAdsAttributes, DWORD dwNumAttributes, PDWORD pdwSize, PDWORD pdwNumValues ) { PADS_ATTR_INFO pThisAttribute = NULL; PADSVALUE pAdsSrcValues = NULL; DWORD dwNumValues = 0; DWORD dwSize = 0; DWORD dwTotalNumValues = 0; for ( DWORD i = 0; i < dwNumAttributes; i++) { pThisAttribute = pAdsAttributes + i; dwNumValues = pThisAttribute->dwNumValues; dwTotalNumValues += dwNumValues; pAdsSrcValues = pThisAttribute->pADsValues; for ( DWORD j = 0; j < dwNumValues; j++) dwSize += AdsTypeSize(pAdsSrcValues + j) + sizeof(ADSVALUE); dwSize += sizeof(ADS_ATTR_INFO); dwSize += ((wcslen(pThisAttribute->pszAttrName) + 1)*sizeof(WCHAR)) + (ALIGN_WORD-1); } *pdwSize = dwSize; *pdwNumValues = dwTotalNumValues; return S_OK; } LPBYTE CopyAttributeName( PADS_ATTR_INFO pThisAdsSrcAttribute, PADS_ATTR_INFO pThisAdsTargAttribute, LPBYTE pDataBuffer ) { // // strings should be WCHAR (i.e., WORD) aligned // pDataBuffer = (LPBYTE) ROUND_UP_POINTER(pDataBuffer, ALIGN_WORD); LPWSTR pCurrentPos = (LPWSTR)pDataBuffer; wcscpy(pCurrentPos, pThisAdsSrcAttribute->pszAttrName); pThisAdsTargAttribute->pszAttrName = pCurrentPos; pDataBuffer = pDataBuffer + (wcslen(pThisAdsSrcAttribute->pszAttrName) + 1)*sizeof(WCHAR); return(pDataBuffer); }