DELPHI下完成端口的应用

最新推荐文章于 2022-05-26 17:23:23 发布
最新推荐文章于 2022-05-26 17:23:23 发布
阅读量2.5k 收藏 1
点赞数
分类专栏： DELPHI 文章标签： delphi integer 数据结构 function string socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/michelsn/article/details/2705543
版权

作者：俞伟   QQ：12400976 MSN：yu924@hotmail.com

 

 DELPHI下面完成端口的资料很少，特别是代码资料，我在前期根据目前网络上的对DELPHI下IOCP分析资料进行了归纳和自己的修改应用，现在把代码帖出来，希望大家多交流学习。


unit uCommNetIOCP;

interface

uses
  Windows, SysUtils, SyncObjs, Classes, uCommNetWinSock, uCommNetMessage;

const
  DATA_BUFSIZE = 8192;

type
  //单IO数据结构
  LPVOID = Pointer;
  LPPER_IO_OPERATION_DATA = ^ PER_IO_OPERATION_DATA ;
  PER_IO_OPERATION_DATA = packed record
    Overlapped: TOVERLAPPED;
    DataBuf: TWSABUF;
    Buffer: array [0..DATA_BUFSIZE] of CHAR;
    BytesSEND: DWORD;  
    BytesRECV: DWORD;  
  end;  
  //单句柄数据结构
  LPPER_HANDLE_DATA = ^ PER_HANDLE_DATA;
  PER_HANDLE_DATA = packed record
    Socket: TSocket;  
  end;
  {------------------------- IOCP接口 -----------------------------------------}     
  ICommNetIOCP = interface
  ['{2DB60BD4-DA67-4BC5-8068-6892AA481903}']
    function Init(AListenIPAddr: string; AListenPort, AMaxConnect: Integer): Boolean; stdcall;
    function Start(AListenQueueCount: Integer = 200): Boolean; stdcall;
    function RegisterMessageFilter(AMessageFilter: TCommNetMessageFilter): Boolean; stdcall;
    procedure UnRegisterMessageFilter(AFilterName: string); stdcall;
    procedure Stop; stdcall;
    procedure Fini; stdcall;
    procedure InvokeMessage(ASocket: Integer; ABuf: PChar; ABufLen: Integer); stdcall;
    function SendDataWithHeadLen(const ASocket: TSocket; AData: array of Char; ADataLen: Integer): Boolean; stdcall;
    function SendDataWithEndString(const ASocket: TSocket; AData: array of Char; ADataLen: Integer; const AEndStr: string = '%%%(EndSTR)%%%'): Boolean; stdcall;
  end;
  TCommNetIOCP = class(TInterfacedObject, ICommNetIOCP)
  private
    fWSAData: TWSAData;
    fCompletionPort: THandle;
    fListenIPAddr: string;
    fListenPort: Integer;
    fMaxConnect: Integer;
    fListenSocket: Integer;
    fListenQueueCount: Integer;
    fListenAddr: TSockAddrIn;
    fLocalSysInfo: TSystemInfo;
    fAcceptThread: THandle;
    fCSInvoke: TCriticalSection;
    fIoCompletionPortWorkThreadArray: array of THandle;
    fMessageFilterList: TThreadList;

    function DoWSAStartup: Boolean;
    procedure DoWSACleanup;
    function DoCreateIoCompletionPort: Boolean;
    function DoInitIoCompletionPortWorkThread: Boolean;
    procedure DoFiniIoCompletionPortWorkThread;
    procedure DoCloseIoCompletionPort;
    function DoCreateListenSocket: Boolean;
    procedure DoCloseListenSocket;
  public
    constructor Create;
    destructor Destroy; override;

    function Init(AListenIPAddr: string; AListenPort, AMaxConnect: Integer): Boolean; stdcall;
    function Start(AListenQueueCount: Integer = 200): Boolean; stdcall;
    function RegisterMessageFilter(AMessageFilter: TCommNetMessageFilter): Boolean; stdcall;
    procedure UnRegisterMessageFilter(AFilterName: string); stdcall;
    procedure Stop; stdcall;
    procedure Fini; stdcall;
    procedure InvokeLock;
    procedure UnInvokeLock;
    procedure InvokeMessage(ASocket: Integer; ABuf: PChar; ABufLen: Integer); stdcall;
    function SendDataWithHeadLen(const ASocket: TSocket; AData: array of Char; ADataLen: Integer): Boolean; stdcall;
    function SendDataWithEndString(const ASocket: TSocket; AData: array of Char; ADataLen: Integer; const AEndStr: string = '%%%(EndSTR)%%%'): Boolean; stdcall;
  published
    property ListenIPAddr: string read fListenIPAddr write fListenIPAddr;
    property ListenPort: Integer read fListenPort write fListenPort default 2000;
    property MaxConnect: Integer  read fMaxConnect write fMaxConnect default 1000;
    property ListenQueueCount: Integer read fListenQueueCount write fListenQueueCount default 200;
    property CompletionPort: THandle read fCompletionPort;
    property ListenSocket: Integer read fListenSocket;
  end;
