windows-server-2003/net/rras/ras/rassfm/usrparms.c

/*
    File    usrparms.c

    Callback routines exported to SAM for migrating and updating
    user parms.

    Paul Mayfield, 9/10/98
*/

#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <ntlsa.h>
#include <ntsam.h>
#include <samrpc.h>
#include <samisrv.h>
#include <windows.h>
#include <lm.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <malloc.h>
#include <raserror.h>
#include <rasman.h>
#include <rasppp.h>
#include <mprapi.h>
#include <mprapip.h>
#include <usrparms.h>       // for UP_CLIENT_DIAL
#include <cleartxt.h>       // for IASParmsGetUserPassword
#include <rassfmhp.h>       // for RasSfmHeap
#include <oaidl.h>

//
// Flags that restrict the values generated for a given
// set of ras user properties.  See UPGenerateDsAttribs
//
#define UP_F_Dialin             0x1     // Generate dialup params
#define UP_F_Callback           0x2     // Generate callback params
#define UP_F_Upgrade            0x4     // Generate upgraded params

//
// Constants in the profiles
//
#define SDO_FRAMED                 2
#define SDO_FRAMED_CALLBACK        4

// Names of user attributes that we set
//
static const WCHAR pszAttrDialin[]          = L"msNPAllowDialin";
static const WCHAR pszAttrServiceType[]     = L"msRADIUSServiceType";
static const WCHAR pszAttrCbNumber[]        = L"msRADIUSCallbackNumber";
static const WCHAR pszAttrSavedCbNumber[]   = L"msRASSavedCallbackNumber";

//
// Will be equal to the number of times the common allocation
// routine is called minus the number of times the common free
// routine is called.  Should be zero else leaking memory.
//
DWORD dwUpLeakCount = 0;

//
// Prototype of free func.
//
VOID WINAPI
UserParmsFree(
    IN PVOID pvData);

//
// Common tracing for the UserParm functions.
//
DWORD UpTrace (LPSTR pszTrace, ...) {
#if 0
    va_list arglist;
    char szBuffer[1024], szTemp[1024];

    va_start(arglist, pszTrace);
    vsprintf(szTemp, pszTrace, arglist);
    va_end(arglist);

    sprintf(szBuffer, "UserParms: %s\n", szTemp);

    OutputDebugStringA(szBuffer);
#endif

    return NO_ERROR;
}

//
// Allocation and free routines for UserParms functions
//
PVOID
UpAlloc(
    IN DWORD dwSize,
    IN BOOL bZero)
{
    dwUpLeakCount++;
    return RtlAllocateHeap(
               RasSfmHeap(),
               (bZero ? HEAP_ZERO_MEMORY : 0),
               dwSize
               );
}

//
// Callback function called by NT5 SAM to free the blob
// returned by UserParmsConvert.
//
VOID
UpFree(
    IN PVOID pvData)
{
    dwUpLeakCount--;
    if (pvData)
        RtlFreeHeap(
            RasSfmHeap(),
            0,
            pvData
            );
}

//
// Returns a heap-allocated copy of the given
// string
//
PWCHAR
UpStrDup(
    IN PCWSTR pszSrc)
{
    PWCHAR pszRet = NULL;
    DWORD dwLen = wcslen(pszSrc);

    pszRet = (PWCHAR) UpAlloc((dwLen + 1) * sizeof(WCHAR), FALSE);
    if (pszRet)
        wcscpy(pszRet, pszSrc);

    return pszRet;
}

//
// Returns a heap-allocated copy of the given unicode
// string converted into multibyte.
//
PUCHAR
UpWcstombsDup(
    IN PWCHAR pszSrc)
{
    PUCHAR pszRet = NULL;
    DWORD dwSize = (wcslen(pszSrc) + 1) * sizeof(WCHAR);

    pszRet = (PUCHAR) UpAlloc(dwSize, TRUE);
    if (pszRet)
        wcstombs(pszRet, pszSrc, dwSize);

    return pszRet;
}


//
// Returns a heap-allocated copy of the given
// blob
//
PVOID
UpBlobDup(
    IN PVOID pvSrc,
    IN ULONG ulLen)
{
    PVOID pvRet = NULL;

    if (ulLen == 0)
        return NULL;

    pvRet = UpAlloc(ulLen + sizeof(WCHAR), TRUE);
    if (pvRet)
    {
        CopyMemory(pvRet, pvSrc, ulLen);
    }
    else
    {
        UpTrace("UpBlobDup: Failed to dupe %x %d.", pvSrc, ulLen);
    }

    return pvRet;
}

