windows-xp/Source/XPSP1/NT/printscan/print/spooler/localspl/forms.c

/*++

Copyright (c) 1990 - 1995  Microsoft Corporation

Module Name:

    forms.c

Abstract:

   This module provides all the public exported APIs relating to the
   Driver-based Spooler Apis for the Local Print Providor

   SplAddForm
   SplDeleteForm
   SplSetForm
   SplGetForm
   SplEnumForms

   Support Functions in forms.c - (Warning! Do Not Add to this list!!)


Author:

    Dave Snipp (DaveSn) 15-Mar-1991

Revision History:

--*/

#include <precomp.h>
#include <offsets.h>

VOID
BroadcastChangeForms(
    PINISPOOLER pIniSpooler);

DWORD
BroadcastChangeFormsThread(
    PINISPOOLER pIniSpooler);


typedef struct _REG_FORM_INFO {

    SIZEL   Size;
    RECTL   ImageableArea;

    DWORD   cFormOrder;
    DWORD   Flags;

} REG_FORM_INFO, *PREG_FORM_INFO;


// These figures are accurate to .001 mm
// There are 25.4 mm per inch

BUILTIN_FORM BuiltInForms[] = {
    0, IDS_FORM_LETTER,                215900, 279400, 0, 0, 215900, 279400,
    0, IDS_FORM_LETTER_SMALL,          215900, 279400, 0, 0, 215900, 279400,
    0, IDS_FORM_TABLOID,               279400, 431800, 0, 0, 279400, 431800,
    0, IDS_FORM_LEDGER,                431800, 279400, 0, 0, 431800, 279400,
    0, IDS_FORM_LEGAL,                 215900, 355600, 0, 0, 215900, 355600,
    0, IDS_FORM_STATEMENT,             139700, 215900, 0, 0, 139700, 215900,
    0, IDS_FORM_EXECUTIVE,             184150, 266700, 0, 0, 184150, 266700,
    0, IDS_FORM_A3,                    297000, 420000, 0, 0, 297000, 420000,
    0, IDS_FORM_A4,                    210000, 297000, 0, 0, 210000, 297000,
    0, IDS_FORM_A4_SMALL,              210000, 297000, 0, 0, 210000, 297000,
    0, IDS_FORM_A5,                    148000, 210000, 0, 0, 148000, 210000,
    0, IDS_FORM_B4,                    257000, 364000, 0, 0, 257000, 364000,
    0, IDS_FORM_B5,                    182000, 257000, 0, 0, 182000, 257000,
    0, IDS_FORM_FOLIO,                 215900, 330200, 0, 0, 215900, 330200,
    0, IDS_FORM_QUARTO,                215000, 275000, 0, 0, 215000, 275000,
    0, IDS_FORM_10X14,                 254000, 355600, 0, 0, 254000, 355600,
    0, IDS_FORM_11X17,                 279400, 431800, 0, 0, 279400, 431800,
    0, IDS_FORM_NOTE,                  215900, 279400, 0, 0, 215900, 279400,
    0, IDS_FORM_ENVELOPE9,                   98425, 225425, 0, 0,  98425, 225425,
    0, IDS_FORM_ENVELOPE10,                 104775, 241300, 0, 0, 104775, 241300,
    0, IDS_FORM_ENVELOPE11,                 114300, 263525, 0, 0, 114300, 263525,
    0, IDS_FORM_ENVELOPE12,                 120650, 279400, 0, 0, 120650, 279400,
    0, IDS_FORM_ENVELOPE14,                 127000, 292100, 0, 0, 127000, 292100,
    0, IDS_FORM_ENVELOPE_CSIZE_SHEET,       431800, 558800, 0, 0, 431800, 558800,
    0, IDS_FORM_ENVELOPE_DSIZE_SHEET,       558800, 863600, 0, 0, 558800, 863600,
    0, IDS_FORM_ENVELOPE_ESIZE_SHEET,       863600,1117600, 0, 0, 863600,1117600,
    0, IDS_FORM_ENVELOPE_DL,                110000, 220000, 0, 0, 110000, 220000,
    0, IDS_FORM_ENVELOPE_C5,                162000, 229000, 0, 0, 162000, 229000,
    0, IDS_FORM_ENVELOPE_C3,                324000, 458000, 0, 0, 324000, 458000,
    0, IDS_FORM_ENVELOPE_C4,                229000, 324000, 0, 0, 229000, 324000,
    0, IDS_FORM_ENVELOPE_C6,                114000, 162000, 0, 0, 114000, 162000,
    0, IDS_FORM_ENVELOPE_C65,               114000, 229000, 0, 0, 114000, 229000,
    0, IDS_FORM_ENVELOPE_B4,                250000, 353000, 0, 0, 250000, 353000,
    0, IDS_FORM_ENVELOPE_B5,                176000, 250000, 0, 0, 176000, 250000,
    0, IDS_FORM_ENVELOPE_B6,                176000, 125000, 0, 0, 176000, 125000,
    0, IDS_FORM_ENVELOPE,              110000, 230000, 0, 0, 110000, 230000,
    0, IDS_FORM_ENVELOPE_MONARCH,       98425, 190500, 0, 0,  98425, 190500,
    0, IDS_FORM_SIX34_ENVELOPE,         92075, 165100, 0, 0,  92075, 165100,
    0, IDS_FORM_US_STD_FANFOLD,        377825, 279400, 0, 0, 377825, 279400,
    0, IDS_FORM_GMAN_STD_FANFOLD,      215900, 304800, 0, 0, 215900, 304800,
    0, IDS_FORM_GMAN_LEGAL_FANFOLD,    215900, 330200, 0, 0, 215900, 330200,

    // Predefined forms currently availble only in Win95.  Included here
    // for compatibility.

    0, IDS_FORM_ISO_B4,                250000, 353000, 0, 0, 250000, 353000,
    0, IDS_FORM_JAPANESE_POSTCARD,     100000, 148000, 0, 0, 100000, 148000,
    0, IDS_FORM_9X11,                  228600, 279400, 0, 0, 228600, 279400,
    0, IDS_FORM_10X11,                 254000, 279400, 0, 0, 254000, 279400,
    0, IDS_FORM_15X11,                 381000, 279400, 0, 0, 381000, 279400,
    0, IDS_FORM_ENV_INVITE,            220000, 220000, 0, 0, 220000, 220000,
    0, IDS_FORM_RESERVED_48,           1,1, 0, 0, 1, 1,
    0, IDS_FORM_RESERVED_49,           1,1, 0, 0, 1, 1,
    0, IDS_FORM_LETTER_EXTRA,          241300, 304800, 0, 0, 241300, 304800,

    0, IDS_FORM_LEGAL_EXTRA,           241300, 381000, 0, 0, 241300, 381000,
    0, IDS_FORM_TABLOID_EXTRA,         304800, 457200, 0, 0, 304800, 457200,
    0, IDS_FORM_A4_EXTRA,                   235458, 322326, 0, 0, 235458, 322326,
    0, IDS_FORM_LETTER_TRANSVERSE,          215900, 279400, 0, 0, 215900, 279400,
    0, IDS_FORM_A4_TRANSVERSE,              210000, 297000, 0, 0, 210000, 297000,
    0, IDS_FORM_LETTER_EXTRA_TRANSVERSE,    241300, 304800, 0, 0, 241300, 304800,
    0, IDS_FORM_A_PLUS,                     227000, 356000, 0, 0, 227000, 356000,
    0, IDS_FORM_B_PLUS,                     305000, 487000, 0, 0, 305000, 487000,
    0, IDS_FORM_LETTER_PLUS,                215900, 322326, 0, 0, 215900, 322326,
    0, IDS_FORM_A4_PLUS,                    210000, 330000, 0, 0, 210000, 330000,
    0, IDS_FORM_A5_TRANSVERSE,              148000, 210000, 0, 0, 148000, 210000,
    0, IDS_FORM_B5_TRANSVERSE,              182000, 257000, 0, 0, 182000, 257000,
    0, IDS_FORM_A3_EXTRA,                   322000, 445000, 0, 0, 322000, 445000,
    0, IDS_FORM_A5_EXTRA,                   174000, 235000, 0, 0, 174000, 235000,
    0, IDS_FORM_B5_EXTRA,                   201000, 276000, 0, 0, 201000, 276000,
    0, IDS_FORM_A2,                         420000, 594000, 0, 0, 420000, 594000,
    0, IDS_FORM_A3_TRANSVERSE,              297000, 420000, 0, 0, 297000, 420000,
    0, IDS_FORM_A3_EXTRA_TRANSVERSE,        322000, 445000, 0, 0, 322000, 445000,

    0, IDS_FORM_DBL_JAPANESE_POSTCARD,           200000, 148000, 0, 0, 200000, 148000,
    0, IDS_FORM_A6,                              105000, 148000, 0, 0, 105000, 148000,
    0, IDS_FORM_JENV_KAKU2,                      240000, 332000, 0, 0, 240000, 332000,
    0, IDS_FORM_JENV_KAKU3,                      216000, 277000, 0, 0, 216000, 277000,
    0, IDS_FORM_JENV_CHOU3,                      120000, 235000, 0, 0, 120000, 235000,
    0, IDS_FORM_JENV_CHOU4,                       90000, 205000, 0, 0,  90000, 205000,
    0, IDS_FORM_LETTER_ROTATED,                  279400, 215900, 0, 0, 279400, 215900,
    0, IDS_FORM_A3_ROTATED,                      420000, 297000, 0, 0, 420000, 297000,
    0, IDS_FORM_A4_ROTATED,                      297000, 210000, 0, 0, 297000, 210000,
    0, IDS_FORM_A5_ROTATED,                      210000, 148000, 0, 0, 210000, 148000,
    0, IDS_FORM_B4_JIS_ROTATED,                  364000, 257000, 0, 0, 364000, 257000,
    0, IDS_FORM_B5_JIS_ROTATED,                  257000, 182000, 0, 0, 257000, 182000,
    0, IDS_FORM_JAPANESE_POSTCARD_ROTATED,       148000, 100000, 0, 0, 148000, 100000,
    0, IDS_FORM_DBL_JAPANESE_POSTCARD_ROTATED,   148000, 200000, 0, 0, 148000, 200000,
    0, IDS_FORM_A6_ROTATED,                      148000, 105000, 0, 0, 148000, 105000,
    0, IDS_FORM_JENV_KAKU2_ROTATED,              332000, 240000, 0, 0, 332000, 240000,
    0, IDS_FORM_JENV_KAKU3_ROTATED,              277000, 216000, 0, 0, 277000, 216000,
    0, IDS_FORM_JENV_CHOU3_ROTATED,              235000, 120000, 0, 0, 235000, 120000,
    0, IDS_FORM_JENV_CHOU4_ROTATED,              205000,  90000, 0, 0, 205000,  90000,
    0, IDS_FORM_B6_JIS,                          128000, 182000, 0, 0, 128000, 182000,
    0, IDS_FORM_B6_JIS_ROTATED,                  182000, 128000, 0, 0, 182000, 128000,
    0, IDS_FORM_12X11,                           304932, 279521, 0, 0, 304932, 279521,
    0, IDS_FORM_JENV_YOU4,                       105000, 235000, 0, 0, 105000, 235000,
    0, IDS_FORM_JENV_YOU4_ROTATED,               235000, 105000, 0, 0, 235000, 105000,
    0, IDS_FORM_P16K,                            188000, 260000, 0, 0, 188000, 260000,
    0, IDS_FORM_P32K,                            130000, 184000, 0, 0, 130000, 184000,
    0, IDS_FORM_P32KBIG,                         140000, 203000, 0, 0, 140000, 203000,
    0, IDS_FORM_PENV_1,                          102000, 165000, 0, 0, 102000, 165000,
    0, IDS_FORM_PENV_2,                          102000, 176000, 0, 0, 102000, 176000,
    0, IDS_FORM_PENV_3,                          125000, 176000, 0, 0, 125000, 176000,
    0, IDS_FORM_PENV_4,                          110000, 208000, 0, 0, 110000, 208000,
    0, IDS_FORM_PENV_5,                          110000, 220000, 0, 0, 110000, 220000,
    0, IDS_FORM_PENV_6,                          120000, 230000, 0, 0, 120000, 230000,
    0, IDS_FORM_PENV_7,                          160000, 230000, 0, 0, 160000, 230000,
    0, IDS_FORM_PENV_8,                          120000, 309000, 0, 0, 120000, 309000,
    0, IDS_FORM_PENV_9,                          229000, 324000, 0, 0, 229000, 324000,
    0, IDS_FORM_PENV_10,                         324000, 458000, 0, 0, 324000, 458000,
    0, IDS_FORM_P16K_ROTATED,                    260000, 188000, 0, 0, 260000, 188000,
    0, IDS_FORM_P32K_ROTATED,                    184000, 130000, 0, 0, 184000, 130000,
    0, IDS_FORM_P32KBIG_ROTATED,                 203000, 140000, 0, 0, 203000, 140000,
    0, IDS_FORM_PENV_1_ROTATED,                  165000, 102000, 0, 0, 165000, 102000,
    0, IDS_FORM_PENV_2_ROTATED,                  176000, 102000, 0, 0, 176000, 102000,
    0, IDS_FORM_PENV_3_ROTATED,                  176000, 125000, 0, 0, 176000, 125000,
    0, IDS_FORM_PENV_4_ROTATED,                  208000, 110000, 0, 0, 208000, 110000,
    0, IDS_FORM_PENV_5_ROTATED,                  220000, 110000, 0, 0, 220000, 110000,
    0, IDS_FORM_PENV_6_ROTATED,                  230000, 120000, 0, 0, 230000, 120000,
    0, IDS_FORM_PENV_7_ROTATED,                  230000, 160000, 0, 0, 230000, 160000,
    0, IDS_FORM_PENV_8_ROTATED,                  309000, 120000, 0, 0, 309000, 120000,
    0, IDS_FORM_PENV_9_ROTATED,                  324000, 229000, 0, 0, 324000, 229000,
    0, IDS_FORM_PENV_10_ROTATED,                 458000, 324000, 0, 0, 458000, 324000,

    0, 0,                                   0,      0, 0, 0,      0,      0
};