implementation

function AcceptLoopThread(ACommNetIOCP: Pointer): Integer; stdcall;
var
  iListenSocket,
  iAcceptSocket: Integer;
  hCompletionPort: THandle;
  PerHandleData: LPPER_HANDLE_DATA;
  PerIoData: LPPER_IO_OPERATION_DATA;
  RecvBytes: DWORD;
  Flags: DWORD;
  cniCommNetIOCP: TCommNetIOCP;
begin
  Result          := 0;
  cniCommNetIOCP  := TCommNetIOCP(ACommNetIOCP);
  iListenSocket   := cniCommNetIOCP.ListenSocket;
  hCompletionPort := cniCommNetIOCP.CompletionPort;
  while True do
  begin
    iAcceptSocket := WSAAccept(iListenSocket, nil, nil, nil, 0);
    //当客户端有连接请求的时候，WSAAccept函数会新创建一个套接字iAcceptSocket。这个套接字就是和客户端通信的时候使用的套接字。
    if (iAcceptSocket = SOCKET_ERROR) then
    begin
      closesocket(iListenSocket);
      Exit;
    end;
    //判断Acceptsc套接字创建是否成功，如果不成功则退出。
    PerHandleData := LPPER_HANDLE_DATA(GlobalAlloc(GPTR, SizeOf(PER_HANDLE_DATA)));
    if PerHandleData = nil then
    begin 
      Exit;
    end;
    PerHandleData.Socket := iAcceptSocket;
    //创建一个“单句柄数据结构”将hAcceptSocket套接字绑定。
    if (CreateIoCompletionPort(iAcceptSocket, hCompletionPort, DWORD(PerHandleData), 0) = 0) then
    begin
      Exit;
    end;
    //将套接字、完成端口和“单句柄数据结构”三者绑定在一起。
    PerIoData := LPPER_IO_OPERATION_DATA(GlobalAlloc(GPTR, SizeOf(PER_IO_OPERATION_DATA)));
    if PerIoData = nil then
    begin
      Exit;
    end;
    ZeroMemory(@PerIoData.Overlapped, SizeOf(OVERLAPPED));
    PerIoData.BytesSEND   := 0;
    PerIoData.BytesRECV   := 0;
    PerIoData.DataBuf.len := 1024;
    PerIoData.DataBuf.buf := @PerIoData.Buffer;
    Flags := 0;
    //创建一个“单IO数据结构”其中将PerIoData.BytesSEND 和PerIoData.BytesRECV 均设置成0。说明此“单IO数据结构”是用来接受的。
    if (WSARecv(iAcceptSocket, @(PerIoData.DataBuf), 1, @RecvBytes, @Flags, @(PerIoData.Overlapped), nil) = SOCKET_ERROR) then
    begin
      if (WSAGetLastError() <> ERROR_IO_PENDING) then
      begin
        Exit;
      end
    end;
    //用此“单IO数据结构”来接受Acceptsc套接字的数据。
  end;
end;

