iggpacket.pas

通信控件

unit IGgPacket;

interface

uses
  Windows, IGgCommonType;

const

  ptVer_01    =$01;
  ptVer_02    =$02;

  pkSPKH      =$00;
  pkWPKH	    =$10;
  pkRPKH	    =$01;
  pkBPKH	    =$02;
  pkMPKH	    =$04;
  pkVPKH	    =$08;
  pkPPKH      =$20;
  
  ThdBUF_     =0;
  OthBUF_     =1;
  SPKH_       =0;
  WPKH_       =1;

  MAX_PACKET_SIZE   = 1280;

type

  TSPKHeader = record
    bptVersion: Byte;
    bpkType:    Byte;
    wSequ:      Word;
    wCommand:   Word;
    wRespond:   Word;
    dwSendID:   DWord;
    wReserved:  array[0..1] of Word;
    wpkSize:    Word;
    wDataOffset:Word;
  end;
  PSPKHeader = ^TSPKHeader;

  TWPKHeader = record
    SPK:        TSPKHeader;
    dwRecvID:   DWord;
    dwIP:       DWord;
    wPort:      Word;
    bReserved:  array[0..1] of Byte;
  end;
  PWPKHeader = ^TWPKHeader;

  TBPKHeader = record
    bptVersion: Byte;
    bpkType:    Byte;
    wSequ:      Word;
    wCommand:   Word;
    wReserved:  Word;
    dwAttachID: DWord;   //接收方ID
    dwIP:       DWord;   //接收方IP
    wPort:      Word;    //接收方Port
    wDataOffset:Word;
  end;
  PBPKHeader = ^TBPKHeader;

  TTCPPack = record
    Operate : WORD;
    Para    : WORD;
    Reserved: WORD;
    PackSour: WORD;
    PackSize: DWORD;
    Pack  	: Pointer;
  end;
  PTCPPack = ^TTCPPack;

  TTCPPackR = record
    Operate : WORD;
    Result  : WORD;
    Reserved: WORD;
    PackSour: WORD;
    PackSize: DWORD;
    Pack  	: Pointer;
  end;
  PTCPPackR = ^TTCPPackR;

const
   SB_USER_REGISTER = $A002;
   RS_USER_REGISTER = $A102;
   SB_USER_UNREGIST = $A003;
   RS_USER_UNREGIST = $A103;
   SB_SET_USER_INFO = $A004;
   RS_SET_USER_INFO = $A104;
   SB_GET_USER_INFO = $A005;
   RS_GET_USER_INFO = $A105;
   SB_GET_UNIQUE_ID = $A006;
   RS_GET_UNIQUE_ID = $A106;

   BUF_RECORD    = $A010;
   BUF_READREQ   = $A011;
   BUF_WRITESEQU = $A012;
   BUF_READCMD   = $A013;
   BUF_WRITECMD  = $A014;
   
type
  TRegisterData = record
    dwID    : DWORD;
    szNameID: array[0..MAX_I_NAMEID-1] of Char;
    RegRoute: TIRegRoute;
    Reserved: array[0..1] of Integer;
  end;
  PRegisterData = ^TRegisterData;

  TRsRegisterData = record
    dwID    : DWORD;
    dwIP    : DWORD;
    dwPort  : DWORD;
    dwResult: DWORD;
    Reserved: array[0..1] of Integer;
  end;
  PRsRegisterData = ^TRsRegisterData;

  TUnregisterData = record
    dwID    : DWORD;
    szNameID: array[0..MAX_I_NAMEID-1] of Char;
    Reserver: array[0..1] of Integer;
  end;
  PUnregisterData = ^TUnregisterData;

  TRsUnregisterData = record
    dwID    : DWORD;
    dwResult: DWORD;
    Reserved: array[0..1] of Integer;
  end;
  PRsUnregisterData = ^TRsUnregisterData;

const
  SB_SOCK_BASE     =$B000;
  RS_SOCK_BASE     =$B100;

  SB_SOCK_SEQU       =(SB_SOCK_BASE+$00);
  RS_SOCK_SEQU       =(RS_SOCK_BASE+$00);

  SB_SOCK_REG        =(SB_SOCK_BASE+$01);
  RS_SOCK_REG        =(RS_SOCK_BASE+$01);
  SB_SOCK_UNREG      =(SB_SOCK_BASE+$02);
  RS_SOCK_UNREG      =(RS_SOCK_BASE+$02);
  SB_SOCK_TOS	       =(SB_SOCK_BASE+$04);
  RS_SOCK_FROMS      =(RS_SOCK_BASE+$04);
  SB_SOCK_TOC        =(SB_SOCK_BASE+$08);
  RS_SOCK_FROMC      =(RS_SOCK_BASE+$08);

  SB_SOCK_EXIT       =(SB_SOCK_BASE+$11);

  SB_SOCK_REQ        =(SB_SOCK_BASE+$20);
  RS_SOCK_REQ        =(RS_SOCK_BASE+$20);
  SB_SOCK_REQBLK     =(SB_SOCK_BASE+$21);
  RS_SOCK_REQBLK     =(RS_SOCK_BASE+$21);
  SB_SOCK_IN_CMD     =(SB_SOCK_BASE+$22);
  SB_SOCK_OUT_CMD    =(SB_SOCK_BASE+$23);

  SB_SOCK_BIG        =(SB_SOCK_BASE+$27);
  RS_SOCK_BIG        =(RS_SOCK_BASE+$27);

