awmodem.pas

测试用例

                UpdateLineSpeed;
                ShutdownSpeedWait;
                DispatchToModemClients(apw_GotLineSpeed, 0, ConnectSpeed);

                EnterFeatureWait;
              end;
            end; { apw_TriggerAvail }
        end; { case }
    end;

    function ShutDownRingWait : Bool;
    var
      Code : Integer;

    begin
      ShutDownRingWait := True;

      with Modem^ do begin
        {$IFDEF DispatchDebug}
        DebugOut('Disabling wait-for-ring');
        {$ENDIF}
        ModemState := msNone;
        Code := DisableResponses(Modem, [RspRing]);
        if (Code < ecOK) then begin
          {Port.aGotError(Code);}
          ShutDownRingWait := False;
        end;

        Port.RemoveTrigger(TimeoutIdx);
      end;
    end;

    procedure GotRing;
      {-Got a ring response during an auto answer }
    var
      Code : Integer;

    begin
      with Modem^ do
        case Msg of
          apw_TriggerData:
            if (TrigIdx = Responses[RspRing].TriggerIdx) then begin
              DispatchToModemClientsNoParm(apw_ModemRing);

              {$IFDEF DispatchDebug}
              DebugOut('Got a RING');
              {$ENDIF}
              Dec(RingWait);
              if (RingWait = 0) then begin
                {$IFDEF DispatchDebug}
                DebugOut('Got the LAST ring, starting answer');
                {$ENDIF}

                if ShutDownRingWait then begin
                  {$IFDEF DispatchDebug}
                  DebugOut('Starting answer');
                  {$ENDIF}

                  {Code := }mAnswerModem(Modem);
                  {if (Code < ecOK) then
                    Port.aGotError(Code);}
                end; { if }
              end else begin
                Code := Port.SetTimerTrigger(TimeoutIdx, RingWaitTimeout, True);
                if (Code < ecOK) then begin
                  ShutDownRingWait;
                end; { if }
              end; { else }
            end; { apw_TriggerData }

          apw_TriggerTimer:
            if wParam = TimeoutIdx then begin
              {$IFDEF DispatchDebug}
              DebugOut('Cancelling auto answer');
              {$ENDIF}
              RingWait := RingCnt;
            end; { apw_TriggerTimer }
        end; { case }
    end; { procedure }

    procedure SwallowData;
      {-Swallow incoming characters on an apw_TriggerAvail }
    var
      Code : Integer;
      Ch   : Char;

    begin
      with Modem^ do begin
        if (Msg <> apw_TriggerAvail) or
           (ModemState = msWaitNumber) or (ModemState = msWaitTerm) then
          Exit;

        {$IFDEF DispatchDebug}
        DebugOut('Swallowing extraneous characters');
        {$ENDIF}

        while (OnChar <= NumChars) do begin
          Code := ModemGetChar(Ch);
          if (Code < ecOK) then begin
            {Port.aGotError(Code);}
            Exit;
          end;
        end;
      end;
    end;

  begin
    {$IFDEF DispatchDebug}
    DebugOut('Entered dispatcher: ' + TriggerTypeStr(Msg));
    {$ENDIF}

    { if the com handle is invalid or there is no modem attached to }
    { the port sending this message, then exit                      }
    if not InitializeCall then begin
      {$IFDEF DispatchDebug}
      DebugOut('Dispatcher exiting: invalid com port or modem');
      {$ENDIF}
      Exit;
    end;

    with Modem^ do begin
      { make sure the modem is actually doing something before proceeding }
      if not CheckModemState(ModemState) then
        Exit;

      case ModemState of
        msCmdWaitRsp  : HandleCommandResponse;
        msDialing,
        msAnswering   : HandleConnectionAttemptResponse;
        msWaitNumber  : GetLineSpeedStart;
        msWaitTerm    : GetLineSpeedEnd;
        msWaitRing    : GotRing;
        msWaitFeatures: CheckModemFeatures;
      end;

      if (Msg = apw_TriggerAvail) and (ModemState = msWaitTerm) and (OnChar <= NumChars) then
        GetLineSpeedEnd;

      SwallowData;
    end;
  end;

