Python ort，但是函数 #下面需要它，所以我们只给它一个虚拟端口。 sent=self.sendto（self.packet，（self.host，1）） self.packet=self.packet[已发送：] def可读（自）： #只要我们没有发送任何东西

ort，但是函数 #下面需要它，所以我们只给它一个虚拟端口。 sent=self.sendto（self.packet，（self.host，1）） self.packet=self.packet[已发送：] def可读（自）： #只要我们没有发送任何东西，频道就必须保持开放。 if（非self.writable（） #一旦我们发送了一些东西，我们应该定期检查回复是否正确 #超时。 和self.timeout<（time.time（）-self.time_sent））： self.close（） 返回错误 #如果频道不应该关闭，我们就不想读一些东西 #直到我们没有发送任何东西。 返回非self.writable（） def句柄读取（自）： read_time=time.time（） 数据包，addr=self.recvfrom（1024） 报头=数据包[20:28] 类型、代码、校验和、p_id、序列=结构解包（“bbHHh”，标题） 如果p_id==self.packet_id: #这种比较是必要的，因为winsocks不仅 #他们自己发送的数据包的回复。 self.time\u received=读取时间 self.close（） def get_结果（自身）： “”“如果可能，返回ping延迟，否则返回无。”“” 如果收到的self.time_>0： 返回self.time\u已接收-self.time\u已发送 def get_主机（自身）： “”“返回已发送或应发送请求的主机。”“” 返回self.host def不处理错误（自身）： #如果需要，只需一个虚拟处理程序来停止回溯打印。 通过 def create_套接字（自身、族、类型、原型）： #覆盖，因为原始文件不支持“proto”参数。 sock=socket.socket（族、类型、原型） 袜子锁紧（0） 自配插座（插座） #原件的一部分，但未使用。（至少是python 2.7） #由于可能的兼容性原因而复制。 self.family_和_type=族，类型 #如果没有以下方法，我们将看到一些非常有用的方法 #可能是来自asyncore的“有用”警告。但我们不想，还是我们不想？ def手柄连接（自）： 通过 def句柄_接受（自身）： 通过 def手柄_关闭（自身）： self.close（） 类子网监视器： 定义初始化（自）： 打印（“子网监视器已启动”） def校验和（自身、源字符串）： #我不太相信这是正确的，但测试似乎是正确的 #建议它给出与ping.c.中所述相同的答案。 总和=0 计数到=（len（源字符串）/2）*2 计数=0 当count>16）+（总和&0xffff） 总和=总和+（总和>>16） 答案=~sum 应答=应答&0xffff #交换字节。如果我知道原因，就烦我。

---

答案=答案>>8|（答：我想使用nmap在LAN中定位主机，然后尝试连接到给定主机中的特定端口是一个好办法。因此，这个线程可能会对nmap很有帮助，你说的nmap是Python nmap或nmap软件，请你详细说明一下我可以在Windows中实现的nmap。我想要一些可以在Windows上工作的东西indows。您的第一个解决方案仅限于linux，第二个代码将输入作为主机名，然后检查主机名是否存在，但我需要的功能是，如果我运行一个代码，并通过LAN连接到5台计算机，则应列出所有5台计算机的IP地址，并且代码不应接受任何输入。我的第一个su中的代码ggestion不限于Linux，它支持所有的平台。第二个链接提供了Scapy的替代方案，但您仍然需要从neighbourt.py复制扫描循环逻辑。我认为我的问题的解决方案可能非常小，因为我只需要执行我在上面的评论中所述的操作，例如5 comp.，我认为分配一个静态IP到以太网可以解决我的问题，但我仍然无法解决。Nmap是一个全面的网络发现和安全审计程序，

python Nmap

是该程序的python包装程序。如果安装第三方软件对您来说不是一个问题，那么这可能是一个很好的方法。请记住为这个问题添加您自己的答案n并在找到可行的解决方案后将其标记为已解决。如果您在使用python nmap时遇到问题，请提出一个新问题，以便其他人能够找到并帮助您。如果您想要一个只使用可移植python库的集成解决方案，我仍然推荐我上面的建议。有一些细节需要解决，但上面的示例证明了这一点完成。您的解决方案很好，但我在尝试将“conn.tmp”附加到一个格式为“2013-11-22-MyProjectName”的文件夹中时出错，因为“-”（带空格）您有解决该问题的方法吗？@Tareck117尝试更改文件夹名称，因为这似乎只是文件夹的问题。