type

  TBlockTaskData = record
    InAttachID: Integer;
    Route: TRoute;
    BlockID: Integer;
    PacketSize: Integer;
    DataSize: Integer;
    DataBit32: Integer;
    SubDataSize: Word;
    SubDataAmount: Word;
    //Packet: PChar....
  end;
  PBlockTaskPacket = ^TBlockTaskPacket;
  TBlockTaskPacket = record
    Header: TBPKHeader;
    Data: TBlockTaskData;
  end;
  TSbSubBlockData = record
    OutID: Integer;
    InID : Integer;
    CompleteBit32: Integer;
    CompleteSize: Word;
    First: Word;
  end;
  PSbSubBlockPacket = ^TSbSubBlockPacket;
  TSbSubBlockPacket = record
    Header: TBPKHeader;
    Data: TSbSubBlockData;
  end;
  TRsSubBlockData = record
    OutID: Integer;
    InID : Integer;
    SubDataSize: Word;
    SubDataSequ: Word;
    LastBlock: Word;
    Reserved: Word;
  end;
  PRsSubBlockPacket = ^TRsSubBlockPacket;
  TRsSubBlockPacket = record
    Header: TBPKHeader;
    Data: TRsSubBlockData;
  end;
  TBlockCommData = record
    OutID: Integer;
    InID : Integer;
    Command: Word;
    SubComm: Word;
    Para1: Integer;
    Para2: Integer;
  end;
  PBlockCommPacket = ^TBlockCommPacket;
  TBlockCommPacket = record
    Header: TBPKHeader;
    Data: TBlockCommData;
  end;

  //从服务器取得网络信息包
  TToServer = record
    SelfID  : Integer;
    Para1   : Integer;
    Para2   : Integer;
    SubmitV : Integer;
  end;
  PToServer = ^TToServer;
  TFromServer = record
    AttachID : Integer;
    LoginIP  : Integer;
    LocalIP  : Integer;
    LoginPort: Word;
    LocalPort: Word;
    Para		 : Integer;
    SubmitV  : Integer;
  end;
  PFromServer = ^TFromServer;
  //穿透包
  TToClient = packed record
    SelfID  : Integer;
    AttachID: Integer;
    Para1   : Integer;
    Para2   : Integer;
    //RecvR   : Byte;
    //SendR   : Byte;
    SubmitV : Integer;
  end;
  PToClient   = ^TToClient;
  TFromClient = TToClient;
  PFromClient = ^TFromClient;

  TConnectSyn = record
    SelfID  : DWORD;
    AttachID: DWORD;
    Operator: DWORD;
    Para1   : WORD;
    Para2   : WORD;
    Para3   : DWORD;
  end;
  PConnectSyn = ^TConnectSyn;

  //TPacketBox = class
  //public
  TPacketBox = record
    FPThdBuf  : PChar;
    FPOthBuf  : PChar;
    FPBlkBuf1 : PChar;
    FPBlkBuf2 : PChar;

    FSelfID   : DWord;
    FSessionID: WORD;
    FSequence : WORD;
  end;
  PPacketBox = ^TPacketBox;

    procedure InitPacketBox(SelfID: DWORD);
    procedure FreePacketBok();

    function SPKHeader(wSequ: Word; wDataSize: Word; wCommand: Word; wRespond: Word=0; bpkType: BYTE=pkSPKH; bptVersion: BYTE=ptVer_01):TSPKHeader; overload;
    function SPKHeader(var Header: PSPKHeader; wDataSize: Word):TSPKHeader; overload;
    function SPKHeader(wCommand: Word; wDataSize: Word): TSPKHeader; overload;
    function WPKHeader(dwRecvID: DWord; wSequ: Word; wDataSize: Word; wCommand: Word; wRespond: Word=0; dwIP: DWord=0; wPort: Word=0; bpkType: BYTE=pkWPKH; bptVersion: BYTE=ptVer_01):TWPKHeader; overload;
    function WPKHeader(var Header: PWPKHeader; wDataSize: Word):TWPKHeader; overload;
    function WPKHeader(dwRecvID: DWORD; wCommand: Word; wDataSize: Word): TWPKHeader; overload;
    function BPKHeader(dwAttachID: DWord; wSequ: Word; wDataOffset: Word; wCommand: Word; dwIP: DWord=0; wPort: Word=0; wReserved: Word=0):TBPKHeader;
    procedure Packet(var PHeader: Pointer; var PData: Pointer; SelBV: Integer=ThdBUF_; SelHV: Integer=SPKH_); overload;
    function Data(var PHeader: PWPKHeader): Pointer; overload;
    function Data(var PHeader: PSPKHeader): Pointer; overload;
    function TCPPacket(wSequ: Word; wCommand: Word; SelBV: Integer=OthBUF_): Pointer;
    function SetSEQU(Header: PWPKHEADER; dwIP_: DWORD; wPort_: WORD): TWPKHEADER; overload;
    function SetSEQU(Header: PSPKHEADER; dwIP_: DWORD; wPort_: WORD): TWPKHEADER; overload;
  //end;

