def _on_token(self,sdata): if self._send_frame_type==True: self._send_frame_type=False self._websocket.send_bytes(utils.Bytes(struct.pack("!hh",801,self._frame_type))) tp = struct.unpack("!h",sdata[0:2])[0] self._semaphore.acquire() try: if tp==10: #TOKEN MONITOR AND SUPPORTED FRAME self._monitor_count = struct.unpack("!h",sdata[2:4])[0] elif tp==11: #SUPPORTED FRAME p=2 cnt = struct.unpack("!h",sdata[p:p+2])[0] self._supported_frame=[] for i in range(cnt): p+=2 self._supported_frame.append(struct.unpack("!h",sdata[p:p+2])[0]) elif tp==1: #TOKEN DISTANCE FRAME self._distanceFrameMsCounter.reset() self._distanceFrameMs=struct.unpack("!i",sdata[2:6])[0] sdata=None elif tp==2: #TOKEN FRAME if self._frame_first_token==True: self._frame_first_token=False self._frame_last_time_sent=utils.get_time() if self._frame_last_time_received==0: self._frame_last_time_received=self._frame_last_time_sent self._websocket.send_bytes(utils.Bytes(struct.pack("!h",800)+str(self._frame_last_time_sent))) #print "self._frame_last_time_sent: " + str(self._frame_last_time_sent); if sdata[2]==1: self._frame_first_token=True #DA ELIMINARE RIMASTO PER COMPATIBILITA ln=len(sdata) self._frame_bytes_distance+=ln #DA ELIMINARE RIMASTO PER COMPATIBILITA #print("FRAME size: " + str(len(sdata)) + " last:" + str(sdata[2])) ''' TODO: I WANT AUTODETECT QUALITY self._frame_bytes_distance+=ln if self._frame_sent_first==True: self._frame_sent_first=False self._frame_sent.append({"size": ln, "current": 0, "complete": False, "time":communication.get_time()}) else: appar=self._frame_sent[len(self._frame_sent)-1] appar["size"]=appar["size"]+ln if struct.unpack("!b",sdata[2:3])[0]==1: appar=self._frame_sent[len(self._frame_sent)-1] appar["complete"]=True ''' finally: self._semaphore.release() if sdata is not None: self._websocket.send_bytes(sdata) #DA ELIMINARE RIMASTO PER COMPATIBILITA ln=len(sdata) self._frame_last_bytes_sent+=ln
def read_token(self): bfl = utils.Bytes() while len(bfl) < 4: bf = self.read(maxbyte=4 - len(bfl)) if bf == None: return None bfl.append_bytes(bf) ln = bfl.get_int() bfret = utils.Bytes() while len(bfret) < ln: bf = self.read(maxbyte=ln - len(bfret)) if bf == None: return None bfret.append_bytes(bf) return bfret
def _send_ws_data(self, data): self._semaphore_send.acquire() try: bts = utils.Bytes() b0 = 0 b0 |= 1 << 7 b0 |= 0x2 % 128 length = len(data) if length <= 125: bts.append_byte(b0) bts.append_byte(0x80 | length) elif length <= 0xFFFF: bts.append_byte(b0) bts.append_byte(0xFE) bts.append_byte(length >> 8 & 0xFF) bts.append_byte(length & 0xFF) else: bts.append_byte(b0) bts.append_byte(0xFF) bts.append_int(length) rnd = 0 bts.append_int(rnd) bts.append_bytes(data) if self._sock is None: raise Exception('connection closed.') utils.socket_sendall(self._sock, bts, 0, len(bts)) finally: self._semaphore_send.release()
def write_res_token(self, t, bts): if bts is not None: bts.insert_byte(0,ord(t)) else: bts=utils.Bytes() bts.append_byte(ord(t)) self._sharedmem.write_token(bts)
def run(self): #print "Thread read started: " + str(self._connection) bfireclose = False bconnLost = True sock = self._connection.get_socket() try: while not self._connection.is_shutdown(): data = self._read_fully(sock, 2) if len(data) == 0: bfireclose = not self._connection.is_close() break else: lendt = 0 bt1 = ord(data[1]) if bt1 <= 125: if bt1 > 0: lendt = bt1 else: bt0 = ord(data[0]) if bt0 == 136: #CLOSE bconnLost = False bfireclose = not self._connection.is_close() break elif bt0 == 138: #PONG #print "SESSION - PONG RICEVUTO!" continue else: continue elif bt1 == 126: data = self._read_fully(sock, 2) if len(data) == 0: bfireclose = not self._connection.is_close() break lendt = struct.unpack('!H', data)[0] elif bt1 == 127: data = self._read_fully(sock, 4) if len(data) == 0: bfireclose = not self._connection.is_close() break lendt = struct.unpack('!I', data)[0] #Legge data if lendt > 0: data = self._read_fully(sock, lendt) if len(data) == 0: bfireclose = not self._connection.is_close() break elif lendt == 0: data = "" else: bfireclose = not self._connection.is_close() break self._connection.fire_data(utils.Bytes(data)) except Exception as e: bfireclose = not self._connection.is_close() #traceback.print_exc() self._connection.fire_except(e) self._connection.shutdown() if bfireclose is True: self._connection.fire_close(bconnLost)
def _send_ws_ping(self): if self._sock is None: raise Exception('connection closed.') bts = utils.Bytes() bts.encode_ws_ping() self._lock_send.acquire() try: utils.socket_sendall(self._sock, bts) finally: self._lock_send.release()
def _send_ws_ping(self): self._semaphore_send.acquire() try: bts = utils.Bytes() b0 = 0 b0 |= 1 << 7 b0 |= 0x9 % 128 bts.append_byte(b0) bts.append_byte(0x80 | 0) rnd = 0 #random.randint(0,2147483647) bts.append_int(rnd) if self._sock is None: raise Exception('connection closed.') utils.socket_sendall(self._sock, bts, 0, len(bts)) finally: self._semaphore_send.release()
def write_token(self,s): bts=utils.Bytes(); bts.append_str(s, "utf8") self._sharedmem.write_token(bts)
def run(self): #last_diff_time=long(time.time() * 1000) cnt_retry=0 ##I tentativi servono quando l'utente si disconnette (Es. in windows) #INVIA ID sdataid=struct.pack("!h",900)+self._id; self._websocket.send_bytes(utils.Bytes(sdataid)) lclose=self.is_close() curmon=-1 max_retry=3 quality=9 while not lclose: try: #print("_send_token_image WAIT time=" + str(long(time.time() * 1000)-apptmwait)); self._inputevents() ''' TODO: I WANT AUTODETECT QUALITY self._frame_sent_first=True ''' #last_diff_time=communication.get_time() self._frame_last_bytes_sent=0 self._distanceFrameMsCounter.reset() self._dskmain._capture_process.difference(self,quality,curmon,self._on_token) max_retry=5; #print("_send_token_image _capture_process time=" + str(communication.get_time()-last_diff_time) + " len=" + str(self._frame_last_bytes_sent)); #Wait new request while True: #self._inputevents() self._semaphore.acquire() try: if self._bclose: lclose=True break #print("self._frame_bytes_distance:" + str(self._frame_bytes_distance) + " self._frame_bps_max: " + str(self._frame_bps_max)) min_distance=self._frame_bps_max/2 if self._frame_bytes_distance<=min_distance: appwait=0 if self._slow_mode: appwait=CAPTURE_INTERVALL_SLOW_MODE else: if not self._distanceFrameMsCounter.is_elapsed(self._distanceFrameMs): appwait=float(self._distanceFrameMs-self._distanceFrameMsCounter.get_value()) / 1000.0 #print("SLEEP: " + str(appwait)) if appwait>0: self._semaphore.wait(appwait) #self._inputevents() if self._monitor_count>0: curmon=self._monitor else: curmon=-1 quality=self._quality break #print("WAIT self._frame_bytes_distance:" + str(self._frame_bytes_distance) + " min_distance:" + str(min_distance) + " fps:" + str(fps)) + " bps:" + str(self._frame_bps_tmp_max) self._semaphore.wait(0.2) finally: self._semaphore.release() cnt_retry=0 except Exception as e: if not self.is_close(): if cnt_retry>=max_retry: #NUMERO TENTATITVI try: self._websocket.send_bytes(utils.Bytes(struct.pack("!h",999) + str(e))) #TOKEN MONITOR = 0 NOT DETECTED #self._websocket.send_bytes(struct.pack("!hh",10,0)) except Exception as ex: None self.terminate() lclose=True self._dskmain._agent_main.write_except(e,"Desktop capture error id:" + self._id) else: #token_empty=True cnt_retry+=1 time.sleep(1) self._dskmain._agent_main.write_err("Desktop capture retry " + str(cnt_retry) + " id:" + self._id + " error:" + str(e)) self._dskmain._agent_main.write_debug(str(e) + "\n" + traceback.format_exc()); else: lclose=True if not self.is_close(): self.terminate() self._destroy();
def listen(self,fname,dbgenable): try: self._dbgenable=(dbgenable.upper()=="TRUE") if self._dbgenable==True: self._logger = logging.getLogger() hdlr = logging.handlers.RotatingFileHandler(u'captureprocess.log', 'a', 10000000, 3) formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s') hdlr.setFormatter(formatter) self._logger.addHandler(hdlr) self._logger.setLevel(logging.DEBUG) sys.stdout=CaptureProcessStdRedirect(self._logger,logging.DEBUG); sys.stderr=CaptureProcessStdRedirect(self._logger,logging.ERROR); self._enable_debug() except Exception as ex: self._debug_print(str(ex) + "\n" + traceback.format_exc()); return self._debug_print("Init capture process. (" + fname + ")") listids={} try: self._sharedmem=sharedmem.Stream() self._sharedmem.connect(fname) self._debug_print("Pronto ad accettare richieste") while not self._sharedmem.is_closed(): bts = self.read_token() if bts==None: #self._debug_print("########## Richiesta: NONE") break srequest=bts.to_str('utf8') self._debug_print("Richiesta: " + srequest) ar = srequest.split(":") try: if len(ar)==1 or len(ar)==2: if len(ar)==2: prms=ar[1].split(";") if ar[0]==u"TERMINATE": appid=int(prms[0]); if appid in listids: del listids[appid] self._get_osmodule().term(appid) elif ar[0]==u"DIFFERENCE": appid=int(prms[0]); bps=int(prms[1]); monidx=int(prms[2]); if appid not in listids: self._get_osmodule().init(appid); listids[appid]={"monitor": monidx}; self._get_osmodule().monitor(appid,monidx) elif listids[appid]["monitor"]!=monidx: self._get_osmodule().monitor(appid,monidx) self._get_osmodule().difference(appid,bps,cb_difference) self.write_res_token("T", None) elif ar[0]==u"COPYTEXT": apps = self._copy_text(int(prms[0])) if apps is None: self.write_res_token("T", None) else: bts = utils.Bytes() bts.append_str(base64.b64encode(apps.encode("utf8")), "utf8") self.write_res_token("T", bts) elif ar[0]==u"PASTETEXT": self._paste_text(int(prms[0]),base64.b64decode(prms[1]).decode("utf8")) elif ar[0]==u"MOUSE": self._get_osmodule().inputMouse(int(prms[0]),int(prms[1]), int(prms[2]), int(prms[3]), int(prms[4]), prms[5]=="True", prms[6]=="True",prms[7]=="True") elif ar[0]==u"KEYBOARD": self._get_osmodule().inputKeyboard(int(prms[0]), str(prms[1]), str(prms[2]), prms[3]=="True", prms[4]=="True",prms[5]=="True") else: bts = utils.Bytes() bts.append_str(u"Request '" + srequest + u"' not found.", "utf8") self.write_res_token("E", bts) else: raise Exception(u"Request '" + srequest + u"' is not valid.") except Exception as ex: self._debug_print(traceback.format_exc()); bts = utils.Bytes() bts.append_str(unicode(ex), "utf8") self.write_res_token("E", bts ) except Exception as ex: self._debug_print(traceback.format_exc()); if self._sharedmem is not None: self._sharedmem.close() for appid in listids.keys(): self._get_osmodule().term(appid) self._debug_print("Term capture process.")
def cb_difference(self, sz, pdata): if sz>0: self.write_res_token("K", utils.Bytes(pdata[0:sz]))
def write_token(self, data): dtwrite = utils.Bytes() dtwrite.append_int(len(data)) dtwrite.append_bytes(data) self.write(dtwrite)
def read(self, timeout=0, maxbyte=0): #0 infinite if not self._is_init(): return None self._initlock() pr = self._get_pointer(self._read_pnt_pos) tm = long(time.time() * 1000) self._condition_shared.acquire() try: while True: pw = self._get_pointer(self._read_pnt_pos - 4) if pr != pw: break #VERIFICA CHIUSURA locstate, appstate = self._get_state() if not self._is_init() or appstate == "X" or appstate == "T": self._close() return None self._condition_shared.wait(0.5) #VERIFICA TIMEOUT elapsed = long(time.time() * 1000) - tm if timeout > 0: if elapsed < 0: #Cambiato orario pc tm = long(time.time() * 1000) elif elapsed >= timeout: return "" finally: self._condition_shared.release() dtread = utils.Bytes() self._semaphore.acquire() try: bread = 0 if pw < pr: bfullread = True appsz = self._read_limit - self._read_data_pos - pr if maxbyte > 0 and appsz > maxbyte: appsz = maxbyte bfullread = False rpr = self._read_data_pos + pr self._mmap.seek(rpr) dtread.append_bytes(utils.mmap_read(self._mmap, appsz)) if bfullread: pr = 0 else: pr += appsz bread += appsz if pw > pr: if maxbyte == 0 or bread < maxbyte: bfullread = True appsz = pw - pr if maxbyte > 0 and appsz > maxbyte - bread: appsz = maxbyte - bread bfullread = False rpr = self._read_data_pos + pr self._mmap.seek(rpr) dtread.append_bytes(utils.mmap_read(self._mmap, appsz)) if bfullread: pr = pw else: pr += appsz self._mmap.seek(self._read_pnt_pos) self._mmap.write(struct.pack('!i', pr)) finally: self._semaphore.release() #NOTIFICA IL CAMBIAMENTO self._condition_shared.acquire() self._condition_shared.notify_all() self._condition_shared.release() return dtread
def run(self): num = 1000 m1 = Stream() fname = None if self._fname == None: fname = m1.create() else: m1.connect(self._fname) if self._fname == None: t2 = TestThread(fname) t2.start() try: for i in range(num): #m1.write(utils.Bytes("PROVA" + str(i+1) + " ")) m1.write_token( utils.Bytes(buffer("PROVA" + str(i + 1) + " "))) ''' appars=[] for i in range(1000): #0000): appars.append("PROVA" + str(i+1) + " ") m1.write_token(utils.Bytes(buffer("".join(appars)))) ''' #m1.write(utils.Bytes("END")) #m1.write_token("END") except Exception as e: print("Errore write remote closed: " + str(e)) time.sleep(8) m1.close() else: print "INIZIO..." cnt = 0 tm = utils.get_time() ar = [] while True: #dt=m1.read() dt = m1.read_token() #s=dt.get_string() if dt is None: #time.sleep(8); raise Exception("Errore read remote closed") ar.append(dt) #print(s) #if s[len(s)-3:]=="END": # break cnt += 1 #print(str(cnt)) if num == cnt: break #print("***************") print("TEMPO:" + str(utils.get_time() - tm)) #print("VERIFICA...") #apps = "".join(ar); #ar=apps.split(" "); #bok=True #for i in range(num): # if ar[i]!="PROVA" + str(i+1): # bok=False # print ("ERRORE: " + ar[i] + " (PROVA" + str(i+1) + ")") #if bok: # print "TUTTO OK" #print "FINE" m1.close() print "ATTESA RIMOZIONE FILE..." time.sleep(8) print "VERIFICARE!"