{******************************************************************************}

  function mInitModem(var Modem : PModemRec; H : TApdBaseDispatcher; var Data : TModemData) : Integer;
    {-Initialize a modem }
  var
    I    : Cardinal;
    Code : Integer;

  begin
    Modem := AllocMem(SizeOf(TModemRec));

    { initialize pointers in structure so we can do a mass dispose later }
    FillChar(Modem^, SizeOf(Modem^), 0);

    with Modem^ do begin
      if not StrNewCheck(InitCmd, Data.Data.InitCmd) or
         not StrNewCheck(DialCmd, Data.Data.DialCmd) or
         not StrNewCheck(DialTerm, Data.Data.DialTerm) or
         not StrNewCheck(DialCancel, Data.Data.DialCancel) or
         not StrNewCheck(HangupCmd, Data.Data.HangupCmd) or
         not StrNewCheck(ConfigCmd, Data.Data.ConfigCmd) or
         not StrNewCheck(AnswerCmd, Data.Data.AnswerCmd) or
         not StrNewCheck(Responses[RspOk].Response, Data.Data.OkMsg) or
         not StrNewCheck(Responses[RspConnect].Response, Data.Data.ConnectMsg) or
         not StrNewCheck(Responses[RspBusy].Response, Data.Data.BusyMsg) or
         not StrNewCheck(Responses[RspVoice].Response, Data.Data.VoiceMsg) or
         not StrNewCheck(Responses[RspNoCarrier].Response, Data.Data.NoCarrierMsg) or
         not StrNewCheck(Responses[RspNoDialTone].Response, Data.Data.NoDialToneMsg) or
         not StrNewCheck(Responses[RspError].Response, Data.Data.ErrorMsg) or
         not StrNewCheck(Responses[RspRing].Response, Data.Data.RingMsg) then begin
        DoneModemDynamic(Modem);
        mInitModem := ecOutOfMemory;
        Exit;
      end;

      NumErrors := Data.NumErrors;
      for I := 1 to NumErrors do
        if not StrNewCheck(ErrorTags[I].Response, Data.Errors[I]) then begin
          DoneModemDynamic(Modem);
          mInitModem := ecOutOfMemory;
          Exit;
        end;

      NumComps := Data.NumComps;
      for I := 1 to NumComps do
        if not StrNewCheck(CompressTags[I].Response, Data.Compression[I]) then begin
          DoneModemDynamic(Modem);
          mInitModem := ecOutOfMemory;
          Exit;
        end;

      Code := H.SetDataPointer(Modem, dpModem);                    
      if (Code < ecOK) then begin
        DoneModemDynamic(Modem);
        mInitModem := Code;
        Exit;
      end;

      DialTimeout     := awmDefDialTimeout;
      AnswerTimeout   := awmDefAnswerTimeout;
      DelayFactor     := awmDefDelayFactor;
      CmdTimeout      := awmDefCmdTimeout;
      DTRDropHold     := awmDefDTRDropHold;
      ModemCharDelay  := awmDefModemCharDelay;
      TildeDelay      := awmDefTildeDelay;
      RingWaitTimeout := awmDefRingWaitTimeout;
      FeatureWait     := awmDefFeatureWait;
      BaudWait        := awmDefBaudWait;
      LockDTE         := Data.LockDTE;
      ModemStarted    := False;
      ModemState      := msNone;
      LastMessage     := wm_Null;
      Port            := H;
      UserData        := 0;
      DelphiComponent := False;
    end;

    mInitModem := ecOK;
  end;

  function mInitModemDelphi(var Modem : PModemRec; H : TApdBaseDispatcher; var Data : TModemData) : Integer;
    {-Initialize a modem}
  var
    Code : Integer;

  begin
    Code := mInitModem(Modem, H, Data);
    if (Code = ecOK) then
      Modem^.DelphiComponent := True;
    mInitModemDelphi := Code;
  end;

  procedure mDoneModem(var Modem : PModemRec);
    {-Destroy a modem }
  begin
    mStopModem(Modem);
    DoneModemDynamic(Modem);
    FreeMem(Modem, SizeOf(TModemRec));
    Modem := nil;                         
  end;

  function mGetComHandle(var Modem : PModemRec) : TApdBaseDispatcher;
    {-Return the handle of a modem's port }
  begin
    mGetComHandle := Modem^.Port;
  end;

  procedure mSetModemDialTimeout(Modem : PModemRec; Secs : Cardinal);
    {-Set the number of seconds before a dial attempt times out }
  begin
    Modem^.DialTimeout := Secs;
  end;

  function mGetModemDialTimeout(Modem : PModemRec) : Cardinal;
    {-Get the number of seconds the modem will wait before aborting a dial }
  begin
    mGetModemDialTimeout := Modem^.DialTimeout;
  end;

  procedure mSetModemAnswerTimeout(Modem : PModemRec; Secs : Cardinal);
    {-Set the number of seconds before an answer attempt times out }
  begin
    Modem^.AnswerTimeout := Secs;
  end;

  procedure mSetModemDelayFactor(Modem : PModemRec; Ticks : Cardinal);
    {-Set the number of ticks to wait between commands sent to the modem }
  begin
    Modem^.DelayFactor := Ticks;
  end;

  procedure mSetModemCmdTimeout(Modem : PModemRec; Ticks : Cardinal);
    {-Set the number of ticks to wait for a modem response }
  begin
    Modem^.CmdTimeout := Ticks;
  end;

  procedure mSetModemDTRDropHold(Modem : PModemRec; Ticks : Cardinal);
    {-Set the number of ticks to hold DTR low during hangup }
  begin
    Modem^.DTRDropHold := Ticks;
  end;

  procedure mSetModemCharDelay(Modem : PModemRec; Ticks : Cardinal);
    {-Set the number of ticks to wait between each command character sent }
  begin
    Modem^.ModemCharDelay := Ticks;
  end;

  procedure mSetTildeDelay(Modem : PModemRec; Ticks : Cardinal);
    {-Set the number of ticks to wait when a '~' is encountered in a command }
  begin
    Modem^.TildeDelay := Ticks;
  end;

  procedure mSetRingWaitTimeout(Modem : PModemRec; Ticks : Cardinal);
    {-Set the number of ticks to wait before mAutoAnswerModem resets }
  begin
    Modem^.RingWaitTimeout := Ticks;
  end;

  function mStartModem(Modem : PModemRec): Integer;
    {-Have the modem start processing messages }
  begin
    with Modem^ do begin
      if ModemStarted then begin
        mStartModem := ecModemBusy;
        Exit;
      end;

      Port.RegisterProcTriggerHandler(ModemDispatcher);
      Port.ChangeLengthTrigger(1);
      ModemStarted := True;
      mStartModem  := ecOK;
    end;
  end;

  procedure mStopModem(Modem : PModemRec);
    {-Have the modem stop processing messages }
  begin
    with Modem^ do begin
      if not ModemStarted then
        Exit;

      if mIsAttemptingConnect(Modem) then
        mCancelDialAnswer(Modem)
      else if (ModemState <> msNone) then begin
        DisableResponses(Modem, RspWaitSet);
        Port.RemoveTrigger(TimeoutIdx);
      end;

      Port.DeregisterProcTriggerHandler(ModemDispatcher);
      ModemStarted := False;
      ModemState   := msNone;
    end;
  end;

  function mPutModemCommand(Modem : PModemRec; Cmd : PChar) : Integer;
    {-Send a command to the modem, dispatching an error code }
  var
    Code : Integer;

  begin
    with Modem^ do begin
      if not ModemStarted then begin
        mPutModemCommand := ecModemNotStarted;
        Exit;
      end;

      if (ModemState <> msNone) then begin
        mPutModemCommand := ecModemBusy;
        Exit;
      end;

      {initialize the last string}
      FillChar(LastString, SizeOf(LastString), 0);
      LastStringLen := 0;
      BlankPending := False;                                

      { enable response codes }
      Code := EnableResponses(Modem, RspWaitSet);
      if (Code < ecOK) then begin
        mPutModemCommand := Code;
        Exit;
      end;

      { add the timeout trigger }
      Code := Port.AddTimerTrigger;
      if (Code < ecOK) then begin
        DisableResponses(Modem, RspWaitSet);
        mPutModemCommand := Code;
        Exit;
      end;
      TimeoutIdx := Code;

      { send the command to the modem }
      Code := ModemPutXlatStr(Modem, Cmd);
      if (Code < ecOK) then begin
        DisableResponses(Modem, RspWaitSet);
        Port.RemoveTrigger(TimeoutIdx);
        mPutModemCommand := Code;
        Exit;
      end;

      { enable the timeout trigger }
      Code := Port.SetTimerTrigger(TimeoutIdx, CmdTimeout, True);
      if (Code < ecOK) then begin
        DisableResponses(Modem, RspWaitSet);
        Port.RemoveTrigger(TimeoutIdx);
        mPutModemCommand := Code;
        Exit;
      end;

      { tell the dispatcher we're waiting for a modem response }
      ModemState := msCmdWaitRsp;

      mPutModemCommand := ecOK;
    end;
  end;

  function mRegisterModemHandler(Modem : PModemRec; HWindow : TApdHwnd; Notify : TApdNotifyProc) : Integer;
    {-Add a window/notification procedure to the modem's notify list }
  var
    NewRegRec : PModemRegisterList;

  begin
    with Modem^ do begin
      NewRegRec := AllocMem(SizeOf(TModemRegisterList));

      with NewRegRec^ do begin
        mrHWindow := HWindow;
        mrNotify  := Notify;

        if (RegisterHead = nil) then
          RegisterHead := NewRegRec
        else begin
          NewRegRec^.mrNext := RegisterHead;
          RegisterHead      := NewRegRec;
        end;