var
  PktBox: TPacketBox;
  wSPKSIZE: WORD = sizeof(TSPKHEADER);
  wWPKSIZE: WORD = sizeof(TWPKHEADER);
  wBPKSIZE: WORD = sizeof(TBPKHEADER);
  //wVPKSIZE: WORD = sizeof(TVPKHEADER);

implementation

uses
  SysUtils;

procedure InitPacketBox(SelfID: DWORD);
begin
  PktBox.FPThdBuf := AllocMem(MAX_PACKET_SIZE);
  PktBox.FPOthBuf := AllocMem(MAX_PACKET_SIZE);
  PktBox.FPBlkBuf1:= AllocMem(MAX_PACKET_SIZE);
  PktBox.FPBlkBuf2:= AllocMem(MAX_PACKET_SIZE);
  PktBox.FSelfID    := SelfID;
  Randomize;
  PktBox.FSessionID := Random(65530);
  PktBox.FSequence  := 0;
end;

procedure FreePacketBok();
begin
  FreeMem(PktBox.FPThdBuf);
  FreeMem(PktBox.FPOthBuf);
  FreeMem(PktBox.FPBlkBuf1);
  FreeMem(PktBox.FPBlkBuf2);
  //FillChar(PktBox, SizeOf(PktBox), 0);
end;

function SPKHeader(wSequ: Word; wDataSize: Word; wCommand: Word; wRespond: Word; bpkType: BYTE; bptVersion: BYTE):TSPKHeader;
begin
  FillChar(Result, SizeOf(Result), 0);
  Result.bptVersion := bptVersion;
  Result.bpkType  := bpkType;
  Result.wSequ    := wSequ;
  Result.wCommand := wCommand;
  Result.wRespond := wRespond;
  Result.dwSendID := PktBox.FSelfID;
  Result.wDataOffset := wSPKSIZE;
  Result.wPkSize     := wSPKSIZE + wDataSize;
  Result.wReserved[1] := PktBox.FSessionID;
end;

function SPKHeader(wCommand: Word; wDataSize: Word): TSPKHeader;
begin
  FillChar(Result, SizeOf(Result), 0);
  Result.bptVersion := ptVer_01;
  Result.bpkType := pkSPKH;
  Result.wCommand := wCommand;
  Result.wDataOffset := wSPKSIZE;
  Result.wpkSize := wSPKSIZE + wDataSize;
end;

function SPKHeader(var Header: PSPKHeader; wDataSize: Word):TSPKHeader;
begin
  if (Header <> nil) then begin
		Result.bptVersion := Header.bptVersion;
		Result.bpkType := Header.bpkType;
		Result.wSequ := Header.wSequ;
		Result.wCommand := Header.wRespond;
		Result.wRespond := 0;
		Result.dwSendID  := 0;
		Result.wDataOffset := wSPKSIZE;
		Result.wPkSize := Result.wDataOffset+wDataSize;
	end;
end;

function WPKHeader(dwRecvID: DWord; wSequ: Word; wDataSize: Word; wCommand: Word; wRespond: Word; dwIP: DWord; wPort: Word; bpkType: BYTE; bptVersion: BYTE):TWPKHeader;
begin
  FillChar(Result, SizeOf(Result), 0);
  Result.SPK.bptVersion := bptVersion;
  Result.SPK.bpkType := bpkType;
  Result.SPK.wSequ := wSequ;
  Result.SPK.wCommand := wCommand;
  Result.SPK.wRespond := wRespond;
  Result.SPK.dwSendID := PktBox.FSelfID;
  Result.SPK.wDataOffset := SizeOf(TWPKHeader);
  Result.SPK.wPkSize := Result.SPK.wDataOffset + wDataSize;
  Result.SPK.wReserved[1] := PktBox.FSessionID;
  Result.dwRecvID := dwRecvID;
  Result.dwIP := dwIP;
  Result.wPort := wPort;