function ServerWorkerThread(ACommNetIOCP: Pointer): Integer; stdcall;
var
  hCompletionPort: THandle;
  BytesTransferred: Cardinal;
  PerHandleData: LPPER_HANDLE_DATA;
  PerIoData: LPPER_IO_OPERATION_DATA;
  TempSocket: Integer;
  RecvBytes: DWORD;
  Flags: DWORD;
  cniCommNetIOCP: TCommNetIOCP;
begin
  cniCommNetIOCP  := TCommNetIOCP(ACommNetIOCP);
  hCompletionPort := cniCommNetIOCP.CompletionPort;
  //得到创建线程是传递过来的IOCP
  while(TRUE) do
  begin                                                                                                        
    //工作者线程会停止到GetQueuedCompletionStatus函数处，直到接受到数据为止
    if (GetQueuedCompletionStatus(hCompletionPort, BytesTransferred, DWORD(PerHandleData), POverlapped(PerIoData), INFINITE) = False) then
    begin 
      //当客户端连接断开或者客户端调用closesocket函数的时候,函数GetQueuedCompletionStatus会返回错误。如果我们加入心跳后，在这里就可以来判断套接字是否依然在连接。  
      if PerHandleData <> nil then
      begin
        closesocket(PerHandleData.Socket);  
        GlobalFree(DWORD(PerHandleData));  
      end;  
      if PerIoData <> nil then 
      begin 
        GlobalFree(DWORD(PerIoData));
      end;
      continue;  
    end;  
    if (BytesTransferred = 0) then 
    begin
      //当客户端调用shutdown函数来从容断开的时候，我们可以在这里进行处理。
      if PerHandleData <> nil then
      begin
        TempSocket := PerHandleData.Socket;
        shutdown(PerHandleData.Socket,1);
        closesocket(PerHandleData.Socket);
        GlobalFree(DWORD(PerHandleData));
      end;
      if PerIoData <> nil then
      begin
        GlobalFree(DWORD(PerIoData));
      end;
      continue;
    end;  
    //在上一篇中我们说到IOCP可以接受来自客户端的数据和自己发送出去的数据，两种数据的区别在于我们定义的结构成员BytesRECV和BytesSEND的值。所以下面我们来判断数据的来自方向。因为我们发送出去数据的时候我们设置了结构成员BytesSEND。所以如果BytesRECV=0同时BytesSEND=0那么此数据就是我们接受到的客户端数据。（这种区分方法不是唯一的，个人可以有自己的定义方法。只要可以区分开数据来源就可以。）  
    if (PerIoData.BytesRECV = 0) and (PerIoData.BytesSEND = 0) then 
    begin
      PerIoData.BytesRECV := BytesTransferred;
      PerIoData.BytesSEND := 0;
    end 
    else 
    begin 
      PerIoData.BytesSEND := BytesTransferred;
      PerIoData.BytesRECV := 0;
    end;  
    //当是接受来自客户端的数据是，我们进行数据的处理。  
    if (PerIoData.BytesRECV > PerIoData.BytesSEND) then 
    begin
      PerIoData.DataBuf.buf := PerIoData.Buffer + PerIoData.BytesSEND;
      PerIoData.DataBuf.len := PerIoData.BytesRECV - PerIoData.BytesSEND;
      //这时变量PerIoData.Buffer就是接受到的客户端数据。数据的长度是PerIoData.DataBuf.len 你可以对数据进行相关的处理了。
      cniCommNetIOCP.InvokeLock;
      try

        cniCommNetIOCP.InvokeMessage(PerHandleData.Socket, PerIoData.Buffer, PerIoData.DataBuf.len);
       
      finally
        cniCommNetIOCP.UnInvokeLock;
      end;
      //当我们将数据处理完毕以后，应该将此套接字设置为结束状态，同时初始化和它绑定在一起的数据结构。  
      ZeroMemory(@(PerIoData.Overlapped), sizeof(OVERLAPPED));  
      PerIoData.BytesRECV := 0;  
      Flags := 0;
      ZeroMemory(@(PerIoData.Overlapped), sizeof(OVERLAPPED));
      PerIoData.DataBuf.len := DATA_BUFSIZE;
      ZeroMemory(@PerIoData.Buffer,sizeof(@PerIoData.Buffer));
      PerIoData.DataBuf.buf := @PerIoData.Buffer;
      if (WSARecv(PerHandleData.Socket, @(PerIoData.DataBuf), 1, @RecvBytes, @Flags,@(PerIoData.Overlapped), nil) = SOCKET_ERROR) then
      begin
        if (WSAGetLastError() <> ERROR_IO_PENDING) then 
        begin
          if PerHandleData <> nil then
          begin
            TempSocket := PerHandleData.Socket;  
            closesocket(PerHandleData.Socket);
            GlobalFree(DWORD(PerHandleData));  
          end;
          if PerIoData <> nil then 
          begin
            GlobalFree(DWORD(PerIoData));  
          end;
          continue;  
        end;
      end;  
    end
    //当我们判断出来接受的数据是我们发送出去的数据的时候，在这里我们清空我们申请的内存空间  
    else
    begin
      GlobalFree(DWORD(PerIoData));
    end;
  end;