//
// Allocates and initializes a dword attribute
//
NTSTATUS
UpInitializeDwordAttr(
    IN SAM_USERPARMS_ATTR * pAttr,
    IN PWCHAR pszAttr,
    IN DWORD dwVal)
{
    if (pszAttr == NULL)
    {
        return STATUS_NO_MEMORY;
    }

    // Initialize the name
    RtlInitUnicodeString (&(pAttr->AttributeIdentifier), pszAttr);
    pAttr->Syntax = Syntax_Attribute;

    // Alloc/Initailze the value structure
    pAttr->Values =
        (SAM_USERPARMS_ATTRVALS*)
        UpAlloc(sizeof(SAM_USERPARMS_ATTRVALS), TRUE);
    if (pAttr->Values == NULL)
        return STATUS_NO_MEMORY;

    // Alloc/Init the value
    pAttr->Values->value = UpAlloc(sizeof(DWORD), TRUE);
    if (pAttr->Values->value == NULL)
        return STATUS_NO_MEMORY;
    *((DWORD*)pAttr->Values->value) = dwVal;
    pAttr->Values->length = sizeof(DWORD);

    // Put in the value count
    pAttr->CountOfValues = 1;

    return STATUS_SUCCESS;
}

//
// Allocates and initializes a dword attribute
//
NTSTATUS
UpInitializeStringAttrA(
    OUT SAM_USERPARMS_ATTR * pAttr,
    IN  PWCHAR pszAttr,
    IN  PUCHAR pszVal)
{
    if (pszAttr == NULL)
    {
        return STATUS_NO_MEMORY;
    }

    // Initialize the name
    RtlInitUnicodeString (&(pAttr->AttributeIdentifier), pszAttr);
    pAttr->Syntax = Syntax_Attribute;

    // Alloc/Initailze the value structure
    pAttr->Values =
        (SAM_USERPARMS_ATTRVALS*)
        UpAlloc(sizeof(SAM_USERPARMS_ATTRVALS), TRUE);
    if (pAttr->Values == NULL)
        return STATUS_NO_MEMORY;

    // Alloc/Init the value
    pAttr->Values->value = pszVal;

    if (pszVal)
    {
        pAttr->Values->length = (strlen(pszVal) + 1) * sizeof(CHAR);
    }
    else
    {
        pAttr->Values->length = 1 * sizeof(CHAR);
    }

    // Put in the value count
    pAttr->CountOfValues = 1;

    return STATUS_SUCCESS;
}

//
// Allocates and initializes a cleartext password attribute
//
NTSTATUS
UpInitializePasswordAttr(
    OUT SAM_USERPARMS_ATTR * pAttr,
    IN  PWSTR pszPassword)
{
    // Alloc/Initialize the value structure
    pAttr->Values =
        (SAM_USERPARMS_ATTRVALS*)
        UpAlloc(sizeof(SAM_USERPARMS_ATTRVALS), TRUE);
    if (pAttr->Values == NULL)
        return STATUS_NO_MEMORY;

    // Alloc/Init the value
    pAttr->Values->value = pszPassword;
    pAttr->Values->length = (wcslen(pszPassword) + 1) * sizeof(WCHAR);

    // Put in the value count
    pAttr->CountOfValues = 1;

    // Initialize the name and syntax.
    RtlInitUnicodeString(
        &pAttr->AttributeIdentifier,
        UpStrDup(L"CLEARTEXT")
        );
    pAttr->Syntax = Syntax_EncryptedAttribute;

    return STATUS_SUCCESS;
}

//
// Allocates and initializes an attribute
// to be deleted.
//
NTSTATUS
UpInitializeDeletedAttr(
    OUT SAM_USERPARMS_ATTR * pAttr,
    IN  PWCHAR pszAttr)
{
    if (pszAttr == NULL)
    {
        return STATUS_NO_MEMORY;
    }

    // Initialize the name
    RtlInitUnicodeString (&(pAttr->AttributeIdentifier), pszAttr);
    pAttr->Syntax = Syntax_Attribute;

    // Value count of zero means delete
    //
    pAttr->CountOfValues = 0;

    return STATUS_SUCCESS;
}