# TODO: This is a quick hack to retrieve the results 
# of the ping, you should probably do something a bit more elegant here!
class PingQuery(Ping):
    def __init__():
        super().__init__()
        result = false

    def print_success(self, delay, ip, packet_size, ip_header, icmp_header):
        result = ip

subnet = "192.168.0." # TODO: Trim the last number off the IP address retrieved earlier
for i in range(1, 255):
    hostname = subnet + i
    p = PingQuery(hostname, 500, 55) # Timeout after 500ms per node
    p.run(1)
    if (p.result):
        print p.result + " is live"

import os
os.system('net view > conn.tmp')
f = open('conn.tmp', 'r')
f.readline();f.readline();f.readline()

conn = []
host = f.readline()
while host[0] == '\\':
    conn.append(host[2:host.find(' ')])
    host = f.readline()

print conn
f.close()    

import re
import subprocess
# ...

nodes = re.findall(r'\\(.+?)(?: .*)?\n',subprocess.check_output('net view'))

import time
import socket
import struct
import select
import random
import json
import asyncore
from netaddr import IPNetwork
import BaseHTTPServer


# From /usr/include/linux/icmp.h; your milage may vary.
ICMP_ECHO_REQUEST = 8 # Seems to be the same on Solaris.

ICMP_CODE = socket.getprotobyname('icmp')
ERROR_DESCR = {
    1: ' - Note that ICMP messages can only be '
       'sent from processes running as root.',
    10013: ' - Note that ICMP messages can only be sent by'
           ' users or processes with administrator rights.'
    }

__all__ = ['create_packet', 'do_one', 'verbose_ping', 'PingQuery',
           'multi_ping_query']


HOST_NAME = '0.0.0.0' # !!!REMEMBER TO CHANGE THIS!!!
PORT_NUMBER = 9000 # Maybe set this to 9000.
SUBNET = '10.10.20.1/24'
host_list = []
"""
Below class would handle all rest requests
"""
class MyHandler(BaseHTTPServer.BaseHTTPRequestHandler):
     def do_HEAD(self,s):
         s.send_response(200)
         s.send_header("Content-type", "text/html")
         s.end_headers()
     def do_GET(s):
        """Respond to a GET request."""  
        s.send_response(200)
        s.send_header("content_disposition", "attachment; filename=serverstatus.json")
        s.send_header("Content-type", "text/json")
        s.end_headers()

        for ip in IPNetwork(SUBNET):
            host_list.append(ip.format(None))

        #Create Object of SubnetMonitor
        monitor =  SubnetMonitor()

        responseData = {}
        for host, ping in monitor.multi_ping_query(host_list).iteritems():

            if ping is not None:
                print(host,'()',socket.gethostbyname(host)   , '=', ping)   
                responseData[host] = 'Is Up'    
            else:
                responseData[host] = 'Is Down'

        json_data = json.dumps(responseData, sort_keys=True, indent=4, separators=(',', ': '))

        s.wfile.write(json_data)


