[Débutant] Wanted Ping

On Tue, 20 Jul 2004 16:00:57 +0200, Loack wrote:

Bonjour à tous,

Je débute sous Python et, j'ai ue question qui va vous sembler ridicule
mais, je trouve pas alors...

Je cherche écrire un script qui, entre autre, me dirai si ma machine est
up ou down. A défaut d'une meilleure idée, je voudrai faire un ping.

Existe-t-il une fonction python ou dois-je passer par un appel systeme?

Merci d'avance,

Il n'est pas très facile à implementer.
Ici il y a une possible implementation python
ftp://ftp.visi.com/users/mdc/ping.py

Ciao,
Riccardo

--
-=Riccardo Galli=-

_,e.
s~ ``
~@. ideralis Programs
. ol
`**~ http://www.sideralis.net

Bonsoir !

Intéressant, ce script. Chez moi, il me signale des "future_warning" que je
ne comprend pas ("hex/oct constants > sys.maxint will return positive values
in Python 2.4")

Mais le script fonctionne quand même, et il est très rapide.


--
Michel Claveau






Et aussi, j'avais ça dans mes archives (mais je ne sais pas d'où ça viens) :




import icmp, ip
import socket
import time
import select
import string
import os, sys

TimedOut = 'TimedOut'

class PingSocket:

def __init__(self, addr):
self.dest = (socket.gethostbyname(addr), 0)
self.open_icmp_socket()

def open_icmp_socket(self):
self.socket = socket.socket(socket.AF_INET, socket.SOCK_RAW,
socket.IPPROTO_ICMP)
self.socket.setblocking(1)

def sendto(self, packet):
self.socket.sendto(packet, self.dest)

def recvfrom(self, maxbytes):
return self.socket.recvfrom(maxbytes)

class Pinger:

def __init__(self, addr, num):
self.num = num
self.last = 0
self.sent = 0
self.times = {}
self.deltas = []
self.sock = PingSocket(addr)
self.pid = os.getpid()
self.addr = addr
name, aliases, ipaddr = socket.gethostbyaddr(addr)
if aliases:
self.destinfo = (aliases[0], ipaddr[0])
else:
self.destinfo = (name, ipaddr[0])

def send_packet(self):
pkt = icmp.Packet()
pkt.type = icmp.ICMP_ECHO
pkt.id = self.pid
pkt.seq = self.sent
pkt.data = 'python pinger'
buf = pkt.assemble()
self.times[self.sent] = time.time()
self.sock.sendto(buf)
self.plen = len(buf)
self.sent = self.sent + 1

def recv_packet(self, pkt, when):
try:
sent = self.times[pkt.seq]
del self.times[pkt.seq]
except KeyError:
return
# limit to ms precision
delta = int((when - sent) * 1000.)
self.deltas.append(delta)
self.recv_output(self.plen, self.destinfo[0],
self.destinfo[1], pkt.seq, delta)
if pkt.seq > self.last:
self.last = pkt.seq

def recv_output(self, bytes, dest, addr, seq, delta):
"Place holder for subclass output/collector method"
pass

def ping(self):
# don't wait more than 10 seconds from now for first reply
self.last_arrival = time.time()
while 1:
if self.sent < self.num:
self.send_packet()
elif not self.times and self.last == self.num - 1:
break
else:
now = time.time()
if self.deltas:
# Wait no more than 10 times the longest delay so far
if (now - self.last_arrival) > max(self.deltas) / 100.:
break
else:
# Wait no more than 10 seconds
if (now - self.last_arrival) > 10.:
break
self.wait()

def wait(self):
start = time.time()
timeout = 1.0
while 1:
rd, wt, er = select.select([self.sock.socket], [], [], timeout)
if rd:
# okay to use time here, because select has told us
# there is data and we don't care to measure the time
# it takes the system to give us the packet.
arrival = time.time()
try:
pkt, who = self.sock.recvfrom(4096)
except socket.error:
continue
# could also use the ip module to get the payload
repip = ip.Packet(pkt)
try:
reply = icmp.Packet(repip.data)
except ValueError:
continue
if reply.id == self.pid:
self.recv_packet(reply, arrival)
self.last_arrival = arrival
timeout = (start + 1.0) - time.time()
if timeout < 0:
break

def get_summary(self):
dmin = min(self.deltas)
dmax = max(self.deltas)
davg = reduce(lambda x, y: x + y, self.deltas) / len(self.deltas)
sent = self.num
recv = sent - len(self.times.values())
loss = float(sent - recv) / float(sent)
return dmin, davg, dmax, sent, recv, loss

class CollectorPinger(Pinger):

def __init__(self, host, num):
Pinger.__init__(self, host, num)
self.results = {}

def recv_output(self, bytes, dest, addr, seq, delta):
self.results[seq] = delta

class CmdlinePinger(Pinger):

def recv_output(self, bytes, dest, addr, seq, delta):
print "%d bytes from %s (%s): icmp_seq=%d. time=%d. ms" %
(bytes, dest, addr, seq, delta)

def ping(self):
print "PING %s" % self.destinfo[0]
Pinger.ping(self)

if __name__ == "__main__":
try:
who = sys.argv[1]
except IndexError:
print "ping.py host [#packets]"
sys.exit(0)
try:
num = string.atoi(sys.argv[2])
except ValueError:
print "ping.py host [#packets]"
sys.exit(0)
except IndexError:
num = 32

p = CmdlinePinger(who, num)
p.ping()
summary = p.get_summary()
print "---Ping statistics---"
print "%d packets transmitted, %d packets received, %d%% packet loss" %

(summary[3], summary[4], int(summary[5] * 100.))
print "round-trip (ms) min/avg/max = %d/%d/%d" %
(summary[0], summary[1], summary[2])

Bonsoir !

Juste un petit truc : il arrive souvent que les réponses ICMP (réponses au
Ping) soient désactivées, pour des raisons de sécurité (beaucoup de
pare-feux bloquent ces requêtes, afin qu'un éventuel pirate ne puisse pas
savoir s'il y a une machine à une adresse donnée).

Je sais que cela ne t'arrange pas, mais il faut tenir compte de cet élément.

@-salutations
--
Michel Claveau

Michel Claveau, résurectionné d'outre-bombe informatique wrote:

Bonsoir !

Juste un petit truc : il arrive souvent que les réponses ICMP (réponses au
Ping) soient désactivées, pour des raisons de sécurité (beaucoup de
pare-feux bloquent ces requêtes, afin qu'un éventuel pirate ne puisse pas
savoir s'il y a une machine à une adresse donnée).

Je sais que cela ne t'arrange pas, mais il faut tenir compte de cet élément.

@-salutations

Je sais bien et, effectivement, ca m'arrange pas mais bon, dans un
premier temps, ce script sera utilisé sur le réseau interne (dont je
suis le sysadmin) alors ca posera pas de problème.

Merci,

--
Loack
http://www.pileouface.org

Il n'est pas très facile à implementer.
Ici il y a une possible implementation python
ftp://ftp.visi.com/users/mdc/ping.py

Ciao,
Riccardo

Je viens de l'essayer mais, j'ai des messages d'erreur :

$python ping 192.168.0.5

ping.py:56: FutureWarning: hex/oct constants > sys.maxint will return
positive values in Python 2.4 and up
sum=sum & 0xffffffff # Necessary?
ping.py:61: FutureWarning: hex/oct constants > sys.maxint will return
positive values in Python 2.4 and up
sum=sum & 0xffffffff # Necessary?
Traceback (most recent call last):
File "ping.py", line 132, in ?
main()
File "ping.py", line 127, in main
delay=doOne(dest)
File "ping.py", line 114, in doOne
mySocket=socket(AF_INET,SOCK_RAW,icmp)
File "/usr/lib/python2.3/socket.py", line 154, in __init__
_sock = _realsocket(family, type, proto)
socket.error: (1, 'Operation not permitted')

Je vais essayer de trouver le pb, mais ca me donne une piste, c'est dj ca,

merci,

--
Loack
http://www.pileouface.org

Il n'est pas très facile à implementer.
Ici il y a une possible implementation python
ftp://ftp.visi.com/users/mdc/ping.py

Ciao,
Riccardo

Je viens de tester le script et, il marche (uniquement qd je suis root
pour le moment, mais bon, doit y avoir une explication).

J'ai moi aussi qqs warnings mais bon, le plus important c'est que ca tourne.

Merci,

--
Loack
http://www.pileouface.org

On Wed, 21 Jul 2004 09:16:17 +0200, Loack wrote:

Il n'est pas très facile à implementer.
Ici il y a une possible implementation python
ftp://ftp.visi.com/users/mdc/ping.py

Je viens de tester le script et, il marche (uniquement qd je suis root
pour le moment, mais bon, doit y avoir une explication).

Oui, il y a.
Comme ping utilise raw IP packets, il doit etre utilisé par root.
Généralement on *NIX ping a le bit SUID active, pour etre accessible à
chaque user.

Riccardo

--
-=Riccardo Galli=-

_,e.
s~ ``
~@. ideralis Programs
. ol
`**~ http://www.sideralis.net

