main.pas

操作数据库的例子

          SendMt(MtSeqId);
        end;
      end;
    end
    else
    begin
      if now - LastLoginTime > 6 / 3600 / 24 then
      begin
        SendPacket(CreatePacket(SMGP13_LOGIN));
        LastLoginTime := now;
      end;
    end;
  end;
end;
// 对外发送函数
procedure TOutReadSMGPThreadObj.SendMt(i: integer);
var
  Buffer: TMtBuffer;
  outpac: TSMGP13_PACKET;
begin
  Buffer := mtbuffer.Read(i);
  outpac := CreatePacket(SMGP13_SUBMIT);
  outpac.MsgHead.SequenceID := i;
  outpac.MsgBody.SUBMIT.MsgType := Buffer.OutMsgType;
  Move(Buffer.OutServiceID, outpac.MsgBody.SUBMIT.ServiceID, sizeof(Buffer.OutServiceID));
  Move(Buffer.OutFeeType, outpac.MsgBody.SUBMIT.FeeType, sizeof(Buffer.OutFeeType));
  Move(Buffer.OutFixedFee, outpac.MsgBody.SUBMIT.FixedFee, sizeof(Buffer.OutFixedFee));
  Move(Buffer.OutFeeCode, outpac.MsgBody.SUBMIT.FeeCode, sizeof(Buffer.OutFeeCode));
  outpac.MsgBody.SUBMIT.MsgFormat := Buffer.Mt.MtMsgFmt;
  Move(Buffer.Mt.MtValidTime, outpac.MsgBody.SUBMIT.ValidTime, sizeof(Buffer.Mt.MtValidTime));
  Move(Buffer.Mt.MtAtTime, outpac.MsgBody.SUBMIT.AtTime, sizeof(Buffer.Mt.MtAtTime));
  Move(Buffer.Mt.MtSpAddr, outpac.MsgBody.SUBMIT.SrcTermID, sizeof(TSMGP13PhoneNum));
  Move(Buffer.Mt.MtFeeAddr, outpac.MsgBody.SUBMIT.ChargeTermID, sizeof(TSMGP13PhoneNum));
  Move(Buffer.Mt.MtUserAddr, outpac.MsgBody.SUBMIT.DestTermID, sizeof(TSMGP13PhoneNum));
  outpac.MsgBody.SUBMIT.MsgLength := Buffer.Mt.MtMsgLenth;
  Move(Buffer.Mt.MtMsgContent, outpac.MsgBody.SUBMIT.MsgContent, Buffer.Mt.MtMsgLenth);
  outpac.MsgHead.PacketLength := sizeof(TSMGP13_HEAD) + sizeof(TSMGP13_SUBMIT) - sizeof(outpac.MsgBody.SUBMIT.MsgContent) + Buffer.Mt.MtMsgLenth;
  SendPacket(outpac);
end;

procedure TOutReadSMGPThreadObj.SendPacket(pac: TSMGP13_PACKET);
var
  sendbuffer: TCOMMBuffer;
  NetPacOut, LocPacOut: TSMGP13_PACKET;
