dial.c

可用于嵌入式编程学习

    ExpandMacros(pszTemp, pszDialPrefix + wcslen(pszDialPrefix), NULL, NULL, 0);
    
    // read in dial suffix
    dwSize = pLineDev->dwMaxCmd * SZWCHAR;
    if (ERROR_SUCCESS != MdmRegGetValue( pLineDev,
                                         szSettings,
                                         szDialSuffix,
                                         REG_SZ,
                                         (PUCHAR)pszTemp,
                                         &dwSize) )
    {
        wcscpy(pszDialSuffix, TEXT(""));
#ifdef TODO
        hPort->mi_fHaveDialSuffix = FALSE;
#endif
    }
    else
    {
#ifdef TODO
        hPort->mi_fHaveDialSuffix = TRUE;
#endif
        ExpandMacros(pszTemp, pszDialSuffix, NULL, NULL, 0);
    }

    // read in prefix terminator
    dwSize = pLineDev->dwMaxCmd * SZWCHAR;
    if (ERROR_SUCCESS == MdmRegGetValue( pLineDev,
                                         szSettings,
                                         szTerminator,
                                         REG_SZ,
                                         (PUCHAR)pszTemp,
                                         &dwSize) )
    {
        ExpandMacros(pszTemp, pszOrigSuffix, NULL, NULL, 0);
        wcscat(pszDialSuffix, pszOrigSuffix);
#ifdef DEBUG
        if (wcslen(pszOrigSuffix) > wcslen(pszDialSuffix))
        {
            DEBUGMSG( ZONE_DIAL,
                      (TEXT("UNIMODEM:CreateDialCommands OrigSuffix longer than DialSuffix!!! (contact developer)\r\n")));
        }
#endif // DEBUG
    }

#ifdef DEBUG
    if ((wcslen(pszDialPrefix) + wcslen(pszDialSuffix)) > pLineDev->dwMaxCmd)
    {
        DEBUGMSG( ZONE_DIAL,
                  (TEXT("UNIMODEM:CreateDialCommands Prefix, Terminator, BlindOn/Off, Dial Prefix, and Dial Suffix are too long!\r\n")));
    }
#endif // DEBUG

    // allocate space for the phone number lines
    {
        DWORD dwCharsAlreadyTaken = wcslen(pszDialPrefix) + wcslen(pszDialSuffix);
        DWORD dwAvailCharsPerLine = (pLineDev->dwMaxCmd - dwCharsAlreadyTaken);
        DWORD dwPhoneNumLen       = wcslen(pLineDev->szAddress);
        DWORD dwNumLines          = dwPhoneNumLen ? (dwPhoneNumLen / dwAvailCharsPerLine +
                                                     (dwPhoneNumLen % dwAvailCharsPerLine ? 1 : 0))
                                                  : 1;  // handle null string
        dwSize                    = (dwPhoneNumLen + dwNumLines * (dwCharsAlreadyTaken + 1) + 1) * SZWCHAR;

        DEBUGMSG( ZONE_DIAL,
                  (TEXT("UNIMODEM:CreateDialCommands Allocation sizes - prefix/suffix %d, Phone num %d, numLines %d\r\n"),
                   dwCharsAlreadyTaken, dwPhoneNumLen, dwNumLines));
    }

    DEBUGMSG( ZONE_DIAL,
              (TEXT("UNIMODEM:CreateDialCommands Allocate %d bytes for Dial Commands.\r\n"), dwSize));

     
    dwSize *= 4;
    
    if (!(pszzDialCommands = (PWCHAR)TSPIAlloc(dwSize)))
    {
        DEBUGMSG( ZONE_DIAL,
                  (TEXT("UNIMODEM:CreateDialCommands ran out of memory and failed a TSPIAlloc!\r\n")));
        goto Failure;
    }
    DEBUGMSG( ZONE_DIAL,
              (TEXT("UNIMODEM:CreateDialCommands Allocated %d bytes at x%X for dial string\r\n"),
               dwSize, pszzDialCommands));
    
    ptchDest = pszzDialCommands;  // point to the beginning of the commands
        
    // build dial line(s):

#ifndef BLIND_OPTION_IN_PREFIX
    // See above : we now split the blind dial out from the dial prefix.

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

    // 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, ptchDest + wcslen(ptchDest), NULL, NULL, 0);
    DEBUGMSG( ZONE_DIAL,
              (TEXT("UNIMODEM:CreateDialCommands prepended Blind dial sequence = %s, len %d\r\n"),
               ptchDest, wcslen(ptchDest)));    

    //OK, be sure to add a CR to this
    ExpandMacros(CR_MACRO, ptchDest + wcslen(ptchDest), NULL, NULL, 0);
    DEBUGMSG( ZONE_DIAL,
              (TEXT("UNIMODEM:CreateDialCommands prepended Blind dial sequence = %s, len %d\r\n"),
               ptchDest, wcslen(ptchDest)));    

    // begin a new dial string
    ptchDest += wcslen(ptchDest) + 1;