Re

Pour un problème (un peu) similaire, je n'y suis pas allé par quatre chemins
: j'ai créé un petit serveur TCP/IP, en Python, sur un port particulier. Ce
script est lancé, au démarrage de chaque machine concernée.

Dès lors, il me suffit d'envoyer une simple trame TCP/IP, particulière, pour
que le script de la machine réponde, ou ne réponde pas.

Du coup, j'ai complété le script, pour des réponses plus puissantes (genre
date/heure de mise en marche de la machine, espace disque libre, nom du user
courant, etc.). Si tu veux essayer, tu verras qu'en Python, faire un
serveur TCP/IP est vraiment très simple (pour faciliter encore plus les
choses, limite le message (trame) à moins de 1024 octets).

Et, pour éviter les aléas des postes, j'ai mis, dans les tâches planifiées,
un autre script, qui vérifie que mon premier est bien en cours d'exécution
(sinon, il le lance).

Autre aspect intéressant, et à condition de paramétrer le routeur et le
coupefeux, on peut tester les machines via Internet (ce qui me permet de
savoir, depuis mon bureau, quelles sont les machines du client qui sont en
fonctionnement).

Michel Claveau, résurectionné d'outre-bombe informatique wrote:

Re

Pour un problème (un peu) similaire, je n'y suis pas allé par quatre chemins
: j'ai créé un petit serveur TCP/IP, en Python, sur un port particulier. Ce
script est lancé, au démarrage de chaque machine concernée.

