[保留] 如何在ping 命令结果前面加上时间日期!!!

Set shell = WScript.CreateObject("WScript.Shell")

Set re=New RegExp

re.Pattern = "^Reply|^Request"

Set myping=shell.Exec("ping 192.168.0.249")

while Not myping.StdOut.AtEndOfStream

	strLine = myping.StdOut.ReadLine()

	r=re.Test(strLine)

	If r Then

		WScript.Echo date & " "& time & chr(9) & strLine

	End if

Wend

#!/usr/bin/perl

open(PING, "ping 192.168.0.249|");

while (<PING>)

{

	if ($_ =~ /^Reply|^Request/)

	{

		my @date=localtime(time);

		printf("%d-%02d-%02d %02d:%02d:%02d %s", $date[5]+1900, $date[4]+1, $date[3], $date[2], $date[1], $date[0], $_);

	}

}

close(PING);

#include <stdio.h>;

#include <string.h>;

#include <time.h>;



int main(int argc, char *argv[])

{

	time_t clock;

	struct tm *tm;	

	char tbuf[20];



	FILE *res;

	char buf[256];

	res=popen("ping 192.168.0.249", "r");



	while (fgets(buf, sizeof(buf), res))

	{

		if (bcmp(buf, "Reply", 5) == 0 || bcmp(buf, "Request", 7) == 0)

		{

			time(&clock);

			tm=localtime(&clock );

			strftime(tbuf, 20, "%Y-%m-%d %H:%M:%S", tm);

			printf("%s\t%s", tbuf, buf);

		}

	}

	pclose(res);

	return 0;

}

# while :;do ping -c 1 172.17.39.251|awk '/ttl=/'|sed "s/^/`date +%Y-%m-%d\|%T` /";sleep 1;done

Dim args, flag, unsuccOut

args=""

otherout=""

flag=0



If WScript.Arguments.count = 0 Then

	WScript.Echo "Usage: cscript tping.vbs [-t] [-a] [-n count] [-l size] [-f] [-i TTL] [-v TOS]"

	WScript.Echo "                         [-s count] [[-j host-list] | [-k host-list]]"

	WScript.Echo "                         [-r count] [-w timeout] destination-list"

	wscript.quit

End if



For i=0 to WScript.Arguments.count - 1

	args=args & " " & WScript.Arguments(i)

Next



Set shell = WScript.CreateObject("WScript.Shell") 

Set re=New RegExp 

re.Pattern="^Reply|^Request" 

Set myping=shell.Exec("ping" & args)



while Not myping.StdOut.AtEndOfStream 

   strLine=myping.StdOut.ReadLine() 

   r=re.Test(strLine) 

   If r Then 

	WScript.Echo date & " "& time & chr(9) & strLine

	flag=1

   Else

	unsuccOut=unsuccOut & strLine

   End if 

Wend



if flag = 0 then

	WScript.Echo unsuccOut

end if

import sys

import os

import struct

import array

import time

import select

import binascii

import math

import getopt

import string

import socket



# total size of data (payload)

ICMP_DATA_STR = 56  



# initial values of header variables

ICMP_TYPE = 8

ICMP_TYPE_IP6 = 128

ICMP_CODE = 0

ICMP_CHECKSUM = 0

ICMP_ID = 0

ICMP_SEQ_NR = 0



# Package definitions.

__program__   = 'ping'

__version__   = '0.5a'

__date__      = '2004/15/12'

__author__    = 'Lars Strand <lars at unik no>;'

__licence__   = 'GPL'

__copyright__ = 'Copyright (C) 2004 Lars Strand'