#endif

    // prime the pump
    DEBUGMSG( ZONE_DIAL,
              (TEXT("UNIMODEM:CreateDialCommands Copying Dial prefix %s to x%X\r\n"),
               pszDialPrefix, ptchDest));
    wcscpy(ptchDest, pszDialPrefix);

    
    // do we have a dial suffix
    if ( /*!hPort->mi_fHaveDialSuffix*/ FALSE )
    {
        
#ifdef DEBUG
        // but, can we fit the dial string?
        if (wcslen(pszDialPrefix) + wcslen(pLineDev->szAddress) +
            wcslen(pszDialSuffix) + 1 > pLineDev->dwMaxCmd)
        {
            DEBUGMSG( ZONE_DIAL,
                      (TEXT("UNIMODEM:CreateDialCommands dial string is too long and we don't have dial suffix capability\r\n")));
        }
        // did we not want to originate?
        if (!(*fOriginate))
        {
            DEBUGMSG( ZONE_DIAL,
                      (TEXT("UNIMODEM:CreateDialCommands was told not to originate, but it has to because it doesn't have a dial suffix! (tsp screwed up!)\r\n")));
        }
#endif // DEBUG

        // build it
        DEBUGMSG( ZONE_DIAL,
                  (TEXT("UNIMODEM:CreateDialCommands Appending phone number %s\r\n"), pLineDev->szAddress));
        wcscat(ptchDest, pLineDev->szAddress);        
        DEBUGMSG( ZONE_DIAL,
                  (TEXT("UNIMODEM:CreateDialCommands Appending Dial Suffix %s\r\n"), pszDialSuffix));
        wcscat(ptchDest, pszDialSuffix);
        DEBUGMSG( ZONE_DIAL,
                  (TEXT("UNIMODEM:CreateDialCommands Final Dial String %s\n"), ptchDest));

    }
    else
    {
        // we have a dial suffix.

        // populate new pszzDialCommands with semi-colons as necessary.

        // go through and add suffixi, making sure lines don't exceed pLineDev->dwMaxCmd
        ptchSrc = pLineDev->szAddress;     // moves a character at a time.
        pszShortTemp[1] = 0;    // null terminate the 1 character temp string

         // step through the source
        while (*ptchSrc)
        {
            if (wcslen(ptchDest) + wcslen(pszDialSuffix) + 1 > pLineDev->dwMaxCmd)
            {
                // finish up this string
                DEBUGMSG( ZONE_DIAL,
                          (TEXT("UNIMODEM:CreateDialCommands Appending Dial suffix %s\r\n"), pszDialSuffix));
                wcscat(ptchDest, pszDialSuffix);

                // begin a new string
                ptchDest += wcslen(ptchDest) + 1;
                DEBUGMSG( ZONE_DIAL,
                          (TEXT("UNIMODEM:CreateDialCommands Copying Dial prefix %s for a new line at 0x%X\r\n"),
                           pszDialPrefix, ptchDest));
                wcscpy(ptchDest, pszDialPrefix);
            }
            else
            {
                // copy char
                DEBUGMSG( ZONE_DIAL,
                          (TEXT("UNIMODEM:CreateDialCommands Appending character %c to dial string %s\r\n"),
                           *ptchSrc, ptchDest));
                pszShortTemp[0] = *ptchSrc;
                wcscat(ptchDest, pszShortTemp);
                ptchSrc++;
            }
        }
        
         // conclude with the approprate Suffix.
        DEBUGMSG( ZONE_DIAL,
                  (TEXT("UNIMODEM:CreateDialCommands Appending Final Dial Suffix %s\r\n"), (*fOriginate ? pszOrigSuffix : pszDialSuffix)));
        wcscat(ptchDest, (*fOriginate ? pszOrigSuffix : pszDialSuffix));
    }

    // close keys  
Exit:
    DEBUGMSG( ZONE_DIAL, (TEXT("UNIMODEM:CreateDialCommands Trying to free pszTemp x%X\r\n"), pszTemp));
    TSPIFree(pszTemp);
    DEBUGMSG( ZONE_DIAL, (TEXT("UNIMODEM:-CreateDialCommands\r\n")));

    return pszzDialCommands;

Failure:
    if (pszzDialCommands)
    {
        DEBUGMSG( ZONE_DIAL|ZONE_ERROR, (TEXT("UNIMODEM:CreateDialCommands - Error, freeing dial string\r\n")));
        TSPIFree(pszzDialCommands);
        pszzDialCommands = NULL;
    }
    goto Exit;
}


BOOL
IsDigit(
    UCHAR ch
    )
{
    switch (ch) {
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
        return TRUE;
    }

    return FALSE;
}