//
// Converts the given user parms blob into a set of
// ras attributes
//
NTSTATUS
UpUserParmsToRasUser0 (
    IN  PVOID pvUserParms,
    OUT RAS_USER_0 * pRasUser0)
{
    DWORD dwErr;

    // Initalize
    ZeroMemory(pRasUser0, sizeof(RAS_USER_0));
    pRasUser0->bfPrivilege = RASPRIV_NoCallback;
    pRasUser0->wszPhoneNumber[0] = UNICODE_NULL;

    // The the user parms are null, the defaults
    // will do.
    if (pvUserParms == NULL)
    {
        return STATUS_SUCCESS;
    }

    //  Truncate user parms at sizeof USER_PARMS
    if (lstrlenW((PWCHAR)pvUserParms) >= sizeof(USER_PARMS))
    {
        // We slam in a null at sizeof(USER_PARMS)-1 which
        // corresponds to user_parms.up_Null
        ((PWCHAR)pvUserParms)[sizeof(USER_PARMS)-1] = L'\0';
    }

    // Get RAS info (and validate) from usr_parms
    dwErr = MprGetUsrParams(
                UP_CLIENT_DIAL,
                (LPWSTR) pvUserParms,
                (LPWSTR) pRasUser0);
    if (dwErr == NO_ERROR)
    {
        // Get RAS Privilege and callback number
        RasPrivilegeAndCallBackNumber(FALSE, pRasUser0);
    }

    return STATUS_SUCCESS;
}

/////////
// Signature of the extraction function.
/////////
typedef HRESULT (WINAPI *IASPARMSQUERYUSERPROPERTY)(
    IN PCWSTR pszUserParms,
    IN PCWSTR pszName,
    OUT VARIANT *pvarValue
    );

//////////
// Uplevel per-user attributes that will be migrated.
//////////
CONST PCWSTR UPLEVEL_PARMS[] =
{
   L"msNPAllowDialin",
   L"msNPCallingStationID",
   L"msRADIUSCallbackNumber",
   L"msRADIUSFramedIPAddress",
   L"msRADIUSFramedRoute",
   L"msRADIUSServiceType"
};

//////////
// Number of per-user attributes.
//////////
#define NUM_UPLEVEL_PARMS (sizeof(UPLEVEL_PARMS)/sizeof(UPLEVEL_PARMS[0]))

/////////
// Converts a ULONG into a SAM_USERPARMS_ATTRVALS struct.
/////////
NTSTATUS
NTAPI
ConvertULongToAttrVal(
    IN ULONG ulValue,
    OUT PSAM_USERPARMS_ATTRVALS pAttrVal
    )
{
   // Allocate memory to hold the ULONG.
   pAttrVal->value = UpAlloc(sizeof(ULONG), FALSE);
   if (pAttrVal->value == NULL) { return STATUS_NO_MEMORY; }

   // Copy in the value.
   *(PULONG)pAttrVal->value = ulValue;

   // Set the length.
   pAttrVal->length = sizeof(ULONG);

   return STATUS_SUCCESS;
}

//////////
// Converts a single-valued VARIANT into a SAM_USERPARMS_ATTRVALS struct.
//////////
NTSTATUS
NTAPI
ConvertVariantToAttrVal(
    IN CONST VARIANT *pvarValue,
    OUT PSAM_USERPARMS_ATTRVALS pAttrVal
    )
{
   NTSTATUS status;
   ULONG length;
   UNICODE_STRING wide;
   ANSI_STRING ansi;

   switch (V_VT(pvarValue))
   {
      case VT_EMPTY:
      {
         // VT_EMPTY means the attribute was deleted.
         pAttrVal->value = NULL;
         pAttrVal->length = 0;
         return STATUS_SUCCESS;
      }

      case VT_I2:
         return ConvertULongToAttrVal(V_I2(pvarValue), pAttrVal);

      case VT_I4:
         return ConvertULongToAttrVal(V_I4(pvarValue), pAttrVal);

      case VT_BSTR:
      {
         // Check the BSTR.
         if (V_BSTR(pvarValue) == NULL) { return STATUS_INVALID_PARAMETER; }

         // Initialize the source string.
         RtlInitUnicodeString(&wide, V_BSTR(pvarValue));

         // Initialize the destination buffer.
         ansi.Length = 0;
         ansi.MaximumLength = wide.MaximumLength / sizeof(WCHAR);
         ansi.Buffer = UpAlloc(ansi.MaximumLength, FALSE);
         if (ansi.Buffer == NULL) { return STATUS_NO_MEMORY; }

         // Convert from wide to ansi.
         status = RtlUnicodeStringToAnsiString(&ansi, &wide, FALSE);
         if (!NT_SUCCESS(status))
         {
            UpFree(ansi.Buffer);
            return status;
         }

         // Store the result.
         pAttrVal->value = ansi.Buffer;
         pAttrVal->length = ansi.Length + 1;

         return STATUS_SUCCESS;
      }

      case VT_BOOL:
         return ConvertULongToAttrVal((V_BOOL(pvarValue) ? 1 : 0), pAttrVal);

      case VT_I1:
         return ConvertULongToAttrVal(V_I1(pvarValue), pAttrVal);

      case VT_UI1:
         return ConvertULongToAttrVal(V_UI1(pvarValue), pAttrVal);

      case VT_UI2:
         return ConvertULongToAttrVal(V_UI2(pvarValue), pAttrVal);

      case VT_UI4:
         return ConvertULongToAttrVal(V_UI4(pvarValue), pAttrVal);

      case VT_ARRAY | VT_I1:
      case VT_ARRAY | VT_UI1:
      {
         // Check the SAFEARRAY.
         if (V_ARRAY(pvarValue) == NULL) { return STATUS_INVALID_PARAMETER; }

         // Allocate memory for the octet string.
         length = V_ARRAY(pvarValue)->rgsabound[0].cElements;
         pAttrVal->value = UpAlloc(length, FALSE);
         if (pAttrVal->value == NULL) { return STATUS_NO_MEMORY; }

         // Copy in the data.
         memcpy(pAttrVal->value, V_ARRAY(pvarValue)->pvData, length);

         // Set the length.
         pAttrVal->length = length;

         return STATUS_SUCCESS;
      }
   }

   // If we made it here it was an unsupported VARTYPE.
   return STATUS_INVALID_PARAMETER;
}

