def open_sockets(self): # Create sockets for the connections. self.recv_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) self.send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, udp) icmp = socket.getprotobyname('icmp') udp = socket.getprotobyname('udp')
def run(host, port): icmp = socket.getprotobyname('icmp') udp = socket.getprotobyname('udp') _ttl = 1 _hop_max = 30 while True: r_icmp_sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) s_udp_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, udp) s_udp_sock.setsockopt(socket.SOL_IP, socket.IP_TTL, _ttl) r_icmp_sock.bind(("0.0.0.0", port)) s_udp_sock.sendto(b"", (host, port)) try: _addr, _port = r_icmp_sock.recvfrom(1024)[1] host_name = socket.gethostbyname(_addr) addr_info = socket.getaddrinfo(_addr, _port) print("{}. - {}:{}\n{}".format(_ttl, _addr, _port, addr_info)) except Exception as e: print(sys.exc_info()[1]) s_udp_sock.close() r_icmp_sock.close() _ttl += 1 if _ttl >= _hop_max: break
def probe(host, ttl=30): sending_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.getprotobyname('udp')) receiving_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname('icmp')) sending_socket.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) receiving_socket.bind(('', PORT_NUM)) receiving_socket.settimeout(3) start_probe_time = time.time() end_probe_time = time.time()+3 #3 is the timeout sending_socket.sendto('', (host, PORT_NUM)) data = None address = None name = None try: data, address = receiving_socket.recvfrom(512) address = address[0] end_probe_time = time.time() try: name = socket.gethostbyaddr(address) name = name[0] except Exception, e: name = address else:
def rtt(result): port = 33434 print ("result: ", result) rtt = 0.0 # initialize important values host_name = result[0] host_ip = result[1] ttl = result[2] udp = socket.getprotobyname("udp") # set up sockets icmp = socket.getprotobyname("icmp") timeout = struct.pack("ll", 3, 0) r = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) # raw socket: receive ICMP messages s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, udp) # raw socket to send UDP packets r.setsockopt(socket.SOL_SOCKET, socket.SO_RCVTIMEO, timeout) # timeout s.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) # initial TTL for the UDP packet send_time = time.time() # record time packet was sent s.sendto("", (host_name, port)) # sends UDP packet to host over port current_ip = None pckt = False att = 3 data = "" while data != "": # listener data, host = r.recvfrom(512) # take 512 bytes rtt = (time.time() - send_time) # in ms r.close() # close sockets s.close() return "{0:.2f}".format(rtt*1000)
def main(dest_name): dest_addr = socket.gethostbyname(dest_name) port = 33434 icmp = socket.getprotobyname('icmp') udp = socket.getprotobyname('udp') ttl = 1 recv_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, udp) send_socket.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) recv_socket.bind(("", port)) send_socket.sendto("", (dest_name, port)) curr_addr = None curr_name = None try: _, curr_addr = recv_socket.recvfrom(512) curr_addr = curr_addr[0] try: curr_name = socket.gethostbyaddr(curr_addr)[0] except socket.error: curr_name = curr_addr except socket.error: pass finally: send_socket.close() recv_socket.close() if curr_addr is not None: curr_host = "%s (%s)" % (curr_name, curr_addr) else: curr_host = "*" print "%d\t%s" % (ttl, curr_host) ttl += 1
def distMeasurement(desthost): print ("Measure the hop distance and RTT of " + desthost) destaddr = socket.gethostbyname(desthost) #get the ip address for a given hsot #print (destaddr) port = 33435 #port used in the destination port field in udp packet udp = socket.getprotobyname("udp") icmp = socket.getprotobyname("icmp") ttl = 32 #the initial TTL in the ip header will be this #use UDP segment to test a host, the UDP segment is send to a port that is unlikely to be used in destination host #create a sending socket using udp protocol sendsocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, udp) sendsocket.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) #set the ttl field in IP header #create a receiving socket as a raw socket, using icmp protocol, in order to receive all the IP datagram recvsocket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) sendtime = send(destaddr, sendsocket, port) TTL, arrivedtime = getreply(recvsocket, destaddr, port) if TTL: delay = arrivedtime - sendtime delay = 1000*delay #delay is going to be showed in the unit of ms. TTL = 32 - TTL #subtracting 32 with the remaining TTL in the header field to get the hop distance print ("Destination host: %s, Hop distance: %s, RTT: %1.1fms" %(desthost, TTL, delay)) sendsocket.close() recvsocket.close()
def trace(address): port = 33500 ttl = 1 icmp_proto = socket.getprotobyname('icmp') upd_proto = socket.getprotobyname('udp') while ttl < 127: ssocket = socket.socket(type=socket.SOCK_DGRAM, proto=upd_proto) rsocket = socket.socket(type=socket.SOCK_RAW, proto=icmp_proto) ssocket.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) rsocket.bind(('', port)) ssocket.sendto('', (address, port)) last_addr = None try: rsocket.settimeout(20) _, last_addr = rsocket.recvfrom(256) last_addr = last_addr[0] print last_addr except socket.timeout: print "* * *" except socket.error: print "* * *" finally: ssocket.close() rsocket.close() if last_addr == address: break else: ttl += 1
def trace(self): """Handles iteration of send/receive messages and setup of sockets. Initial ttl=1, then increments ttl and repeats until the destination is reached or *max_hops* is exceeded. """ icmp = socket.getprotobyname('icmp') udp = socket.getprotobyname('udp') receive_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, udp) while True: send_socket.setsockopt(socket.SOL_IP, socket.IP_TTL, self.ttl) time_sent = time.time() self.send_message(send_socket, self.destination_name) current_address, current_name = self.receive_message(receive_socket) receive_time = time.time() - time_sent if current_address is not None: current_host = '{host} ({address})'.format(host=current_name, address=current_address) else: current_host = '*' print("{ttl}\t{host} {time} msec".format(ttl=self.ttl, host=current_host, time=round(receive_time * 1000, 3))) if current_address == self.destination_address or self.ttl >= self.max_hops: break self.ttl += 1 send_socket.close() receive_socket.close()
def __icmpSocket(self): '''创建ICMP Socket''' if not self.IPv6: Sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname("icmp")) else: Sock = socket.socket(socket.AF_INET6, socket.SOCK_RAW, socket.getprotobyname("ipv6-icmp")) return Sock
def traceroute(dest_addr, max_hops=30, timeout=0.2): proto_icmp = socket.getprotobyname('icmp') proto_udp = socket.getprotobyname('udp') port = 33434 for ttl in xrange(1, max_hops+1): rx = socket.socket(socket.AF_INET, socket.SOCK_RAW, proto_icmp) rx.settimeout(timeout) rx.bind(('', port)) tx = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, proto_udp) tx.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) tx.sendto('', (dest_addr, port)) try: data, curr_addr = rx.recvfrom(512) curr_addr = curr_addr[0] except socket.error: curr_addr = None finally: rx.close() tx.close() yield curr_addr if curr_addr == dest_addr: break
def start(self, *args, **kws): with\ closing(socket.socket( socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname('icmp') )) as self.ipv4,\ closing(socket.socket( socket.AF_INET6, socket.SOCK_RAW, socket.getprotobyname('ipv6-icmp') )) as self.ipv6: return self._start(*args, **kws)
def raw_traceroute(target, ttl): port = 33433 # icmp = socket.getprotobyname('icmp') # udp = socket.getprotobyname('udp') recv_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname('icmp')) send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.getprotobyname('udp')) send_socket.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) recv_socket.bind(("", port)) recv_socket.settimeout(30) # Start timing in milliseconds t0 = time.time() * 1000.00 t1 = 0 send_socket.sendto("", (target, port)) try: #If we receive something, stop the clock recv_packet, curr_addr = recv_socket.recvfrom(1024) t1 = time.time() * 1000.00 except socket.error: pass finally: send_socket.close() recv_socket.close() #If we didn't get an answer, return Nones if (t1 == 0): return None, None else: return curr_addr[0], t1 - t0
def addport( csvline, domain=defaultdomain ): """ Adds a network port to the FMC """ proto,port,name,description = csvline.split(",") post_data = { "type": "ProtocolPortObject" } try: #Checks if proto is a string and a known protocol socket.getprotobyname( proto ) except: try: #Check if protocol is a number int( protocol ) + 1 except: raise ValueError( "addport", "ERROR", "Unknown value: {value} for {field} in csv line: {line}".format( value=repr( proto ), field="protocol", line=repr( csvline ) ) ) post_data[ "protocol" ] = proto try: portname = socket.getservbyname( port ) except: try: portname = socket.getservbyport( port ) except: raise ValueError( "addport", "ERROR", "Unknown value: {value} for {field} in csv line: {line}".format( value=repr( port ), field="port", line=repr( csvline ) ) ) post_data[ "port" ] = port post_data[ "overridable" ] = "true" post_data[ "description" ] = description post_data[ "name" ] = name api_path = "/api/fmc_config/v1/domain/" + domain + "/object/protocolportobjects" json_resp = requesttofmc( api_path, post_data ) objectadded( json_resp [ "name" ], json_resp [ "type" ], json_resp [ "id" ] ) return True
def main(dest_name, logfilename): logfile = open(logfilename, "wb") headline = "#time\tduration\tmin\tavg_60\tavg_300\tmax\taddress" print headline logfile.write(headline + "\n") dest_addr = socket.gethostbyname(dest_name) port = random.randint(1, 65535) icmp = socket.getprotobyname("icmp") udp = socket.getprotobyname("udp") recv_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, udp) # send_socket.setsockopt(socket.SOL_IP) recv_socket.bind(("", port)) curr_addr = None curr_name = None min_value = 99.0 max_value = 0.0 avg_60 = 0.0 avg_300 = 0.0 while True: starttime = time.time() duration = 0 send_socket.sendto("", (dest_name, port)) try: recv_socket.setblocking(0) # set receive timeout in seconds ready = select.select([recv_socket], [], [], recv_timeout) if ready[0]: _, curr_addr = recv_socket.recvfrom(512) duration = time.time() - starttime curr_addr = curr_addr[0] if duration > max_value: max_value = duration if duration < min_value: min_value = duration avg_60 = (59 * avg_60 + duration) / 60 avg_300 = (299 * avg_300 + duration) / 300 output = "%d\t%0.8f\t%0.8f\t%0.8f\t%0.8f\t%0.8f\t%s" % ( starttime, duration, min_value, avg_60, avg_300, max_value, curr_addr, ) print output logfile.write(output + "\n") logfile.flush() else: print "%d Timeout waiting for response" % starttime except socket.error: pass time.sleep(1) send_socket.close() recv_socket.close() logfile.close()
def PING_START(type, source, alive = 0, timeout = 1.0, ipv6 = 0, number = sys.maxint, node = None, flood = 0, size = ICMP_DATA_STR, status_only = 0): repl = '' if ipv6: if socket.has_ipv6: try: info, port = socket.getaddrinfo(node, None) host = info[4][0] if host == node: noPrintIPv6adr = 1 except: repl += (u'Не могу найти %s: Неизвестный хост' % node)+'\n' else: repl += u'Недоступно IPv6 для на данной платформе\n' else: try: host = socket.gethostbyname(node) except: repl += (u'Не могу найти %s: Неизвестный хост' % node)+'\n' if not ipv6: try: if int(string.split(host, ".")[-1]) == 0: repl += u'Нет поддержки пинга в сети'+'\n' except: repl += u'Пинг: ошибка, не корректный запрос'+'\n' host = '0.0.0.0' if number == 0: repl += (u'Ошибка количества пакетов на передачу: %s' % str(a))+'\n' if alive: number = 1 start, mint, maxt, avg, lost, tsum, tsumsq = 1, 999, 0.0, 0.0, 0, 0.0, 0.0 if not alive: if ipv6 and not status_only: if noPrintIPv6adr == 1: repl += (u'Пинг: %s : %d байты (40+8+%d)' % (str(node), 40 + 8 + size, size))+'\n' else: repl += (u'Пинг: %s (%s): %d байты (40+8+%d)' % (str(node), str(host), 40 + 8 + size, size))+'\n' elif not status_only: repl += (u'Пинг: %s (%s): %d байты (20+8+%d)' % (str(node), str(host), 20 + 8 + size, size))+'\n' try: while start <= number: lost += 1 if ipv6: try: Psocket = socket.socket(socket.AF_INET6, socket.SOCK_RAW, socket.getprotobyname("ipv6-icmp")) except socket.error, e: repl += u'Ошибка сокета: %s' % e+u' You must be root (%s uses raw sockets)' % os.path.basename(sys.argv[0])+'\n' else: try: Psocket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname("icmp")) except socket.error, e: repl += u'Ошибка сокета: %s' % e+u' You must be root (%s uses raw sockets)' % os.path.basename(sys.argv[0])+'\n' Packet = Packet_construct(start, size, ipv6) try: Psocket.sendto(Packet,(node, 1)) except socket.error, e: repl += u'Ошибка сокета: %s' % e+'\n'
def create_sockets(ttl): ''"Set up receiving and sending sockets.''" recv_socket = socket.socket( socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname('icmp')) send_socket = socket.socket( socket.AF_INET, socket.SOCK_DGRAM, socket.getprotobyname('udp')) send_socket.setsockopt( socket.SOL_IP, socket.IP_TTL, ttl) return recv_socket, send_socket
def __init__ (self, domain): self.domain = domain self.finished = False self.ip = DomainLookup.Domain_to_IP(domain) self.icmp = socket.getprotobyname('icmp') self.udp = socket.getprotobyname('udp') self.counter = 0 self.port = 33434 self.times = []
def main(destination): # get the IP address of the destination adress dest_address = socket.gethostbyname(destination) port = 33434 # gets a particular protocol by name... needed for RAW Sockets # it specifies what protocol I want to use icmp = socket.getprotobyname('icmp') udp = socket.getprotobyname('udp') # Start the time to live at 1 ttl = 1 max_hops = 30 while True: recv_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, udp) send_socket.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) # bind the adress to recv_socket. empty string because we are accepting # packets from any host on port 33434 (unlikely port) recv_socket.bind(("", port)) # Send no data (empty string) to the destination host # on an unlikely port send_socket.sendto("", (destination, port)) current_adress = None try: # get data from the recv_socket, # recvfrom() returns the packet data and adress # we dont care about the packet data so we use _ _, current_adress = recv_socket.recvfrom(512) # get the IP address current_adress = current_adress[0] try: # reverse DNS lookup current_name = socket.gethostbyaddr(current_adress)[0] except socket.error: current_name = current_adress except socket.error: pass finally: send_socket.close() recv_socket.close() # print the data if current_adress is not None: current_host = "%s (%s)" % (current_name, current_adress) else: current_host = "*" print "%d\t%s" % (ttl, current_host) ttl += 1 # break out the loop when the following are true: if current_adress == dest_address or ttl > max_hops: break
def main(dest_name): port = 33434 dest_addr = socket.gethostbyname(dest_name) icmp = socket.getprotobyname("icmp") udp = socket.getprotobyname("udp") ttl = 1 max_hops = 255 RTT = 0 print "Destination: %s" % (dest_addr) while True: # open connections recv_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, udp) send_socket.setsockopt(socket.SOL_IP, socket.IP_TTL, 255) recv_socket.bind(("", port)) recv_socket.settimeout(10) start_time = time.time() send_socket.sendto("", (dest_name, port)) curr_addr = None curr_name = None try: #Throw away the packet into _ and extract IP _, curr_addr = recv_socket.recvfrom(1024) end_time = time.time() curr_addr = curr_addr[0] try: #Try to get host name by IP curr_name = socket.gethostbyaddr(curr_addr)[0] except socket.error: #If it has no name, just use it's IP curr_name = curr_addr except socket.timeout: print "Socket timed out" except socket.error: print "Socket error" finally: send_socket.close() recv_socket.close() # print data if curr_addr is not None: RTT = end_time-start_time curr_host = "%s (%s) %fs" % (curr_name, curr_addr, RTT) else: curr_host = "*" print "%d\t%s" % (ttl, curr_host) ttl += 1 # break if useful if curr_addr == dest_addr or ttl > max_hops: print "RTT = %ss" % (RTT) print "TTL = %ss" % (ttl) break
def create_sockets(ttl): recv_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname('icmp')) send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.getprotobyname('udp')) send_socket.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) recv_socket.setblocking(0) return recv_socket, send_socket
def main(dest_name): dest_addr = socket.gethostbyname(dest_name) port = 33434 max_hops = 30 icmp = socket.getprotobyname('icmp') udp = socket.getprotobyname('udp') ttl = 1 while True: recv_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, udp) send_socket.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) # Build the GNU timeval struct (seconds, microseconds) timeout = struct.pack("ll", 5, 0) # Set the receive timeout so we behave more like regular traceroute recv_socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVTIMEO, timeout) recv_socket.bind(("", port)) sys.stdout.write(" %d " % ttl) send_socket.sendto("", (dest_name, port)) curr_addr = None curr_name = None curr_data = None finished = False tries = 3 while not finished and tries > 0: try: curr_data, curr_addr = recv_socket.recvfrom(512) finished = True curr_addr = curr_addr[0] try: curr_name = socket.gethostbyaddr(curr_addr)[0] except socket.error: curr_name = curr_addr except socket.error as (errno, errmsg): tries = tries - 1 sys.stdout.write("* ") send_socket.close() recv_socket.close() if not finished: pass if curr_addr is not None: curr_host = "%s (%s)" % (curr_name, curr_addr) else: curr_host = "" sys.stdout.write("%s\n%s\n" % (curr_data, curr_host)) ttl += 1 if curr_addr == dest_addr or ttl > max_hops: break
def trace(dest, PORTNUM=5005, max_hops=30): """Traceroute to specified hostname (e.g. 'google.com'). Can optionally specify port to send on (defaults 5005). """ IPADDR = socket.gethostbyname(dest) icmp = socket.getprotobyname('icmp') udp = socket.getprotobyname('udp') ack = False ttl = 1 print "Starting trace to {0}, {1}".format(dest, IPADDR) while not ack: curr_addr, curr_name = None, None # Initialize and connect UDP socket s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, udp) r = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) s.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) r.bind(("", PORTNUM)) s.sendto("", (IPADDR, PORTNUM)) try: r.settimeout(3) # don't block forever dat, curr_addr = r.recvfrom(512) # curr_addr is in form (host, port) try: curr_name = socket.gethostbyaddr(curr_addr[0])[0] except socket.error: curr_name = curr_addr[0] # Catch timeout errors except socket.error: pass finally: s.close() r.close() if curr_addr is None: curr_host = "*" else: curr_host = "{0} ({1})".format(curr_name, curr_addr[0]) if curr_addr[0] == IPADDR or ttl > max_hops: ack = True print "{0}\t{1}".format(ttl, curr_host) ttl += 1
def _create_socket(self): if not utils.is_user_admin(): # RAW socket need root privilege raise OSError("Operation not permitted") if self._v6: proto = socket.getprotobyname("ipv6-icmp") else: proto = socket.getprotobyname("icmp") # Create RAW socket for ping test sock = socket.socket(self._family, socket.SOCK_RAW, proto) sock.settimeout(self._timeout) return sock
def gethostIP(): """ This returns the public IP address from where this is being called """ recv_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname("icmp")) send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.getprotobyname("udp")) send_socket.setsockopt(socket.SOL_IP, socket.IP_TTL, 1) recv_socket.bind(("", 33434)) recv_socket.settimeout(10) send_socket.sendto("", ("google.com", 33434)) _, curr_addr = recv_socket.recvfrom(1024) return curr_addr[0]
def calculateDistance(targetHost, maxHops=16): """ Calculates the number of hops between the source and target hosts @type targetHost: str @param targetHost: alphanumeric string representing the host name @type maxHops: int @param maxHops: maximum distance (in hops) allowed. Hosts above this limit are considered to be unreacheable @rtype: int @return: 0 for success, -1 for failure """ # convert host names into IP addresses destAddress = socket.gethostbyname(targetHost) port = 33434 ttl = 0 while ttl < maxHops: ttl += 1 # the answers are sent back using ICMP icmp = socket.getprotobyname('icmp') receiverSocket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) receiverSocket.setblocking(0) # send pings using UDP udp = socket.getprotobyname('udp') senderSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, udp) senderSocket.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) # sender and receiver sockets using traceroute's standard port receiverSocket.bind(("", 0)) senderSocket.sendto("", (targetHost, port)) receiverAddress = None try: ready = select.select([receiverSocket],[],[],1.0) if ready [0]: _, receiverAddress = receiverSocket.recvfrom(512) receiverAddress = receiverAddress[0] except socket.error: pass finally: senderSocket.close() receiverSocket.close() # target host reached: return elif receiverAddress == destAddress: return ttl
def tracert(dest_name, max_hops=30, timeout=5): goal = dest_name try: dest_addr = socket.gethostbyname(dest_name) except socket.gaierror: exit("Serious!? Check the address, now!") print("Start traceroute to {} ({})".format(dest_name, dest_addr)) print("#\tIP\t\tCountry\tAS\tHost Name") port = 33434 icmp = socket.getprotobyname('icmp') udp = socket.getprotobyname('udp') ttl = 1 while True: recv_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, udp) send_socket.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) recv_socket.settimeout(timeout) recv_socket.bind((b"", port)) send_socket.sendto(b"", (dest_name, port)) curr_addr = None curr_name = None try: _, curr_addr = recv_socket.recvfrom(512) curr_addr = curr_addr[0] try: curr_name = socket.gethostbyaddr(curr_addr)[0] except socket.error: curr_name = curr_addr except socket.error as e: pass finally: send_socket.close() recv_socket.close() if curr_addr is not None: prefix = int(curr_addr.split('.')[0]) server = db[prefix] whs = whois(curr_addr, server) curr_host = "{}\t{}\t{}\t{}".format(curr_addr, whs['country'], whs['AS'], curr_name) else: curr_host = "*" print("{}\t{}".format(ttl, curr_host)) ttl += 1 if curr_addr == dest_addr: print("{} is reached, for {} hops".format(goal, ttl-1)) break elif ttl > max_hops: print("{} is don't reached".format(goal, ttl-1)) break
def udptracepath(host, port): dest_addr = host port = port max_hops = 10 route = [] icmp = socket.getprotobyname("icmp") udp = socket.getprotobyname("udp") ttl = 1 while True: if VERBOSE == "1": print "ttl:", ttl, recv_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, udp) send_socket.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) recv_socket.bind(("", port)) send_socket.sendto("", (dest_addr, port)) curr_addr = None curr_name = None try: _, curr_addr = recv_socket.recvfrom(512) curr_addr = curr_addr[0] try: curr_name = socket.gethostbyaddr(curr_addr)[0] except socket.error: curr_name = curr_addr except socket.error: pass finally: send_socket.close() recv_socket.close() if curr_addr is not None: curr_host = "%s (%s)" % (curr_name, curr_addr) else: curr_host = "*" if VERBOSE: print "ttl(%d)\t%s" % (ttl, curr_host) else: print "#", print "eof" if curr_host != "*": route.append(curr_addr) ttl += 1 if curr_addr == dest_addr or ttl > max_hops: break return route
def checkProtocol(protocol): try: i = int(protocol) except ValueError: # string try: socket.getprotobyname(protocol) except: return False else: if i < 0 or i > 255: return False return True
def main(dest_name): # some useful vriables dest_addr = socket.gethostbyname(dest_name) port = 33434 icmp = socket.getprotobyname('icmp') udp = socket.getprotobyname('udp') ttl = 1 max_hops = 30 while True: # create the sockets recv_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, udp) send_socket.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) # bind the recv socket to listen for all hosts on our port # bind the send socket to send to our destination recv_socket.bind(("", port)) send_socket.sendto("", (dest_name, port)) # try and get data from the address curr_addr = None try: # only want the address not the data _, curr_addr = recv_socket.recvfrom(512) curr_addr = curr_addr[0] # get the name try: curr_name = socket.gethostbyaddr(curr_addr)[0] except socket.error: curr_name = curr_addr except socket.error: pass finally: send_socket.close() recv_socket.close() if curr_addr is not None: curr_host = '%s %s' % (curr_name, curr_addr) else: curr_host = '*' print '%d\t%s' % (ttl, curr_host) ttl += 1 if curr_addr == dest_addr or ttl > max_hops: break
def main(dest): dest_ip = socket.gethostbyname(dest) port = 33434 icmp = socket.getprotobyname("icmp") udp = socket.getprotobyname("udp") ttl = 1 max_hops = 30 while True: recv_socket = socket.socket(socket.AF_INET,socket.SOCK_RAW,icmp) send_socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,udp) send_socket.setsockopt(socket.SOL_IP,socket.IP_TTL,ttl) recv_socket.bind(("",port)) send_socket.sendto("",(dest,port)) cur_addr =None try: _,curr_addr = recv_socket.recvfrom(512) curr_addr = curr_addr[0] try: curr_name = socket.gethostbyaddr(curr_addr)[0] except socket.error: curr_name = curr_addr except socket.error: pass finally: send_socket.close(); recv_socket.close(); if curr_addr is not None: curr_host = "%s (%s)" % (curr_name,curr_addr) else: curr_host ="*" print"%d\t%s" % (ttl,curr_host) ttl+=1 if curr_addr == dest_ip or ttl>max_hops: break
class ICMP(object): ICMP_ECHO_REQ = 0x08 ICMP_ECHO_REP = 0x00 PROTO_STRUCT_FMT = "!BBHHH" PROTO_CODE = socket.getprotobyname("icmp") NBYTES_TIME = struct.calcsize("d") def _checksum_wrapper(func): if sys.byteorder == "big": @wraps(func) def _checksum_inner(cls, pkt): if len(pkt) % 2 == 1: pkt += "\0" s = sum(array.array("H", pkt)) s = (s >> 16) + (s & 0xffff) s += s >> 16 s = ~s return s & 0xffff else: @wraps(func) def _checksum_inner(cls, pkt): if len(pkt) % 2 == 1: pkt += "\0" s = sum(array.array("H", pkt)) s = (s >> 16) + (s & 0xffff) s += s >> 16 s = ~s return (((s >> 8) & 0xff) | s << 8) & 0xffff return _checksum_inner @classmethod @_checksum_wrapper def checksum(cls, pkt): pass
def do_one(myStats, destIP, hostname, timeout, mySeqNumber, packet_size, quiet=False): """ Returns either the delay (in ms) or None on timeout. """ delay = None try: # One could use UDP here, but it's obscure mySocket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname("icmp")) except socket.error as e: print("failed. (socket error: '%s')" % e.args[1]) raise # raise the original error my_ID = os.getpid() & 0xFFFF sentTime = send_one_ping(mySocket, destIP, my_ID, mySeqNumber, packet_size) if sentTime == None: mySocket.close() return delay myStats.pktsSent += 1 recvTime, dataSize, iphSrcIP, icmpSeqNumber, iphTTL = receive_one_ping(mySocket, my_ID, timeout) mySocket.close() if recvTime: delay = (recvTime - sentTime) * 1000 if not quiet: print("%d bytes from %s: icmp_seq=%d ttl=%d time=%d ms" % ( dataSize, socket.inet_ntoa(struct.pack("!I", iphSrcIP)), icmpSeqNumber, iphTTL, delay) ) myStats.pktsRcvd += 1 myStats.totTime += delay if myStats.minTime > delay: myStats.minTime = delay if myStats.maxTime < delay: myStats.maxTime = delay else: delay = None print("Request timed out.") return delay
def ping(address, payload=None, timeout=2.0, seq_number=0): if payload is None: payload = b'PING' * 16 try: with socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname('icmp')) as s: # Send ICMP_ECHO_REQUEST checksum = 0 header = struct.pack('!BBHHH', ICMP_ECHO_REQUEST, 0, checksum, os.getpid(), seq_number) packet = header + payload checksum = icmp_checksum(packet) packet = packet[:2] + struct.pack('!H', checksum) + packet[4:] send_time = time.perf_counter() s.sendto(packet, (address, 0)) # Receive ICMP_ECHO_REPLY current_timeout = timeout while True: select_time = time.perf_counter() readable, _, __ = select.select([s], [], [], current_timeout) if len(readable) == 0: current_timeout -= time.perf_counter() - select_time if current_timeout <= 0: return None time.sleep(0) else: reply_time = time.perf_counter() packet, address = s.recvfrom(len(payload) + 28) icmp_header = IcmpEchoReplyHeader( *struct.unpack('!BBHHH', packet[20:28])) if icmp_header.type == ICMP_ECHO_REPLY and icmp_header.id == os.getpid() and \ icmp_header.seq_number == seq_number: ip_header = IpHeader( *struct.unpack('!BBHHHBBHII', packet[:20])) return IcmpEchoReply(icmp_header, ip_header, reply_time - send_time, packet[28:]) except socket.error as e: raise Exception('Ping failed.') from e
def traceroute(ip_address): """ Performs a UDP tracerout to the target IP address. This is only performed if the '-tr' option is given. """ print "<-------------TRACE ROUTE---------------------------->" icmp = socket.getprotobyname('icmp') max_hops = 30 ttl = 1 while True: try: recv = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) send = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) send.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) recv.bind(("", 33434)) send.sendto("", (ip_address, 33434)) except socket.error, e: print "Error:", print os.strerror(e.errno) return address = None try: _, address = recv.recvfrom(512) address = address[0] try: curr_name = socket.gethostbyaddr(address)[0] except socket.error: curr_name = address except socket.error: pass send.close() recv.close() if address is not None: curr_host = "%s (%s)" % (curr_name, address) else: curr_host = "*" print "%d\t%s" % (ttl, curr_host) ttl = ttl + 1 if (address == ip_address) or (ttl > max_hops): break
def connect(self, server: str, port: int) -> None: log.debug("WhiskerImmSocket: connect") proto = socket.getprotobyname("tcp") try: self.immsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, proto) self.immsock.connect((server, port)) self.connected = True except socket.error as x: self.immsock.close() self.immsock = None self.error = str(x) return # Disable the Nagle algorithm: self.immsock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) log.debug("Immediate port: Nagle algorithm disabled (TCP_NODELAY set)") # Set blocking self.immsock.setblocking(True) log.debug("Immediate port: set to blocking mode")
def doOnePing(destinationAddress, timeout): # 1. Create ICMP socket icmp = socket.getprotobyname("icmp") try: icmpSocket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) except socket.error as e: if e.errno == 1: e.msg = e.msg + ("ICMP messages can only be sent from root user processes") raise socket.error(e.msg) raise ID = os.getpid() & 0xFFFF # get Operating Sys ID # 2. Call sendOnePing function sendOnePing(icmpSocket, destinationAddress, ID) # 3. Call receiveOnePing function delay = receiveOnePing(icmpSocket, destinationAddress, ID, timeout) # 4. Close ICMP socket icmpSocket.close() # 5. Return total network delay return delay
def create_raw_socket(dest_address): ''' Creates raw socket using icmp header @param: dest_address : destination address @return: socket_raw: raw socket ''' icmp=socket.getprotobyname("icmp") #gets icmp icmp protocol try: socket_raw = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) #creates raw socket except socket.error: msg='ICMP failure' print ('Socket could not be created. Error Code : ' + msg) sys.exit() return socket_raw
def ping_wait(ip_addr, timeout): """ return either delay (in second) or none on timeout. """ # Translate an Internet protocol name to a constant suitable for # passing as the (optional) third argument to the socket() function. # This is usually only needed for sockets opened in “raw” mode. icmp = socket.getprotobyname('icmp') try: # socket.socket([family[, type[, proto]]]) # Create a new socket using the given address family(default: AF_INET), # socket type(SOCK_STREAM) and protocol number(zero or may be omitted). my_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) except socket.error: raise #send_ping(my_socket, ip_addr, my_ID) delay = receive_ping(my_socket, timeout) my_socket.close() return delay
def single_ping(self, ttl = None): icmp = socket.getprotobyname("icmp") #Create the ICMP Socket icmp_sock= socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) if(ttl != None): #Riwa & Jaafar icmp_sock.setsockopt(socket.SOL_IP, socket.IP_TTL, ttl) # os.getpid() --> gets process id from the operating system PID = os.getpid() & 0xFFFF self.send_echo_req(icmp_sock, PID) #Send the echo request #Stores time that the packet was sent to be used for delay calculations try: start = time.time() pack_delay, recv_packet = self.rec_echo(start,icmp_sock, PID, self.timeout) #Receive echo reply and then close the socket as it is no longer needed icmp_sock.close() return pack_delay, recv_packet #packet delay recieved from the echo reply except Exception: icmp_sock.close() return (None, None)
def __init__(self, host, delay=1.0, its_dead_jim=4, verbose=True, persistent=False): self.host = host self.delay = delay self.verbose = verbose self.persistent = persistent self.obituary_delay = its_dead_jim * delay self.pad = "getoff my lawn" # should be 14 chars or more socket.setdefaulttimeout(0.01) self.started = 0 self.thread = None self._isup = False self.sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname('icmp')) try: self.sock.connect((host, 22)) except socket.gaierror as ex: self.log("ping socket cannot connect to %s: %s" % (host, ex[1])) self.sock.close() return
def main(ip_server, delay): """ :param ip_server: :param delay: :return: """ sequence = 1 identifier = os.getpid() & 0xFFFF try: my_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname("icmp")) except socket.error, (errno, msg): if errno == 1: # permit denny msg = msg + ( " - Note that ICMP messages can only be sent from processes" " running as root.") raise socket.error(msg) raise
def do_one(self, dest_addr, timeout): """ Returns either the delay (in seconds) or none on timeout. """ icmp = socket.getprotobyname("icmp") try: my_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) except PermissionError as e: e.args = (e.args if e.args else tuple()) + ( (" - Note that ICMP messages can only be sent from processes" " running as root."), ) raise my_ID = os.getpid() & 0xFFFF self.send_one_ping(my_socket, dest_addr, my_ID) delay = self.receive_one_ping(my_socket, my_ID, timeout) my_socket.close() return delay
def __init__(self, ip_daddr): # We're only interested in ICMP, so happy to have this hard coded. try: self.icmp_listener = socket.socket( socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname("icmp") ) except PermissionError as e: print(e) print("Please run as root!") exit(1) # TODO: Test Timestamps correctly SO_TIMESTAMPNS = 35 self.icmp_listener.setsockopt(socket.SOL_SOCKET, SO_TIMESTAMPNS, 1) self.ip_daddr = ip_daddr self.mutex = threading.Lock() logging.debug("Starting") self.icmp_packets = dict() t = threading.Thread(target=self.listener) t.setDaemon(True) t.start()
def _set_outer_l3v4_fields(self, outer_l3v4): """ setup outer l3v4 fields from traffic profile """ ip_params = {} if 'proto' in outer_l3v4: ip_params['proto'] = socket.getprotobyname(outer_l3v4['proto']) if outer_l3v4['proto'] == 'tcp': self.udp_packet = Pkt.TCP() self.udp[DST_PORT] = 'TCP.dport' self.udp[SRC_PORT] = 'TCP.sport' tcp_params = {'flags': '', 'window': 0} self._set_proto_fields(UDP, **tcp_params) if 'ttl' in outer_l3v4: ip_params['ttl'] = outer_l3v4['ttl'] self._set_proto_fields(IP, **ip_params) if 'dscp' in outer_l3v4: self._set_proto_addr(DSCP, TYPE_OF_SERVICE, outer_l3v4['dscp']) if 'srcip4' in outer_l3v4: self._set_proto_addr(IP, SRC, outer_l3v4['srcip4'], outer_l3v4['count']) if 'dstip4' in outer_l3v4: self._set_proto_addr(IP, DST, outer_l3v4['dstip4'], outer_l3v4['count'])
def ping_multi_by_select(self, hosts): icmp = socket.getprotobyname("icmp") packet = self.get_packet() socks = [] ips = set() self.sock_map = {} for host in hosts: sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) sock.setblocking(False) target_addr = socket.gethostbyname(host) self.sock_map[sock] = target_addr ips.add(target_addr) sock.sendto(packet, (target_addr, 1)) socks.append(sock) active_hosts = self.receive_from_hosts(socks, ips) for sock in socks: sock.close() return active_hosts
def do_one_ping(self, dest_addr, timeout): """ Returns either the delay (in seconds) or none on timeout. """ icmp = socket.getprotobyname("icmp") try: my_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) except socket.error as serr: if serr.errno == 1: # Operation not permitted serr.msg += ( " - Note that ICMP messages can only be sent from processes" " running as root.") raise socket.error(serr.msg) raise # raise the original error my_ID = os.getpid() & 0xFFFF self.send_one_ping(my_socket, dest_addr, my_ID) delay = self.receive_one_ping(my_socket, my_ID, timeout) my_socket.close() return delay
def one_ping(dst_addr, icmp_sq, timeout=2, cmd=b"|cmd=|"): try: rawsocket = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname("icmp")) except socket.error as e: if e.errno == 1: msg = "{0} please run as root ".format(e) raise socket.error(msg) raise icmp_id = os.getpid() & 0xFFFF send_time, addr = send_one_ping(rawsocket, dst_addr, icmp_id, icmp_sq, cmd=cmd) time, type, code, checksum, packet_id, sequence, all_icmpHeader = recv_one_ping( rawsocket, icmp_id, icmp_sq, send_time, timeout) return time, type, code, checksum, packet_id, sequence, addr, all_icmpHeader
def ping_once(self): """ Returns the delay in seconds, or none on timeout """ icmp = socket.getprotobyname("icmp") msg = '' try: sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) except socket.error as errno: if errno == 1: # Not SuperUser or Root, so the operation is not permitted msg += "ICMP messages can only be sent from processes with root user permission" raise socket.error(msg) except Exception as e: print("Exception: (%s)" % e) my_ID = os.getpid() & 0xFFFF self.send_ping(sock, my_ID) delay = self.receive_pong(sock, my_ID, self.timeout) sock.close() return delay
def ping(addr): print "PING (%s): %d data bytes" % (addr, datalen) ## create socket s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname('icmp')) s.connect((addr, 22)) ## setuid back to normal user os.setuid(os.getuid()) seq_num = 0 packet_count = 0 process_id = os.getpid() base_packet = Packet((8, 0)) while 1: ## create ping packet seq_num += 1 pdata = struct.pack("!HHd", process_id, seq_num, time.time()) ## send initial packet base_packet.data = pdata s.send(base_packet.packet) ## recv packet buf = s.recv(BUFSIZE) current_time = time.time() ## parse packet; remove IP header first r = Packet.parse(buf[20:]) ## parse ping data (ident, seq, timestamp) = struct.unpack("!HHd", r.data) ## calculate rounttrip time rtt = current_time - timestamp rtt *= 1000 print "%d bytes from %s: id=%s, seq=%u, rtt=%.3f ms" % ( len(buf), addr, ident, seq, rtt) time.sleep(1)
def wyslij(id_komunikatu, dane): try: #print("wyslij") proto = socket.getprotobyname('tcp') sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, proto) sock.connect(("192.168.1.201", 1001)) # msg = bytearray.fromhex(toHex(id_komunikatu)) #print("id hex = ", toHex(id_komunikatu)) msg = bytearray() msg.append(0xAA) # b4 = (id_komunikatu >> 24) & 0xFF; # print("4 hex = ", toHex(b4)) # msg.append(b4) # msg.append(0x30) # b3 = (id_komunikatu >> 16) & 0xFF; # print("3 hex = ", toHex(b3)) # msg.append(b3) # msg.append(0x10) b2 = (id_komunikatu >> 8) & 0xFF; # print("2 hex = ", toHex(b2)) msg.append(b2) # msg.append(0x02) b1 = (id_komunikatu) & 0xFF; # print("1 hex = ", toHex(b1)) msg.append(b1) # msg.append(0x01) for val in dane: msg.append(val) msg.append(hap_crc(msg)) msg.append(0xA5) sock.sendall(msg) print('wyslano =', binascii.hexlify(msg)) # sock.sendall(bytearray(b'\xaa\x10\x90\xf0\xf0\xff\xff\x02\x01\xff\xff\xff\xff}\xa5')) except socket.error: pass finally: sock.close()
def do_one(dest_addr, timeout): icmp = socket.getprotobyname("ICMP") try: my_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) except socket.error as err: errno, msg = err.errno, err.strerror if errno == 1: msg = msg + ( " - Note that ICMP messages can only be sent from processes" " running as root.") raise socket.error(msg) raise # берем последние два байта my_id = os.getpid() & 0xFFFF send_one_ping(my_socket, dest_addr, my_id) delay = receive_one_ping(my_socket, my_id, timeout) my_socket.close() return delay
def do_one(dest_addr, timeout, psize): """ Returns either the delay (in seconds) or none on timeout. """ icmp = socket.getprotobyname("icmp") try: my_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) except socket.error as xxx_todo_changeme: (errno, msg) = xxx_todo_changeme.args if errno == 1: # Operation not permitted msg = msg + ( " - Note that ICMP messages can only be sent from processes" " running as root.") raise socket.error(msg) raise # raise the original error my_id = os.getpid() & 0xFFFF send_one_ping(my_socket, dest_addr, my_id, psize) delay = receive_one_ping(my_socket, my_id, timeout) my_socket.close() return delay
def ping_once(self): """ Returns the delay (in seconds) or none on timeout. """ icmp = socket.getprotobyname("icmp") try: sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) except socket.error as e: if e.errno == 1: # Not superuser, so operation not permitted e.msg += "ICMP messages can only be sent from root user processes" raise socket.error(e.msg) except Exception as e: print("Exception: %s" % (e)) my_ID = os.getpid() & 0xFFFF self.send_ping(sock, my_ID) delay = self.receive_pong(sock, my_ID, self.timeout) sock.close() return delay
def load_from_config(cls, config): params = { 'name': config['name'], 'host': config.get('host', 'localhost'), 'port': int(config.get('port', '8080')), 'path': config.get('path'), 'interface': config.get('interface', None), 'family': _FAMILY[config.get('family', 'AF_INET').upper()], 'type': _TYPE[config.get('type', 'SOCK_STREAM').upper()], 'backlog': int(config.get('backlog', 2048)), 'umask': int(config.get('umask', 8)) } proto_name = config.get('proto') if proto_name is not None: params['proto'] = socket.getprotobyname(proto_name) s = cls(**params) # store the config for later checking if config has changed s._cfg = config.copy() return s
def _create_socket(self): try: socket.inet_pton(socket.AF_INET, self.dest) dest_ip = self.dest except socket.error: try: dest_ip = socket.gethostbyname(self.dest) except socket.gaierror: self.ret_code = EXIT_STATUS.ERROR_HOST_NOT_FOUND return self.dest_ip = dest_ip try: self.sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname("icmp")) except socket.error as e: if e.errno == 1: self.ret_code = EXIT_STATUS.ERROR_ROOT_REQUIRED else: self.ret_code = EXIT_STATUS.ERROR_CANT_OPEN_SOCKET return
def do_one(destination, timeout, sequence_num): """ Completes an entire ping packet send/receive and returns the time taken for this process :param destination: the host to ping :param timeout: the maximum time to wait for a response to the ping :param sequence_num: the sequence number of the ping :return: the time taken to complete the ping or None on timeout """ try: sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.getprotobyname("icmp")) except socket.error: print("oops") sys.exit() process_id = os.getpid() & 0xFFFF send_one_ping(sock, destination, process_id, sequence_num) delay = receive_one_ping(sock, timeout) sock.close() return delay
def do_one(dest_addr, timeout): """ Returns either the delay (in seconds) or none on timeout. """ delay = None icmp = socket.getprotobyname("icmp") try: my_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp) my_ID = os.getpid() & 0xFFFF send_one_ping(my_socket, dest_addr, my_ID) delay = receive_one_ping(my_socket, my_ID, timeout) my_socket.close() except socket.error: if errno == 1: # Operation not permitted msg = msg + (" - not root.") raise socket.error(msg) #raise # raise the original error except Exception as e: print(e) return delay
def __init__(self, destination, protocol, source=None, options=()): """Creates a network socket to exchange messages :param destination: Destination IP address :type destination: str :param protocol: Name of the protocol to use :type protocol: str :param options: Options to set on the socket :type options: tuple :param source: Source IP to use - implemented in future releases :type source: Union[None, str]""" self.destination = socket.gethostbyname(destination) self.protocol = socket.getprotobyname(protocol) if source is not None: raise NotImplementedError( 'PythonPing currently does not support specification of source IP' ) self.socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, self.protocol) if options: self.socket.setsockopt(*options)
def ParseProtocol(protocol_string): """Attempt to parse a protocol number from a string. Args: protocol_string: The string to parse. Returns: The corresponding protocol number. Raises: ValueError: If the protocol_string is not a valid protocol string. """ try: protocol = socket.getprotobyname(protocol_string) except (socket.error, TypeError): try: protocol = int(protocol_string) except (ValueError, TypeError): raise ValueError('Invalid protocol: %s' % protocol_string) return protocol
def send_command(msg, host): protocol = 'udp' service = 'predict' try: port = socket.getservbyname(service, protocol) except IOError as ex: try: port = int(service) except ValueError: raise ex addr = socket.gethostbyname(host) proto = socket.getprotobyname(protocol) if protocol == 'udp': type_ = socket.SOCK_DGRAM else: type_ = socket.SOCK_STREAM with socket.socket(socket.AF_INET, type_, proto) as sock: sock.settimeout(1) sock.sendto(bytes(msg + '\n', 'utf-8'), (host, port)) resp, server = sock.recvfrom(1024) return resp.decode('utf-8')