"""
Below class is used to send/receive all ping/icmp requests 
"""     
class PingQuery(asyncore.dispatcher):


    def __init__(self, host, p_id, timeout=0.5, ignore_errors=False,monitor=None):
        """
       Derived class from "asyncore.dispatcher" for sending and
       receiving an icmp echo request/reply.

       Usually this class is used in conjunction with the "loop"
       function of asyncore.

       Once the loop is over, you can retrieve the results with
       the "get_result" method. Assignment is possible through
       the "get_host" method.

       "host" represents the address under which the server can be reached.
       "timeout" is the interval which the host gets granted for its reply.
       "p_id" must be any unique integer or float except negatives and zeros.

       If "ignore_errors" is True, the default behaviour of asyncore
       will be overwritten with a function which does just nothing.

       """
        self.monitor = monitor
        asyncore.dispatcher.__init__(self)
        try:
            self.create_socket(socket.AF_INET, socket.SOCK_RAW, ICMP_CODE)
        except socket.error as e:
            if e.errno in ERROR_DESCR:
                # Operation not permitted
                raise socket.error(''.join((e.args[1], ERROR_DESCR[e.errno])))
            raise # raise the original error
        self.time_received = 0
        self.time_sent = 0
        self.timeout = timeout
        # Maximum for an unsigned short int c object counts to 65535 so
        # we have to sure that our packet id is not greater than that.
        self.packet_id = int((id(timeout) / p_id) % 65535)
        self.host = host
        self.packet = self.monitor.create_packet(self.packet_id)
        if ignore_errors:
            # If it does not care whether an error occured or not.
            self.handle_error = self.do_not_handle_errors
            self.handle_expt = self.do_not_handle_errors

    def writable(self):
        return self.time_sent == 0

    def handle_write(self):
        self.time_sent = time.time()
        while self.packet:
            # The icmp protocol does not use a port, but the function
            # below expects it, so we just give it a dummy port.
            sent = self.sendto(self.packet, (self.host, 1))
            self.packet = self.packet[sent:]

    def readable(self):
        # As long as we did not sent anything, the channel has to be left open.
        if (not self.writable()
            # Once we sent something, we should periodically check if the reply
            # timed out.
            and self.timeout < (time.time() - self.time_sent)):
            self.close()
            return False
        # If the channel should not be closed, we do not want to read something
        # until we did not sent anything.
        return not self.writable()

    def handle_read(self):
        read_time = time.time()
        packet, addr = self.recvfrom(1024)
        header = packet[20:28]
        type, code, checksum, p_id, sequence = struct.unpack("bbHHh", header)
        if p_id == self.packet_id:
            # This comparison is necessary because winsocks do not only get
            # the replies for their own sent packets.
            self.time_received = read_time
            self.close()

    def get_result(self):
        """Return the ping delay if possible, otherwise None."""
        if self.time_received > 0:
            return self.time_received - self.time_sent

    def get_host(self):
        """Return the host where to the request has or should been sent."""
        return self.host

    def do_not_handle_errors(self):
        # Just a dummy handler to stop traceback printing, if desired.
        pass

    def create_socket(self, family, type, proto):
        # Overwritten, because the original does not support the "proto" arg.
        sock = socket.socket(family, type, proto)
        sock.setblocking(0)
        self.set_socket(sock)
        # Part of the original but is not used. (at least at python 2.7)
        # Copied for possible compatiblity reasons.
        self.family_and_type = family, type

    # If the following methods would not be there, we would see some very
    # "useful" warnings from asyncore, maybe. But we do not want to, or do we?
    def handle_connect(self):
        pass

    def handle_accept(self):
        pass

    def handle_close(self):
        self.close()