Dès lors, il me suffit d'envoyer une simple trame TCP/IP, particulière, pour
que le script de la machine réponde, ou ne réponde pas.

Du coup, j'ai complété le script, pour des réponses plus puissantes (genre
date/heure de mise en marche de la machine, espace disque libre, nom du user
courant, etc.). Si tu veux essayer, tu verras qu'en Python, faire un
serveur TCP/IP est vraiment très simple (pour faciliter encore plus les
choses, limite le message (trame) à moins de 1024 octets).

Et, pour éviter les aléas des postes, j'ai mis, dans les tâches planifiées,
un autre script, qui vérifie que mon premier est bien en cours d'exécution
(sinon, il le lance).

Autre aspect intéressant, et à condition de paramétrer le routeur et le
coupefeux, on peut tester les machines via Internet (ce qui me permet de
savoir, depuis mon bureau, quelles sont les machines du client qui sont en
fonctionnement).

Re,

C'est effectivement une bonne solution. Je regarderai pour mettre ca en
pratique sous peu, en plus, ca me fera travailler mon python ;)

Pour le moment, j'ai pas trop de temps pour, et, ma solution (basique de
chez basique) correspond plutot bien. Mais, je note la remarque dans ma
todo-list pour le mettre en application des que mon planning le permettra.

Merci du coup de main,

Loack - Débutant Pythonnien pleinement satisfait

Du coup, j'ai complété le script, pour des réponses plus puissantes (genre
date/heure de mise en marche de la machine, espace disque libre, nom du user
courant, etc.). Si tu veux essayer, tu verras qu'en Python, faire un
serveur TCP/IP est vraiment très simple (pour faciliter encore plus les
choses, limite le message (trame) à moins de 1024 octets).

Pour encore plus simplifier les choses, on peut même faire un serveur
HTTP (par exemple avec BaseHTTPServer), qui permettra indiféremment
d'accéder aux infos avec un navigateur intenet ou un script python (via
urlib2 par exemple).

Ce n'est que mon avis, mais quand on peut utiliser un protocole
existant, pourquoi en implementer un nouveau, et quand il s'agit de
faire une question/réponse, j'ai pas encore trouvé mieux que HTTP.

Xavier