精华内容
下载资源
问答
  • winsocket编程

    2010-06-28 22:38:00
    winsocket编程

    // 服务器代码

    #include <Winsock2.h>

    #include <stdio.h>

    void main()

    {

    WORD wVersionRequested; //版本号

    WSADATA  wsaData;        //数据

    int err;

    wVersionRequested = MAKEWORD(1,1);

    err = WSAStartup(wVersionRequested,&wsaData);

    if( err != 0)

    {

    return;

    }

    if(LOBYTE( wsaData.wVersion ) != 1||

    HIBYTE( wsaData.wVersion) != 1)

    {

    WSACleanup();

    return;

    }

    SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0); //建立套接字

    SOCKADDR_IN addrSrv; 

    addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);

    addrSrv.sin_family=AF_INET;

    addrSrv.sin_port=htons(6000);

    bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));  //绑定端口

    listen(sockSrv,5);   //转换socket套接子为侦听套接子

    SOCKADDR_IN addrClient;

    int len=sizeof(SOCKADDR);

    while(1)   //无限循环

    {

    SOCKET sockConn=accept(sockSrv,(SOCKADDR*)&addrClient,&len);

    char sendBuf[100];

    sprint(sendBuf,"Welcome %s to http://www.sunxin.org",

    inet_ntoa(addrClient.sin_addr));

    send(sockConn,sendBuf,strlen(sendBuf)+1,0);

    char recvBuf[100];

    recv(sockConn,recvBuf);

    printf("%sn",recvBuf);

    closesocket(sockConn);

    WSACleanup();

    }

    }

    注:这是Server端;File->New->Win32 Console Application,工程名:TcpSrv;然后,File->New->C++ Source File,文件名:TcpSrv;在该工程的SettingLinkObject/library modules项要加入ws2_32.lib

    #include <Winsock2.h>

    #include <stdio.h>

    void main()

    {

    WORD    wVersionRequested;

    WSADATA   wsaData;

    int err;

    wVersionRequested = MAKEWORD(1,1);

    err = WSAStartup(wVersionRequested,&wsaData); //启动winsock Dll

    if( err != 0)

    {

    return;

    }

    if(LOBYTE( wsaData.wVersion ) != 1||

    HIBYTE( wsaData.wVersion) != 1)

    {

    WSACleanup();

    return;

    }

    SOCKET sockClient=socket(AF_INET,SOCK_STREAM,0);

    SOCKADDR_IN addrSrv;
    addrSrv.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");

    addrSrv.sin_family=AF_INET;

    addrSrv.sin_port = htons(6000);

    connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));

    char recvBuf[100];

    recv(sockClient,recvBuf,100,0);

    printf("%sn",recvBuf);

    send(sockClient,"This is zhangsan",strlen("This is zhangsan")+1,0);

    closesocket(sockClient);

    WSACleanup();

    }

    注:这是Client端;File->New->Win32 Console Application,工程名:TcpClient;然后,File->New->C++ Source File,文件名:TcpClient;同理,在该工程的SettingLinkObject/library modules项要加入ws2_32.lib

    展开全文
  • WinSocket 编程

    千次阅读 2018-08-01 21:20:00
    套接字 套接字指通信双方在通信时所使用的通信点(Endpoint),通信的双方通过通信点来交换信息和数据。不同类型的通信会使用不同的类型通信点,比如对于电话通信而言,通信点就是电话号码和分机号码的组合,这时...

    套接字

    套接字指通信双方在通信时所使用的通信点(Endpoint),通信的双方通过通信点来交换信息和数据。不同类型的通信会使用不同的类型通信点,比如对于电话通信而言,通信点就是电话号码和分机号码的组合,这时因为如果你想和朋友通话,就需要拨打你朋友的电话号码和分机号码。对于IP网络通信而言,通信点就是套接字,即两个进程在进行网络通信的时候,他们通过套接字来交换信息和数据。

    和电话通信类似,当一个进程想和另一个进程进行网络通信时,它必须知道另外一个进程所在的目标机器IP地址,同时也必须有一种机制来标识目标机器上的进程,这种机制就是我们前面章节提到的端口号,目标机器正是通过端口号才能确定应该把接收到的数据发往哪一个进程。也就是说套接字这种通信点必须通过端口号标识和IP地址,另外由于网络通信也有不同类型,同一个端口号在使用不同的传输层协议时含义是不一样的,所以套接字还和传输层协议有关。

     

    一个套接字包含:

    • IP地址
    • 端口号
    • 传输协议

     

    一个已连接的TCP套接字对应如下:

    【本地IP,端口,目标机IP,端口】

    服务器可以分为迭代服务器和并发服务器

    迭代服务器工作方式如下(UDP):

    • 等待客户请求
    • 当接受到客户请求时,处理该请求并把结果返回该客户
    • 回到步骤1,继续等待下一个客户请求。

    并发服务器的工作方式如下(TCP):

    • 等待客户请求
    • 当接收到客户请求,为该客户开启一个新的服务器实例(进程、线程等),并且由这个新的服务器实例来处理该客户的请求并把结果返回客户,之后该新的服务器实例就终止。
    • 回到步骤一,继续等待下一个客户请求

    TCP客户端与服务器交互过程

    TCP服务器端连接套接字创建、关闭交互过程说明如下:

    1. 服务器创建一个套接字。
    2. 服务器把本地套接字地址(本地IP地址和本地端口)绑定(Bing)到该套接字。客户端将使用在这里的绑定的套接字地址来连接到该服务器
    3. 服务器把该套接字置为等待状态,也叫(Listen)这时套接字也被称为监听套接字。
    4. 服务器开始接受(Accept)客户端的连接请求。如果这时没有连接求,则服务器就等待请求的到来;如果有连接请求,则服务器为该连接请求创建一个新的套接字,该新的套接字用来描述这个连接,既它对应于一个四元组:[本地IP地址,本地端口,远程IP地址,远程端口]。我们把这个新的套接字被称为已连接套接字,以便于区分监听套接字。
    5. 服务器使用已经连接的套接字来接受来自客户端的数据,或者发送数据到客户端。
    6. 当完成和客户端的数据交互之后,服务器关闭套接字。

    一般来说,当服务器创建了已连接套接字后,会生成一个新的服务器实例(线程或进程等)。然后这个新的实例执行5,、6步,即处理和客户端的数据交互。

     

    TCP客户端

    TCP客户端连接套接字创建,关闭过程说明

    1. 客户端创建一个套接字
    2. 客户端把本地套接字地址(本地IP地址和本地端口)绑定到套接字。注意,这个步骤对于客户端来说不是必须的。如果执行的话就按四元组中的地址分配,如果没有执行则系统自动分配地址。
    3. 客户端使用在步骤1中创建的套接字来连接(Connect)到一个远程套接字的地址(远程IP地址和远程端口),即服务器的监听套接字地址。在连接成功之后,这个连接将由客户端套接字来描述,这个客户端套接字也对应于一个四元组:[本地IP地址,本地端口,远程IP地址,远端端口]。此时,这个客户端套接字也成为一个连接套接字。
    4. 客户端使用已连接套接字发送来发送数据到服务器,或者接受来自服务器的数据。
    5. 当完成和服务器的数据交互之后,客户端关闭连接套接字。

    这整个过程都只有一个套接字和一个客户端实例

    展开全文
  • Winsocket编程

    2015-12-10 23:12:23
    原始套接字是WINSOCK公开的一个套接字编程接口,它让我们可以在 IP 层对套接字进行编程,控制其行为,常见的应用有抓包 (Sniffer)、分析包、洪水攻击、ICMP ping等,但它不能截取包(所谓的截取包就是把包拦截下来...

    原始套接字是WINSOCK公开的一个套接字编程接口,它让我们可以在 IP 层对套接字进行编程,控制其行为,常见的应用有抓包 (Sniffer)、分析包、洪水攻击、ICMP ping等,但它不能截取包(所谓的截取包就是把包拦截下来,要做到这种“防火墙”的功能,还需要再低一层的驱动层才可以做到)。但是能把网络上的包复制到本机就已经是一个很有用的功能了。我就曾经试过在一个局域网里打开我的SNIFFER,然后把同事们电脑发出的包都复制过来了。然后如果再对包进行一些分析,哼哼。。。

    其实原始套接字最根本的就是可以在IP层构造自己的IP包,然后把这个IP包发送出去。同样,我们可以把从TCP/UDP传输层过来的包抓取过来并进行分析。。。

    要写原始套接字的程序其实也很容易,因为WINDOWS已经帮我们定义实现好了这些接口(WINSOCK)。另外我们还要有一些定义,就是IP包头、UDP包头等的那些结构定义,具体请查看下面的代码。

    下面是我定义的一个RawSniffer类,这个类是使用了原始套接字来实现一个侦听器,这个类还依赖于MFC(我一直都在WINDOWS平台下开发,用的比较多的也是MFC,所以对MFC有点偏好。。。)。下面是类的代码:

    // 头文件

    #ifndef RAW_DEF_H
    #define RAW_DEF_H

    #include <winsock2.h> 
    #pragma comment(lib,"ws2_32")

    #include <ws2tcpip.h>
    #include <mstcpip.h> // 此文件是 Windows platform SDK 的函数,如果找不到,请安装SDK

    #define PROTOCOL_STRING_ICMP_TXT "ICMP"
    #define PROTOCOL_STRING_TCP_TXT "TCP"
    #define PROTOCOL_STRING_UDP_TXT "UDP"
    #define PROTOCOL_STRING_SPX_TXT "SPX"
    #define PROTOCOL_STRING_NCP_TXT "NCP"
    #define PROTOCOL_STRING_UNKNOW_TXT "UNKNOW"

    // 定义IP首部 
    typedef struct ip_hdr 

     unsigned char h_verlen;   // 4位首部长度,4位IP版本号 
     unsigned char tos;    // 8位服务类型TOS 
     unsigned short total_len;       // 16位总长度(字节) 
     unsigned short ident;      // 16位标识 
     unsigned short frag_and_flags;  // 3位标志位 
     unsigned char ttl;       // 8位生存时间 TTL 
     unsigned char proto;      // 8位协议 (TCP, UDP 或其他) 
     unsigned short checksum;  // 16位IP首部校验和 
     unsigned int sourceIP;   // 32位源IP地址 
     unsigned int destIP;   // 32位目的IP地址 
    }IPHEADER;

    // 定义TCP伪首部 
    typedef struct tsd_hdr 

     unsigned long saddr;    // 源地址 
     unsigned long daddr;    // 目的地址 
     char mbz;                        // 0
     char ptcl;       // 协议类型 UDP的协议类型为17,TCP为6 
     unsigned short tcpl;    // TCP数据包长度 
    }PSDHEADER;

    // 定义TCP首部 
    typedef struct tcp_hdr 

     USHORT th_sport;     // 16位源端口 
     USHORT th_dport;     // 16位目的端口 
     unsigned int th_seq;    // 32位序列号 
     unsigned int th_ack;    // 32位确认号 
     unsigned char th_lenres;   // 4位首部长度/6位保留字 
     unsigned char th_flag;    // 6位标志位 
     USHORT th_win;      // 16位窗口大小 
     USHORT th_sum;      // 16位校验和 
     USHORT th_urp;      // 16位紧急数据偏移量 
    }TCPHEADER;

    // 定义ICMP首部
    typedef struct icmp_hdr
    {
     unsigned char  i_type;           // 类型
     unsigned char  i_code;           // 代码
     unsigned short i_cksum;          // 校验码
     unsigned short i_id;             // 非标准的ICMP首部  
     unsigned short i_seq;
     unsigned long  timestamp;
    }ICMPHEADER;

    // 定义UDP首部
    // The UDP packet is lick this. Took from RFC768.
    //                  0      7 8     15 16    23 24    31  
    //                 +--------+--------+--------+--------+ 
    //                 |     Source      |   Destination   | 
    //                 |      Port       |      Port       | 
    //                 +--------+--------+--------+--------+ 
    //                 |                 |                 | 
    //                 |     Length      |    Checksum     | 
    //                 +--------+--------+--------+--------+ 
    //                 |                                     
    //                 |          data octets ...            
    //                 +---------------- ...      

    typedef struct udp_hdr  // 8 Bytes
    {
     unsigned short uh_sport;         
     unsigned short uh_dport;
     unsigned short uh_len;
     unsigned short uh_sum;
    } UDPHEADER;


    /* 
    // 函数实现不要放在头文件,否则会导致在不同的地方重复定义
    //CheckSum:计算校验和的子函数 
    USHORT checksum(USHORT *buffer, int size) 

     unsigned long cksum=0; 
     while(size >1) 
     { 
      cksum+=*buffer++; 
      size -=sizeof(USHORT); 
     } 
     if(size ) 
     { 
      cksum += *(UCHAR*)buffer; 
     } 
     
     cksum = (cksum >> 16) + (cksum & 0xffff); 
     cksum += (cksum >>16); 
     return (USHORT)(~cksum); 
    }
    */

    USHORT checksum(USHORT *buffer, int size);


    // 回调函数

    // 抓到一个包就会调用这个回调函数
    typedef int (CALLBACK *CaptureDef)(CString  &strMsg);

    class YRawSniffer
    {
    public:
     YRawSniffer();
     ~YRawSniffer();
     BOOL StartAll();
     BOOL ExitAll();
     BOOL Capture(CaptureDef CaptureFunc = NULL);
     BOOL StopCapture();

     static DWORD WINAPI CaptureThread(LPVOID lpParam);
     HANDLE m_hCaptureThread;

     // Filter 过滤条件
     BOOL m_bCapTCP;
     BOOL m_bCapUDP;
     BOOL m_bCapICMP;
     CString m_strSrcIP;
     CString m_strDstIP;
     
     SOCKET m_rawSock;
    // CString m_strFilePath;

    private:
     CaptureDef m_CaptureFunc;
     BOOL m_bExitCapture;
     
     IPHEADER m_ipHeader; 
     TCPHEADER m_tcpHeader;
     ICMPHEADER m_icmpheader;
     UDPHEADER m_udpheader;
    };

    #endif

    // CPP 文件

    #include "stdafx.h"
    #include "RawDef.h"

    //CheckSum:计算校验和的子函数 
    USHORT checksum(USHORT *buffer, int size) 

     unsigned long cksum=0; 
     while(size >1) 
     { 
      cksum+=*buffer++; 
      size -=sizeof(USHORT); 
     } 
     if(size ) 
     { 
      cksum += *(UCHAR*)buffer; 
     } 
     
     cksum = (cksum >> 16) + (cksum & 0xffff); 
     cksum += (cksum >>16); 
     return (USHORT)(~cksum); 
    }

    char * GetProtocol(int proto)
    {
     switch(proto)
     {
         case IPPROTO_ICMP: return PROTOCOL_STRING_ICMP_TXT;
      case IPPROTO_TCP:  return PROTOCOL_STRING_TCP_TXT;
      case IPPROTO_UDP:  return PROTOCOL_STRING_UDP_TXT;
      default:     return PROTOCOL_STRING_UNKNOW_TXT;
     }
    }

    DWORD WaitForObjectEx( HANDLE hHandle, DWORD dwMilliseconds )
    {
     BOOL bRet;
     MSG msg;
     INT iWaitRet;
     DWORD nTimeOut = 0;
     while( (bRet = ::GetMessage( &msg, NULL, 0, 0 )) != 0)
     { 
      if( nTimeOut++ * 100 >= dwMilliseconds )
       break;

      iWaitRet = WaitForSingleObject(hHandle, 100);
      if(iWaitRet != WAIT_TIMEOUT)
      {
       break;
      }
      if (bRet == -1)
      {
       break;
      }
      else
      {
       ::TranslateMessage(&msg); 
       ::DispatchMessage(&msg); 
      }
     }

     return iWaitRet;
    }

     


    ///
    YRawSniffer *g_rawSniffer;

    YRawSniffer::YRawSniffer()
    {
     m_bCapTCP = FALSE;
     m_bCapUDP = FALSE;
     m_bCapICMP = FALSE;
     m_strSrcIP = "";
     m_strDstIP = "";

     m_rawSock = INVALID_SOCKET;
    // m_strFilePath = "";

     m_bExitCapture = FALSE;
     m_CaptureFunc = NULL;
     m_hCaptureThread = NULL;

     g_rawSniffer = this;

     WSADATA wsaData;
     if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0)
     {
      TRACE1("WSAStartup() ERROR! %d", GetLastError());
      return;
     }

    }

    YRawSniffer::~YRawSniffer()
    {
     WSACleanup(); 
    }

    BOOL YRawSniffer::ExitAll()
    {
     m_bExitCapture = TRUE;

     shutdown(m_rawSock, SD_BOTH);
     
     if(m_hCaptureThread != NULL)
     {
      DWORD dwRet = 0;
      dwRet = WaitForObjectEx(m_hCaptureThread, INFINITE);
      if(dwRet == WAIT_OBJECT_0)
      {
       TRACE("CaptureThread exit Success!");
      }
      closesocket(m_rawSock);
      m_rawSock = INVALID_SOCKET;
      CloseHandle(m_hCaptureThread);
      m_hCaptureThread = NULL;
     }

     TRACE("ExitAll OK!");

     return TRUE;
    }

    BOOL YRawSniffer::StartAll()
    {
     m_bExitCapture = FALSE;

     SOCKADDR_IN addr_in;

     if(m_rawSock == INVALID_SOCKET)
      m_rawSock = socket(AF_INET, SOCK_RAW, IPPROTO_IP);

        BOOL flag = TRUE;

     if(setsockopt(m_rawSock, IPPROTO_IP, IP_HDRINCL, (char*)&flag, sizeof(flag)) != 0)
     {
            TRACE1("setsockopt() ERROR! %d", WSAGetLastError());
      return FALSE;
     }
     
     char  LocalName[16];
     struct hostent *pHost;

     // 获取本机名 
     if (gethostname((char*)LocalName, sizeof(LocalName)-1) == SOCKET_ERROR) 
     {
      TRACE1("gethostname error! %d", WSAGetLastError());
      return FALSE;
     }
     
     // 获取本地 IP 地址 
     if ((pHost = gethostbyname((char*)LocalName)) == NULL) 
     {
      TRACE1("gethostbyname error! %d", WSAGetLastError());
      return FALSE;
     }
     
     // m_strSrcIP = pHost->h_addr_list[0];
     addr_in.sin_addr  = *(in_addr *)pHost->h_addr_list[0]; // IP 
     addr_in.sin_family = AF_INET; 
     addr_in.sin_port  = htons(57274);
     
     if( bind(m_rawSock, (struct sockaddr *)&addr_in, sizeof(addr_in)) != 0)
     {
      TRACE1("bind error! %d", WSAGetLastError());
      return FALSE;
     }
     
     // 设置网卡的I/O行为,接收网络上所有的数据包
     DWORD dwValue = 1; 
     if( ioctlsocket(m_rawSock, SIO_RCVALL, &dwValue) != 0)
     {
      TRACE1("ioctlsocket error! %d", WSAGetLastError());
      return FALSE;
     } 

     return TRUE;
    }

    DWORD WINAPI YRawSniffer::CaptureThread(LPVOID lpParam)
    {
     //CFile fLog;
     //BOOL bLogFile = FALSE;
     // 打开记录文件
     //if(g_rawSniffer->m_strFilePath == "")
     // g_rawSniffer->m_strFilePath = "c://Capture.txt";
     //if(g_rawSniffer->m_strFilePath != "")
    // {
    //  if( !fLog.Open(g_rawSniffer->m_strFilePath, CFile::modeCreate|CFile::modeReadWrite) )
    //   TRACE1("file fLog Open failed! %d", GetLastError());
    //  else
    //   bLogFile = TRUE;
    // }

     const int MAX_RECEIVEBUF = 1000;
     char recvBuf[MAX_RECEIVEBUF] = {0};
     char msg[MAX_RECEIVEBUF] = {0};

     char *ptr = NULL;

     CString strLog, strTmp, strContent;

     DWORD nTCPCnt = 0, nUDPCnt = 0, nICMPCnt = 0;

     while(!g_rawSniffer->m_bExitCapture)
     {
      int ret = recv(g_rawSniffer->m_rawSock, recvBuf, MAX_RECEIVEBUF, 0);
      if(ret == SOCKET_ERROR)
       TRACE1("%d, recv(g_rawSniffer->m_rawSock, recvBuf, MAX_RECEIVEBUF, 0) failed!", GetLastError());
      
      strLog = "";
      strContent = "";

      if(ret > 0)
      {   
       g_rawSniffer->m_ipHeader = *(IPHEADER*)recvBuf;
                
       // 取得正确的IP头长度
       int iIphLen = sizeof(unsigned long) * (g_rawSniffer->m_ipHeader.h_verlen & 0xf);
       int cpysize = 0;

       // 过滤目标IP或者源IP
       //if(g_rawSniffer->m_strSrcIP.Find(".") > 0 
       // || g_rawSniffer->m_strDstIP.Find(".") > 0)
       {
        if(g_rawSniffer->m_strSrcIP != "" 
         || g_rawSniffer->m_strDstIP != "")
        {
         if( inet_ntoa(*(in_addr*)&g_rawSniffer->m_ipHeader.sourceIP) != g_rawSniffer->m_strSrcIP
          && inet_ntoa(*(in_addr*)&g_rawSniffer->m_ipHeader.destIP) != g_rawSniffer->m_strDstIP)
          continue;
        }
       }

       /*
       // 过滤目标IP或者源IP
       if(g_rawSniffer->m_strSrcIP != "")
       {
        if( inet_ntoa(*(in_addr*)&g_rawSniffer->m_ipHeader.sourceIP) != g_rawSniffer->m_strSrcIP)
         continue;
       }

       if(g_rawSniffer->m_strDstIP != "")
       {
        if( inet_ntoa(*(in_addr*)&g_rawSniffer->m_ipHeader.destIP) != g_rawSniffer->m_strDstIP)
         continue;
       }
       */
       
       if(g_rawSniffer->m_ipHeader.proto == IPPROTO_TCP && g_rawSniffer->m_bCapTCP)
       {
        nTCPCnt++;
        g_rawSniffer->m_tcpHeader = *(TCPHEADER*)(recvBuf + iIphLen);
        strTmp.Format("取得 %d TCP包", nTCPCnt); strLog += strTmp;
        strTmp.Format("协议: %s /r/n", GetProtocol(g_rawSniffer->m_ipHeader.proto)); strLog += strTmp;
        strTmp.Format("IP源地址: %s /r/n", inet_ntoa(*(in_addr*)&g_rawSniffer->m_ipHeader.sourceIP)); strLog += strTmp;
        strTmp.Format("IP目标地址: %s /r/n", inet_ntoa(*(in_addr*)&g_rawSniffer->m_ipHeader.destIP)); strLog += strTmp;
        strTmp.Format("TCP源端口号: %d /r/n", g_rawSniffer->m_tcpHeader.th_sport); strLog += strTmp;
        strTmp.Format("TCP目标端口号:%d /r/n", g_rawSniffer->m_tcpHeader.th_dport); strLog += strTmp;
        strTmp.Format("数据包长度: %d /r/n", ntohs(g_rawSniffer->m_ipHeader.total_len)); strLog += strTmp;
        strTmp.Format("TCP数据包的报文内容:/r/n"); strLog += strTmp;
        
        ptr = recvBuf + iIphLen + (4 * ((g_rawSniffer->m_tcpHeader.th_lenres & 0xf0)>>4|0));
        cpysize = ntohs(g_rawSniffer->m_ipHeader.total_len) - (iIphLen + (4 * ((g_rawSniffer->m_tcpHeader.th_lenres & 0xf0)>>4|0)));
        
        // ASCII码
        memcpy(msg, ptr, cpysize);
        for(int i = 0; i < cpysize ; i++)
        {
         if(msg[i] >= 32 && msg[i] < 255)
         {
          strContent.Format("%c", (unsigned char)msg[i]); strLog += strContent;
         }
         else
         {
          strContent.Format("."); strLog += strContent;
         }
        }
        strTmp.Format("/r/n /r/n"); strLog += strTmp;
       }
       
       
       if(g_rawSniffer->m_ipHeader.proto == IPPROTO_ICMP  && g_rawSniffer->m_bCapICMP)
       {
        nICMPCnt++;
        g_rawSniffer->m_icmpheader = *(ICMPHEADER*)(recvBuf + iIphLen);
        strTmp.Format("取得 %d ICMP包", nICMPCnt); strLog += strTmp;
        strTmp.Format("协议: %s/r/n", GetProtocol(g_rawSniffer->m_ipHeader.proto)); strLog += strTmp;
        strTmp.Format("IP源地址: %s/r/n", inet_ntoa(*(in_addr*)&g_rawSniffer->m_ipHeader.sourceIP)); strLog += strTmp;
        strTmp.Format("IP目标地址: %s/r/n", inet_ntoa(*(in_addr*)&g_rawSniffer->m_ipHeader.destIP)); strLog += strTmp;
        strTmp.Format("ICMP返回类型:%d/r/n", g_rawSniffer->m_icmpheader.i_type); strLog += strTmp;
        strTmp.Format("ICMP返回代码:%d/r/n", g_rawSniffer->m_icmpheader.i_code); strLog += strTmp;
        strTmp.Format("数据包长度: %d/r/n/r/n/r/n", ntohs(g_rawSniffer->m_ipHeader.total_len)); strLog += strTmp;    
       }
      
       if(g_rawSniffer->m_ipHeader.proto == IPPROTO_UDP && g_rawSniffer->m_bCapUDP)
       {
        nUDPCnt++;
        g_rawSniffer->m_udpheader = *(UDPHEADER*)(recvBuf + iIphLen);
        strTmp.Format("取得 %d UDP包", nUDPCnt); strLog += strTmp;
        strTmp.Format("协议: %s/r/n", GetProtocol(g_rawSniffer->m_ipHeader.proto)); strLog += strTmp;
        strTmp.Format("IP源地址: %s/r/n", inet_ntoa(*(in_addr*)&g_rawSniffer->m_ipHeader.sourceIP)); strLog += strTmp;
        strTmp.Format("IP目标地址: %s/r/n", inet_ntoa(*(in_addr*)&g_rawSniffer->m_ipHeader.destIP)); strLog += strTmp;
        strTmp.Format("UDP源端口号: %d/r/n", g_rawSniffer->m_udpheader.uh_sport); strLog += strTmp;
        strTmp.Format("UDP目标端口号:%d/r/n", g_rawSniffer->m_udpheader.uh_dport); strLog += strTmp;
        strTmp.Format("数据包长度: %d/r/n", ntohs(g_rawSniffer->m_ipHeader.total_len)); strLog += strTmp;
        strTmp.Format("UDP数据包的报文内容:/r/n"); strLog += strTmp;
        
        ptr = recvBuf + iIphLen + 8;
        cpysize = ntohs(g_rawSniffer->m_ipHeader.total_len) - (iIphLen + 8);
        memcpy(msg, ptr, cpysize);
        
        strTmp.Format("ASCII码格式: /r/n");
        for(int i = 0; i < cpysize; i++)
        {
         if(msg[i] >= 32 && msg[i] < 255)
         {
          strContent.Format("%c",(unsigned char)msg[i]); strLog += strContent;
         }
         else
         {
          strContent.Format("."); strLog += strContent;
         }
        }
        strTmp.Format("/r/n/r/n");  strLog += strTmp;    
        
        strTmp.Format("16进制码格式: /r/n");  strLog += strTmp;
        for(i = 0; i < cpysize; i++)
        {
         strTmp.Format("%2.2X ", (unsigned char)msg[i]);  strLog += strTmp;
        }
        strTmp.Format("/r/n/r/n");  strLog += strTmp;
        
       }

       if(g_rawSniffer->m_CaptureFunc != NULL && strLog.GetLength() > 0 && strContent.GetLength() > 0)
        g_rawSniffer->m_CaptureFunc(strLog);

       Sleep(10);
      }
     }


     // 关闭记录文件
    // if(bLogFile)
    //  fLog.Close(); 

     return 0;
    }

    BOOL YRawSniffer::Capture(CaptureDef CaptureFunc /*= NULL*/)
    {
     StartAll();

     if(CaptureFunc != NULL)
      m_CaptureFunc = CaptureFunc;

     // 创建线程截取包
     m_bExitCapture = FALSE;
     m_hCaptureThread = CreateThread(NULL, 0, CaptureThread, NULL, 0, NULL);
     if(NULL == m_hCaptureThread)
      TRACE1(" /"m_hCaptureThread = CreateThread(NULL, 0, CaptureThread, NULL, 0, NULL)/" failed! %d ", GetLastError());

     return TRUE;
    }

    BOOL YRawSniffer::StopCapture()
    {
     return ExitAll();
    }

    这个类的使用很简单,声明一个全局的对象(或者成员变量),使用它的Capture和StopCapture就可以了。记得在程序退出的时候也调用一下StopCapture。

    调用Capture 函数的时候,需要把一些过滤条件赋给它:

      // 过滤条件
      g_sniffer.m_bCapTCP = m_bCapTCP; // 抓TCP包,TRUE为抓,FALSE不抓
      g_sniffer.m_bCapUDP = m_bCapUDP; // 抓UDP包,TRUE为抓,FALSE不抓
      g_sniffer.m_bCapICMP = m_bCapICMP; // 抓ICMP包,TRUE为抓,FALSE不抓
      g_sniffer.m_strSrcIP = m_strSrcIP; // 包的源IP串,空为不限制
      g_sniffer.m_strDstIP = m_strDstIP; // 包的目标IP串,空为不限制

      g_sniffer.Capture(CapFunc);

    抓到的包会在一个回调函数中把抓到的包格式化好了传给你。

    例如我的回调函数是这样的:

    int CALLBACK CapFunc(CString &strLog)
    {
     g_rawDlg->AddLog(strLog); // 把抓到的包在DLG的一个编辑框里输出
     g_log.WriteLogFileRaw(strLog); // 写进一个LOG文件里

     return 0;
    }

    有了上面的这些知识就可以使用这个类实现一个SNIFFER了,很简单的3步:1、把类加进工程 2、包含头文件,声明对象 3、使用这个对象的Capture和StopCapture。

    上面还可以看出我原来的设计是把记录包的功能放在了类里。但是后面觉得这个类还是不要干那么多的活,让记录包的工作都放在上层吧。所以就用了回调函数。

    通过上面代码的研究,你应该很明白原始套接字了吧,这项技术不但可以做SNIFFER,还可以实现洪水攻击等等(因为可以自己构造IP包)。

    展开全文
  • WinSocket编程

    千次阅读 2013-04-22 16:17:25
    ftp协议实现多线程断点续传 点对点多线程断点续传的实现 http://www.codeproject.com/Articles/412511/Simple-client-server-network-using-Cplusplus-and-W 先抽出时间把这两篇看完

    ftp协议实现多线程断点续传

    点对点多线程断点续传的实现

    http://www.codeproject.com/Articles/412511/Simple-client-server-network-using-Cplusplus-and-W

    先抽出时间把这两篇看完

    展开全文
  • winsocket 编程

    2008-07-02 22:21:00
    windows 网络编程,实现查杀139端口Time_wait链接
  • 网络课程设计终于进入了第三阶段,很不幸的是,我的协议分析器和协议编辑器还编辑得不好意思见人,因此,就先把第三阶段(SOCKET编程)的部分总结一下吧,待过几天有时间了,再将协议分析器与协议编辑器的成果与大家...
  • WinSocket编程获得计算机MAC地址 查看本机的MAC地址
  • MFC WinSocket编程

    千次阅读 2013-03-08 14:23:12
    MFC WinSocket编程  MFC提供了两个高级类:CAsyncSocket和CSocket。  CAsyncSocket对winsocket API进行了一对一的包装,是相对低级的一个类,需要编程者知道更多的细节。  CSocket继承了CAsyncSocket,...
  • MFC局域网的winsocket编程

    千次阅读 2018-05-28 20:27:30
    MFC局域网的winsocket编程 1.功能简介 客户端: 与服务器建立连接 发送消息到服务器 断开与服务器的连接 服务器端: 接受客户端的请求 将某个客户端发来的消息广播到其他的在线客户端 ...
  • winsocket编程c++实现

    2018-12-14 17:39:46
    基于对话框的windows应用程序的编写过程。Windows Socket编程应用VisualC++中MFCCSocket类,实现网络数据传输。制作实用的局域网数据传输程序。
  • (1,2步骤可参考:WinSocket编程(C++)实例一) 3、直接上代码了: tcp_server_win.cpp #include "stdafx.h" #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;...
  • winSocket编程简单入门例子
  • (1,2步骤可参考:WinSocket编程(C++)实例一) 3、直接上代码: ient_adrconv_win.cpp #include "stdafx.h" #include &lt;stdio.h&gt; #include &lt;WinSock2.h&gt...
  • (1,2步骤可参考:WinSocket编程(C++)实例一) 3、直接上代码: gethostbyaddr_win.cpp #include "stdafx.h" #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt;...
  • Winsocket编程之套接字原理
  • 创建解决方案,添加ws2_32.lib就不说了,详情参考WinSocket编程(C++)实例一 迭代回声服务器端/客户端: 服务器端在同一时刻只与一个客户端相连, 并提供回声服务。 服务器端依次向5个客户端提供服务并退出。 ...
  • Socket编程是网络编程的重要组成部分,编写简单的服务端程的程序的一般的步骤如下 第一步:包含WinSocket的头文件和动态链接库(DLL) #include #include #pragma comment(lib,"ws2_32") 第二步:初始化WSAStartup...
  • C语言winsocket编程

    2012-11-11 13:38:00
    我只用在DOS下输入check3389.exe username password 这样就可以了。如果错误就提示错误,否则就正确嘛。...我看了winsocket的基础编程。但是都没有说怎么验证这个密码的,我要怎么发送这个帐号和密码他才知道接收?
  • WinSocket编程——原始套接字[转] 分类: 网络编程技术2007-12-21 12:00 4088人阅读 评论(69) 收藏 举报 原始套接字是WINSOCK公开的一个套接字编程接口,它让我们可以在 IP 层对套接字进行编程,控制...
  • WinSocket编程详解

    2011-07-10 21:50:00
    1、WinSocket编程分为服务端和客户端, 他们有着各自不同的行为, 因此创建他们的过程也不一样, 以TCP为例子, 下面是创建的过程。 Server: 1、初始化WinSock。 这里一般使用WSAStartUp函数。 2、创建一个Socket套...
  • 借此地方整理以下socket编程的多种语言的实现,socket可以跨平台的通信,因此多语言、多平台下的实现有必要了解的。代码都是源自网上,感谢网友的分享。socket编程在windows下的C语言实现,dev C++下编译通过编译时...
  • 针对公司平台的一个winsocket代码,期间遇到了打印字符串出错,100054错误,前一种主要是通过lr_eval_string()转换得出值,后一个主要是通过加一个lrs_close_socket();解决 char *ActualBuffer; int ...
  • 我在本机创建2个UDP程序,一个发送数据,另一个接收数据,可每次只能发送一次数据,第二次发送数据的时候那边就收不到了,是怎么回事啊,这是代码 #include #include #pragma comment(lib,"WS2_32.lib") ...
  • Winsocket编程之TCP/IP体系结构一、TCP/IP 体系结构与特点 1、TCP/IP体系结构 TCP/IP协议实际上就是在物理网上的一组完整的网络协议。其中TCP是提供传输层服务,而IP则是提供网络层服务。TCP/IP包括以下协议:...
  • 一,WIN32平台上的WINSOCK编程都要经过下列步骤:  定义变量->获得WINDOCK版本->加载WINSOCK库->初始化->创建套接字->设置套接字选项->关闭套接字->卸载WINSOCK库->释放资源 二,WINSOCK C/S的建立过程:  ...
  • winsocket编程实例

    2009-08-23 19:37:00
    #include #include void main(){ WORDwVersionRequested; WSADATA wsaData; int err; wVersionRequested = MAKEWORD(1,1); err = WSAStartup(wVersionRequested,&wsaData); if( err != 0){ return

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 271
精华内容 108
关键字:

winsocket编程