def _construct(id, size, ipv6):

    """Constructs a ICMP echo packet of variable size

    """



    # size must be big enough to contain time sent

    if size < int(struct.calcsize("d")):

        _error("packetsize to small, must be at least %d" % int(struct.calcsize("d")))

    

    # construct header

    if ipv6:

        header = struct.pack('BbHHh', ICMP_TYPE_IP6, ICMP_CODE, ICMP_CHECKSUM, \

                             ICMP_ID, ICMP_SEQ_NR+id)

    else:

        header = struct.pack('bbHHh', ICMP_TYPE, ICMP_CODE, ICMP_CHECKSUM, \

                             ICMP_ID, ICMP_SEQ_NR+id)



    # if size big enough, embed this payload

    load = "-- IF YOU ARE READING THIS YOU ARE A NERD! --"

    

    # space for time

    size -= struct.calcsize("d")



    # construct payload based on size, may be omitted :)

    rest = ""

    if size >; len(load):

        rest = load

        size -= len(load)



    # pad the rest of payload

    rest += size * "X"



    # pack

    data = struct.pack("d", time.time()) + rest

    packet = header + data          # ping packet without checksum

    checksum = _in_cksum(packet)    # make checksum



    # construct header with correct checksum

    if ipv6:

        header = struct.pack('BbHHh', ICMP_TYPE_IP6, ICMP_CODE, checksum, \

                             ICMP_ID, ICMP_SEQ_NR+id)

    else:

        header = struct.pack('bbHHh', ICMP_TYPE, ICMP_CODE, checksum, ICMP_ID, \

                             ICMP_SEQ_NR+id)



    # ping packet *with* checksum

    packet = header + data 



    # a perfectly formatted ICMP echo packet

    return packet



def _in_cksum(packet):

    """THE RFC792 states: 'The 16 bit one's complement of

    the one's complement sum of all 16 bit words in the header.'



    Generates a checksum of a (ICMP) packet. Based on in_chksum found

    in ping.c on FreeBSD.

    """



    # add byte if not dividable by 2

    if len(packet) & 1:              

        packet = packet + '\0'



    # split into 16-bit word and insert into a binary array

    words = array.array('h', packet) 

    sum = 0



    # perform ones complement arithmetic on 16-bit words

    for word in words:

        sum += (word & 0xffff) 



    hi = sum >;>; 16 

    lo = sum & 0xffff 

    sum = hi + lo

    sum = sum + (sum >;>; 16)

    

    return (~sum) & 0xffff # return ones complement