PINIFORM
CreateFormEntry(
    LPWSTR  pFormName,
    SIZEL   Size,
    RECTL  *pImageableArea,
    DWORD   Type,
    DWORD   cFormOrder,
    PINISPOOLER pIniSpooler
    )

/*++

Routine Description:

    Creates a Form entry, and insert it into the right place in
    pIniSpooler.

Arguments:

    pFormName - Name of Form.

    Size - Size of form.

    pImageableArea - Area of form that the printer can print to.

    Type - Type of form (usually indicates if BUILTIN form).

    cFormOrder - Where the form should be inserted for user-defined forms,
        form order increases from beginning to end.

        If this value is -1, generate a new cFormOrder for this form.
        (Put it at the end.)

Return Value:

    pIniForm - Created form, NULL = error.

Notes:

    This routine ensures that forms are put in proper order so that
    EnumForms always returns them in the same order.  We do this by
    scanning the list and inserting the new form such that all forms
    with cFormOrder =< the current on are to the left of it.

    This routine updates pIniSpooler->pIniForm (inserts or appends) and
    updates pIniSpooler->cFormOrderMax if necessary.

    i.e., 0 0 0 2 3 4 6
               ^
           New 0 inserted here.
--*/

{
    DWORD       cb;
    PINIFORM    pIniForm, pForm;

    cb = sizeof(INIFORM) + wcslen(pFormName)*sizeof(WCHAR) + sizeof(WCHAR);

    if ( pIniForm = AllocSplMem(cb) ) {

        pIniForm->pName         = wcscpy((LPWSTR)(pIniForm+1), pFormName);
        pIniForm->pNext         = NULL;
        pIniForm->signature     = IFO_SIGNATURE;
        pIniForm->Size          = Size;
        pIniForm->ImageableArea = *pImageableArea;
        pIniForm->Type          = Type;
        pIniForm->cFormOrder    = cFormOrder;

        //
        // This code will insert the item in order, but will always never
        // insert before the first item.  The built-in forms are always
        // at the front so this is not an issue.
        //

        if ( pForm = pIniSpooler->pShared->pIniForm ) {

            for( ; pForm->pNext; pForm = pForm->pNext ){

                //
                // If the next form is greater than the one we want
                // to insert, then insert it right now.
                //
                if( pForm->pNext->cFormOrder > cFormOrder ){

                    //
                    // The current from should be inserted here.
                    //
                    break;
                }
            }

            //
            // Link it up.
            //
            pIniForm->pNext = pForm->pNext;
            pForm->pNext = pIniForm;

        } else {

            pIniSpooler->pShared->pIniForm = pIniForm;
        }

        //
        // If the added form has a higher count than the current global
        // count, update the global.
        //
        if( cFormOrder > pIniSpooler->cFormOrderMax ){
            pIniSpooler->cFormOrderMax = cFormOrder;
        }
    }

    return pIniForm;
}