begin
  //初始化变量
  ZeroMemory(@sendbuffer, sizeof(TCOMMBuffer));
  sendbuffer.BufferSize := 0;
  NetPacOut := pac;
  LocPacOut := pac;

  //包头部分，进行网络字节序转换
  //htonl（将32位主机字符顺序转换成网络字符顺序）.
  NetPacOut.MsgHead.PacketLength := htonl(LocPacOut.MsgHead.PacketLength);
  NetPacOut.MsgHead.RequestID := htonl(LocPacOut.MsgHead.RequestID);
  NetPacOut.MsgHead.SequenceID := htonl(LocPacOut.MsgHead.SequenceID);

  //将包头复制到发送缓冲中
  //move函数的作用是将输入数组中的元素从后面开始，两两交换，循环次数用n控制
  Move(NetPacOut.MsgHead, sendbuffer.Buffer, sizeof(TSMGP13_HEAD));
  sendbuffer.BufferSize := sizeof(TSMGP13_HEAD);

  case pac.MsgHead.RequestID of
    SMGP13_LOGIN:
      begin
        NetPacOut.MsgBody.LOGIN.TimeStamp := htonl(LocPacOut.MsgBody.LOGIN.TimeStamp);
        Move(NetPacOut.MsgBody.LOGIN, sendbuffer.Buffer[sendbuffer.BufferSize], sizeof(TSMGP13_LOGIN));
        sendbuffer.BufferSize := sendbuffer.BufferSize + sizeof(TSMGP13_LOGIN);
      end;

    SMGP13_SUBMIT:
      begin
        Move(NetPacOut.MsgBody.SUBMIT, sendbuffer.Buffer[sendbuffer.BufferSize], 127);
        sendbuffer.BufferSize := sendbuffer.BufferSize + 127;
        Move(NetPacOut.MsgBody.SUBMIT.MsgContent, sendbuffer.Buffer[sendbuffer.BufferSize], NetPacOut.MsgBody.SUBMIT.MsgLength);
        sendbuffer.BufferSize := sendbuffer.BufferSize + NetPacOut.MsgBody.SUBMIT.MsgLength;
        Move(NetPacOut.MsgBody.SUBMIT.Reserve, sendbuffer.Buffer[sendbuffer.BufferSize], sizeof(NetPacOut.MsgBody.SUBMIT.Reserve));
        sendbuffer.BufferSize := sendbuffer.BufferSize + sizeof(NetPacOut.MsgBody.SUBMIT.Reserve);
      end;

    SMGP13_DELIVER_RESP:
      begin
        NetPacOut.MsgBody.DELIVER_RESP.Status := htonl(LocPacOut.MsgBody.DELIVER_RESP.Status);
        Move(NetPacOut.MsgBody.DELIVER_RESP, sendbuffer.Buffer[sendbuffer.BufferSize], sizeof(TSMGP13_DELIVER_RESP));
        sendbuffer.BufferSize := sendbuffer.BufferSize + sizeof(TSMGP13_DELIVER_RESP);
      end;

    SMGP13_ACTIVE_TEST:
      begin

      end;

    SMGP13_ACTIVE_TEST_RESP:
      begin

      end;
  end;

  if sendbuffer.BufferSize = LocPacOut.MsgHead.PacketLength then
  begin
    if LocPacOut.MsgHead.RequestID = SMGP13_SUBMIT then
    begin
      inc(WindowSize);
      mtbuffer.Update(LocPacOut.MsgHead.SequenceID);
      inc(FMtCount);
    end;

    if MainForm.OutMonitor.Checked then
    begin
      MonitorThread.OutMonitorBuffer.Add(LocPacOut);
    end;

    try
      FTCPClient.WriteBuffer(sendbuffer.Buffer, sendbuffer.BufferSize);
    except
      on e: exception do
      begin
        AddMsgToMemo('SMGP外部网关发送线程' + e.Message);
        FTCPClient.Disconnect;
      end;
    end;
  end;
end;

procedure TOutReadSMGPThreadObj.ThAddMsgToMemo;
begin
  if MainForm <> nil then
  begin
    MainForm.ShowToMemo(ErrMsg, MainForm.MonitorMemo);
  end;
end;
//SMGP
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


//CMPP
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
{CMPP0 移动 7890  TMtSendCMPPThreadObj}
procedure TMtSendCMPPThreadObj.AddMsgToMemo(const Msg: string);
begin
  ErrMsg := Msg;
  Synchronize(ThAddMsgToMemo);
end;

constructor TMtSendCMPPThreadObj.Create(CreateSuspended: boolean);
begin
  inherited;
  LastActiveTime := now;
end;

destructor TMtSendCMPPThreadObj.destroy;
begin
  LastActiveTime := 0;
  inherited;