//////////
// Frees the values array of a SAM_USERPARMS_ATTR struct.
//////////
VOID
NTAPI
FreeUserParmsAttrValues(
    IN PSAM_USERPARMS_ATTR pAttrs
    )
{
   ULONG i;

   if (pAttrs)
   {
      for (i = 0; i < pAttrs->CountOfValues; ++i)
      {
         UpFree(pAttrs->Values[i].value);
      }

      UpFree(pAttrs->Values);
   }
}

//////////
// Converts a VARIANT into a SAM_USERPARMS_ATTR struct.
//////////
NTSTATUS
NTAPI
ConvertVariantToUserParmsAttr(
    IN CONST VARIANT *pvarSrc,
    OUT PSAM_USERPARMS_ATTR pAttrs
    )
{
   NTSTATUS status;
   ULONG nelem;
   CONST VARIANT *srcVal;
   SAM_USERPARMS_ATTRVALS *dstVal;

   // Get the array of values to be converted.
   if (V_VT(pvarSrc) != (VT_VARIANT | VT_ARRAY))
   {
      nelem = 1;
      srcVal = pvarSrc;
   }
   else
   {
      nelem = V_ARRAY(pvarSrc)->rgsabound[0].cElements;
      srcVal = (CONST VARIANT *)V_ARRAY(pvarSrc)->pvData;
   }

   // Initialize CountOfValues to zero. We'll use this to track how many
   // values have been successfully converted.
   pAttrs->CountOfValues = 0;

   // Allocate memory to hold the values.
   pAttrs->Values = UpAlloc(sizeof(SAM_USERPARMS_ATTRVALS) * nelem, TRUE);
   if (pAttrs->Values == NULL) { return STATUS_NO_MEMORY; }

   // Loop through each value to be converted.
   for (dstVal = pAttrs->Values; nelem > 0; ++srcVal, ++dstVal, --nelem)
   {
      status = ConvertVariantToAttrVal(srcVal, dstVal);
      if (!NT_SUCCESS(status))
      {
         // Clean-up the partial results.
         FreeUserParmsAttrValues(pAttrs);
         return status;
      }

      ++(pAttrs->CountOfValues);
   }

   return STATUS_SUCCESS;
}

