dial.c

可用于嵌入式编程学习

// ******************************************************************
// **Copyright (c) 1995-2000 Microsoft Corporation.  All rights reserved.
// **             
// ******************************************************************
//
//	dial.c		The dialing state machine for Unimodem
//
//	@doc	EX_TSPI
//
//	@topic	TSPI |
//
//		Tspi Stuff
//
//

#include "windows.h"
#include "types.h"
#include "memory.h"
#include "mcx.h"
#include "tspi.h"
#include "linklist.h"
#include "tspip.h"
#include "tapicomn.h"
#include "dial.h"
#include "termctrl.h"
#include "resource.h"

// Functions from modem.c
extern LONG ToggleCommMask(PTLINEDEV pLineDev);
extern void SetDCBfromDevMiniCfg(DCB * pDCB,PDEVMINICFG lpDevMiniCfg);
extern void WriteModemLog(PTLINEDEV pLineDev, UCHAR * szCommand, DWORD dwOp);

// Unimodem thread priority
extern DWORD g_dwUnimodemThreadPriority;

// Some keys we read to get modem related info from registry
const WCHAR szSettings[] =   TEXT("Settings");
const WCHAR szDialSuffix[] = TEXT("DialSuffix");
static const WCHAR szInit[] =   TEXT("Init");
#define MAXINITKEYS 5
static const PWCHAR szInitNum[MAXINITKEYS] = {
    TEXT("1"),
    TEXT("2"),
    TEXT("3"),
    TEXT("4"),
    TEXT("5") 
};

int strncmpi(char *dst, const char *src, long count)
{
    while (count) {
        if (toupper(*dst) != toupper(*src))
            return 1;
        if (*src == 0)
            return 0;
        dst++;
        src++;
        count--;
    }

    return 0;
}


/******************************************************************************

 @doc INTERNAL

 @api BOOL | ExpandMacros | Takes the string pszLine, and copies it to 
 lpszVal after expanding macros
 
 @parm char * | pszRegResponse | ptr to response string from registry.
 
 @parm char * | pszExpanded | ptr to buffer to copy string to w/ macros expanded
 
 @parm DWORD * | pdwValLen | length of pszVal w/ expanded macros.
 
 @rdesc Returns FALSE if a needed macro translation could not be found in the
 pMacroXlations table, TRUE otherwise.
 
*****************************************************************************/

BOOL
ExpandMacros(
    PWCHAR  pszRegResponse,
    PWCHAR  pszExpanded,
    DWORD * pdwValLen,
    MODEMMACRO * pMdmMacro,
    DWORD cbMacros
    )
{
    PWCHAR pszValue;
    DWORD cbTmp;
    BOOL  bFound;
    PWCHAR ptchTmp;
    DWORD i;
        
    DEBUGMSG(ZONE_DIAL, (TEXT("UNIMODEM:+ExpandMacros : Original \"%s\"\r\n"), pszRegResponse ));

    pszValue = pszExpanded;

    for ( ; *pszRegResponse; ) 
    {
        // check for a macro
        if ( *pszRegResponse == LMSCH ) 
        {
            // <cr>
            if (!wcsnicmp(pszRegResponse,CR_MACRO,CR_MACRO_LENGTH)) 
            {
                *pszValue++ = CR;
                pszRegResponse += CR_MACRO_LENGTH;
                continue;
            }
            // <lf>
            if (!wcsnicmp(pszRegResponse,LF_MACRO,LF_MACRO_LENGTH)) 
            {
                *pszValue++ = LF;
                pszRegResponse += LF_MACRO_LENGTH;
                continue;
            }
            // <hxx>
            if ((pszRegResponse[1] == 'h' || pszRegResponse[1] == 'H') &&
                     isxdigit(pszRegResponse[2]) &&
                     isxdigit(pszRegResponse[3]) &&
                     pszRegResponse[4] == RMSCH ) 
            {
                *pszValue++ = (char) ((ctox(pszRegResponse[2]) << 4) + ctox(pszRegResponse[3]));
                pszRegResponse += 5;
                continue;
            }
            // <macro>
            if (pMdmMacro) 
            {
                bFound = FALSE;
                // Check for a matching macro.
                for (i = 0; i < cbMacros; i++)
                {
                    cbTmp = wcslen(pMdmMacro[i].MacroName);
                    if (!wcsnicmp(pszRegResponse, pMdmMacro[i].MacroName, cbTmp))
                    {
                        ptchTmp = pMdmMacro[i].MacroValue;
                        while (*ptchTmp)
                        {
                            *pszValue++ = *ptchTmp++;
                        }
                        pszRegResponse += cbTmp;
                        bFound = TRUE;
                        break;
                    }
                }
                if (bFound)  // Did we get a match?
                {
                    continue;
                }
            }  // <macro>
        } // LMSCH
        
        // No matches, copy the character verbatim.
        *pszValue++ = *pszRegResponse++;
    } // for

    *pszValue = 0;
    if (pdwValLen)
    {
        *pdwValLen = pszValue - pszExpanded;
    }

    DEBUGMSG( ZONE_DIAL, (TEXT("UNIMODEM:-ExpandMacros : Expanded \"%s\"\r\n"), pszExpanded ));

    return TRUE;
}



