def pingNode(alive=0, timeout=1.0, ipv6=0, number=sys.maxint, node=None, \

             flood=0, size=ICMP_DATA_STR):

    """Pings a node based on input given to the function.

    """



    # if no node, exit

    if not node:

        _error("")



    # if not a valid host, exit

    if ipv6:

        if socket.has_ipv6:

            try:

                info, port = socket.getaddrinfo(node, None)

                host = info[4][0]

                # do not print ipv6 twice if ipv6 address given as node

                if host == node: 

                    noPrintIPv6adr = 1

            except:

                _error("cannot resolve %s: Unknow host" % node)

        else:

            _error("No support for IPv6 on this plattform")

    else:    # IPv4

        try:

            host = socket.gethostbyname(node)

        except:

            _error("cannot resolve %s: Unknow host" % node)



    # trying to ping a network?

    if not ipv6:

        if int(string.split(host, ".")[-1]) == 0:

            _error("no support for network ping")



    # do some sanity check

    if number == 0:

        _error("invalid count of packets to transmit: '%s'" % str(a))

    if alive:

        number = 1



    # Send the ping(s)

    start = 1; mint = 999; maxt = 0.0; avg = 0.0

    lost = 0; tsum = 0.0; tsumsq = 0.0



    # tell the user what we do

    if not alive:

        if ipv6:

            # do not print the ipv6 twice if ip adress given as node

            # (it can be to long in term window)

            if noPrintIPv6adr == 1:

                # add 40 (header) + 8 (icmp header) + payload

                print "PING %s : %d data bytes (40+8+%d)" % (str(node), \

                                                             40+8+size, size)

            else:

                # add 40 (header) + 8 (icmp header) + payload

                print "PING %s (%s): %d data bytes (40+8+%d)" % (str(node), \

                                                                 str(host), 40+8+size, size)

        else:

            # add 20 (header) + 8 (icmp header) + payload

            print "PING %s (%s): %d data bytes (20+8+%d)" % (str(node), str(host), \

                                                             20+8+size, size)

        

    # trap ctrl-d and ctrl-c

    try:

        

        # send the number of ping packets as given

        while start <= number:

            lost += 1 # in case user hit ctrl-c

            

            # create the IPv6/IPv4 socket

            if ipv6:

                # can not create a raw socket if not root or setuid to root

                try:

                    pingSocket = socket.socket(socket.AF_INET6, socket.SOCK_RAW, \

                                               socket.getprotobyname("ipv6-icmp"))

                except socket.error, e:

                    print "socket error: %s" % e

                    _error("You must be root (uses raw sockets)" % os.path.basename(sys.argv[0]))

                    

            # IPv4

            else:

                # can not create a raw socket if not root or setuid to root

                try:

                    pingSocket = socket.socket(socket.AF_INET, socket.SOCK_RAW, \

                                               socket.getprotobyname("icmp"))

                except socket.error, e:

                    print "socket error: %s" % e

                    _error("You must be root (%s uses raw sockets)" % os.path.basename(sys.argv[0]))

                

            packet = _construct(start, size, ipv6) # make a ping packet



            # send the ping

            try:

                pingSocket.sendto(packet,(node,1))

            except socket.error, e:

                _error("socket error: %s" % e)



            # reset values

            pong = ""; iwtd = []



            # wait until there is data in the socket

            while 1:

                # input, output, exceptional conditions

                iwtd, owtd, ewtd = select.select([pingSocket], [], [], timeout)

                break # no data and timout occurred 



            # data on socket - this means we have an answer

            if iwtd:  # ok, data on socket

                endtime = time.time()  # time packet received

                # read data (we only need the header)

                pong, address = pingSocket.recvfrom(size+48)

                lost -= 1 # in case user hit ctrl-c



                # examine packet

                # fetch TTL from IP header

                if ipv6:

                    # since IPv6 header and any extension header are never passed

                    # to a raw socket, we can *not* get hoplimit field..

                    # I hoped that a socket option would help, but it's not

                    # supported:

                    #   pingSocket.setsockopt(IPPROTO_IPV6, IPV6_RECVHOPLIMIT, 1)

                    # so we can't fetch hoplimit..



                    # fetch hoplimit

                    #rawPongHop = struct.unpack("c", pong[7])[0]



                    # fetch pong header

                    pongHeader = pong[0:8]

                    pongType, pongCode, pongChksum, pongID, pongSeqnr = \

                              struct.unpack("bbHHh", pongHeader)



                    # fetch starttime from pong

                    starttime = struct.unpack("d", pong[8:16])[0]



                # IPv4

                else:

                    # time to live

                    rawPongHop = struct.unpack("s", pong[8])[0]



                    # convert TTL from 8 bit to 16 bit integer

                    pongHop = int(binascii.hexlify(str(rawPongHop)), 16)



                    # fetch pong header

                    pongHeader = pong[20:28]

                    pongType, pongCode, pongChksum, pongID, pongSeqnr = \

                              struct.unpack("bbHHh", pongHeader)



                    # fetch starttime from pong

                    starttime = struct.unpack("d", pong[28:36])[0]



                # valid ping packet received?

                if not pongSeqnr == start:

                    pong = None



            # NO data on socket - timeout waiting for answer

            if not pong:

                if alive:

                    print "no reply from %s (%s)" % (str(node), str(host))

                else:

                    print "ping timeout: %s (icmp_seq=%d) " % (host, start)



                # do not wait if just sending one packet

                if number != 1 and start < number:

                    time.sleep(flood ^ 1)

                start += 1

                continue  # lost a packet - try again



            triptime  = endtime - starttime # compute RRT

            tsum     += triptime            # triptime for all packets (stddev)

            tsumsq   += triptime * triptime # triptime^2  for all packets (stddev)



            # compute statistic

            maxt = max ((triptime, maxt))

            mint = min ((triptime, mint))



            if alive:

                print str(node) + " (" + str(host) +") is alive"

            else:

                if ipv6:

                    # size + 8 = payload + header

                    print "%d bytes from %s: icmp_seq=%d time=%.5f ms" % \

                          (size+8, host, pongSeqnr, triptime*1000)

                else:

                    print "%d bytes from %s: icmp_seq=%d ttl=%s time=%.5f ms" % \

                          (size+8, host, pongSeqnr, pongHop, triptime*1000)



            # do not wait if just sending one packet

            if number != 1 and start < number:

                # if flood = 1; do not sleep - just ping                

                time.sleep(flood ^ 1) # wait before send new packet



            # the last thing to do is update the counter - else the value

            # (can) get wrong when computing summary at the end (if user

            # hit ctrl-c when pinging)

            start += 1

            # end ping send/recv while



    # if user ctrl-d or ctrl-c

    except (EOFError, KeyboardInterrupt):

        # if user disrupts ping, it is most likly done before

        # the counter get updates - if do not update it here, the

        # summary get all wrong.

        start += 1

        pass



    # compute and print som stats

    # stddev computation based on ping.c from FreeBSD

    if start != 0 or lost >; 0:  # do not print stats if 0 packet sent

        start -= 1              # since while is '<='

        avg = tsum / start      # avg round trip

        vari = tsumsq / start - avg * avg 

        # %-packet lost

        if start == lost:

            plost = 100

        else:

            plost = (lost/start)*100



        if not alive:

            print "\n--- %s ping statistics ---" % node

            print "%d packets transmitted, %d packets received, %d%% packet loss" % \

                  (start, start-lost, plost)

            # don't display summary if 100% packet-loss

            if plost != 100:

                print "round-trip min/avg/max/stddev = %.3f/%.3f/%.3f/%.3f ms" % \

                      (mint*1000, (tsum/start)*1000, maxt*1000, math.sqrt(vari)*1000)



    pingSocket.close()

    