//////////
// Extracts the NT5 per-user attributes from a SAM UserParameters string and
// converts them to a SAM_USERPARMS_ATTRBLOCK struct.
//////////
NTSTATUS
NTAPI
ConvertUserParmsToAttrBlock(
    IN PCWSTR lpUserParms,
    OUT PSAM_USERPARMS_ATTRBLOCK *ppAttrs
    )
{
   static IASPARMSQUERYUSERPROPERTY IASParmsQueryUserProperty;

   NTSTATUS status;
   PSAM_USERPARMS_ATTR dst;
   PWSTR szPassword;
   ULONG i;
   HRESULT hr;
   VARIANT src;

   //////////
   // Make sure we have the extraction function loaded.
   //////////

   if (IASParmsQueryUserProperty == NULL)
   {
      IASParmsQueryUserProperty = (IASPARMSQUERYUSERPROPERTY)
                                  GetProcAddress(
                                      LoadLibraryW(
                                          L"IASSAM.DLL"
                                          ),
                                      "IASParmsQueryUserProperty"
                                      );

      if (!IASParmsQueryUserProperty) { return STATUS_PROCEDURE_NOT_FOUND; }
   }

   //////////
   // Allocate memory for the SAM_USERPARMS_ATTRBLOCK.
   //////////

   *ppAttrs = (PSAM_USERPARMS_ATTRBLOCK)
              UpAlloc(
                  sizeof(SAM_USERPARMS_ATTRBLOCK),
                  TRUE
                  );
   if (*ppAttrs == NULL)
   {
      return STATUS_NO_MEMORY;
   }

   (*ppAttrs)->UserParmsAttr = (PSAM_USERPARMS_ATTR)
                               UpAlloc(
                                   sizeof(SAM_USERPARMS_ATTR) *
                                   (NUM_UPLEVEL_PARMS + 1),
                                   TRUE
                                   );
   if ((*ppAttrs)->UserParmsAttr == NULL)
   {
      UpFree(*ppAttrs);
      return STATUS_NO_MEMORY;
   }

   //////////
   // Convert the cleartext password.
   //////////

   dst = (*ppAttrs)->UserParmsAttr;

   szPassword = NULL;
   IASParmsGetUserPassword(
       lpUserParms,
       &szPassword
       );

   if (szPassword)
   {
      status = UpInitializePasswordAttr(
                   dst,
                   UpStrDup(szPassword)
                   );

      LocalFree(szPassword);

      if (NT_SUCCESS(status))
      {
         ++dst;
      }
   }

   //////////
   // Convert the dial-in parameters.
   //////////

   for (i = 0; i < NUM_UPLEVEL_PARMS; ++i)
   {
      // Try to extract the parameter from UserParms.
      hr = IASParmsQueryUserProperty(
               lpUserParms,
               UPLEVEL_PARMS[i],
               &src
               );
      if (FAILED(hr) || V_VT(&src) == VT_EMPTY) { continue; }

      // Convert to a SAM_USERPARMS_ATTRVALS array.
      status = ConvertVariantToUserParmsAttr(
                   &src,
                   dst
                   );
      if (NT_SUCCESS(status))
      {
         // Fill in the AttributeIdentifier ...
         RtlInitUnicodeString(
             &dst->AttributeIdentifier,
             UpStrDup(UPLEVEL_PARMS[i])
                      );

         // ... and the Syntax.
         dst->Syntax = Syntax_Attribute;

         // All went well, so advance to the next element in the array.
         ++dst;
      }

      // We're done with the VARIANT.
      VariantClear(&src);
   }

   (*ppAttrs)->attCount = (ULONG)(dst - (*ppAttrs)->UserParmsAttr);

   // If there weren't any attributes, then free the UserParmsAttr array.
   if ((*ppAttrs)->attCount == 0)
   {
      UpFree((*ppAttrs)->UserParmsAttr);

      (*ppAttrs)->UserParmsAttr = NULL;
   }

   return status;
}