//
// Extract the connection speed from an extended CONNECT or CARRIER modem response
// and store it in pLineDev->dwCurrentBaudRate
//
void
ParseConnectSpeed(
    PTLINEDEV pLineDev,
    PUCHAR pszResponse
    )
{
    DWORD dwSpeed = 0;
    PUCHAR psz;

    DEBUGMSG(ZONE_FUNC|ZONE_CALLS, (TEXT("UNIMODEM:+ParseConnectSpeed %a\n"), pszResponse));
    //
    // CONNECT and CARRIER typically follow the form:
    // CONNECT <speed></protocol>< protocol> <compressed>
    // CARRIER <speed></protocol> < protocol> <compressed>
    // Sometimes there is a colon and/or a space before the speed.
    // Sometimes a K follows the speed indicating * 1000
    // Sometimes there are commas in the speed
    //

    //
    // Skip to the first digit
    //
    psz = pszResponse;
    while (*psz) {
        if (IsDigit(*psz)) {
            break;
        }
        psz++;
    }

    while (*psz) {
        if (IsDigit(*psz)) {
            dwSpeed = dwSpeed * 10 + (DWORD)(*psz - '0');
        } else if (*psz == 'K') {
            dwSpeed *= 1000;
        } else if (*psz != ',') {
            break;
        }
        psz++;
    }

    if (dwSpeed) {
        pLineDev->dwCurrentBaudRate = dwSpeed;
        if (pLineDev->htCall) {
            CallLineEventProc(
                pLineDev,
                pLineDev->htCall,
                LINE_CALLINFO,
                LINECALLINFOSTATE_RATE,
                0,
                0
                );
        }
        
    }

    DEBUGMSG(ZONE_FUNC|ZONE_CALLS, (TEXT("UNIMODEM:-ParseConnectSpeed %d\n"), dwSpeed));
}


const
MODEM_RESPONSE ResponseTable[] =
{
    { "OK",             MODEM_SUCCESS },
    { "RING",           MODEM_RING },
    { "RINGING",        MODEM_RING },
    { "NO CARRIER",     MODEM_HANGUP },
    { "ERROR",          MODEM_FAILURE },
    { "NO DIALTONE",    MODEM_NODIALTONE },
    { "NO DIAL TONE",   MODEM_NODIALTONE },
    { "BUSY",           MODEM_BUSY},
    { "NO ANSWER",      MODEM_NOANSWER },
    { "CONNECT",        MODEM_CONNECT },
    { "FCERROR",        MODEM_FAILURE },
    { "FCON",           MODEM_FAILURE },
    { "BLACKLIST",      MODEM_NOANSWER },
    { "CARRIER",        MODEM_CARRIER },
    { "DATA",           MODEM_FAILURE },
    { "DATE",           MODEM_PROGRESS },
    { "DELAYED",        MODEM_FAILURE },
    { "DIALING",        MODEM_PROGRESS },
    { "FAX",            MODEM_FAILURE },
    { "VCON",           MODEM_SUCCESS },
    { "VOICE",          MODEM_FAILURE },
    { "PROTOCOL",       MODEM_PROTOCOL },
    { "RRING",          MODEM_RING},
};

#ifdef DEBUG
LPWSTR
ResponseName(
    MODEMRESPCODES MdmRsp
    )
{
    switch (MdmRsp) {
    case MODEM_SUCCESS:     return TEXT("MODEM_SUCCESS");
    case MODEM_PENDING:     return TEXT("MODEM_PENDING");
    case MODEM_CONNECT:     return TEXT("MODEM_CONNECT");
    case MODEM_FAILURE:     return TEXT("MODEM_FAILURE");
    case MODEM_HANGUP:      return TEXT("MODEM_HANGUP");
    case MODEM_NODIALTONE:  return TEXT("MODEM_NODIALTONE");
    case MODEM_BUSY:        return TEXT("MODEM_BUSY");
    case MODEM_NOANSWER:    return TEXT("MODEM_NOANSWER");
    case MODEM_RING:        return TEXT("MODEM_RING");
    case MODEM_CARRIER:     return TEXT("MODEM_CARRIER");
    case MODEM_PROTOCOL:    return TEXT("MODEM_PROTOCOL");
    case MODEM_PROGRESS:    return TEXT("MODEM_PROGRESS");
    case MODEM_UNKNOWN:     return TEXT("MODEM_UNKNOWN");
    case MODEM_IGNORE:      return TEXT("MODEM_IGNORE");
    case MODEM_EXIT:        return TEXT("MODEM_EXIT");
    default:                return TEXT("UNKNOWN Modem Response Code!!!");
    }
}
#endif // DEBUG

// The only valid NULL_MODEM response is "CLIENTSERVER"
const UCHAR pchDCCResp[] = "CLIENTSERVER";
const UCHAR pchDCCCmd[] = "CLIENT";
        
#define SZ_RESPONSE_TABLE (sizeof(ResponseTable)/sizeof(MODEM_RESPONSE))