sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP)

sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP) 是创建一个原始套接字的例子。其中，socket.AF_INET指定了套接字使用IPv4协议，socket.SOCK_RAW指定了套接字类型为原始套接字，socket.IPPROTO_ICMP指定了使用ICMP协议。

相关问题

将下列代码转化为C++代码：import socket def scan_ports(host, start_port, end_port, protocol='tcp'): for port in range(start_port, end_port + 1): try: if protocol == 'tcp': sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.settimeout(1) # 设置超时时间为1秒 result = sock.connect_ex((host, port)) if result == 0: print(f"Port {port} is open") sock.close() elif protocol == 'udp': sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.settimeout(1) sock.sendto(b'Ping', (host, port)) data, addr = sock.recvfrom(1024) if data: print(f"Port {port} is open") sock.close() else: print(f"Unsupported protocol {protocol}") return except socket.error: pass if __name__ == '__main__': host = '127.0.0.1' # 目标IP地址 start_port = 1 # 起始端口号 end_port = 65535 # 终止端口号 protocols = ['tcp', 'udp'] for protocol in protocols: print(f"Scanning {protocol} ports...") scan_ports(host, start_port, end_port, protocol)

以下是将代码转化为C++的结果：

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

void scan_ports(const char* host, int start_port, int end_port, const char* protocol) {
    struct sockaddr_in target;
    int result, sock, port;
    memset(&target, 0, sizeof(target));
    target.sin_family = AF_INET;
    target.sin_addr.s_addr = inet_addr(host);

    for(port = start_port; port <= end_port; port++) {
        try {
            if(strcmp(protocol, "tcp") == 0) {
                sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
                if(sock < 0) {
                    std::cerr << "Failed to create socket.\n";
                    exit(1);
                }
                target.sin_port = htons(port);
                struct timeval timeout;
                timeout.tv_sec = 1;
                timeout.tv_usec = 0;
                setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
                setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
                result = connect(sock, (struct sockaddr*)&target, sizeof(target));
                if(result == 0) {
                    std::cout << "Port " << port << " is open.\n";
                }
                close(sock);
            }
            else if(strcmp(protocol, "udp") == 0) {
                sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
                if(sock < 0) {
                    std::cerr << "Failed to create socket.\n";
                    exit(1);
                }
                target.sin_port = htons(port);
                struct timeval timeout;
                timeout.tv_sec = 1;
                timeout.tv_usec = 0;
                setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
                setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
                char buffer[] = "Ping";
                result = sendto(sock, buffer, strlen(buffer), 0, (struct sockaddr*)&target, sizeof(target));
                if(result < 0) {
                    std::cerr << "Failed to send data.\n";
                    exit(1);
                }
                char recv_buffer[1024];
                socklen_t recv_len = sizeof(target);
                result = recvfrom(sock, recv_buffer, sizeof(recv_buffer), 0, (struct sockaddr*)&target, &recv_len);
                if(result > 0) {
                    std::cout << "Port " << port << " is open.\n";
                }
                close(sock);
            }
            else {
                std::cerr << "Unsupported protocol " << protocol << "\n";
                exit(1);
            }
        }
        catch(...) {
            continue;
        }
    }
}

int main(int argc, char** argv) {
    const char* host = "127.0.0.1";
    int start_port = 1;
    int end_port = 65535;
    const char* protocols[] = {"tcp", "udp"};
    int i, num_protocols = sizeof(protocols) / sizeof(protocols[0]);
    for(i = 0; i < num_protocols; i++) {
        std::cout << "Scanning " << protocols[i] << " ports...\n";
        scan_ports(host, start_port, end_port, protocols[i]);
    }
    return 0;
}

注释以下代码import time import socket import threading activeDegree = dict() flag = True def main(): global activeDegree, flag HOST = socket.gethostbyname(socket.gethostname()) # 获取IP地址 s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_IP) s.bind((HOST, 0)) # 0表示所有端口 s.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON) # 打开混杂模式，接收所有包 while flag: data, addr = s.recvfrom(65565) # 接收一个数据包 host = addr[0] activeDegree[host] = activeDegree.get(host, 0) + 1 if addr[0] != '10.2.1.8': # 过滤指定IP地址的消息 print(data, addr) s.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF) # 关闭混杂模式 s.close() t = threading.Thread(target=main) # 创建线程 t.start() # 启动线程，开始嗅探 time.sleep(60) # 主线程等待60秒 flag = False t.join() # 等待子线程结束 for item in activeDegree.items(): print(item)

以下是对代码的注释：

import time
import socket
import threading

activeDegree = dict()   # 存储活跃主机的字典
flag = True             # 标志位，用于控制程序运行

def main():
    global activeDegree, flag
    
    HOST = socket.gethostbyname(socket.gethostname())   # 获取本机IP地址
    s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_IP)   # 创建原始套接字
    s.bind((HOST, 0))    # 绑定到本机所有端口
    s.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)   # 打开混杂模式，接收所有数据包
    
    while flag:
        data, addr = s.recvfrom(65565)   # 接收一个数据包
        host = addr[0]
        activeDegree[host] = activeDegree.get(host, 0) + 1   # 更新活跃主机字典
        if addr[0] != '10.2.1.8':   # 过滤指定IP地址的消息
            print(data, addr)
        
    s.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)   # 关闭混杂模式
    s.close()

t = threading.Thread(target=main)   # 创建线程
t.start()                          # 启动线程，开始嗅探

time.sleep(60)   # 主线程等待60秒

flag = False   # 标志位设为False，停止子线程运行
t.join()       # 等待子线程结束

# 打印活跃主机字典中的内容
for item in activeDegree.items():
    print(item)

该程序使用 Python 的 socket 模块实现了网络嗅探功能，用于检测局域网内的活跃主机。程序中创建了一个原始套接字，打开混杂模式，接收所有数据包。通过遍历接收到的数据包，获取数据包的源主机地址，更新活跃主机字典。同时，程序也过滤了指定IP地址的消息，避免干扰正常的网络流量。

程序中使用了多线程实现嗅探和主程序的分离，主线程等待一定时间后停止子线程的运行，并打印活跃主机字典中的内容。