BOOL
InitializeForms(
    PINISPOOLER pIniSpooler
)
{
    PBUILTIN_FORM pBuiltInForm;
    HKEY          hFormsKey;
    DWORD         cUserDefinedForms;
    WCHAR         FormName[MAX_PATH];
    WCHAR         FormBuffer[FORM_NAME_LEN+1];
    DWORD         cchFormName;
    REG_FORM_INFO RegFormInfo;
    DWORD         cbRegFormInfo;

    DWORD         dwError;
    BOOL          bUpgradeTried = FALSE;
    BOOL          bStatus = TRUE;

    WORD PrimaryLangId = PRIMARYLANGID( GetSystemDefaultLangID( ));

    if (pIniSpooler->SpoolerFlags & SPL_TYPE_LOCAL)
    {
        for( pBuiltInForm = BuiltInForms; pBuiltInForm->NameId; pBuiltInForm++ ) {

            FormBuffer[0] = 0;

            LoadString( hInst,
                        pBuiltInForm->NameId,
                        FormBuffer,
                        FORM_NAME_LEN+1 );

            if ( CreateFormEntry( FormBuffer,
                             pBuiltInForm->Size,
                             &pBuiltInForm->ImageableArea,
                             FORM_BUILTIN,
                             0,
                             pIniSpooler ) == NULL)
            {
                bStatus = FALSE;
                break;
            }
        }
    }

    if ( bStatus )
    {
        //
        // Now see if there are any user-defined forms in the registry:
        //
        if ( RegOpenKeyEx( HKEY_LOCAL_MACHINE,
                           pIniSpooler->pszRegistryForms,
                           0,
                           KEY_READ | KEY_WRITE,
                           &hFormsKey) == NO_ERROR ) {

            for( cUserDefinedForms = 0; TRUE; ++cUserDefinedForms ){

    Retry:
                cchFormName = COUNTOF( FormName );
                cbRegFormInfo = sizeof( RegFormInfo );

                dwError = RegEnumValue( hFormsKey,
                                        cUserDefinedForms,
                                        (LPWSTR)FormName,
                                        &cchFormName,
                                        NULL,
                                        NULL,
                                        (LPBYTE)&RegFormInfo,
                                        &cbRegFormInfo );

                if( dwError ){
                    break;
                }

                //
                // We will attempt the upgrade only if
                //     we are on the first item,
                //     the size is incorrect, and
                //     we haven't tried upgrading once in the function before.
                //

                if( !cUserDefinedForms                     &&
                    cbRegFormInfo != sizeof( RegFormInfo ) &&
                    !bUpgradeTried ){

                    Upgrade35Forms( hFormsKey, pIniSpooler );
                    bUpgradeTried = TRUE;

                    goto Retry;
                }

                if ( CreateFormEntry( FormName,
                                 RegFormInfo.Size,
                                 &RegFormInfo.ImageableArea,
                                 RegFormInfo.Flags,
                                 RegFormInfo.cFormOrder,
                                 pIniSpooler ) == NULL )
                {
                    bStatus = FALSE;
                    break;
                }
            }

            RegCloseKey( hFormsKey );
            hFormsKey = NULL;
        }
    }


    return bStatus;
}


