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!"
