示例#1
0
    def __init__(self,
                 ip="127.0.0.1",
                 port="80",
                 snapshot="/?action=snapshot",
                 rootfolder=os.path.join("web", "timelapse"),
                 singlepicfolder=os.path.join("web", "timelapse", "general"),
                 interval=5):
        self._timer = None
        self.interval = interval

        self.is_running = False
        self.piccounter = 1

        self.rootfolder = rootfolder
        self.tlfolder = ""
        self.tlfolder_full = ""

        self.singlepicfolder = singlepicfolder

        if not os.path.exists(self.singlepicfolder):
            os.makedirs(self.singlepicfolder)
            helpers.fix_ownership(self.singlepicfolder)

        self.urlsnapshot = "/?action=snapshot"
        self.ip = ip
        self.port = str(port)
        self.cmd_snapshot = "http://" + self.ip + ":" + self.port + self.urlsnapshot
        self.cmd_ipport = "http://" + self.ip + ":" + self.port + "/"

        self.connected = False
        self.pygamesurface = None
示例#2
0
 def grab_jpg_tl(self):
     img_temp = "tl" + str(self.piccounter).zfill(5) + ".jpg"
     urllib.urlretrieve(
         self.cmd_snapshot,
         os.path.join(self.rootfolder, self.tlfolder, img_temp))
     print "TL Saved:" + img_temp
     helpers.fix_ownership(
         os.path.join(self.rootfolder, self.tlfolder, img_temp))
     self.piccounter = self.piccounter + 1
示例#3
0
    def TakeScreenShot(self, filename=""):

        #check again if folder exists...
        if not os.path.exists(self.singlepicfolder):
            os.makedirs(self.singlepicfolder)
            helpers.fix_ownership(self.singlepicfolder)

        if filename == "":
            img_temp = self.createDTFile() + ".jpg"
        else:
            img_temp = filename

        urllib.urlretrieve(self.cmd_snapshot,
                           os.path.join(self.singlepicfolder, img_temp))
        helpers.fix_ownership(os.path.join(self.singlepicfolder, img_temp))
        return img_temp
示例#4
0
    def setCurrentTLFolder(self, setfoldername):
        if setfoldername == "":
            self.tlfolder = self.createDTfolder()
        else:
            self.tlfolder = setfoldername

        fullpath = os.path.join(self.rootfolder, self.tlfolder)

        if os.path.exists(fullpath):
            fullpath = os.path.join(self.rootfolder,
                                    self.tlfolder + self.createDTfolder())
            os.makedirs(fullpath)
            helpers.fix_ownership(fullpath)
            self.tlfolder = self.tlfolder + self.createDTfolder()
        else:
            os.makedirs(fullpath)
            helpers.fix_ownership(fullpath)

        self.tlfolder_full = fullpath
示例#5
0
def capture_packets():
    '''
    This page:
    http://www.binarytides.com/python-packet-sniffer-code-linux/
    significantly helped me get with handling raw packets, and has more details
    ---------------------
    create a AF_PACKET type raw socket (thats basically packet level)
    define ETH_P_ALL    0x0003          /* Every packet (be careful!!!) */
    '''
    try:
        s = socket.socket(socket.AF_PACKET, socket.SOCK_RAW,
                          socket.ntohs(0x0003))
        s.settimeout(5)  # force the loop to spin with a timeout
    except socket.error as msg:
        print 'Socket could not be created. Error Code : ' + str(
            msg[0]) + ' Message ' + msg[1]
        sys.exit()

    tvals = list()
    lastarr = 0.0
    # receive a packet
    while True:
        arr_time = time.time()
        # don't dump unless you're not currently serving
        if dump_time - arr_time <= 0 and arr_time - lastarr >= 5:
            print "dumping..."
            if len(tvals) > 0:
                fname = packetsdir + str(arr_time) + "_packets.json"
                with open(fname, "w+") as f:
                    json.dump(tvals, f)
                fix_ownership(fname)
                datadict = {'post_handler': 'save_packet_data', 'data': tvals}
                sendstr(datahost, dataport, json.dumps(datadict))
                tvals = list()
            update_dump_time()
            print "dumped!"
        else:
            try:
                packet = s.recvfrom(65565)
            except socket.timeout:
                continue

            #packet string from tuple
            packet = packet[0]

            #parse ethernet header
            eth_length = 14

            eth_header = packet[:eth_length]
            eth = struct.unpack('!6s6sH', eth_header)
            eth_protocol = socket.ntohs(eth[2])

            #Parse IP packets, IP Protocol number = 8
            if eth_protocol == 8:
                #Parse IP header
                #take first 20 characters for the ip header
                ip_header = packet[eth_length:20 + eth_length]

                #now unpack them :)
                iph = struct.unpack('!BBHHHBBH4s4s', ip_header)

                version_ihl = iph[0]
                version = version_ihl >> 4
                ihl = version_ihl & 0xF

                iph_length = ihl * 4

                ttl = iph[5]
                protocol = iph[6]
                pdat = dict()
                pdat['s_ip'] = socket.inet_ntoa(iph[8])
                pdat['d_ip'] = socket.inet_ntoa(iph[9])

                #TCP protocol
                if protocol == 6:
                    t = iph_length + eth_length
                    tcp_header = packet[t:t + 20]

                    #now unpack them :)
                    tcph = struct.unpack('!HHLLBBHHH', tcp_header)
                    pdat['s_port'] = tcph[0]
                    pdat['d_port'] = tcph[1]
                    pdat['seq'] = tcph[2]
                    pdat['ack'] = tcph[3]
                    pdat['flags'] = tcph[5]
                    pdat['cwnd'] = tcph[6]
                    pdat['time'] = arr_time
                    if (pdat['s_ip'] == myip and pdat['s_port'] in myports) or \
                            (pdat['d_ip'] == myip and pdat['d_port'] in myports):
                        print "adding to tvals..."
                        tvals.append(pdat)
                        lastarr = arr_time