DWORD
GetFormSize(
    PINIFORM    pIniForm,
    DWORD       Level
)
{
    DWORD   cb;

    switch (Level) {

    case 1:

        cb=sizeof(FORM_INFO_1) +
           wcslen(pIniForm->pName)*sizeof(WCHAR) + sizeof(WCHAR);
        break;

    default:
        cb = 0;
        break;
    }

    return cb;
}

// We are being a bit naughty here as we are not sure exactly how much
// memory to allocate for the source strings. We will just assume that
// FORM_INFO_1 is the biggest structure around for the moment.

LPBYTE
CopyIniFormToForm(
    PINIFORM pIniForm,
    DWORD   Level,
    LPBYTE  pFormInfo,
    LPBYTE  pEnd
)
{
    LPWSTR   SourceStrings[sizeof(FORM_INFO_1)/sizeof(LPWSTR)];
    LPWSTR   *pSourceStrings=SourceStrings;
    LPFORM_INFO_1 pFormInfo1=(LPFORM_INFO_1)pFormInfo;
    DWORD   *pOffsets;

    switch (Level) {

    case 1:
        pOffsets = FormInfo1Strings;
        break;

    default:
        return pEnd;
    }

    switch (Level) {

    case 1:

        *pSourceStrings++=pIniForm->pName;

        pEnd = PackStrings(SourceStrings, pFormInfo, pOffsets, pEnd);

        pFormInfo1->Flags |= pIniForm->Type;
        pFormInfo1->Size = pIniForm->Size;
        pFormInfo1->ImageableArea = pIniForm->ImageableArea;

        break;

    default:
        return pEnd;
    }

    return pEnd;
}