end;

{ TCommNetIOCP }

constructor TCommNetIOCP.Create;
begin
  fMessageFilterList := TThreadList.Create;
  fCSInvoke := TCriticalSection.Create;
end;

destructor TCommNetIOCP.Destroy;
begin
  Fini;
  if fCSInvoke <> nil then
  begin
    fCSInvoke.Free;
  end;
  if fMessageFilterList <> nil then
  begin
    fMessageFilterList.Clear;
    fMessageFilterList.Free;
  end;
  inherited;
end;

procedure TCommNetIOCP.DoCloseIoCompletionPort;
begin
  if fCompletionPort <> 0 then
  begin
    CloseHandle(fCompletionPort);
    fCompletionPort := 0;
  end;
end;

procedure TCommNetIOCP.DoCloseListenSocket;
begin
  if fListenSocket > 0 then
  begin
    closesocket(fListenSocket);
    fListenSocket := 0;
  end;
end;

function TCommNetIOCP.DoCreateIoCompletionPort: Boolean;
begin
  Result := False;
  fCompletionPort := CreateIOCompletionPort(INVALID_HANDLE_VALUE, 0, 0, 0);
  if fCompletionPort <> 0 then
    Result := True;
end;

function TCommNetIOCP.DoCreateListenSocket: Boolean;
begin
  Result        := False;
  fListenSocket := WSASocket(AF_INET, SOCK_STREAM, 0, nil, 0, WSA_FLAG_OVERLAPPED);
  if fListenSocket = SOCKET_ERROR then
  begin
    closesocket(fListenSocket);
    WSACleanup;
    Exit;
  end;
  Result := True;
end;

procedure TCommNetIOCP.DoFiniIoCompletionPortWorkThread;
var
  I: Integer;
begin
  if Length(fIoCompletionPortWorkThreadArray) = 0 then Exit;
 
  for I := 0 to Length(fIoCompletionPortWorkThreadArray) - 1 do
  begin
    if fIoCompletionPortWorkThreadArray[I] <> 0 then
    begin
      TerminateThread(fIoCompletionPortWorkThreadArray[I], 0);
      fIoCompletionPortWorkThreadArray[I] := 0;
    end;
  end;
  SetLength(fIoCompletionPortWorkThreadArray, 0);
end;

function TCommNetIOCP.DoInitIoCompletionPortWorkThread: Boolean;
var
  I, J: Integer;
  cThreadID: Cardinal;
begin
  Result := False;
  GetSystemInfo(fLocalSysInfo);
  for I := 0 to fLocalSysInfo.dwNumberOfProcessors * 2 - 1 do
  begin
    SetLength(fIoCompletionPortWorkThreadArray, Length(fIoCompletionPortWorkThreadArray) + 1);
    fIoCompletionPortWorkThreadArray[I] := CreateThread(nil, 0, @ServerWorkerThread, Pointer(Self), 0, cThreadID);
    if fIoCompletionPortWorkThreadArray[I] = 0 then
    begin
      for J := 0 to Length(fIoCompletionPortWorkThreadArray) - 1 do
      begin
        TerminateThread(fIoCompletionPortWorkThreadArray[J], 0);
        fIoCompletionPortWorkThreadArray[J] := 0;
      end;
      SetLength(fIoCompletionPortWorkThreadArray, 0);
      Exit;
    end;
  end;
  Result := True;