PWCHAR
CreateDialCommands(
    PTLINEDEV pLineDev,
    BOOL *fOriginate
    )
{
    DWORD  dwSize;
    PWCHAR pszTemp;
    PWCHAR pszDialPrefix;    // ex. "ATX4DT" or "ATX3DT"
    PWCHAR pszDialSuffix;    // ex. ";<cr>"
    PWCHAR pszOrigSuffix;    // ex. "<cr>"
    PWCHAR pszzDialCommands = NULL;
    PWCHAR ptchSrc, ptchDest;
    WCHAR  pszShortTemp[2];
    static const WCHAR szPrefix[] =     TEXT("Prefix");
    static const WCHAR szTerminator[] = TEXT("Terminator");
    static const WCHAR szDialPrefix[] = TEXT("DialPrefix");
    static const WCHAR szPulse[] =      TEXT("Pulse");
    static const WCHAR szTone[] =       TEXT("Tone");
    static const WCHAR *szDialType;  // szTone or szPulse
    static const WCHAR szBlindOff[] =   TEXT("Blind_Off");
    static const WCHAR szBlindOn[] =    TEXT("Blind_On");
    static const WCHAR *szBlindType;  // szBlindOn or szBlindOff

    DEBUGMSG( ZONE_DIAL, (TEXT("UNIMODEM:+CreateDialCommands - number %s\r\n"),
               pLineDev->szAddress ? pLineDev->szAddress : TEXT("") ));

     // Figure out fOriginate
    ptchSrc = pLineDev->szAddress;
    
    *fOriginate = TRUE;
    while (*ptchSrc)
    {
        if (pLineDev->chContinuation == *ptchSrc)   // usually a semicolon
        {
            *fOriginate = FALSE;
#ifdef DEBUG
            // make sure the string is correctly formed.
            if (ptchSrc[1])
            {
                DEBUGMSG(ZONE_DIAL, (TEXT("UNIMODEM: CreateDialCommands szPhoneNumber had a line continuation character not at the end.\r\n")));
            }
#endif // DEBUG
        }
        ptchSrc++;
    }

    // Trim the command continuation character off the end, now that we know this is not an origination string.
    if (!(*fOriginate))
    {
        DEBUGMSG(ZONE_DIAL, (TEXT("UNIMODEM:CreateDialCommands Non-originate string, trim trailing \"%c\"\r\n"),pLineDev->chContinuation));
#ifdef DEBUG
        if (ptchSrc[-1] != pLineDev->chContinuation)    // usually a semicolon
        {
            DEBUGMSG( ZONE_DIAL, (TEXT("UNIMODEM:CreateDialCommands made a bad assumption.\r\n")));
        }
#endif // DEBUG
        ptchSrc[-1] = 0;
    }

    // At this point, szPhoneNumber is just a string of digits to be dialed, with no semicolon at
    // the end.  Plus we know whether to originate or not.

    // make some temp space
    dwSize = ((pLineDev->dwMaxCmd + 1 +    // pszTemp
               pLineDev->dwMaxCmd + 1 +    // pszDialPrefix
               pLineDev->dwMaxCmd + 1 +    // pszDialSuffix
               pLineDev->dwMaxCmd + 1)     // pszOrigSuffix
              * SZWCHAR);

    pszTemp = (PWCHAR)TSPIAlloc( dwSize );
    if (!pszTemp)
    {
        DEBUGMSG( ZONE_DIAL, (TEXT("UNIMODEM:-CreateDialCommands : out of memory.\r\n")));
        return NULL;
    }
    DEBUGMSG(ZONE_DIAL, (TEXT("UNIMODEM:CreateDialCommands Allocated %d bytes at x%X for tmp dial strings\r\n"),
               dwSize, pszTemp));

    pszDialPrefix = pszTemp       + pLineDev->dwMaxCmd + 1;
    pszDialSuffix = pszDialPrefix + pLineDev->dwMaxCmd + 1;
    pszOrigSuffix = pszDialSuffix + pLineDev->dwMaxCmd + 1;

        // read in prefix
        dwSize = pLineDev->dwMaxCmd * SZWCHAR;
        if (ERROR_SUCCESS !=
            MdmRegGetValue( pLineDev,
                            szSettings,
                            szPrefix,
                            REG_SZ,
                            (PUCHAR)pszTemp,
                            &dwSize) )
        {
            goto Failure;
        }
        ExpandMacros(pszTemp, pszDialPrefix, NULL, NULL, 0);

        





        if ( (MDM_BLIND_DIAL & pLineDev->DevMiniCfg.dwModemOptions) ||
             (MDM_BLIND_DIAL & pLineDev->dwDialOptions) )
        {   // Turn on blind dialing
            szBlindType = szBlindOn;
            DEBUGMSG( ZONE_DIAL,
                      (TEXT("UNIMODEM:CreateDialCommands BLIND DIALING - ModemOptions 0x%X, DialOptions 0x%X\r\n"),
                       pLineDev->DevMiniCfg.dwModemOptions, pLineDev->dwDialOptions ));
        }
        else
        {   // Turn off blind dialing
            szBlindType = szBlindOff;        
        }
    
        


#ifdef BLIND_OPTION_IN_PREFIX
        // read in appropriate blind options
        dwSize = pLineDev->dwMaxCmd * SZWCHAR;
        if (ERROR_SUCCESS !=
            MdmRegGetValue( pLineDev,
                            szSettings,
                            szBlindType,
                            REG_SZ,
                            (PUCHAR)pszTemp,
                            &dwSize) )
        {
            goto Failure;
        }
        ExpandMacros(pszTemp, pszDialPrefix + wcslen(pszDialPrefix), NULL, NULL, 0);
#endif
    

    // read in dial prefix
    dwSize = pLineDev->dwMaxCmd * SZWCHAR;
    if (ERROR_SUCCESS != MdmRegGetValue( pLineDev,
                                         szSettings,
                                         szDialPrefix,
                                         REG_SZ,
                                         (PUCHAR)pszTemp,
                                         &dwSize) )
    {
        goto Failure;
    }
    
    ExpandMacros(pszTemp, pszDialPrefix + wcslen(pszDialPrefix), NULL, NULL, 0);
    
    


    dwSize = pLineDev->dwMaxCmd * SZWCHAR;
    if (MDM_TONE_DIAL & pLineDev->dwDialOptions)
    {   // We want to do tone dialing
        szDialType = szTone;
    }
    else
    {   // We want to do pulse dialing
        szDialType = szPulse;
    }
            
    if (ERROR_SUCCESS != MdmRegGetValue( pLineDev,
                                         szSettings,
                                         szDialType,
                                         REG_SZ,
                                         (PUCHAR)pszTemp,
                                         &dwSize) )
    {
        goto Failure;
    }