/* Checks for logically impossible sizes.
 */
BOOL
ValidateForm(
    LPBYTE pForm
)
{
    LPFORM_INFO_1 pFormInfo = (LPFORM_INFO_1)pForm;
    DWORD    Error = NO_ERROR;

    if( !pForm ||
        (pFormInfo->Flags != FORM_USER &&
         pFormInfo->Flags != FORM_BUILTIN &&
         pFormInfo->Flags != FORM_PRINTER)) {

        Error = ERROR_INVALID_PARAMETER;

    } else

      /* Make sure name isn't longer than GDI DEVMODE specifies:
       */
    if( ( !pFormInfo->pName ) ||
        ( !pFormInfo->pName[0] ) ||
        ( wcslen( pFormInfo->pName ) > FORM_NAME_LEN )){

        Error = ERROR_INVALID_FORM_NAME;

    } else
    if( ( pFormInfo->Size.cx <= 0 )     /* Check for negative width */
        ||( pFormInfo->Size.cy <= 0 )     /* ... and height           */

      /* Check for strange imageable area:
       */
        || (pFormInfo->ImageableArea.right < 0)
        || (pFormInfo->ImageableArea.left < 0)
        || (pFormInfo->ImageableArea.bottom < 0)
        || (pFormInfo->ImageableArea.top < 0)
        ||( pFormInfo->ImageableArea.right <= pFormInfo->ImageableArea.left )
        ||( pFormInfo->ImageableArea.bottom <= pFormInfo->ImageableArea.top ) ) {

        Error = ERROR_INVALID_FORM_SIZE;
    }

    if( Error != NO_ERROR ) {

        SetLastError(Error);
        return FALSE;
    }

    return TRUE;
}