//
// Generate an appropriate set of ds attributes based on the
// ras user information provided
//
NTSTATUS
UpGenerateDsAttribs (
    IN DWORD dwFlags,
    IN RAS_USER_0 * pRasUser0,
    IN PWSTR szPassword,
    OUT PSAM_USERPARMS_ATTRBLOCK * ppAttrs)
{
    PSAM_USERPARMS_ATTRBLOCK pRet = NULL;
    SAM_USERPARMS_ATTR * pCurAttr = NULL;
    PWCHAR pszDupPassword, pszCurAttr = NULL;
    DWORD dwCurVal = 0, dwDsParamCount;
    NTSTATUS ntStatus = STATUS_SUCCESS;

    UpTrace("UpGenerateDsAttribs: enter %x", dwFlags);

    do
    {
        // pmay: 330184
        //
        // If we're upgrading, then having NULL userparms or having
        // deny set explicitly should cause us to not add the msNPAllowDialin
        // value so that user will be managed by policy.
        //
        if (
            (dwFlags & UP_F_Upgrade) &&
            (!(pRasUser0->bfPrivilege & RASPRIV_DialinPrivilege))
           )
        {
            dwFlags &= ~UP_F_Dialin;
        }

        // Initialize the return value
        pRet = (PSAM_USERPARMS_ATTRBLOCK)
                    UpAlloc(sizeof(SAM_USERPARMS_ATTRBLOCK), TRUE);
        if (pRet == NULL)
        {
            UpTrace("UpGenerateDsAttribs: alloc block failed");
            ntStatus = STATUS_NO_MEMORY;
            break;
        }

        // Calculate the total number of values
        dwDsParamCount = 0;
        if (dwFlags & UP_F_Dialin)
        {
            dwDsParamCount += 1;
        }
        if (dwFlags & UP_F_Callback)
        {
            dwDsParamCount += 3;
        }
        if (szPassword != NULL)
        {
            dwDsParamCount += 1;
        }

        //
        // Set the array to be big enough to accomodate 4 attributes:
        //   1. Dialin bit
        //   2. Callback Number or Saved Callback Number
        //   3. Deleted version of #2
        //   4. Service Type (for callback policy)
        //
        pCurAttr = (SAM_USERPARMS_ATTR*)
            UpAlloc(sizeof(SAM_USERPARMS_ATTR) * dwDsParamCount, TRUE);
        if (pCurAttr == NULL)
        {
            ntStatus = STATUS_NO_MEMORY;
            UpTrace("UpGenerateDsAttribs: alloc of %d values failed",
                     dwDsParamCount);
            break;
        }
        pRet->attCount = dwDsParamCount;
        pRet->UserParmsAttr = pCurAttr;

        // Set any appropriate dialin parameters
        //
        if (dwFlags & UP_F_Dialin)
        {
            dwCurVal =
                (pRasUser0->bfPrivilege & RASPRIV_DialinPrivilege) ? 1 : 0;

            // Initialize the dialin setting
            ntStatus = UpInitializeDwordAttr(
                        pCurAttr,
                        UpStrDup((PWCHAR)pszAttrDialin),
                        dwCurVal);
            if (ntStatus != STATUS_SUCCESS)
            {
                UpTrace("UpGenerateDsAttribs: fail dialin val %x", ntStatus);
                break;
            }

            pCurAttr++;
        }

        // Set any appropriate callback parameters
        //
        if (dwFlags & UP_F_Callback)
        {

            // The following logic was modified for SP1 of Win2K.  The reason is that
            // the values being set did not conform to the rules outlined in the
            // comments to the UserParmsConvert function.
            //
            // Namely,
            //   1.  the msRADIUSServiceType was being set to SDO_FRAMED instead of
            //       <empty> when RASPRIV_NoCallback was set.
            //
            //   2.  When RASPRIV_NoCallback was set, the msRADIUSCallbackNumber was
            //       set and the msRASSavedCallbackNumber was deleted instead of the
            //       vice-versa
            //

            // Initialize the service type
            if (pRasUser0->bfPrivilege & RASPRIV_NoCallback)
            {
                ntStatus = UpInitializeDeletedAttr(
                            pCurAttr,
                            UpStrDup((PWCHAR)pszAttrServiceType));
            }
            else
            {
                ntStatus = UpInitializeDwordAttr(
                            pCurAttr,
                            UpStrDup((PWCHAR)pszAttrServiceType),
                            SDO_FRAMED_CALLBACK);
            }

            if (ntStatus != STATUS_SUCCESS)
            {
                UpTrace("UpGenerateDsAttribs: fail ST val %x", ntStatus);
                break;
            }
            pCurAttr++;

            // Initialize the callback number that will be committed
            pszCurAttr = (pRasUser0->bfPrivilege & RASPRIV_AdminSetCallback) ?
                         (PWCHAR) pszAttrCbNumber                            :
                         (PWCHAR) pszAttrSavedCbNumber;
            if (*(pRasUser0->wszPhoneNumber))
            {
                ntStatus = UpInitializeStringAttrA(
                            pCurAttr,
                            UpStrDup(pszCurAttr),
                            UpWcstombsDup(pRasUser0->wszPhoneNumber));
                if (ntStatus != STATUS_SUCCESS)
                {
                    UpTrace("UpGenerateDsAttribs: fail CB val %x", ntStatus);
                    break;
                }
            }
            else
            {
                ntStatus = UpInitializeDeletedAttr(
                            pCurAttr,
                            UpStrDup(pszCurAttr));
                if (ntStatus != STATUS_SUCCESS)
                {
                    UpTrace("UpGenerateDsAttribs: fail del CB val %x", ntStatus);
                    break;
                }
            }
            pCurAttr++;

            // Remove the callback number that doesn't apply.
            pszCurAttr = (pszCurAttr == pszAttrCbNumber) ?
                         (PWCHAR) pszAttrSavedCbNumber   :
                         (PWCHAR) pszAttrCbNumber;
            ntStatus = UpInitializeDeletedAttr(
                        pCurAttr,
                        UpStrDup(pszCurAttr));
            if (ntStatus != STATUS_SUCCESS)
            {
                UpTrace("UpGenerateDsAttribs: fail del SCB val %x", ntStatus);
                break;
            }
            pCurAttr++;
        }

        // Set the cleartext password if present
        //
        if (szPassword != NULL)
        {
            // Make a duplicate copy of the password
            if ((pszDupPassword = UpStrDup(szPassword)) == NULL)
            {
                ntStatus = STATUS_NO_MEMORY;
                break;
            }

            // Initialize the password attribute
            ntStatus = UpInitializePasswordAttr(
                        pCurAttr,
                        pszDupPassword);
            if (ntStatus != STATUS_SUCCESS)
            {
                UpTrace("UpGenerateDsAttribs: fail password val %x", ntStatus);
                break;
            }

            pCurAttr++;
        }

    } while (FALSE);

    // Cleanup
    {
        if (ntStatus != STATUS_SUCCESS)
        {
            UserParmsFree(pRet);
            *ppAttrs = NULL;
        }
        else
        {
            *ppAttrs = pRet;
        }
    }

    return ntStatus;
}