end;

procedure TMtSendCMPPThreadObj.Execute;
begin
  FreeOnTerminate := True;
  while not Terminated do
  begin
    try
      try
        MtPrc;
      except
        on e: exception do
        begin
          AddMsgToMemo('MTCMPP消息发送线程:' + e.Message);
        end;
      end;
    finally
      LastActiveTime := now;
      //这里需要做流量限制
      sleep(1000 div GGATECONFIG.Flux);
    end;
  end;
end;

procedure TMtSendCMPPThreadObj.MtPrc;
begin
  if OutReadCMPPThread <> nil then
  begin
    OutReadCMPPThread.PrcMt;
  end;
end;

procedure TMtSendCMPPThreadObj.ThAddMsgToMemo;
begin
  if MainForm <> nil then
  begin
    MainForm.ShowToMemo(ErrMsg, MainForm.MonitorMemo);
  end;
end;

{CMPP0 移动 7890  TOutReadCMPPThreadObj}
procedure TOutReadCMPPThreadObj.AddMsgToMemo(const Msg: string);
begin
  ErrMsg := Msg;
  Synchronize(ThAddMsgToMemo);
end;

procedure TOutReadCMPPThreadObj.ClientRead;
begin
  //CMPP 读取到CMPP缓冲
  try
    try
      FTCPCmppClient.CheckForGracefulDisconnect();
    except
      on e: exception do
      begin
        AddMsgToMemo('TOutReadCmppThreadObj' + e.Message);
        sleep(1000);
      end;
    end;

    if FTCPCmppClient.Connected then
    begin
      if FRecCmppBuffer.BufferSize = 0 then
      begin
        //初始化结构体，用来分别存放网络数据包和本地数据包
        ZeroMemory(@FlocCmppPacketIn, sizeof(TCMPP20_PACKET));
        ZeroMemory(@FnetCmppPacketIn, sizeof(TCMPP20_PACKET));
        //这里阻塞读取数据包头
        FTCPCmppClient.ReadBuffer(FRecCmppBuffer.Buffer, sizeof(TCMPP_HEAD));
        FRecCmppBuffer.BufferSize := sizeof(TCMPP_HEAD);
        //将读到的包头数据复制到网络结构体中
        Move(FRecCmppBuffer.Buffer, FnetCmppPacketIn.MsgHead, sizeof(TCMPP_HEAD));
        //经网络字节序转换后，将网络结构体包头复制到本地结构体中
        FlocCmppPacketIn.MsgHead.Total_Length := ntohl(FnetCmppPacketIn.MsgHead.Total_Length);
        FlocCmppPacketIn.MsgHead.Command_ID := ntohl(FnetCmppPacketIn.MsgHead.Command_ID);
        FlocCmppPacketIn.MsgHead.Sequence_ID := ntohl(FnetCmppPacketIn.MsgHead.Sequence_ID);
      end;

      case FlocCmppPacketIn.MsgHead.Command_ID of
        CMPP_CONNECT_RESP:
          begin
            //登录应答包，读取对应的长度，并复制到网络结构体和本地结构体中
            FTCPCmppClient.ReadBuffer(FRecCmppBuffer.Buffer[FRecCmppBuffer.BufferSize], sizeof(TCMPP_CONNECT_RESP));
            FRecCmppBuffer.BufferSize := FRecCmppBuffer.BufferSize + sizeof(TCMPP_CONNECT_RESP);
            Move(FRecCmppBuffer.Buffer, FnetCmppPacketIn, FRecCmppBuffer.BufferSize);
            FlocCmppPacketIn.MsgBody.CMPP_CONNECT_RESP := FnetCmppPacketIn.MsgBody.CMPP_CONNECT_RESP;
            FlocCmppPacketIn.MsgBody.CMPP_CONNECT_RESP.Status := ntohl(FnetCmppPacketIn.MsgBody.CMPP_CONNECT_RESP.Status);
          end;

        CMPP_SUBMIT_RESP:
          begin
            //下行应答包，读取对应的长度，并复制到网络结构体和本地结构体中
            FTCPCmppClient.ReadBuffer(FRecCmppBuffer.Buffer[FRecCmppBuffer.BufferSize], sizeof(TCMPP_SUBMIT_RESP));
            FRecCmppBuffer.BufferSize := FRecCmppBuffer.BufferSize + sizeof(TCMPP_SUBMIT_RESP);
            Move(FRecCmppBuffer.Buffer, FnetCmppPacketIn, FRecCmppBuffer.BufferSize);
            FlocCmppPacketIn.MsgBody.CMPP_SUBMIT_RESP := FnetCmppPacketIn.MsgBody.CMPP_SUBMIT_RESP;
            FlocCmppPacketIn.MsgBody.CMPP_SUBMIT_RESP.result := ntohl(FnetCmppPacketIn.MsgBody.CMPP_SUBMIT_RESP.result);
          end;

        CMPP_DELIVER:
          begin
            FTCPCmppClient.ReadBuffer(FRecCmppBuffer.Buffer[FRecCmppBuffer.BufferSize], FlocCmppPacketIn.MsgHead.Total_Length - FRecCmppBuffer.BufferSize);
            FRecCmppBuffer.BufferSize := FlocCmppPacketIn.MsgHead.Total_Length;
            Move(FRecCmppBuffer.Buffer, FnetCmppPacketIn, FRecCmppBuffer.BufferSize);
            FnetCmppPacketIn.MsgBody.CMPP_DELIVER.MSG_LENGTH := FlocCmppPacketIn.MsgHead.Total_Length - sizeof(TCMPP_HEAD) - 77;
            FlocCmppPacketIn.MsgBody.CMPP_DELIVER := FnetCmppPacketIn.MsgBody.CMPP_DELIVER;
            ZeroMemory(@FlocCmppPacketIn.MsgBody.CMPP_DELIVER.Msg_Content, sizeof(FlocCmppPacketIn.MsgBody.CMPP_DELIVER.Msg_Content));
            ZeroMemory(@FlocCmppPacketIn.MsgBody.CMPP_DELIVER.Reserved, sizeof(FlocCmppPacketIn.MsgBody.CMPP_DELIVER.Reserved));
            Move(FnetCmppPacketIn.MsgBody.CMPP_DELIVER.Msg_Content, FlocCmppPacketIn.MsgBody.CMPP_DELIVER.Msg_Content, FlocCmppPacketIn.MsgBody.CMPP_DELIVER.MSG_LENGTH);
            Move(FnetCmppPacketIn.MsgBody.CMPP_DELIVER.Msg_Content[FlocCmppPacketIn.MsgBody.CMPP_DELIVER.MSG_LENGTH], FlocCmppPacketIn.MsgBody.CMPP_DELIVER.Reserved, sizeof(FlocCmppPacketIn.MsgBody.CMPP_DELIVER.Reserved));
            FnetCmppPacketIn.MsgBody := FlocCmppPacketIn.MsgBody;
          end;

        CMPP_ACTIVE_TEST:
          begin
            //AddMsgToMemo('CMPP外部网关活动测试要求');
          end;

        CMPP_ACTIVE_TEST_RESP:
          begin
            //AddMsgToMemo('CMPP外部网关活动测试回复');
          end;
        CMPP_TERMINATE:
          begin
            AddMsgToMemo('CMPP外部网关要求终止连接');
          end;
        CMPP_TERMINATE_RESP:
          begin
            AddMsgToMemo('CMPP外部网关要求终止连接应答');
          end;

      else
        begin
          FTCPCmppClient.Disconnect;
        end;
      end;

      if MainForm.OutMonitor.Checked then
      begin
        //暂时取消监控 2005/11/12
        MonitorThread.OutMonitorcmppBuffer.Add(FlocCmppPacketIn);
      end;

      case FlocCmppPacketIn.MsgHead.Command_ID of
        CMPP_CONNECT_RESP:
          begin
            if (FlocCmppPacketIn.MsgBody.CMPP_CONNECT_RESP.Status = 0) and (FlocCmppPacketIn.MsgBody.CMPP_CONNECT_RESP.Version <> 0) then
            begin
              FLogined := True;
              AddMsgToMemo('CMPP外部网关端口登录成功');
            end
            else
            begin
              FLogined := false;
              AddMsgToMemo('CMPP外部网关登录失败');
            end;
          end;

        CMPP_SUBMIT_RESP:
          begin
            if FlocCmppPacketIn.MsgBody.CMPP_SUBMIT_RESP.Msg_Id = 0 then
            begin
              AddMsgToMemo('NO');
            end else
            begin
              AddMsgToMemo('YES');
            end;
            mtcmppbuffer.UpdateResp(FlocCmppPacketIn.MsgHead.Command_ID, FlocCmppPacketIn.MsgBody.CMPP_SUBMIT_RESP.Msg_Id, FlocCmppPacketIn.MsgBody.CMPP_SUBMIT_RESP.result);
            inc(FMtRespCount);
            WindowSize := WindowSize - 1;
            if WindowSize < 0 then WindowSize := 0;
          end;

        CMPP_DELIVER: //mo上行过来的写入缓冲
          begin
            //写入缓冲，或是状态报告
            if FlocCmppPacketIn.MsgBody.CMPP_DELIVER.Registered_Delivery = 1 then
            begin
              //状态报告,写入状态报告缓冲中
              rptcmppbuffer.Add(FlocCmppPacketIn);
              inc(FRptCount);
            end
            else
            begin
              //MO,将Mo写入Mo缓冲中
              mocmppbuffer.Add(FlocCmppPacketIn);
              inc(FMoCount);
            end;

            //应答
            SendPacket(CreateRespPacket(FlocCmppPacketIn));
          end;

        CMPP_ACTIVE_TEST:
          begin
            WindowSize := 0;
            SendPacket(CreateRespPacket(FlocCmppPacketIn));
            LastSendActiveTime := now();
          end;

        CMPP_ACTIVE_TEST_RESP:
          begin
            WindowSize := 0;
            LastSendActiveTime := now();
          end;
      end;

      FRecCmppBuffer.BufferSize := 0;
      ZeroMemory(@FRecCmppBuffer.Buffer, sizeof(FRecCmppBuffer.Buffer));
    end;
  except
    on e: exception do
    begin
      AddMsgToMemo('CMPP外部网关接收线程:' + e.Message);
      sleep(1000);
      FTCPCmppClient.Disconnect;
    end;
  end;

end;

constructor TOutReadCMPPThreadObj.Create(CreateSuspended: boolean);
begin
  inherited;
  ZeroMemory(@FRecCmppBuffer.Buffer, sizeof(FRecCmppBuffer.Buffer));
  FRecCmppBuffer.BufferSize := 0;
  ZeroMemory(@FlocCmppPacketIn, sizeof(TCMPP20_PACKET));
  ZeroMemory(@FnetCmppPacketIn, sizeof(TCMPP20_PACKET));
  FLogined := false;
  FMoCount := 0;
  FMtCount := 0;
  FRptCount := 0;
  FMtRespCount := 0;
  FMtRefuseCount := 0;
  Seqid := 1;
  WindowSize := 0;
  FLastActiveTime := now;
  MtHasUnsendMessage := false;
  MtMessage := '';
  MtNumber := '';
  MtUnsend := 100;
  log_port := 0;
end;

function TOutReadCMPPThreadObj.CreatePacket(
  const RequestID: Cardinal): TCMPP20_PACKET;
var
  pac: TCMPP20_PACKET;
  Time: string;
  strTemp: string;
  tempArray: array[0..255] of char