def recv(self):
"""Receive a packet at the Enqueue layer, performing reassemble of
fragmented packets if necessary.
:return: received :class:`SAPEnqueue` packet
:rtype: :class:`SAPEnqueue`
:raise socket.error: if the connection was close
"""
# Receive the NI packet
packet = SAPNIStreamSocket.recv(self)
if SAPEnqueue in packet and packet[SAPEnqueue].more_frags:
log_sapenqueue.debug("Received Enqueue fragmented packet")
head = str(packet[SAPEnqueue])[:20]
data = str(packet[SAPEnqueue])[20:]
total_length = packet[SAPEnqueue].len - 20
recvd_length = len(packet[SAPEnqueue]) - 20
log_sapenqueue.debug("Received %d up to %d bytes", recvd_length,
total_length)
while (recvd_length < total_length
and packet[SAPEnqueue].more_frags == 1):
response = SAPNIStreamSocket.recv(self)[SAPEnqueue]
data += str(response)[20:]
recvd_length += len(response) - 20
log_sapenqueue.debug("Received %d up to %d bytes",
recvd_length, total_length)
packet = SAPEnqueue(head + data)
return packet
def recv(self):
"""Receive a packet at the Enqueue layer, performing reassemble of
fragmented packets if necessary.
:return: received :class:`SAPEnqueue` packet
:rtype: :class:`SAPEnqueue`
:raise socket.error: if the connection was close
"""
# Receive the NI packet
packet = SAPNIStreamSocket.recv(self)
if SAPEnqueue in packet and packet[SAPEnqueue].more_frags:
log_sapenqueue.debug("Received Enqueue fragmented packet")
head = str(packet[SAPEnqueue])[:20]
data = str(packet[SAPEnqueue])[20:]
total_length = packet[SAPEnqueue].len - 20
recvd_length = len(packet[SAPEnqueue]) - 20
log_sapenqueue.debug("Received %d up to %d bytes", recvd_length, total_length)
while recvd_length < total_length and packet[SAPEnqueue].more_frags == 1:
response = SAPNIStreamSocket.recv(self)[SAPEnqueue]
data += str(response)[20:]
recvd_length += len(response) - 20
log_sapenqueue.debug("Received %d up to %d bytes", recvd_length, total_length)
packet = SAPEnqueue(head + data)
return packet
def recv(self):
"""Receive a packet from the target host. If the talk mode in use is
native and we've already set the route, the packet received is a raw
packet. Otherwise, the packet received is a NI layer packet in the same
way the :class:`SAPNIStreamSocket` works.
"""
# If we're working on native mode and the route was accepted, we don't
# need the NI layer anymore. Just use the plain socket inside the
# NIStreamSockets.
if self.routed and self.talk_mode == 1:
return StreamSocket.recv(self)
# If the route was not accepted yet or we're working on non-native talk
# mode, we need the NI layer.
return SAPNIStreamSocket.recv(self)
def recv(self):
"""Receive a packet from the target host. If the talk mode in use is
native and we've already set the route, the packet received is a raw
packet. Otherwise, the packet received is a NI layer packet in the same
way the :class:`SAPNIStreamSocket` works.
"""
# If we're working on native mode and the route was accepted, we don't
# need the NI layer anymore. Just use the plain socket inside the
# NIStreamSockets.
if self.routed and self.talk_mode == 1:
return StreamSocket.recv(self)
# If the route was not accepted yet or we're working on non-native talk
# mode, we need the NI layer.
return SAPNIStreamSocket.recv(self)
def server_mode(options):
""""Implements the niping server running mode
:param options: option set from the command line
:type options: Values
"""
if not options.host:
options.host = "0.0.0.0"
sock = socket()
try:
sock.bind((options.host, options.port))
sock.listen(0)
logging.info("")
logging.info(datetime.today().ctime())
logging.info("ready for connect from client ...")
while True:
sc, sockname = sock.accept()
client = SAPNIStreamSocket(sc)
logging.info("")
logging.info(datetime.today().ctime())
logging.info("connect from host '{}', client hdl {} o.k.".format(
sockname[0], client.fileno()))
try:
while True:
r = client.recv()
client.send(r.payload)
except SocketError:
pass
finally:
logging.info("")
logging.info(datetime.today().ctime())
logging.info("client hdl {} disconnected ...".format(
client.fileno()))
except SocketError:
logging.error("[*] Connection error")
except KeyboardInterrupt:
logging.error("[*] Cancelled by the user")
finally:
sock.shutdown(SHUT_RDWR)
sock.close()
def server_mode(options):
""""Implements the niping server running mode
:param options: option set from the command line
:type options: Values
"""
if not options.host:
options.host = "0.0.0.0"
sock = socket()
try:
sock.bind((options.host, options.port))
sock.listen(0)
print("")
print(datetime.today().ctime())
print("ready for connect from client ...")
while True:
sc, sockname = sock.accept()
client = SAPNIStreamSocket(sc)
print("")
print(datetime.today().ctime())
print("connect from host '{}', client hdl {} o.k.".format(sockname[0], client.fileno()))
try:
while True:
r = client.recv()
client.send(r.payload)
except SocketError:
pass
finally:
print("")
print(datetime.today().ctime())
print("client hdl {} disconnected ...".format(client.fileno()))
except SocketError:
print("[*] Connection error")
except KeyboardInterrupt:
print("[*] Cancelled by the user")
finally:
sock.shutdown(SHUT_RDWR)
sock.close()
class PySAPNIStreamSocketTest(PySAPBaseServerTest):
test_port = 8005
test_address = "127.0.0.1"
test_string = "TEST" * 10
def test_sapnistreamsocket(self):
"""Test SAPNIStreamSocket"""
self.start_server(self.test_address, self.test_port, SAPNITestHandler)
sock = socket.socket()
sock.connect((self.test_address, self.test_port))
self.client = SAPNIStreamSocket(sock)
packet = self.client.sr(Raw(self.test_string))
packet.decode_payload_as(Raw)
self.client.close()
self.assertIn(SAPNI, packet)
self.assertEqual(packet[SAPNI].length, len(self.test_string))
self.assertEqual(packet.payload.load, self.test_string)
self.stop_server()
def test_sapnistreamsocket_base_cls(self):
"""Test SAPNIStreamSocket handling of custom base packet classes"""
self.start_server(self.test_address, self.test_port, SAPNITestHandler)
class SomeClass(Packet):
fields_desc = [StrField("text", None)]
sock = socket.socket()
sock.connect((self.test_address, self.test_port))
self.client = SAPNIStreamSocket(sock, base_cls=SomeClass)
packet = self.client.sr(Raw(self.test_string))
self.client.close()
self.assertIn(SAPNI, packet)
self.assertIn(SomeClass, packet)
self.assertEqual(packet[SAPNI].length, len(self.test_string))
self.assertEqual(packet[SomeClass].text, self.test_string)
self.stop_server()
def test_sapnistreamsocket_getnisocket(self):
"""Test SAPNIStreamSocket get nisocket class method"""
self.start_server(self.test_address, self.test_port, SAPNITestHandler)
self.client = SAPNIStreamSocket.get_nisocket(self.test_address,
self.test_port)
packet = self.client.sr(Raw(self.test_string))
packet.decode_payload_as(Raw)
self.client.close()
self.assertIn(SAPNI, packet)
self.assertEqual(packet[SAPNI].length, len(self.test_string))
self.assertEqual(packet.payload.load, self.test_string)
self.stop_server()
def test_sapnistreamsocket_without_keep_alive(self):
"""Test SAPNIStreamSocket without keep alive"""
self.start_server(self.test_address, self.test_port,
SAPNITestHandlerKeepAlive)
sock = socket.socket()
sock.connect((self.test_address, self.test_port))
self.client = SAPNIStreamSocket(sock, keep_alive=False)
packet = self.client.sr(Raw(self.test_string))
packet.decode_payload_as(Raw)
# We should receive our packet first
self.assertIn(SAPNI, packet)
self.assertEqual(packet[SAPNI].length, len(self.test_string))
self.assertEqual(packet.payload.load, self.test_string)
# Then we should get a we should receive a PING
packet = self.client.recv()
self.assertIn(SAPNI, packet)
self.assertEqual(packet[SAPNI].length, len(SAPNI.SAPNI_PING))
self.assertEqual(packet.payload.load, SAPNI.SAPNI_PING)
self.client.close()
self.stop_server()
def test_sapnistreamsocket_with_keep_alive(self):
"""Test SAPNIStreamSocket with keep alive"""
self.start_server(self.test_address, self.test_port,
SAPNITestHandlerKeepAlive)
sock = socket.socket()
sock.connect((self.test_address, self.test_port))
self.client = SAPNIStreamSocket(sock, keep_alive=True)
self.client.send(Raw(self.test_string))
packet = self.client.recv()
packet.decode_payload_as(Raw)
# We should receive our packet first
self.assertIn(SAPNI, packet)
self.assertEqual(packet[SAPNI].length, len(self.test_string))
self.assertEqual(packet.payload.load, self.test_string)
# Then we should get a connection reset if we try to receive from the server
self.assertRaises(socket.error, self.client.recv)
self.client.close()
self.stop_server()
def test_sapnistreamsocket_close(self):
"""Test SAPNIStreamSocket with a server that closes the connection"""
self.start_server(self.test_address, self.test_port,
SAPNITestHandlerClose)
sock = socket.socket()
sock.connect((self.test_address, self.test_port))
self.client = SAPNIStreamSocket(sock, keep_alive=False)
with self.assertRaises(socket.error):
self.client.sr(Raw(self.test_string))
self.stop_server()