//
// Callback function called by NT5 SAM whenever the user parms
// of a particular user are modified.  The job of this callout
// is to take the new value of user parms and generate a set of
// domain attributes that need to be set for the given user so
// that per-user DS attributes and userparms are kept in sync.
//
// This callout will be invoked during dcpromo to upgrade user parms
// and whenever userparms is modified (by downlevel api's and apps).
//
// Callback functions for NT5 SAM are registered in the following
// registry key:
//
//      HKLM\SYS\CCS\Control\LSA\NotificationPackages
//
// The following are the rules of the RAS LDAP parameters:
//
//  msNPAllowDialin
//      - Empty = Use policy to determine dialin privilege
//      - 1 = Allow dialin
//      - 2 = Deny dialin
//
//  msRADIUSServiceType
//      - Empty = NoCallback policy
//      - 4 = CallerCallback if msRADIUSCallbackNumber is empty
//            AdminCallback if msRADIUSCallbackNumber is not empty
//
//  msRADIUSCallbackNumber
//      - Determines the callback policy depending on msRADIUSServiceType
//
//  msRASSavedCallbackNumber
//      - Used to store the last known value of msRADIUSCallbackNumber when
//        switching from AdminCallback policy to some other policy.
//

NTSTATUS
UserParmsConvert (
    IN ULONG ulFlags,
    IN PSID pDomainSid,
    IN ULONG ulObjectRid,
    IN ULONG ulOrigLen,
    IN PVOID pvOrigUserParms,
    IN ULONG ulNewLen,
    IN PVOID pvNewUserParms,
    OUT PSAM_USERPARMS_ATTRBLOCK * ppAttrs)
{
    RAS_USER_0 RasUser00, *pOrigUser = &RasUser00;
    RAS_USER_0 RasUser01, *pNewUser  = &RasUser01;
    NTSTATUS ntStatus = STATUS_SUCCESS;
    PVOID pvOrig = NULL, pvNew = NULL;
    DWORD dwFlags = 0, dwMask;
    PWSTR szPassword = NULL;

    UpTrace(
        "UPConvert: F=%x, Rid=%x, OLen=%d, OPar=%x, NLen=%d, NPar=%x",
        ulFlags, ulObjectRid, ulOrigLen, pvOrigUserParms,
        ulNewLen, pvNewUserParms);

    // Validate parameters
    if (ppAttrs == NULL)
        return STATUS_INVALID_PARAMETER;

    // Initialize the return value;
    *ppAttrs = NULL;

    // If the user parms passed to us are NULL,
    // then keep defaults.
    if ((pvNewUserParms == NULL) || (ulNewLen == 0))
    {
        return STATUS_SUCCESS;
    }

    do
    {
        // Allocate and initialize local copies of
        // the user parms
        pvOrig = UpBlobDup(pvOrigUserParms, ulOrigLen);
        pvNew = UpBlobDup(pvNewUserParms, ulNewLen);

        // If this is a NT5 standalone being promoted to a DC, then we
        // just convert the uplevel userparms 'as is'.
        if ((ulFlags & SAM_USERPARMS_DURING_UPGRADE) &&
            !SamINT4UpgradeInProgress())
        {
           ntStatus = ConvertUserParmsToAttrBlock(pvNew, ppAttrs);
           break;
        }

        // Get the new ras properties
        ntStatus = UpUserParmsToRasUser0(
                        pvNew,
                        pNewUser);
        if (ntStatus != STATUS_SUCCESS)
        {
            UpTrace("UPConvert: Conversion to RAS_USER_0 failed.(1)");
            break;
        }

        // If we're upgrading, then we should blindly
        // set whatever information is stored in the user.
        if (ulFlags & SAM_USERPARMS_DURING_UPGRADE)
        {
            IASParmsGetUserPassword(pvNewUserParms, &szPassword);

            ntStatus =  UpGenerateDsAttribs(
                            UP_F_Dialin | UP_F_Callback | UP_F_Upgrade,
                            pNewUser,
                            szPassword,
                            ppAttrs);

            LocalFree(szPassword);

            if (ntStatus != STATUS_SUCCESS)
            {
                UpTrace("UPConvert: GenerateDsAttribs failed %x", ntStatus);
            }
            break;
        }

        // Get the ras properties of the old user parms
        ntStatus = UpUserParmsToRasUser0(
                        pvOrig,
                        pOrigUser);
        if (ntStatus != STATUS_SUCCESS)
        {
            UpTrace("UPConvert: Conversion to RAS_USER_0 failed.(2)");
            break;
        }

        // Find out if the dialin privilege should be updated
        dwFlags = 0;
        if (!!(pOrigUser->bfPrivilege & RASPRIV_DialinPrivilege) !=
            !!(pNewUser->bfPrivilege  & RASPRIV_DialinPrivilege))
        {
            dwFlags |= UP_F_Dialin;
        }

        // pmay: 264409
        //
        // If we are adding null usrparms for the first time,
        // go ahead and add the dialin bit value to the ds.
        //
        if ((pvOrig == NULL) && (pvNew != NULL))
        {
            dwFlags |= UP_F_Dialin;
        }

        // Findout if any callback info should be updated
        dwMask = RASPRIV_NoCallback        |
                 RASPRIV_CallerSetCallback |
                 RASPRIV_AdminSetCallback;
        if (((pOrigUser->bfPrivilege & dwMask)  !=
             (pNewUser->bfPrivilege  & dwMask)) ||
            (wcscmp(pOrigUser->wszPhoneNumber, pNewUser->wszPhoneNumber) != 0)
           )
        {
            dwFlags |= UP_F_Callback;
        }

        // If there were no changes, we're done.
        if (dwFlags == 0)
        {
            UpTrace("UPConvert: nothing to update.");
            ntStatus = STATUS_SUCCESS;
            break;
        }

        // Create the new attributes
        ntStatus =  UpGenerateDsAttribs(dwFlags, pNewUser, NULL, ppAttrs);
        if (ntStatus != STATUS_SUCCESS)
        {
            UpTrace("UPConvert: UpGenerateDsAttribs failed %x.", ntStatus);
            break;
        }

    } while (FALSE);

    // Cleanup
    {
        if (pvOrig)
        {
            UpFree(pvOrig);
        }
        if (pvNew)
        {
            UpFree(pvNew);
        }
    }

    return ntStatus;
}