def _error(err):

    """Exit if running standalone, else raise an exception

    """



    if __name__ == '__main__':

        print "%s: %s" % (os.path.basename(sys.argv[0]), str(err))

        print "Try `%s --help' for more information." % os.path.basename(sys.argv[0])

        sys.exit(1)

    else:

        raise Exception, str(err)

    

def _usage():

    """Print usage if run as a standalone program

    """

    print """usage: %s [OPTIONS] HOST

Send ICMP ECHO_REQUEST packets to network hosts.



Mandatory arguments to long options are mandatory for short options too.

  -c, --count=N    Stop after sending (and receiving) 'N' ECHO_RESPONSE

                   packets.

  -s, --size=S     Specify the number of data bytes to be sent. The default

                   is 56, which translates into 64 ICMP data bytes when

                   combined with the 8 bytes of ICMP header data.

  -f, --flood      Flood ping. Outputs packets as fast as they come back. Use

                   with caution!

  -6, --ipv6       Ping using IPv6.

  -t, --timeout=s  Specify a timeout, in seconds, before a ping packet is

                   considered 'lost'.

  -h, --help       Display this help and exit



Report bugs to lars [at] gnist org""" % os.path.basename(sys.argv[0])





if __name__ == '__main__':

    """Main loop

    """



    # version control

    version = string.split(string.split(sys.version)[0][:3], ".")

    if map(int, version) < [2, 3]:

        _error("You need Python ver 2.3 or higher to run!")



    try:

        # opts = arguments recognized,

        # args = arguments NOT recognized (leftovers)

        opts, args = getopt.getopt(sys.argv[1:-1], "hat:6c:fs:", \

                                   ["help", "alive", "timeout=", "ipv6", \

                                    "count=", "flood", "packetsize="])

    except getopt.GetoptError:

        # print help information and exit:

        _error("illegal option(s) -- " + str(sys.argv[1:]))



    # test whether any host given

    if len(sys.argv) >;= 2:

        node = sys.argv[-1:][0]   # host to be pinged

        if node[0] == '-' or node == '-h' or node == '--help' :  

            _usage()

    else:

        _error("No arguments given")



    if args:

        _error("illegal option -- %s" % str(args))

        

    # default variables

    alive = 0; timeout = 1.0; ipv6 = 0; count = sys.maxint;

    flood = 0; size = ICMP_DATA_STR



    # run through arguments and set variables

    for o, a in opts:

        if o == "-h" or o == "--help":    # display help and exit

            _usage()

            sys.exit(0)

        if o == "-t" or o == "--timeout": # timeout before "lost"

            try:

                timeout = float(a)

            except:

                _error("invalid timout: '%s'" % str(a))

        if o == "-6" or o == "--ipv6":    # ping ipv6

            ipv6 = 1

        if o == "-c" or o == "--count":   # how many pings?

            try:

                count = int(a)

            except:

                _error("invalid count of packets to transmit: '%s'" % str(a))

        if o == "-f" or o == "--flood":   # no delay between ping send

            flood = 1

        if o == "-s" or o == "--packetsize":  # set the ping payload size

            try:

                size = int(a)

            except:

                _error("invalid packet size: '%s'" % str(a))

        # just send one packet and say "it's alive"

        if o == "-a" or o == "--alive":   

            alive = 1



    # here we send

    pingNode(alive=alive, timeout=timeout, ipv6=ipv6, number=count, \

             node=node, flood=flood, size=size)

    # if we made it this far, do a clean exit

    sys.exit(0)



### end