BOOL
SplAddForm(
    HANDLE  hPrinter,
    DWORD   Level,
    LPBYTE  pForm
)
{
    LPFORM_INFO_1 pFormInfo;
    PINIFORM      pIniForm;
    HKEY          hFormsKey;
    REG_FORM_INFO RegFormInfo;
    DWORD         Status;
    PSPOOL        pSpool = (PSPOOL)hPrinter;
    PINISPOOLER   pIniSpooler;
    HANDLE        hToken = INVALID_HANDLE_VALUE;


    if (!ValidateSpoolHandle( pSpool, 0 )) {
        return(FALSE);
    }

    pIniSpooler = pSpool->pIniSpooler;

    if (Level != 1) {
        return FALSE;
    }

    if (!ValidateForm(pForm)) {

        /* ValidateForm sets the appropriate error code:
         */
        return FALSE;
    }


    if ( !ValidateObjectAccess(SPOOLER_OBJECT_SERVER,
                               SERVER_ACCESS_ADMINISTER,
                               NULL, NULL, pIniSpooler )) {

        return FALSE;
    }

    EnterSplSem();

    pFormInfo = (LPFORM_INFO_1)pForm;

    pIniForm = FindForm(pFormInfo->pName, pIniSpooler);

    /* If there's already a form by this name, don't go on:
     */
    if (pIniForm) {

        /* Is there a better error code than this?? */
        SetLastError(ERROR_FILE_EXISTS);
        LeaveSplSem();
        return FALSE;
    }

    //
    //  Revert to LocalSystem, since a regular user cannot do this CreateKey call.
    //

    hToken = RevertToPrinterSelf();

    Status = RegCreateKeyEx(HKEY_LOCAL_MACHINE, pIniSpooler->pszRegistryForms, 0, NULL, 0,
                            KEY_WRITE, NULL, &hFormsKey, NULL);

    if (Status == NO_ERROR) {

        RegFormInfo.Size = pFormInfo->Size;
        RegFormInfo.ImageableArea = pFormInfo->ImageableArea;
        RegFormInfo.cFormOrder = pIniSpooler->cFormOrderMax + 1;
        RegFormInfo.Flags = pFormInfo->Flags;

        Status = RegSetValueEx( hFormsKey, pFormInfo->pName, 0, REG_BINARY,
                                (LPBYTE)&RegFormInfo, sizeof RegFormInfo );

        RegCloseKey( hFormsKey );

        if ( Status == NO_ERROR ) {

            CreateFormEntry( pFormInfo->pName,
                             pFormInfo->Size,
                             &pFormInfo->ImageableArea,
                             RegFormInfo.Flags,
                             RegFormInfo.cFormOrder,
                             pIniSpooler );

            SetPrinterChange( NULL,
                              NULL,
                              NULL,
                              PRINTER_CHANGE_ADD_FORM,
                              pIniSpooler );

            BroadcastChangeForms( pIniSpooler );
        }
    }

    ImpersonatePrinterClient( hToken );

    RunForEachSpooler( NULL, DsUpdateAllDriverKeys);

    LeaveSplSem();

    if ( Status != NO_ERROR )
        SetLastError( Status );

    SplLogEvent( pIniSpooler,
                 LOG_INFO,
                 MSG_FORM_ADDED,
                 FALSE,
                 pFormInfo->pName,
                 NULL );


    return ( Status == NO_ERROR );
}

BOOL
DeleteFormEntry(
    PINIFORM pIniForm,
    PINISPOOLER pIniSpooler
)
{
    PINIFORM *ppCurForm;

    ppCurForm = &pIniSpooler->pShared->pIniForm;

    while (*ppCurForm != pIniForm)
        ppCurForm = &(*ppCurForm)->pNext;

    *ppCurForm = (*ppCurForm)->pNext;

    FreeSplMem(pIniForm);

    return TRUE;

}