end;

procedure TCommNetIOCP.DoWSACleanup;
begin
  WSACleanup;
end;

function TCommNetIOCP.DoWSAStartup: Boolean;
begin
  Result := False;
  if WSAStartUp($202, fWSAData) <> 0 then
  begin
     WSACleanup();
     Exit;
  end;
  Result := True;
end;

procedure TCommNetIOCP.Fini;
begin
  Stop;
  DoCloseListenSocket;
  DoFiniIoCompletionPortWorkThread;
  DoCloseIoCompletionPort;
  DoWSACleanup;
end;

function TCommNetIOCP.Init(AListenIPAddr: string; AListenPort, AMaxConnect: Integer): Boolean;
begin
  Result := False;

  ListenIPAddr := AListenIPAddr;
  ListenPort   := AListenPort;
  MaxConnect   := AMaxConnect;

  if DoWSAStartup then
  begin
    //创建一个完成端口
    if not DoCreateIoCompletionPort then Exit;
    if not DoInitIoCompletionPortWorkThread then Exit;
    //创建Listen Socket
    if not DoCreateListenSocket then Exit;
    //绑定地址
    fListenAddr.sin_family      := AF_INET;
    fListenAddr.sin_port        := htons(ListenPort);
    fListenAddr.sin_addr.S_addr := inet_addr(PChar(ListenIPAddr));
    if bind(fListenSocket, @fListenAddr, SizeOf(fListenAddr)) = SOCKET_ERROR then
    begin
      closesocket(fListenSocket);
      WSACleanup;
      Exit;
    end;
    Result := True;
  end; 
end;

procedure TCommNetIOCP.InvokeLock;
begin
  if fCSInvoke <> nil then
  begin
    fCSInvoke.Enter;
  end;
end;

procedure TCommNetIOCP.InvokeMessage(ASocket: Integer; ABuf: PChar;
  ABufLen: Integer);
var
  I: Integer;
  FilterList: TList;
  pmfhHandler: PCommNetMessageFilterHandler;
  bAccept: Boolean;
begin
  FilterList := fMessageFilterList.LockList;
  try
    for I := 0 to FilterList.Count - 1 do
    begin
      pmfhHandler := PCommNetMessageFilterHandler(FilterList.Items[I]);
      if pmfhHandler <> nil then
      begin
        bAccept := False;
        pmfhHandler^.MessageFilter.InvokeMessage(ASocket, ABuf, ABufLen, bAccept);
        if bAccept then
        begin
          Break;
        end;
      end;
    end;
  finally
    fMessageFilterList.UnlockList;
  end;
end;

function TCommNetIOCP.RegisterMessageFilter(
  AMessageFilter: TCommNetMessageFilter): Boolean;
var
  pmfhHandler: PCommNetMessageFilterHandler;
begin
  Result := False;
  if AMessageFilter = nil then Exit;

  New(pmfhHandler);
  pmfhHandler^.MessageFilter := AMessageFilter;

  fMessageFilterList.LockList;
  fMessageFilterList.Add(pmfhHandler);
  fMessageFilterList.UnlockList;

  Result := True;
end;

function TCommNetIOCP.SendDataWithEndString(const ASocket: TSocket;
  AData: array of Char; ADataLen: Integer; const AEndStr: string): Boolean;
var
  PerIoData : LPPER_IO_OPERATION_DATA;
  SendBytes,
  RecvBytes : DWORD;
  Flags     : DWORD;
  LenStr    : string;
  SendBuf   : array [0..DATA_BUFSIZE] of Char;
  iEndStrLen: Integer;