end;

function WPKHeader(var Header: PWPKHeader; wDataSize: Word):TWPKHeader;
begin
end;

function WPKHeader(dwRecvID: DWORD; wCommand: Word; wDataSize: Word): TWPKHeader;
begin
  FillChar(Result, SizeOf(Result), 0);
  Result.SPK.bptVersion := ptVer_01;
  Result.SPK.bpkType := pkWPKH;
  Result.SPK.wCommand := wCommand;
  Result.SPK.wDataOffset := wSPKSIZE;
  Result.SPK.wpkSize := wSPKSIZE + wDataSize;
  Result.dwRecvID := dwRecvID;
end;

function BPKHeader(dwAttachID: DWord; wSequ: Word; wDataOffset: Word; wCommand: Word; dwIP: DWord=0; wPort: Word=0; wReserved: Word=0):TBPKHeader;
begin
  Result.bptVersion := ptVer_01;
  Result.bpkType := pkBPKH;
  Result.wSequ := wSequ;
  Result.wCommand := wCommand;
  Result.wReserved := wReserved;
  Result.dwAttachID := dwAttachID;
  Result.dwIP := dwIP;
  Result.wPort := wPort;
  Result.wDataOffset := wDataOffset;
end;

procedure Packet(var PHeader: Pointer; var PData: Pointer; SelBV: Integer; SelHV: Integer);
begin
  if (SelBV = 0) then
    PHeader := PktBox.FPThdBuf
  else
    PHeader := PktBox.FPOthBuf;
  FillChar(PChar(PHeader)^, MAX_PACKET_SIZE, 0);
  case SelHV of
    0: PData := PChar(PHeader) + SizeOf(TSPKHeader);
    1: PData := PChar(PHeader) + SizeOf(TWPKHeader);
    2: PData := PChar(PHeader) + SizeOf(TBPKHeader);
  else PData := nil; end;
end;

function Data(var PHeader: PWPKHeader): Pointer;
begin
  Result := PChar(PHeader) + PHeader.SPK.wDataOffset;
  if (PHeader.SPK.bpkType <> pkBPKH) and (PHeader.SPK.wpkSize = PHeader.SPK.wDataOffset) then
    Result := nil;
end;

function Data(var PHeader: PSPKHeader): Pointer;
begin
  Result := PChar(PHeader) + PHeader.wDataOffset;
  if (PHeader.bpkType <> pkBPKH) and (PHeader.wpkSize = PHeader.wDataOffset) then
    Result := nil;
end;

function TCPPacket(wSequ: Word; wCommand: Word; SelBV: Integer=OthBUF_): Pointer;
var
  Pp: PSPKHeader;
  Pd: PTCPPack;
begin
  Packet(Pointer(Pp), Pointer(Pd), SelBV, SPKH_);
  Pp^ := SPKHeader(wSequ, SizeOf(TTCPPack)-SizeOf(Pointer), wCommand, 0, pkSPKH, ptVer_01);
  Result := Pp;
end;

function SetSEQU(Header: PWPKHEADER; dwIP_: DWORD; wPort_: WORD): TWPKHEADER;
begin
  FillChar(Result, SizeOf(Result), 0);
	Result.SPK.bptVersion  := Header.SPK.bptVersion;
	Result.SPK.bpkType     := Header.SPK.bpkType;
	Result.SPK.wSequ       := Header.SPK.wSequ;
	Result.SPK.wCommand    := RS_SOCK_SEQU;
	Result.SPK.wRespond    := 0;
	Result.SPK.dwSendID    := 0;
	Result.SPK.wDataOffset := wWPKSIZE;
	Result.SPK.wPkSize     := wWPKSIZE;
	Result.dwRecvID := Header.SPK.dwSendID;
	Result.dwIP     := dwIP_;
	Result.wPort    := wPort_;
end;

function SetSEQU(Header: PSPKHEADER; dwIP_: DWORD; wPort_: WORD): TWPKHEADER;
begin
	Result.SPK.bptVersion  := Header.bptVersion;
	Result.SPK.bpkType     := Header.bpkType;
	Result.SPK.wSequ       := Header.wSequ;
	Result.SPK.wCommand    := RS_SOCK_SEQU;
	Result.SPK.wRespond    := 0;
	Result.SPK.dwSendID    := 0;
	Result.SPK.wDataOffset := wWPKSIZE;
	Result.SPK.wPkSize     := wWPKSIZE;
	Result.dwRecvID := Header.dwSendID;
	Result.dwIP     := dwIP_;
	Result.wPort    := wPort_;
end;

initialization
  InitPacketBox(0);

finalization;
  FreePacketBok();

end.