static
NTSTATUS
NetrAllocateRidWithAttribute(
OUT PRID_WITH_ATTRIBUTE pOut,
IN OUT PDWORD pdwOffset,
IN OUT PDWORD pdwSpaceLeft,
IN PRID_WITH_ATTRIBUTE pRids,
IN OUT PDWORD pdwSize
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
PVOID pBuffer = pOut;
BAIL_ON_INVALID_PTR(pdwOffset, ntStatus);
BAIL_ON_INVALID_PTR(pRids, ntStatus);
BAIL_ON_INVALID_PTR(pdwSize, ntStatus);
LWBUF_ALLOC_DWORD(pBuffer, pRids->dwRid);
LWBUF_ALLOC_DWORD(pBuffer, pRids->dwAttributes);
cleanup:
if (ntStatus == STATUS_SUCCESS &&
dwError != ERROR_SUCCESS)
{
ntStatus = LwWin32ErrorToNtStatus(dwError);
}
return ntStatus;
error:
goto cleanup;
}
DWORD
DsrAllocateDsRoleInfo(
OUT PDSR_ROLE_INFO pOut,
IN OUT PDWORD pdwOffset,
IN OUT PDWORD pdwSpaceLeft,
IN PDSR_ROLE_INFO pIn,
IN WORD swLevel,
IN OUT PDWORD pdwSize
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
PVOID pBuffer = pOut;
BAIL_ON_INVALID_PTR(pdwOffset, ntStatus);
BAIL_ON_INVALID_PTR(pIn, ntStatus);
BAIL_ON_INVALID_PTR(pdwSize, ntStatus);
switch(swLevel)
{
case DS_ROLE_BASIC_INFORMATION:
LWBUF_ALLOC_DWORD(pBuffer, pIn->Basic.dwRole);
LWBUF_ALLOC_DWORD(pBuffer, pIn->Basic.dwFlags);
LWBUF_ALLOC_PWSTR(pBuffer, pIn->Basic.pwszDomain);
LWBUF_ALLOC_PWSTR(pBuffer, pIn->Basic.pwszDnsDomain);
LWBUF_ALLOC_PWSTR(pBuffer, pIn->Basic.pwszForest);
LWBUF_ALLOC_BLOB(pBuffer,
sizeof(pIn->Basic.DomainGuid),
&pIn->Basic.DomainGuid);
break;
case DS_ROLE_UPGRADE_STATUS:
LWBUF_ALLOC_WORD(pBuffer, pIn->Upgrade.swUpgradeStatus);
LWBUF_ALIGN_TYPE(pdwOffset, pdwSize, pdwSpaceLeft, DWORD);
LWBUF_ALLOC_DWORD(pBuffer, pIn->Upgrade.dwPrevious);
break;
case DS_ROLE_OP_STATUS:
LWBUF_ALLOC_WORD(pBuffer, pIn->OpStatus.swStatus);
break;
default:
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
BAIL_ON_WIN_ERROR(dwError);
cleanup:
if (dwError == ERROR_SUCCESS &&
ntStatus != STATUS_SUCCESS)
{
dwError = LwNtStatusToWin32Error(dwError);
}
return dwError;
error:
goto cleanup;
}
NTSTATUS
LsaAllocateTranslatedSids3(
OUT TranslatedSid3 *pOut,
IN OUT PDWORD pdwOffset,
IN OUT PDWORD pdwSpaceLeft,
IN TranslatedSidArray3 *pIn,
IN OUT PDWORD pdwSize
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
PVOID pBuffer = pOut;
DWORD iTransSid = 0;
BAIL_ON_INVALID_PTR(pdwOffset, ntStatus);
BAIL_ON_INVALID_PTR(pIn, ntStatus);
BAIL_ON_INVALID_PTR(pdwSize, ntStatus);
for (iTransSid = 0; iTransSid < pIn->count; iTransSid++)
{
LWBUF_ALLOC_WORD(pBuffer, pIn->sids[iTransSid].type);
LWBUF_ALIGN_PTR(pdwOffset, pdwSize, pdwSpaceLeft);
if (pIn->sids[iTransSid].sid)
{
LWBUF_ALLOC_PSID(pBuffer, pIn->sids[iTransSid].sid);
}
else if (pIn->sids[iTransSid].type == SID_TYPE_DOMAIN ||
pIn->sids[iTransSid].type == SID_TYPE_INVALID ||
pIn->sids[iTransSid].type == SID_TYPE_UNKNOWN)
{
LWBUF_ALLOC_PSID(pBuffer, NULL);
}
else
{
ntStatus = STATUS_INVALID_SID;
BAIL_ON_NT_STATUS(ntStatus);
}
LWBUF_ALLOC_DWORD(pBuffer, pIn->sids[iTransSid].index);
LWBUF_ALLOC_DWORD(pBuffer, pIn->sids[iTransSid].unknown1);
}
cleanup:
if (ntStatus == STATUS_SUCCESS &&
dwError != ERROR_SUCCESS)
{
ntStatus = LwWin32ErrorToNtStatus(dwError);
}
return ntStatus;
error:
goto cleanup;
}
static
NTSTATUS
NetrAllocateSidAttr(
OUT NetrSidAttr *pOut,
IN OUT PDWORD pdwOffset,
IN OUT PDWORD pdwSpaceLeft,
IN NetrSidAttr *pIn,
IN OUT PDWORD pdwSize
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
PVOID pBuffer = pOut;
BAIL_ON_INVALID_PTR(pdwOffset, ntStatus);
BAIL_ON_INVALID_PTR(pIn, ntStatus);
BAIL_ON_INVALID_PTR(pdwSize, ntStatus);
LWBUF_ALLOC_PSID(pBuffer, pIn->sid);
LWBUF_ALLOC_DWORD(pBuffer, pIn->attribute);
LWBUF_ALIGN(pdwOffset, pdwSize, pdwSpaceLeft);
cleanup:
if (ntStatus == STATUS_SUCCESS &&
dwError != ERROR_SUCCESS)
{
ntStatus = LwWin32ErrorToNtStatus(dwError);
}
return ntStatus;
error:
goto cleanup;
}
NTSTATUS
NetrAllocateDomainTrusts(
OUT NetrDomainTrust *pOut,
IN OUT PDWORD pdwOffset,
IN OUT PDWORD pdwSpaceLeft,
IN NetrDomainTrustList *pIn,
IN OUT PDWORD pdwSize
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
PVOID pBuffer = pOut;
UINT32 i = 0;
BAIL_ON_INVALID_PTR(pdwOffset, ntStatus);
BAIL_ON_INVALID_PTR(pIn, ntStatus);
BAIL_ON_INVALID_PTR(pdwSize, ntStatus);
for (i = 0; i < pIn->count; i++)
{
LWBUF_ALLOC_PWSTR(pBuffer, pIn->array[i].netbios_name);
LWBUF_ALLOC_PWSTR(pBuffer, pIn->array[i].dns_name);
LWBUF_ALLOC_DWORD(pBuffer, pIn->array[i].trust_flags);
LWBUF_ALLOC_DWORD(pBuffer, pIn->array[i].parent_index);
LWBUF_ALLOC_WORD(pBuffer, pIn->array[i].trust_type);
LWBUF_ALIGN_TYPE(pdwOffset, pdwSize, pdwSpaceLeft, DWORD);
LWBUF_ALLOC_DWORD(pBuffer, pIn->array[i].trust_attrs);
LWBUF_ALLOC_PSID(pBuffer, pIn->array[i].sid);
LWBUF_ALLOC_BLOB(pBuffer,
sizeof(pIn->array[i].guid),
&(pIn->array[i].guid));
}
cleanup:
if (ntStatus == STATUS_SUCCESS &&
dwError != ERROR_SUCCESS)
{
ntStatus = LwWin32ErrorToNtStatus(dwError);
}
return ntStatus;
error:
goto cleanup;
}
NTSTATUS
LsaAllocateTranslatedSids2(
OUT TranslatedSid2 *pOut,
IN OUT PDWORD pdwOffset,
IN OUT PDWORD pdwSpaceLeft,
IN TranslatedSidArray2 *pIn,
IN OUT PDWORD pdwSize
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
PVOID pBuffer = pOut;
DWORD iTransSid = 0;
BAIL_ON_INVALID_PTR(pdwOffset, ntStatus);
BAIL_ON_INVALID_PTR(pIn, ntStatus);
BAIL_ON_INVALID_PTR(pdwSize, ntStatus);
for (iTransSid = 0; iTransSid < pIn->count; iTransSid++)
{
LWBUF_ALLOC_WORD(pBuffer, pIn->sids[iTransSid].type);
LWBUF_ALIGN_TYPE(pdwOffset, pdwSize, pdwSpaceLeft, DWORD);
LWBUF_ALLOC_DWORD(pBuffer, pIn->sids[iTransSid].rid);
LWBUF_ALLOC_DWORD(pBuffer, pIn->sids[iTransSid].index);
LWBUF_ALLOC_DWORD(pBuffer, pIn->sids[iTransSid].unknown1);
}
cleanup:
if (ntStatus == STATUS_SUCCESS &&
dwError != ERROR_SUCCESS)
{
ntStatus = LwWin32ErrorToNtStatus(dwError);
}
return ntStatus;
error:
goto cleanup;
}
NTSTATUS
LsaAllocateTranslatedNames(
OUT TranslatedName *pOut,
IN OUT PDWORD pdwOffset,
IN OUT PDWORD pdwSpaceLeft,
IN TranslatedNameArray *pIn,
IN OUT PDWORD pdwSize
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
PVOID pBuffer = pOut;
DWORD iTransName = 0;
BAIL_ON_INVALID_PTR(pdwOffset, ntStatus);
BAIL_ON_INVALID_PTR(pIn, ntStatus);
BAIL_ON_INVALID_PTR(pdwSize, ntStatus);
for (iTransName = 0; iTransName < pIn->count; iTransName++)
{
LWBUF_ALIGN(pdwOffset, pdwSize, pdwSpaceLeft);
LWBUF_ALLOC_WORD(pBuffer, pIn->names[iTransName].type);
LWBUF_ALIGN_PTR(pdwOffset, pdwSize, pdwSpaceLeft);
LWBUF_ALLOC_UNICODE_STRING(
pBuffer,
(PUNICODE_STRING)&pIn->names[iTransName].name);
LWBUF_ALLOC_DWORD(pBuffer, pIn->names[iTransName].sid_index);
}
cleanup:
if (ntStatus == STATUS_SUCCESS &&
dwError != ERROR_SUCCESS)
{
ntStatus = LwWin32ErrorToNtStatus(dwError);
}
return ntStatus;
error:
goto cleanup;
}
NTSTATUS
NetrAllocateDcNameInfo(
OUT DsrDcNameInfo *pOut,
IN OUT PDWORD pdwOffset,
IN OUT PDWORD pdwSpaceLeft,
IN DsrDcNameInfo *pIn,
IN OUT PDWORD pdwSize
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
DsrDcNameInfo *pBuffer = pOut;
BAIL_ON_INVALID_PTR(pdwOffset, ntStatus);
BAIL_ON_INVALID_PTR(pIn, ntStatus);
BAIL_ON_INVALID_PTR(pdwSize, ntStatus);
LWBUF_ALLOC_PWSTR(pBuffer, pIn->dc_name);
LWBUF_ALLOC_PWSTR(pBuffer, pIn->dc_address);
LWBUF_ALLOC_WORD(pBuffer, pIn->address_type);
LWBUF_ALLOC_BLOB(pBuffer, sizeof(pIn->domain_guid), &pIn->domain_guid);
LWBUF_ALLOC_PWSTR(pBuffer, pIn->domain_name);
LWBUF_ALLOC_PWSTR(pBuffer, pIn->forest_name);
LWBUF_ALLOC_DWORD(pBuffer, pIn->flags);
LWBUF_ALLOC_PWSTR(pBuffer, pIn->dc_site_name);
LWBUF_ALLOC_PWSTR(pBuffer, pIn->cli_site_name);
cleanup:
if (ntStatus == STATUS_SUCCESS &&
dwError != ERROR_SUCCESS)
{
ntStatus = LwWin32ErrorToNtStatus(dwError);
}
return ntStatus;
error:
goto cleanup;
}
NTSTATUS
LsaAllocateRefDomainList(
OUT RefDomainList *pOut,
IN OUT PDWORD pdwOffset,
IN OUT PDWORD pdwSpaceLeft,
IN RefDomainList *pIn,
IN OUT PDWORD pdwSize
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
PVOID pBuffer = pOut;
PVOID pCursor = NULL;
PVOID pDomains = NULL;
PVOID *ppDomains = NULL;
DWORD iDom = 0;
DWORD dwDomainsSize = 0;
DWORD dwDomainsSpaceLeft = 0;
DWORD dwDomainsOffset = 0;
BAIL_ON_INVALID_PTR(pdwOffset, ntStatus);
BAIL_ON_INVALID_PTR(pIn, ntStatus);
BAIL_ON_INVALID_PTR(pdwSize, ntStatus);
LWBUF_ALLOC_DWORD(pBuffer, pIn->count);
LWBUF_ALIGN_PTR(pdwOffset, pdwSize, pdwSpaceLeft);
if (pIn->count > 0)
{
for (iDom = 0; iDom < pIn->count; iDom++)
{
ntStatus = LsaAllocateDomainInfo(NULL,
&dwDomainsOffset,
NULL,
&(pIn->domains[iDom]),
&dwDomainsSize);
BAIL_ON_NT_STATUS(ntStatus);
}
}
if (pBuffer && pdwSpaceLeft)
{
BAIL_IF_NOT_ENOUGH_SPACE(dwDomainsSize, pdwSpaceLeft, dwError);
pCursor = pBuffer + (*pdwOffset);
if (pIn->count)
{
pDomains = LWBUF_TARGET_PTR(pBuffer, dwDomainsSize, pdwSpaceLeft);
/* sanity check - the data pointer and current buffer cursor
must not overlap */
BAIL_IF_PTR_OVERLAP(PBYTE, pDomains, dwError);
dwDomainsSpaceLeft = dwDomainsSize;
dwDomainsOffset = 0;
/* Allocate the entries */
for (iDom = 0; iDom < pIn->count; iDom++)
{
PVOID pDomCursor = pDomains + (iDom * sizeof(pIn->domains[0]));
ntStatus = LsaAllocateDomainInfo(pDomCursor,
&dwDomainsOffset,
&dwDomainsSpaceLeft,
&(pIn->domains[iDom]),
pdwSize);
BAIL_ON_NT_STATUS(ntStatus);
dwDomainsOffset = 0;
}
}
ppDomains = (PVOID*)pCursor;
*ppDomains = (PVOID)pDomains;
(*pdwSpaceLeft) -= (pDomains) ? LWBUF_ALIGN_SIZE(dwDomainsSize) : 0;
/* recalculate space after setting the pointer */
(*pdwSpaceLeft) -= sizeof(PVOID);
}
else
{
(*pdwSize) += LWBUF_ALIGN_SIZE(dwDomainsSize);
}
/* include size of the pointer */
(*pdwOffset) += sizeof(PVOID);
(*pdwSize) += sizeof(PVOID);
LWBUF_ALLOC_DWORD(pBuffer, pIn->max_size);
cleanup:
if (ntStatus == STATUS_SUCCESS &&
dwError != ERROR_SUCCESS)
{
ntStatus = LwWin32ErrorToNtStatus(dwError);
}
return ntStatus;
error:
goto cleanup;
}
DWORD
WkssAllocateNetrWkstaInfo(
OUT PNETR_WKSTA_INFO pOut,
IN OUT PDWORD pdwOffset,
IN OUT PDWORD pdwSpaceLeft,
IN DWORD dwLevel,
IN PNETR_WKSTA_INFO pIn,
IN OUT PDWORD pdwSize
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
PVOID pBuffer = NULL;
BAIL_ON_INVALID_PTR(pOut, ntStatus);
BAIL_ON_INVALID_PTR(pdwOffset, ntStatus);
BAIL_ON_INVALID_PTR(pIn, ntStatus);
BAIL_ON_INVALID_PTR(pdwSize, ntStatus);
if (dwLevel >= 100 && dwLevel <= 102)
{
pBuffer = pOut->pInfo100;
LWBUF_ALLOC_DWORD(pBuffer, pIn->pInfo100->wksta100_platform_id);
LWBUF_ALLOC_WC16STR(pBuffer, pIn->pInfo100->wksta100_name);
LWBUF_ALLOC_WC16STR(pBuffer, pIn->pInfo100->wksta100_domain);
LWBUF_ALLOC_DWORD(pBuffer, pIn->pInfo100->wksta100_version_major);
LWBUF_ALLOC_DWORD(pBuffer, pIn->pInfo100->wksta100_version_minor);
}
if (dwLevel >= 101 && dwLevel <= 102)
{
/* Level 101 is an extension of level 100 and
pBuffer points to the same place as pInfo101 */
LWBUF_ALLOC_WC16STR(pBuffer, pIn->pInfo101->wksta101_domain);
}
if (dwLevel == 102)
{
/* Level 102 is an extension of level 101 and
pBuffer points to the same place as pInfo102 */
LWBUF_ALLOC_DWORD(pBuffer, pIn->pInfo102->wksta102_logged_users);
}
if (pBuffer == NULL &&
pdwSpaceLeft != NULL)
{
/* No matching infolevel has been found */
dwError = ERROR_INVALID_LEVEL;
BAIL_ON_WIN_ERROR(dwError);
}
cleanup:
if (ntStatus == STATUS_SUCCESS &&
dwError != ERROR_SUCCESS)
{
ntStatus = LwWin32ErrorToNtStatus(dwError);
}
return dwError;
error:
goto cleanup;
}
NTSTATUS
LsaAllocatePolicyInformation(
OUT LsaPolicyInformation *pOut,
IN OUT PDWORD pdwOffset,
IN OUT PDWORD pdwSpaceLeft,
IN WORD swLevel,
IN LsaPolicyInformation *pIn,
IN OUT PDWORD pdwSize
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
PVOID pBuffer = pOut;
BAIL_ON_INVALID_PTR(pdwOffset, ntStatus);
BAIL_ON_INVALID_PTR(pIn, ntStatus);
BAIL_ON_INVALID_PTR(pdwSize, ntStatus);
switch (swLevel)
{
case LSA_POLICY_INFO_AUDIT_LOG:
LWBUF_ALLOC_DWORD(pBuffer, pIn->audit_log.percent_full);
LWBUF_ALLOC_DWORD(pBuffer, pIn->audit_log.log_size);
LWBUF_ALLOC_NTTIME(pBuffer, pIn->audit_log.retention_time);
LWBUF_ALLOC_BYTE(pBuffer, pIn->audit_log.shutdown_in_progress);
LWBUF_ALLOC_NTTIME(pBuffer, pIn->audit_log.time_to_shutdown);
LWBUF_ALLOC_DWORD(pBuffer, pIn->audit_log.next_audit_record);
LWBUF_ALLOC_DWORD(pBuffer, pIn->audit_log.unknown);
break;
case LSA_POLICY_INFO_AUDIT_EVENTS:
ntStatus = LsaAllocateAuditEventsInfo(pBuffer,
pdwOffset,
pdwSpaceLeft,
&pIn->audit_events,
pdwSize);
break;
case LSA_POLICY_INFO_DOMAIN:
ntStatus = LsaAllocateDomainInfo(pBuffer,
pdwOffset,
pdwSpaceLeft,
&pIn->domain,
pdwSize);
break;
case LSA_POLICY_INFO_PD:
LWBUF_ALLOC_UNICODE_STRING(pBuffer, (PUNICODE_STRING)&pIn->pd.name);
break;
case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
ntStatus = LsaAllocateDomainInfo(pBuffer,
pdwOffset,
pdwSpaceLeft,
&pIn->account_domain,
pdwSize);
break;
case LSA_POLICY_INFO_ROLE:
LWBUF_ALLOC_WORD(pBuffer, pIn->role.unknown);
LWBUF_ALLOC_WORD(pBuffer, pIn->role.role);
break;
case LSA_POLICY_INFO_REPLICA:
LWBUF_ALLOC_UNICODE_STRING(pBuffer,
(PUNICODE_STRING)&pIn->replica.source);
LWBUF_ALLOC_UNICODE_STRING(pBuffer,
(PUNICODE_STRING)&pIn->replica.account);
break;
case LSA_POLICY_INFO_QUOTA:
LWBUF_ALLOC_DWORD(pBuffer, pIn->quota.paged_pool);
LWBUF_ALLOC_DWORD(pBuffer, pIn->quota.non_paged_pool);
LWBUF_ALLOC_DWORD(pBuffer, pIn->quota.min_wss);
LWBUF_ALLOC_DWORD(pBuffer, pIn->quota.max_wss);
LWBUF_ALLOC_DWORD(pBuffer, pIn->quota.pagefile);
LWBUF_ALLOC_ULONG64(pBuffer, pIn->quota.unknown);
break;
case LSA_POLICY_INFO_DB:
LWBUF_ALLOC_ULONG64(pBuffer, pIn->db.modified_id);
LWBUF_ALLOC_NTTIME(pBuffer, pIn->db.db_create_time);
break;
case LSA_POLICY_INFO_AUDIT_FULL_SET:
LWBUF_ALLOC_BYTE(pBuffer, pIn->audit_set.shutdown_on_full);
break;
case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
LWBUF_ALLOC_WORD(pBuffer, pIn->audit_query.unknown);
LWBUF_ALLOC_BYTE(pBuffer, pIn->audit_query.shutdown_on_full);
LWBUF_ALLOC_BYTE(pBuffer, pIn->audit_query.log_is_full);
break;
case LSA_POLICY_INFO_DNS:
LWBUF_ALLOC_UNICODE_STRING(pBuffer,
(PUNICODE_STRING)&pIn->dns.name);
LWBUF_ALLOC_UNICODE_STRING(pBuffer,
(PUNICODE_STRING)&pIn->dns.dns_domain);
LWBUF_ALLOC_UNICODE_STRING(pBuffer,
(PUNICODE_STRING)&pIn->dns.dns_forest);
LWBUF_ALIGN(pdwOffset, pdwSize, pdwSpaceLeft);
LWBUF_ALLOC_BLOB(pBuffer,
sizeof(pIn->dns.domain_guid),
(PBYTE)&(pIn->dns.domain_guid));
LWBUF_ALLOC_PSID(pBuffer, pIn->dns.sid);
break;
default:
ntStatus = STATUS_INVALID_LEVEL;
BAIL_ON_NT_STATUS(ntStatus);
}
cleanup:
if (ntStatus == STATUS_SUCCESS &&
dwError != ERROR_SUCCESS)
{
ntStatus = LwWin32ErrorToNtStatus(dwError);
}
return ntStatus;
error:
goto cleanup;
}
static
NTSTATUS
NetrAllocateSamInfo3(
OUT NetrSamInfo3 *pOut,
IN OUT PDWORD pdwOffset,
IN OUT PDWORD pdwSpaceLeft,
IN NetrSamInfo3 *pIn,
IN OUT PDWORD pdwSize
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
PVOID pBuffer = pOut;
PVOID pCursor = NULL;
UINT32 iSid = 0;
DWORD dwSidsOffset = 0;
DWORD dwSidsSize = 0;
DWORD dwSidsSpaceLeft = 0;
PVOID pSids = NULL;
NetrSidAttr **ppSids = NULL;
BAIL_ON_INVALID_PTR(pdwOffset, ntStatus);
BAIL_ON_INVALID_PTR(pIn, ntStatus);
BAIL_ON_INVALID_PTR(pdwSize, ntStatus);
ntStatus = NetrInitSamBaseInfo((NetrSamBaseInfo*)pBuffer,
pdwOffset,
pdwSpaceLeft,
&pIn->base,
pdwSize);
BAIL_ON_NT_STATUS(ntStatus);
LWBUF_ALLOC_DWORD(pBuffer, pIn->sidcount);
LWBUF_ALIGN(pdwOffset, pdwSize, pdwSpaceLeft);
if (pIn->sidcount)
{
for (iSid = 0; iSid < pIn->sidcount; iSid++)
{
ntStatus = NetrAllocateSidAttr(NULL,
&dwSidsOffset,
NULL,
&(pIn->sids[iSid]),
&dwSidsSize);
BAIL_ON_NT_STATUS(ntStatus);
}
}
if (pBuffer && pdwSpaceLeft)
{
BAIL_IF_NOT_ENOUGH_SPACE(dwSidsSize, pdwSpaceLeft, dwError);
pCursor = pBuffer + (*pdwOffset);
if (pIn->sids)
{
pSids = LWBUF_TARGET_PTR(pBuffer, dwSidsSize, pdwSpaceLeft);
/* sanity check - the sids pointer and current buffer cursor
must not overlap */
BAIL_IF_PTR_OVERLAP(NetrSidAttr*, pSids, dwError);
dwSidsSpaceLeft = dwSidsSize;
dwSidsOffset = 0;
/* Allocate the sid entries */
for (iSid = 0; iSid < pIn->sidcount; iSid++)
{
PVOID pSidCursor = pSids + (iSid * sizeof(pIn->sids[0]));
ntStatus = NetrAllocateSidAttr(pSidCursor,
&dwSidsOffset,
&dwSidsSpaceLeft,
&(pIn->sids[iSid]),
pdwSize);
BAIL_ON_NT_STATUS(ntStatus);
dwSidsOffset = 0;
}
}
ppSids = (NetrSidAttr**)pCursor;
*ppSids = (NetrSidAttr*)pSids;
(*pdwSpaceLeft) -= (pSids) ? LWBUF_ALIGN_SIZE(dwSidsSize) : 0;
/* recalculate space after setting the pointer */
(*pdwSpaceLeft) -= sizeof(NetrSidAttr*);
}
else
{
(*pdwSize) += LWBUF_ALIGN_SIZE(dwSidsSize);
}
/* include size of the pointer */
(*pdwOffset) += sizeof(NetrSidAttr*);
(*pdwSize) += sizeof(NetrSidAttr*);
cleanup:
if (ntStatus == STATUS_SUCCESS &&
dwError != ERROR_SUCCESS)
{
ntStatus = LwWin32ErrorToNtStatus(dwError);
}
return ntStatus;
error:
goto cleanup;
}
static
NTSTATUS
NetrAllocateRidWithAttributeArray(
OUT PVOID *pOut,
IN OUT PDWORD pdwOffset,
IN OUT PDWORD pdwSpaceLeft,
IN PRID_WITH_ATTRIBUTE_ARRAY pIn,
IN OUT PDWORD pdwSize
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
PVOID pBuffer = pOut;
PVOID pCursor = NULL;
DWORD dwRidsSize = 0;
DWORD dwRidsSpaceLeft = 0;
DWORD dwRidsOffset = 0;
DWORD iRid = 0;
PVOID pRids = NULL;
PRID_WITH_ATTRIBUTE *ppRids = NULL;
BAIL_ON_INVALID_PTR(pdwOffset, ntStatus);
BAIL_ON_INVALID_PTR(pIn, ntStatus);
BAIL_ON_INVALID_PTR(pdwSize, ntStatus);
LWBUF_ALIGN(pdwOffset, pdwSize, pdwSpaceLeft);
LWBUF_ALLOC_DWORD(pBuffer, pIn->dwCount);
LWBUF_ALIGN(pdwOffset, pdwSize, pdwSpaceLeft);
if (pIn->dwCount)
{
dwRidsSize = sizeof(pIn->pRids[0]) * pIn->dwCount;
}
if (pBuffer && pdwSpaceLeft)
{
BAIL_IF_NOT_ENOUGH_SPACE(dwRidsSize, pdwSpaceLeft, dwError);
pCursor = pBuffer + (*pdwOffset);
if (pIn->pRids)
{
pRids = LWBUF_TARGET_PTR(pBuffer, dwRidsSize, pdwSpaceLeft);
/* sanity check - the rids pointer and current buffer cursor
must not overlap */
BAIL_IF_PTR_OVERLAP(PRID_WITH_ATTRIBUTE, pRids, dwError);
dwRidsSpaceLeft = dwRidsSize;
dwRidsOffset = 0;
/* Allocate the rid entries */
for (iRid = 0; iRid < pIn->dwCount; iRid++)
{
PVOID pRidCursor = pRids + (iRid * sizeof(pIn->pRids[0]));
ntStatus = NetrAllocateRidWithAttribute(pRidCursor,
&dwRidsOffset,
&dwRidsSpaceLeft,
&(pIn->pRids[iRid]),
pdwSize);
BAIL_ON_NT_STATUS(ntStatus);
dwRidsOffset = 0;
}
}
ppRids = (PRID_WITH_ATTRIBUTE*)pCursor;
*ppRids = (PRID_WITH_ATTRIBUTE)pRids;
(*pdwSpaceLeft) -= (pRids) ? LWBUF_ALIGN_SIZE(dwRidsSize) : 0;
/* recalculate space after setting the pointer */
(*pdwSpaceLeft) -= sizeof(PRID_WITH_ATTRIBUTE);
}
else
{
(*pdwSize) += LWBUF_ALIGN_SIZE(dwRidsSize);
}
/* include size of the pointer */
(*pdwOffset) += sizeof(PRID_WITH_ATTRIBUTE);
(*pdwSize) += sizeof(PRID_WITH_ATTRIBUTE);
cleanup:
if (ntStatus == STATUS_SUCCESS &&
dwError != ERROR_SUCCESS)
{
ntStatus = LwWin32ErrorToNtStatus(dwError);
}
return ntStatus;
error:
goto cleanup;
}
static
NTSTATUS
NetrInitSamBaseInfo(
OUT NetrSamBaseInfo *pOut,
IN OUT PDWORD pdwOffset,
IN OUT PDWORD pdwSpaceLeft,
IN NetrSamBaseInfo *pIn,
IN OUT PDWORD pdwSize
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
PVOID pBuffer = pOut;
BAIL_ON_INVALID_PTR(pdwOffset, ntStatus);
BAIL_ON_INVALID_PTR(pIn, ntStatus);
BAIL_ON_INVALID_PTR(pdwSize, ntStatus);
LWBUF_ALIGN(pdwOffset, pdwSize, pdwSpaceLeft);
LWBUF_ALLOC_WINNTTIME(pBuffer, pIn->last_logon);
LWBUF_ALLOC_WINNTTIME(pBuffer, pIn->last_logoff);
LWBUF_ALLOC_WINNTTIME(pBuffer, pIn->acct_expiry);
LWBUF_ALLOC_WINNTTIME(pBuffer, pIn->last_password_change);
LWBUF_ALLOC_WINNTTIME(pBuffer, pIn->allow_password_change);
LWBUF_ALLOC_WINNTTIME(pBuffer, pIn->force_password_change);
LWBUF_ALLOC_UNICODE_STRING(pBuffer, (PUNICODE_STRING)&pIn->account_name);
LWBUF_ALLOC_UNICODE_STRING(pBuffer, (PUNICODE_STRING)&pIn->full_name);
LWBUF_ALLOC_UNICODE_STRING(pBuffer, (PUNICODE_STRING)&pIn->logon_script);
LWBUF_ALLOC_UNICODE_STRING(pBuffer, (PUNICODE_STRING)&pIn->profile_path);
LWBUF_ALLOC_UNICODE_STRING(pBuffer, (PUNICODE_STRING)&pIn->home_directory);
LWBUF_ALLOC_UNICODE_STRING(pBuffer, (PUNICODE_STRING)&pIn->home_drive);
LWBUF_ALLOC_WORD(pBuffer, pIn->logon_count);
LWBUF_ALLOC_WORD(pBuffer, pIn->bad_password_count);
LWBUF_ALLOC_DWORD(pBuffer, pIn->rid);
LWBUF_ALLOC_DWORD(pBuffer, pIn->primary_gid);
ntStatus = NetrAllocateRidWithAttributeArray(pBuffer,
pdwOffset,
pdwSpaceLeft,
&pIn->groups,
pdwSize);
BAIL_ON_NT_STATUS(ntStatus);
LWBUF_ALLOC_DWORD(pBuffer, pIn->user_flags);
LWBUF_ALLOC_SESSION_KEY(pBuffer, &pIn->key);
LWBUF_ALLOC_UNICODE_STRING(pBuffer, (PUNICODE_STRING)&pIn->logon_server);
LWBUF_ALLOC_UNICODE_STRING(pBuffer, (PUNICODE_STRING)&pIn->domain);
LWBUF_ALLOC_PSID(pBuffer, pIn->domain_sid);
LWBUF_ALLOC_SESSION_KEY(pBuffer, &pIn->lmkey);
LWBUF_ALLOC_DWORD(pBuffer, pIn->acct_flags);
LWBUF_ALLOC_BLOB(pBuffer, sizeof(pIn->unknown), pIn->unknown);
cleanup:
if (ntStatus == STATUS_SUCCESS &&
dwError != ERROR_SUCCESS)
{
ntStatus = LwWin32ErrorToNtStatus(dwError);
}
return ntStatus;
error:
goto cleanup;
}
NTSTATUS
NetrInitIdentityInfo(
OUT PVOID *pIdentity,
IN OUT PDWORD pdwOffset,
IN OUT PDWORD pdwSpaceLeft,
IN PCWSTR pwszDomain,
IN PCWSTR pwszWorkstation,
IN PCWSTR pwszAccount,
IN UINT32 ParamControl,
IN UINT32 LogonIdLow,
IN UINT32 LogonIdHigh,
IN OUT PDWORD pdwSize
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
PVOID pBuffer = pIdentity;
PWSTR pwszNbtWorkstation = NULL;
size_t sNbtWorkstationLen = 0;
BAIL_ON_INVALID_PTR(pdwOffset, ntStatus);
BAIL_ON_INVALID_PTR(pwszWorkstation, ntStatus);
BAIL_ON_INVALID_PTR(pwszAccount, ntStatus);
BAIL_ON_INVALID_PTR(pdwSize, ntStatus);
/*
* Create "\\WORKSTATION" name
*/
dwError = LwWc16sLen(pwszWorkstation, &sNbtWorkstationLen);
BAIL_ON_WIN_ERROR(dwError);
ntStatus = NetrAllocateMemory(OUT_PPVOID(&pwszNbtWorkstation),
sizeof(WCHAR) * (sNbtWorkstationLen + 3));
BAIL_ON_NT_STATUS(ntStatus);
if (sw16printfw(
pwszNbtWorkstation,
sNbtWorkstationLen + 3,
L"\\\\%ws",
pwszWorkstation) < 0)
{
ntStatus = ErrnoToNtStatus(errno);
BAIL_ON_NT_STATUS(ntStatus);
}
LWBUF_ALLOC_UNICODE_STRING_FROM_WC16STR(pBuffer, pwszDomain);
LWBUF_ALLOC_DWORD(pBuffer, ParamControl);
LWBUF_ALLOC_DWORD(pBuffer, LogonIdLow);
LWBUF_ALLOC_DWORD(pBuffer, LogonIdHigh);
LWBUF_ALLOC_UNICODE_STRING_FROM_WC16STR(pBuffer, pwszAccount);
LWBUF_ALLOC_UNICODE_STRING_FROM_WC16STR(pBuffer, pwszNbtWorkstation);
cleanup:
if (pwszNbtWorkstation)
{
NetrFreeMemory(pwszNbtWorkstation);
}
if (ntStatus == STATUS_SUCCESS &&
dwError != ERROR_SUCCESS)
{
ntStatus = LwWin32ErrorToNtStatus(dwError);
}
return ntStatus;
error:
goto cleanup;
}
static
NTSTATUS
LsaAllocateAuditEventsInfo(
OUT PVOID pOut,
IN OUT PDWORD pdwOffset,
IN OUT PDWORD pdwSpaceLeft,
IN AuditEventsInfo *pIn,
IN OUT PDWORD pdwSize
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
PVOID pBuffer = pOut;
PVOID pCursor = NULL;
PVOID pBlob = NULL;
PVOID *ppBlob = NULL;
DWORD dwBlobSize = 0;
DWORD dwBlobSpaceLeft = 0;
DWORD dwBlobOffset = 0;
LWBUF_ALLOC_DWORD(pBuffer, pIn->auditing_mode);
LWBUF_ALIGN_PTR(pdwOffset, pdwSize, pdwSpaceLeft);
if (pIn->count)
{
dwBlobSize = sizeof(pIn->settings[0]) * pIn->count;
}
/* Set pointer to the entries array */
if (pBuffer && pdwSpaceLeft)
{
BAIL_IF_NOT_ENOUGH_SPACE(dwBlobSize, pdwSpaceLeft, dwError);
pCursor = pBuffer + (*pdwOffset);
if (pIn->count)
{
pBlob = LWBUF_TARGET_PTR(pBuffer, dwBlobSize, pdwSpaceLeft);
/* sanity check - the blob and current buffer cursor
must not overlap */
BAIL_IF_PTR_OVERLAP(AuditEventsInfo*, pBlob, dwError);
dwBlobSpaceLeft = dwBlobSize;
dwBlobSize = 0;
dwBlobOffset = 0;
dwError = LwBufferAllocFixedBlob(
pBlob,
&dwBlobSize,
&dwBlobSpaceLeft,
(PBYTE)pIn->settings,
sizeof(pIn->settings[0]) * pIn->count,
&dwBlobSize);
BAIL_ON_WIN_ERROR(dwError);
}
ppBlob = (PVOID*)pCursor;
*ppBlob = (PVOID)pBlob;
(*pdwSpaceLeft) -= (pBlob) ? LWBUF_ALIGN_SIZE(dwBlobSize) : 0;
/* recalculate space after setting the pointer */
(*pdwSpaceLeft) -= sizeof(PVOID);
}
else
{
(*pdwSize) += LWBUF_ALIGN_SIZE(dwBlobSize);
}
/* include size of the pointer */
(*pdwOffset) += sizeof(PVOID);
(*pdwSize) += sizeof(PVOID);
LWBUF_ALLOC_DWORD(pBuffer, pIn->count);
cleanup:
if (ntStatus == STATUS_SUCCESS &&
dwError != ERROR_SUCCESS)
{
ntStatus = LwWin32ErrorToNtStatus(dwError);
}
return ntStatus;
error:
goto cleanup;
}
static
NTSTATUS
NetrAllocateDomainInfo1(
OUT NetrDomainInfo1 *pOut,
IN OUT PDWORD pdwOffset,
IN OUT PDWORD pdwSpaceLeft,
IN NetrDomainInfo1 *pIn,
IN OUT PDWORD pdwSize
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
PVOID pBuffer = pOut;
PVOID pCursor = NULL;
DWORD iTrust = 0;
DWORD dwTrustsSize = 0;
DWORD dwTrustsOffset = 0;
DWORD dwTrustsSpaceLeft = 0;
PVOID pTrusts = NULL;
NetrDomainTrustInfo **ppTrusts = NULL;
BAIL_ON_INVALID_PTR(pdwOffset, ntStatus);
BAIL_ON_INVALID_PTR(pIn, ntStatus);
BAIL_ON_INVALID_PTR(pdwSize, ntStatus);
LWBUF_ALIGN(pdwOffset, pdwSize, pdwSpaceLeft);
ntStatus = NetrAllocateDomainTrustInfo(pBuffer,
pdwOffset,
pdwSpaceLeft,
&pIn->domain_info,
pdwSize);
BAIL_ON_NT_STATUS(ntStatus);
LWBUF_ALLOC_DWORD(pBuffer, pIn->num_trusts);
LWBUF_ALIGN(pdwOffset, pdwSize, pdwSpaceLeft);
if (pIn->num_trusts)
{
for (iTrust = 0; iTrust < pIn->num_trusts; iTrust++)
{
ntStatus = NetrAllocateDomainTrustInfo(NULL,
&dwTrustsOffset,
NULL,
&(pIn->trusts[iTrust]),
&dwTrustsSize);
BAIL_ON_NT_STATUS(ntStatus);
}
}
if (pBuffer && pdwSpaceLeft)
{
BAIL_IF_NOT_ENOUGH_SPACE(dwTrustsSize, pdwSpaceLeft, dwError);
pCursor = pBuffer + (*pdwOffset);
if (pIn->trusts)
{
pTrusts = LWBUF_TARGET_PTR(pBuffer, dwTrustsSize, pdwSpaceLeft);
/* sanity check - the rids pointer and current buffer cursor
must not overlap */
BAIL_IF_PTR_OVERLAP(NetrDomainTrustInfo*, pTrusts, dwError);
dwTrustsSpaceLeft = dwTrustsSize;
dwTrustsOffset = 0;
/* Allocate the trust entries */
for (iTrust = 0; iTrust < pIn->num_trusts; iTrust++)
{
PVOID pTrustCursor = pTrusts +
(iTrust * sizeof(NetrDomainTrustInfo));
ntStatus = NetrAllocateDomainTrustInfo(pTrustCursor,
&dwTrustsOffset,
&dwTrustsSpaceLeft,
&(pIn->trusts[iTrust]),
pdwSize);
BAIL_ON_NT_STATUS(ntStatus);
dwTrustsOffset = 0;
}
}
ppTrusts = (NetrDomainTrustInfo**)pCursor;
*ppTrusts = (NetrDomainTrustInfo*)pTrusts;
(*pdwSpaceLeft) -= (pTrusts) ? LWBUF_ALIGN_SIZE(dwTrustsSize) : 0;
/* recalculate space after setting the pointer */
(*pdwSpaceLeft) -= sizeof(NetrDomainTrustInfo*);
}
else
{
(*pdwSize) += LWBUF_ALIGN_SIZE(dwTrustsSize);
}
/* include size of the pointer */
(*pdwOffset) += sizeof(NetrDomainTrustInfo*);
(*pdwSize) += sizeof(NetrDomainTrustInfo*);
cleanup:
if (ntStatus == STATUS_SUCCESS &&
dwError != ERROR_SUCCESS)
{
ntStatus = LwWin32ErrorToNtStatus(dwError);
}
return ntStatus;
error:
goto cleanup;
}