begin
  try
    //由于粘包的关系，所以在需要发送的数据前面加入４位这次发送数据的长度。（详见我的前一篇文章）
    FillChar(SendBuf, SizeOf(SendBuf), #0);
    iEndStrLen := Length(AEndStr);
    StrMove(SendBuf + 0, AData, ADataLen);
    CopyMemory(SendBuf + ADataLen, @AEndStr, iEndStrLen);

    //在这里申请一个发送数据的"单IO数据结构"
    PerIoData := LPPER_IO_OPERATION_DATA(GlobalAlloc(GPTR, SizeOf(PER_IO_OPERATION_DATA)));
    if (PerIoData = nil) then
    begin
      Result := False;
      Exit;
    end;
    ZeroMemory(@PerIoData.Overlapped, sizeof(OVERLAPPED));
    //设置发送标记
    PerIoData.BytesRECV   := 0;
    PerIoData.DataBuf.len := ADataLen + iEndStrLen;
    PerIoData.DataBuf.buf := @SendBuf;
    PerIoData.BytesSEND   := ADataLen + iEndStrLen;
    Flags                 := 0;
    //使用WSASend函数将数据发送
    if (WSASend(ASocket, @(PerIoData.DataBuf), 1, @SendBytes, 0,@(PerIoData.Overlapped), nil) = SOCKET_ERROR) then
    begin
      if (WSAGetLastError() <> ERROR_IO_PENDING) then
      begin
        Result := False;
        Exit;
      end;
    end;
    Result := True;
  except
    Result := False;
  end;
end;

function TCommNetIOCP.SendDataWithHeadLen(const ASocket: TSocket; AData: array of Char;
  ADataLen: Integer): Boolean;
var
  PerIoData : LPPER_IO_OPERATION_DATA;
  SendBytes,
  RecvBytes : DWORD;
  Flags     : DWORD;
  LenStr    : string;
  SendBuf   : array [0..DATA_BUFSIZE] of Char;
begin
  try
    //由于粘包的关系，所以在需要发送的数据前面加入４位这次发送数据的长度。（详见我的前一篇文章）
    FillChar(SendBuf, SizeOf(SendBuf), #0);
    CopyMemory(SendBuf + 0, @ADataLen, 4);
    StrMove(SendBuf + 4, AData, ADataLen);

    //在这里申请一个发送数据的"单IO数据结构"
    PerIoData := LPPER_IO_OPERATION_DATA(GlobalAlloc(GPTR, SizeOf(PER_IO_OPERATION_DATA)));
    if (PerIoData = nil) then
    begin
      Result := False;
      Exit;
    end;
    ZeroMemory(@PerIoData.Overlapped, sizeof(OVERLAPPED));
    //设置发送标记
    PerIoData.BytesRECV   := 0;
    PerIoData.DataBuf.len := ADataLen + 4;
    PerIoData.DataBuf.buf := @SendBuf;
    PerIoData.BytesSEND   := ADataLen + 4;
    Flags                 := 0;
    //使用WSASend函数将数据发送
    if (WSASend(ASocket, @(PerIoData.DataBuf), 1, @SendBytes, 0,@(PerIoData.Overlapped), nil) = SOCKET_ERROR) then
    begin
      if (WSAGetLastError() <> ERROR_IO_PENDING) then
      begin
        Result := False;
        Exit;
      end;
    end;
    Result := True;
  except
    Result := False;
  end;
end;

function TCommNetIOCP.Start(AListenQueueCount: Integer): Boolean;
var
  cThreadID: Cardinal;
begin
  Result := False;
  if fListenSocket > 0 then
  begin
    listen(fListenSocket, AListenQueueCount);
    fAcceptThread := CreateThread(nil, 0, @AcceptLoopThread, Pointer(Self), 0, cThreadID);
    if fAcceptThread = 0 then
    begin
      Exit;
    end;
    Result := True;
  end;
end;

procedure TCommNetIOCP.Stop;
begin
  if fAcceptThread <> 0 then
  begin
    TerminateThread(fAcceptThread, 0);
    fAcceptThread := 0;
  end;
end;

procedure TCommNetIOCP.UnInvokeLock;
begin
  if fCSInvoke <> nil then
  begin
    fCSInvoke.Leave;
  end;
end;

procedure TCommNetIOCP.UnRegisterMessageFilter(AFilterName: string);
var
  I: Integer;
  FilterList: TList;
  pmfhHandler: PCommNetMessageFilterHandler;
begin
  FilterList := fMessageFilterList.LockList;
  try
    for I := 0 to FilterList.Count - 1 do
    begin
      pmfhHandler := PCommNetMessageFilterHandler(FilterList.Items[I]);
      if pmfhHandler <> nil then
      begin
        if SameText(AFilterName, pmfhHandler^.MessageFilter.FilterName) then
        begin
          FilterList.Delete(I);
          Dispose(pmfhHandler);
          Break;
        end;
      end;
    end;
  finally
    fMessageFilterList.UnlockList;
  end;  
end;

end.

 

SZ大伟
关注
专栏目录
L2TP拨号软件 宽带拨号
11-03
L2TP拨号软件 宽带拨号
Delphi拦截网络数据封包
byteh的专栏
06-10 4565
有时候我们需要对其它应用程序发送和接收的网络数据进行拦截,比如要对IE发送的HTTP头进行分析,得到请求的地址等.这次我们可以用一些例如WPE, Sniffer之类的工具来达到目的.但是工具功能有限,要想实现更强大的功能,还是我们自己动手来DIY吧.      拦截网络数据封包的方法有三种,一是将网卡设为混杂模式,这次就可以监视到局域网上所有的数据包,二是HOOK目标进程的发送和接收的API函
IOCP 完成端口的最简说明 - 附DELPHI源码
m0_60908963的博客
05-26 439
IOCP 完成端口最简说明 IOCP越说越复杂，我想尝试简明的从初学者的概念来说明，把最迷惑的部分简要说明： 关键点一：完成IO端口返回的消息，系统会自动保存在队列里！不是触发或者立刻返回！因为服务器需要快，所以完成端口自己先把处理好的消息全部保存到队列里！它不管你现在干嘛，只要合法的它都帮你存好！用不用你取出来再判断！所以我们关键的动作是从完成端口的队列去把消息取出来并处理！ 关键点二：它的关键函数：到队列去取数据的函数，它是阻塞式的。你执行了这个函数，如果队列里没有消息，它会停住等到有消息..
Delphi 完成端口使用
xia_xing的专栏
02-22 1201
Delphi 完成端口相关函数。 FCompletionPort : THandle; //完成端口的相关信息 //创建完成端口 1、FCompletionPort := CreateIOCompletionPort(INVALID_HANDLE_VALUE, 0, 0, 0); 参数： __in HANDLE FileHandle, __in_
Delphi完成端口控件
09-23
总的来说，Delphi完成端口控件为Delphi开发者提供了一个强大的工具，帮助他们构建高性能、高并发的网络应用程序。通过合理地使用和理解完成端口的工作原理，开发者可以创建出更加稳定和高效的服务器端解决方案。
iocp.rar_IOCP_delphi iocp_iocp delphi_完成端口
09-22
标题中的“iocp.rar”可能是指一个包含有关IOCP（I/O完成端口）技术的Delphi编程资源的压缩文件。IOCP是Windows操作系统中的一种高效I/O模型，主要用于处理大量并发的网络连接，尤其在服务器开发中非常常见。这个...
iocp.rar_IOCP_delphi_delphi iocp_完成端口
09-19
**IOCP（IO Completion Port，IO完成端口）**是一种在Windows操作系统中实现高效率、高性能网络编程的技术。它是Windows系统内核提供的一个同步I/O模型，特别适用于处理大量并发连接的情况，如服务器应用程序。在...
完成端口()delphi
06-13
完成端口（IO Completion Ports，IOCP）是Windows操作系统中的一种高效、多线程的I/O模型，主要用于处理大量的并发I/O操作。在Delphi编程环境中，开发人员可以利用IOCP来构建高并发、高性能的服务器应用。...
Delphi 实现的完成端口
11-10
标题中的“Delphi实现的完成端口”指的是在Delphi编程环境中利用Windows操作系统的I/O完成端口（IOCP，Input/Output Completion Ports）技术进行的高性能网络编程。完成端口是一种多线程并发处理I/O操作的机制，它...
Adsl自动连接，断线（delphi源码）
12-12
Adsl自动连接,断线!需要控件Dialup,BusinessSkin控件,控件在componet 下
GIS地质信息监控系统源码
11-13
GIS地质信息监控系统源码 [注：本内容来自网络，在此分享仅为帮助有需要的网友，如果侵犯了您的权利，麻烦联系我，我会第一时间删除，谢谢您。]
Delphi高性能完成端口模型IOCP
11-05
本例程可以作为初学者的学习之用，亦可以作为大型服务程序的通讯模块。其处理速度可以说，优化到了极点。如果理解了本例程的精髓，加上一个高效的通讯协议，你完全可以用它来构建一个高性能的通讯服务器。
稳定高效的IOCP控件
08-21
一个稳定高效率的IOCP控件,内包括有开发示例!!!!!
高效稳定的 IOCP 完成端口动态链接库！
06-23
鉴于完成端口中的很多细节和需要巧妙设计的地方，令很多刚刚接触完成端口的开发人员感到茫然，在此 ChinaIM.net 给大家提供了高效稳定的完成端口链接库（压缩包中带有使用的完整源码例子，使用非常方便）；IOCP库，最新版本下载：http://www.chinaim.net/thread-155-1-1.html
DELPHI高性能大容量SOCKET并发（三）：接收、发送、缓存
热门推荐
SQLDebug_Fan的专栏
08-25 1万+
接收 完成端口是结合重叠端口一起使用的，在接收数据之前，我们需要投递一个接收请求，使用function WSARecv(s: TSocket; lpBuffers: LPWSABUF; dwBufferCount: DWORD;  var lpNumberOfBytesRecvd, lpFlags: DWORD; lpOverlapped: LPWSAOVERLAPPED;  lpCompl
WSASend 异步IO发送数据的机理浅析
weixin_30420305的博客
07-24 1714
WSASend 异步IO发送数据的机理浅析 最近在摸索WSASend函数在IOCP网络模型中的发送机制, 首先当我们使用Overlapped的Socket的时候, 其实已经就是在异步使用该Socket了, 这就有一个疑问, WSASend到底是如何发送数据, 在应用层又是如何处理发送的内存的呢, 带着这个疑问查阅了Reactos的代码, 终于有了一些答案, 针对网上一直说关于WSA...
Winsock完成端口模型-Delphi代码
技术天地
11-02 4204
 原文出处 《Windows网络编程技术》第8章 完成端口模型 由于原书附的是C代码，我把其翻译成Delphi代码。   其中winsock2.pas在delphi中不带，要另外下载http://jungla.dit.upm.es/~bti/files/winsock2.pas     program CompletionIO; {$AP
delphi 完成端口
最新发布
08-07
Delphi是一种高级编程语言，可以用于开发Windows操作系统上的应用程序。通过Delphi，可以实现与端口的交互操作。 在Delphi中，可以通过创建相应的类或使用现有的库函数来完成端口的操作。可以使用TComPort组件来实现通过串口与外部设备进行通信。该组件提供了丰富的属性和方法，可以设置端口的波特率、数据位、校验位等参数，并且可以读取和写入数据。 要使用TComPort组件，首先需要在Delphi的设计视图中安装该组件。然后在应用程序中引用该组件，并在代码中创建一个TComPort对象。可以通过设置TComPort对象的属性来配置要使用的端口。 接下来，可以使用TComPort对象的Open方法来打开端口，并使用Read和Write方法来读取和写入数据。通过监听OnRxChar事件，可以实时监测到接收到的数据，并进行相应的处理。 除了串口，Delphi还支持通过TCP/IP协议与网络上的设备进行通信。可以使用TIdTCPServer或TIdTCPClient组件来实现TCP/IP通信。通过设置相应的属性和事件处理程序，可以实现与网络设备的连接、发送和接收数据等操作。 总之，Delphi提供了丰富的组件和库函数，可以方便地完成与端口的交互操作。无论是串口还是网络端口，都可以通过Delphi来实现数据的读取、写入和处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值