//
// Callback function called by NT5 SAM to free the blob
// returned by UserParmsConvert.
//
VOID
UserParmsFree(
    IN PSAM_USERPARMS_ATTRBLOCK pData)
{
    SAM_USERPARMS_ATTR * pCur = NULL;
    DWORD i, j;

    UpTrace("UserParmsFree: Entered. %x", pData);

    // If no attributes were given, we're all done
    if (pData == NULL)
        return;

    if  (pData->UserParmsAttr)
    {
        // Loop through all the attributes, freeing them
        // as you go.
        for (i = 0; i < pData->attCount; i++)
        {
            // Keep track of the current attribute
            pCur = &(pData->UserParmsAttr[i]);

            // Free the copied attribute name
            if (pCur->AttributeIdentifier.Buffer)
                UpFree(pCur->AttributeIdentifier.Buffer);

            // Free any associated values as well.
            if (pCur->Values)
            {
                for (j = 0; j < pCur->CountOfValues; j++)
                {
                    // Assume there's only one value since that's
                    // all we ever set. Free the value
                    if (pCur->Values[j].value)
                        UpFree(pCur->Values[j].value);
                }

                // Free the value structure
                UpFree(pCur->Values);
            }
        }

        // Free the array of attributes
        UpFree (pData->UserParmsAttr);
    }

    // Finally, free the whole structure
    UpFree (pData);
}