BOOL
SplDeleteForm(
    HANDLE  hPrinter,
    LPWSTR   pFormName
)
{
    HKEY     hFormsKey;
    DWORD    Status;
    PINIFORM pIniForm;
    PSPOOL   pSpool = (PSPOOL) hPrinter;
    HANDLE   hToken = INVALID_HANDLE_VALUE;
    PINISPOOLER pIniSpooler;


    if (!ValidateSpoolHandle( pSpool, 0 )) {
        return(FALSE);
    }

    pIniSpooler = pSpool->pIniSpooler;

    if (!pFormName) {

        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    if ( !ValidateObjectAccess(SPOOLER_OBJECT_SERVER,
                               SERVER_ACCESS_ADMINISTER,
                               NULL, NULL, pIniSpooler )) {

        return FALSE;
    }

    EnterSplSem();


    pIniForm = FindForm(pFormName, pIniSpooler);

    if (!pIniForm || ((pIniForm->Type == FORM_BUILTIN) && 
        pIniSpooler->SpoolerFlags & SPL_TYPE_LOCAL)) {

        SetLastError( pIniForm ?
                          ERROR_INVALID_PARAMETER :
                          ERROR_INVALID_FORM_NAME );
        LeaveSplSem();
        return FALSE;
    }

    hToken = RevertToPrinterSelf();

    Status = RegOpenKeyEx(HKEY_LOCAL_MACHINE, pIniSpooler->pszRegistryForms, 0,
                          KEY_WRITE, &hFormsKey);

    if (Status == NO_ERROR) {

        Status = RegDeleteValue(hFormsKey, pFormName);

        RegCloseKey(hFormsKey);

        if (Status == NO_ERROR) {

            DeleteFormEntry(pIniForm , pIniSpooler );

            SetPrinterChange(NULL,
                             NULL,
                             NULL,
                             PRINTER_CHANGE_DELETE_FORM,
                             pIniSpooler);

            BroadcastChangeForms(pIniSpooler);

            RunForEachSpooler( NULL, DsUpdateAllDriverKeys);
        }
    }

    if(hToken != INVALID_HANDLE_VALUE)
    {
        ImpersonatePrinterClient( hToken );
    }

    LeaveSplSem();

    if (Status != NO_ERROR)
        SetLastError(Status);

    SplLogEvent( pIniSpooler,
                 LOG_INFO,
                 MSG_FORM_DELETED,
                 FALSE,
                 pFormName,
                 NULL );

    return (Status == NO_ERROR);
}

BOOL
SplGetForm(
    HANDLE  hPrinter,
    LPWSTR   pFormName,
    DWORD   Level,
    LPBYTE  pForm,
    DWORD   cbBuf,
    LPDWORD pcbNeeded
)
{
    PINIFORM    pIniForm;
    DWORD       cb;
    LPBYTE      pEnd;
    PSPOOL      pSpool = (PSPOOL)hPrinter;
    PINISPOOLER pIniSpooler;

    if (!ValidateSpoolHandle(pSpool, 0 )) {
        return(FALSE);
    }

    if (!pSpool->pIniPrinter ||
        !pSpool->pIniSpooler ||
        (pSpool->pIniPrinter->signature != IP_SIGNATURE)) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

   EnterSplSem();

    SPLASSERT(pSpool->pIniSpooler->signature == ISP_SIGNATURE);

    pIniSpooler = pSpool->pIniSpooler;


    cb=0;

    if (pIniForm=FindForm(pFormName, pIniSpooler)) {

        cb=GetFormSize(pIniForm, Level);

        *pcbNeeded=cb;

        if (cb > cbBuf) {
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
           LeaveSplSem();
            SplOutSem();
            return FALSE;
        }

        pEnd=pForm+cbBuf;

        CopyIniFormToForm(pIniForm, Level, pForm, pEnd);
    } else {
        SetLastError( ERROR_INVALID_FORM_NAME );
    }

   LeaveSplSem();
    SplOutSem();

    return !!pIniForm;
}

BOOL
SplSetForm(
    HANDLE  hPrinter,
    LPWSTR   pFormName,
    DWORD   Level,
    LPBYTE  pForm
)
{
    HKEY     hFormsKey;
    DWORD    Status;
    PINIFORM pIniForm;
    LPFORM_INFO_1 pFormInfo;
    REG_FORM_INFO RegFormInfo;
    PINISPOOLER pIniSpooler;
    PSPOOL   pSpool = (PSPOOL)hPrinter;


    //
    // Validate this Printer Handle
    // Disallow Mask: PRINTER_HANDLE_SERVER
    //

    if (!ValidateSpoolHandle( pSpool , 0 )) {
        return(FALSE);
    }

    pIniSpooler = pSpool->pIniSpooler;

    if (Level != 1) {
        SetLastError(ERROR_INVALID_LEVEL);
        return FALSE;
    }

    if (!ValidateForm(pForm)) {

        /* ValidateForm sets the appropriate error code:
         */
        return FALSE;
    }

    if ( !ValidateObjectAccess(SPOOLER_OBJECT_SERVER,
                               SERVER_ACCESS_ADMINISTER,
                               NULL, NULL, pIniSpooler )) {

        return FALSE;
    }

    EnterSplSem();


    SPLASSERT( pIniSpooler->signature == ISP_SIGNATURE );

    pFormInfo = (LPFORM_INFO_1)pForm;

    pIniForm = FindForm(pFormName, pIniSpooler);

    if (!pIniForm || (pIniForm->Type == FORM_BUILTIN) || (pFormInfo->Flags & FORM_BUILTIN)) {

        SetLastError( pIniForm ?
                          ERROR_INVALID_PARAMETER :
                          ERROR_INVALID_FORM_NAME );
        LeaveSplSem();
        return FALSE;
    }

    Status = RegOpenKeyEx(HKEY_LOCAL_MACHINE, pIniSpooler->pszRegistryForms, 0,
                          KEY_WRITE, &hFormsKey);

    if (Status == NO_ERROR) {

        RegFormInfo.Size = pFormInfo->Size;
        RegFormInfo.ImageableArea = pFormInfo->ImageableArea;
        RegFormInfo.Flags = pFormInfo->Flags;

        Status = RegSetValueEx(hFormsKey, pFormInfo->pName, 0, REG_BINARY,
                               (LPBYTE)&RegFormInfo, sizeof RegFormInfo);

        RegCloseKey(hFormsKey);
    }

    if (Status == NO_ERROR) {

        pIniForm->Size = pFormInfo->Size;
        pIniForm->ImageableArea = pFormInfo->ImageableArea;
        pIniForm->Type = pFormInfo->Flags;

        SetPrinterChange(NULL,
                         NULL,
                         NULL,
                         PRINTER_CHANGE_SET_FORM,
                         pIniSpooler);

        BroadcastChangeForms(pIniSpooler);
    }

    LeaveSplSem();

    return (Status == NO_ERROR);
}


BOOL
SplEnumForms(
    HANDLE  hPrinter,
    DWORD   Level,
    LPBYTE  pForm,
    DWORD   cbBuf,
    LPDWORD pcbNeeded,
    LPDWORD pcReturned
    )
{
    PINIFORM    pIniForm;
    DWORD       cb;
    LPBYTE      pEnd;
    PSPOOL      pSpool = (PSPOOL)hPrinter;
    PINISPOOLER pIniSpooler;

    if (!ValidateSpoolHandle(pSpool, 0 )) {
        return FALSE;
    }

    *pcReturned=0;

   EnterSplSem();

    pIniSpooler = pSpool->pIniSpooler;

    SPLASSERT( ( pIniSpooler != NULL ) &&
               ( pIniSpooler->signature == ISP_SIGNATURE ));


    cb=0;
    pIniForm=pIniSpooler->pShared->pIniForm;

    while (pIniForm) {
        cb+=GetFormSize(pIniForm, Level);
        pIniForm=pIniForm->pNext;
    }

    *pcbNeeded=cb;

    if (cb > cbBuf) {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
       LeaveSplSem();
        SplOutSem();
        return FALSE;
    }

    pIniForm=pIniSpooler->pShared->pIniForm;
    pEnd=pForm+cbBuf;
    while (pIniForm) {
        pEnd = CopyIniFormToForm(pIniForm, Level, pForm, pEnd);
        switch (Level) {
        case 1:
            pForm+=sizeof(FORM_INFO_1);
            break;
        }
        pIniForm=pIniForm->pNext;
        (*pcReturned)++;
    }


   LeaveSplSem();
    SplOutSem();
    return TRUE;
}

DWORD dwBroadcastChangeFormsThread = 0;

VOID
BroadcastChangeForms(
    PINISPOOLER pIniSpooler)

/*++

Routine Description:

    Notify all applications that their devmode may have changed (when
    a form is changed).

Arguments:

Return Value:

--*/

{
    PINIPRINTER pIniPrinter;
    WCHAR       PrinterName[ MAX_UNC_PRINTER_NAME ];
    UINT        MachineNameLen;

    SplInSem();

    if( !( pIniSpooler->SpoolerFlags & SPL_FORMS_CHANGE )) {
        return;
    }

    INCSPOOLERREF( pIniSpooler );

    ++dwBroadcastChangeFormsThread;

    if ( pIniSpooler != pLocalIniSpooler ) {

        //
        // For Non Local Printers prepend the Machine Name
        //
        wsprintf( PrinterName, L"%ws\\", pIniSpooler->pMachineName );

    } else {

        PrinterName[0] = L'\0';
    }

    MachineNameLen = wcslen( PrinterName ) ;

    for( pIniPrinter = pIniSpooler->pIniPrinter;
         pIniPrinter;
         pIniPrinter = pIniPrinter->pNext ) {

        wcscpy ( &PrinterName[MachineNameLen], pIniPrinter->pName );

        //
        // Stress testing has shown that SendNotifyMessage can take
        // a long time to return, so leave critical section.
        //
        INCPRINTERREF( pIniPrinter );

        LeaveSplSem();
        SplOutSem();

        SendNotifyMessage(HWND_BROADCAST,
                          WM_DEVMODECHANGE,
                          0,
                          (LPARAM)PrinterName);
        EnterSplSem();

        DECPRINTERREF( pIniPrinter );
    }

    DECSPOOLERREF( pIniSpooler );
}


VOID
Upgrade35Forms(
    IN     HKEY hFormsKey,
    IN OUT PINISPOOLER pIniSpooler
    )

/*++

Routine Description:

    Upgrade the forms entries in hFormsKey to include an extra DWORD
    FormOrder value.  This value is used to determine the order of
    user-defined forms (built-in forms always go in the front).  In
    the upgrade case, we assign the order based on the registry order
    (this is arbitrary).

    It is necessary to keep pIniSpooler->pIniForm in the same order
    to ensure EnumForms returns them in the same order, since drivers
    call EnumForms and assign index numbers to these forms.  If the
    order is different, the indicies will change, and dmPaperSize in
    the DEVMODE will point to a different paper size.

    If forms are added (either by the user or by the driver when it has
    new paper sizes), they will be placed at the end of the list so that
    previous indicies do not change.  If forms are deleted, then some
    indicies will change, and the printout will use the incorrect form
    (later we will add FORM_INFO_2 which returns a unique, non-changing
    index).

Arguments:

    hFormsKey - Key pointing to 3.5, 3.1 forms that need to be updated.

    pIniSpooler - Current spooler.

Return Value:

    VOID

Notes:

    pIniSpooler->cFormsOrderMax updated.

--*/

{
    DWORD         cUserDefinedForms;
    WCHAR         FormName[MAX_PATH];
    DWORD         cchFormName;
    REG_FORM_INFO RegFormInfo;
    DWORD         cbRegFormInfo;

    //
    // Read in the old FORM info, which lacks the cFormOrder and/or Flags, then
    // write it out with the new cFormOrder and/or Flags.
    //
    for( cUserDefinedForms = 0;
         TRUE;
         ++cUserDefinedForms ){

        cchFormName = COUNTOF( FormName );
        cbRegFormInfo = sizeof( RegFormInfo );

        if( RegEnumValue( hFormsKey,
                          cUserDefinedForms,
                          (LPWSTR)FormName,
                          &cchFormName,
                          NULL,
                          NULL,
                          (LPBYTE)&RegFormInfo,
                          &cbRegFormInfo ) != NO_ERROR ){

            break;
        }

        RegFormInfo.cFormOrder  = cUserDefinedForms;
        RegFormInfo.Flags       = FORM_USER;

        //
        // Write it out with the new value cFormOrderMax value.
        //
        RegSetValueEx( hFormsKey,
                       (LPWSTR)FormName,
                       0,
                       REG_BINARY,
                       (LPBYTE)&RegFormInfo,
                       sizeof( RegFormInfo ));
    }

    pIniSpooler->cFormOrderMax = cUserDefinedForms - 1;
}