class SubnetMonitor:

    def __init__(self):
        print("Subnet Monitor Started")     

    def checksum(self,source_string):
        # I'm not too confident that this is right but testing seems to
        # suggest that it gives the same answers as in_cksum in ping.c.
        sum = 0
        count_to = (len(source_string) / 2) * 2
        count = 0
        while count < count_to:
            this_val = ord(source_string[count + 1])*256+ord(source_string[count])
            sum = sum + this_val
            sum = sum & 0xffffffff # Necessary?
            count = count + 2
        if count_to < len(source_string):
            sum = sum + ord(source_string[len(source_string) - 1])
            sum = sum & 0xffffffff # Necessary?
        sum = (sum >> 16) + (sum & 0xffff)
        sum = sum + (sum >> 16)
        answer = ~sum
        answer = answer & 0xffff
        # Swap bytes. Bugger me if I know why.
        answer = answer >> 8 | (answer << 8 & 0xff00)
        return answer


    def create_packet(self,id):
        """Create a new echo request packet based on the given "id"."""
        # Header is type (8), code (8), checksum (16), id (16), sequence (16)
        header = struct.pack('bbHHh', ICMP_ECHO_REQUEST, 0, 0, id, 1)
        data = 192 * 'Q'
        # Calculate the checksum on the data and the dummy header.
        my_checksum = self.checksum(header + data)
        # Now that we have the right checksum, we put that in. It's just easier
        # to make up a new header than to stuff it into the dummy.
        header = struct.pack('bbHHh', ICMP_ECHO_REQUEST, 0,
                             socket.htons(my_checksum), id, 1)
        return header + data


    def do_one(self,dest_addr, timeout=1):
        """
        Sends one ping to the given "dest_addr" which can be an ip or hostname.
        "timeout" can be any integer or float except negatives and zero.
        Returns either the delay (in seconds) or None on timeout and an invalid
        address, respectively.
        """
        try:
            my_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, ICMP_CODE)
        except socket.error as e:
            if e.errno in ERROR_DESCR:
                # Operation not permitted
                raise socket.error(''.join((e.args[1], ERROR_DESCR[e.errno])))
            raise # raise the original error
        try:
            host = socket.gethostbyname(dest_addr)
        except socket.gaierror:
            return
        # Maximum for an unsigned short int c object counts to 65535 so
        # we have to sure that our packet id is not greater than that.
        packet_id = int((id(timeout) * random.random()) % 65535)
        packet = self.create_packet(packet_id)
        while packet:
            # The icmp protocol does not use a port, but the function
            # below expects it, so we just give it a dummy port.
            sent = my_socket.sendto(packet, (dest_addr, 1))
            packet = packet[sent:]
        delay = self.receive_ping(my_socket, packet_id, time.time(), timeout)
        my_socket.close()
        return delay


    def receive_ping(self,my_socket, packet_id, time_sent, timeout):
        # Receive the ping from the socket.
        time_left = timeout
        while True:
            started_select = time.time()
            ready = select.select([my_socket], [], [], time_left)
            how_long_in_select = time.time() - started_select
            if ready[0] == []: # Timeout
                return
            time_received = time.time()
            rec_packet, addr = my_socket.recvfrom(1024)
            icmp_header = rec_packet[20:28]
            type, code, checksum, p_id, sequence = struct.unpack(
                'bbHHh', icmp_header)
            if p_id == packet_id:
                return time_received - time_sent
            time_left -= time_received - time_sent
            if time_left <= 0:
                return


    def verbose_ping(self,dest_addr, timeout=2, count=4):
        """
        Sends one ping to the given "dest_addr" which can be an ip or hostname.
        "timeout" can be any integer or float except negatives and zero.
        "count" specifies how many pings will be sent.
        Displays the result on the screen.

        """
        for i in range(count):
            print('ping {}...'.format(dest_addr))
            delay = self.do_one(dest_addr, timeout)
            if delay == None:
                print('failed. (Timeout within {} seconds.)'.format(timeout))
            else:
                delay = round(delay * 1000.0, 4)
                print('get ping in {} milliseconds.'.format(delay))
        print('')


    def multi_ping_query(self,hosts, timeout=1, step=512, ignore_errors=False):
        """
        Sends multiple icmp echo requests at once.
        "hosts" is a list of ips or hostnames which should be pinged.
        "timeout" must be given and a integer or float greater than zero.
        "step" is the amount of sockets which should be watched at once.
        See the docstring of "PingQuery" for the meaning of "ignore_erros".
        """
        results, host_list, id = {}, [], 0
        for host in hosts:
            try:
                host_list.append(socket.gethostbyname(host))
            except socket.gaierror:
                results[host] = None
        while host_list:
            sock_list = []
            for ip in host_list[:step]: # select supports only a max of 512
                id += 1
                sock_list.append(PingQuery(ip, id, timeout, ignore_errors,self))
                host_list.remove(ip)
            # Remember to use a timeout here. The risk to get an infinite loop
            # is high, because noone can guarantee that each host will reply!
            asyncore.loop(timeout)
            for sock in sock_list:
                results[sock.get_host()] = sock.get_result()
        return results      


if __name__ == '__main__':
     server_class = BaseHTTPServer.HTTPServer
     httpd = server_class((HOST_NAME, PORT_NUMBER), MyHandler)
     print time.asctime(), "Server Starts - %s:%s" % (HOST_NAME, PORT_NUMBER)
     try:
         httpd.serve_forever()
     except KeyboardInterrupt:
         pass
     httpd.server_close()
     print time.asctime(), "Server Stops - %s:%s" % (HOST_NAME, PORT_NUMBER)