def data_received(self, data):
self._deserializer.update(data)
for packet in self._deserializer.nextPackets():
if self.logging:
print()
if self.transport == None:
continue
# Do checksum verification first!
if (packet.verifyChecksum() == False):
if self.logging:
print("PEEP Client side: checksum is bad")
self.state = "error_state"
else: # checksum is good, now we look into the packet
if self.logging:
print("PEEP Client side: checksum is good")
if packet.Type == 1: # incoming an SYN-ACK handshake packet
if self.state != "SYN_ACK_State_1":
if self.logging:
print(
"PEEP Client Side: Error: State Error! Expecting SYN_ACK_State but getting %s"
% self.state)
self.state = "error_state"
else:
outBoundPacket = Util.create_outbound_packet(
2, packet.Acknowledgement + 1,
packet.SequenceNumber + 1)
if self.logging:
print(
"PEEP Client Side: SYN-ACK reveived: Seq = %d, Ack = %d, Checksum = (%d)"
% (packet.SequenceNumber,
packet.Acknowledgement, packet.Checksum))
print(
"PEEP Client Side: ACK sent: Seq = %d, Ack = %d, Checksum = (%d)"
% (outBoundPacket.SequenceNumber,
outBoundPacket.Acknowledgement,
outBoundPacket.Checksum))
packetBytes = outBoundPacket.__serialize__()
self.state = "Transmission_State_2"
self.transport.write(packetBytes)
if self.logging:
print(
"PEEP Client Side: ### THREE-WAY HANDSHAKE established ###"
)
print()
higherTransport = StackingTransport(self.transport)
self.higherProtocol().connection_made(higherTransport)
else:
if self.logging:
print(
"PEEP Client Side: Error: Unrecognize HandShake Type received!"
)
self.state = "error_state"
if self.transport == None:
continue
if self.state == "error_state":
self.transport.close()
def connection_made(self, transport):
print('Pass Through 2 connection made')
peername = transport.get_extra_info('peername')
print('Connection from {}'.format(peername))
self.transport = transport
higherTransport = StackingTransport(self.transport)
self.higherProtocol().connection_made(higherTransport)
def connection_made(self, transport):
self.transport = transport
print(
"PassThroughLayer2: connection_made called, sending higher transport to ClientDemo"
)
higherTransport = StackingTransport(self.transport)
self.higherProtocol().connection_made(higherTransport)
def connection_made(self, transport):
print('passthrough1')
self.transport = transport
higherTransport1 = StackingTransport(self.transport)
try:
self.higherProtocol().connection_made(higherTransport1)
except Exception as e:
print('failed', e)
def setPlaygroundConnectionInfo(self, application, source, sourcePort, destination, destinationPort):
nextTransport = StackingTransport(self.transport, {"sockname":(source, sourcePort),
"peername":(destination, destinationPort)})
p = self
while p.higherProtocol():
p = p.higherProtocol()
p.setHigherProtocol(application)
self.higherProtocol().connection_made(nextTransport)
self._higherConnectionMade = True
while self._backlog:
self.higherProtocol().data_received(self._backlog.pop(0))
def setPlaygroundConnectionInfo(self, application, source, sourcePort,
destination, destinationPort):
nextTransport = StackingTransport(
self.transport, {
"sockname": (source, sourcePort),
"peername": (destination, destinationPort)
})
p = self
while p.higherProtocol():
p = p.higherProtocol()
p.setHigherProtocol(application)
self.higherProtocol().connection_made(nextTransport)
def data_received(self, data):
self.deserializer.update(data)
for pkt in self.deserializer.nextPackets():
if pkt.Type == 0:
print("SYN Packet Received")
print("Type= {} SequenceNumber = {} Checksum = {}".format(
pkt.Type, pkt.SequenceNumber, pkt.Checksum))
oldChecksum = pkt.Checksum
pkt.Checksum = 0
bytes = pkt.__serialize__()
self.Checksum = oldChecksum
verify = zlib.adler32(bytes) & 0xffff
if verify == oldChecksum:
print("SYN Packet Verified")
pack = PEEPPacket()
pack.Type = 1
pack.Acknowledgement = pkt.SequenceNumber + 1
pack.SequenceNumber = random.randrange(10)
pack.Checksum = 0
packet4Bytes = pack.__serialize__()
pack.Checksum = calculateChecksum(packet4Bytes)
packet4Bytes = pack.__serialize__()
print(
"Type= {} Acknowledgment = {} SequenceNumber = {} Checksum = {}"
.format(pack.Type, pack.Acknowledgement,
pack.SequenceNumber, pack.Checksum))
self.transport.write(packet4Bytes)
print("SYN-ACK Packet Sent")
else:
connection_lost(self)
elif pkt.Type == 2:
print("ACK Packet Received")
print(
"Type= {} Acknowledgment = {} SequenceNumber = {} Checksum = {}"
.format(pkt.Type, pkt.Acknowledgement, pkt.SequenceNumber,
pkt.Checksum))
oldChecksum = pkt.Checksum
pkt.Checksum = 0
bytes = pkt.__serialize__()
self.Checksum = oldChecksum
verify = zlib.adler32(bytes) & 0xffff
if verify == oldChecksum:
print("ACK Packet Verified")
peeptransport = PeepServerTransport(self, self.transport)
higherTransport = StackingTransport(peeptransport)
self.higherProtocol().connection_made(higherTransport)
else:
connection_lost(self)
else:
connection_lost(self)
def setPlaygroundConnectionInfo(self, stack, application, source, sourcePort, destination, destinationPort):
self.setHigherProtocol(stack)
nextTransport = StackingTransport(self.transport, {"sockname":(source, sourcePort),
"peername":(destination, destinationPort),
"spawnport":self._spawnPort})
p = self
while p.higherProtocol():
p = p.higherProtocol()
p.setHigherProtocol(application)
logger.debug("Creating tranport for higher protocol {} with spawnport {}".format(self.higherProtocol(), self._spawnPort))
self.higherProtocol().connection_made(nextTransport)
self._higherConnectionMade = True
while self._backlog:
self.higherProtocol().data_received(self._backlog.pop(0))
def connection_made(self, transport):
print("1 connection made")
trans = StackingTransport(transport)
self.higherProtocol().connection_made(trans)
def connection_made(self, transport):
self.transport = transport
print('1:Start Call Connection')
self.higherProtocol().connection_made(StackingTransport(
self.transport))
def connection_made(self, transport):
self.transport = transport
print("Layer 2 connected")
higherTransport = StackingTransport(self.transport)
self.higherProtocol().connection_made(higherTransport)
def connection_made(self, transport):
self.transport = transport
print("PassThroughLayer1 connection made")
self.higherProtocol().connection_made(StackingTransport(
self.transport))
def connection_made(self, transport):
print("Pass through 2 - connection made")
self.transport = transport
higherTransport = StackingTransport(self.transport)
self.higherProtocol().connection_made(higherTransport)
def connection_made(self, transport):
print('passthrough2')
self.transport = transport
higherTransport2 = StackingTransport(self.transport)
self.higherProtocol().connection_made(higherTransport2)
def connection_made(self, transport):
print("HigherPassThrough--connection_made")
self.transport = transport
highertransport = StackingTransport(transport)
self.higherProtocol().connection_made(highertransport)
def connection_made(self, transport):
self.transport = transport
higherTransport = StackingTransport(self.transport)
self.higherProtocol().connection_made(higherTransport)
print("passthroughlayer2 connection_made success")
def connection_made(self, transport):
if self.logging:
print("[Pass Through Protocol]: Connection Made...")
self.transport = transport
higherTransport = StackingTransport(self.transport)
self.higherProtocol().connection_made(higherTransport)
def connection_made(self, transport):
#self.setHigherProtocol(PassThroughServer1)
self.transport = transport
higherTransport = StackingTransport(self.transport)
print("passthrough2 connection_made")
self.higherProtocol().connection_made(higherTransport)
def connection_made(self, transport):
logger.debug(
"{} passthrough connection made. Calling connection made higher.".
format(self._mode))
higher_transport = StackingTransport(transport)
self.higherProtocol().connection_made(higher_transport)
def data_received(self, buffer):
logger.debug("{} passthrough received a buffer of size {}".format(
self._mode, len(buffer)))
#own code
print("data_received begin")
#variable protocol is used to identify whether the connection between client and server is built
#when protocol ==0, transport handshake_packet
#else, transport packetType_packet
if self.protocol == 0:
self.deserializer = HandshakePacket.Deserializer()
else:
self.deserializer = PacketType.Deserializer()
#self.buffer.update(buffer)
self.deserializer.update(buffer)
for packet in self.deserializer.nextPackets():
if self._mode == "server":
print("ohttttt", packet)
if isinstance(packet, HandshakePacket):
#Secondly, if server receive a packet(status = 0), it send modify SYN to SYN+1, and send
#server also sets ACK to 0, and status SUCCESS(1)
if packet.status == 0:
server_packet = HandshakePacket()
server_packet.SYN = packet.SYN + 1
server_packet.ACK = 0
server_packet.status = 1
self.transport.write(server_packet.__serialize__())
print("second success")
#Fourthly, the server checks if ACK is 1
#if right, the server acknowledges this connection, sets protocol to 1
#and set up a higher layer transport
#if wrong, sends error
elif packet.ACK == 1:
self.protocol = 1
higher_transport = StackingTransport(self.transport)
self.higherProtocol().connection_made(higher_transport)
#self.higherProtocol().data_received(buffer)
self._mode = "higher"
print("fourth success")
else:
server_packet_error = HandshakePacket()
server_packet_error.status = 2
self.transport.write(
server_packet_error.__serialize__())
print("fourth fail")
#Thirdly, the client checks if SYN == SYN+1
#if right, it sends ACK as 1 and status SUCCESS(1), it also set protocol to 1, means
# acknowledge this connection with server and set up a higher layer transport
#if wrong, it sends status ERROR(2)
elif self._mode == "client":
if isinstance(packet, HandshakePacket):
if packet.SYN == self.SYN + 1:
client_packet2 = HandshakePacket()
client_packet2.ACK = 1
client_packet2.status = 1
self.protocol = 1
self.transport.write(client_packet2.__serialize__())
higher_transport = StackingTransport(self.transport)
self.higherProtocol().connection_made(higher_transport)
#self.higherProtocol().data_received(buffer)
self._mode = "higher"
print("third success")
else:
client_packet_error = HandshakePacket()
client_packet_error.status = 2
self.transport.write(
client_packet_error.__serialize__())
print("third fail")
else:
print("higher start")
self.higherProtocol().data_received(buffer)
def connection_made(self, transport):
passThroughPrint("Connection made at 2nd pass-through layer on " +
type(self.higherProtocol()).__name__)
self.transport = transport
higherTransport = StackingTransport(transport)
self.higherProtocol().connection_made(higherTransport)
def connection_made(self, transport):
self.transport = transport
self.higherProtocol().connection_made(StackingTransport(transport))
print("Connection made to Client")
def connection_made(self, transport):
self.transport = transport
print("\nConnection Made to passthrough 2\n")
self.higherProtocol().connection_made(StackingTransport(transport))
def connection_made(self, transport):
print("pass through 1 connection made")
higherTransport = StackingTransport(transport)
self.higherProtocol().connection_made(higherTransport)
def connection_made(self,transport):
print("connection made")
self.transport=transport
higherTransport=StackingTransport(self.transport)
self.higherProtocol().connection_made(higherTransport)
print('PassThrough1 connection is made')
def connection_made(self, transport):
self.transport = transport
print("Client: Passthrough Layer connected")
higherTransport = StackingTransport(self.transport)
self.higherProtocol().connection_made(higherTransport)
def connection_made(self,transport): self.transport = transport highertransport = StackingTransport(self.transport) self.higherProtocol().connection_made(highertransport)
def connection_made(self,transport):
print('stack1:connection made')
self.transport=transport
higherTransport=StackingTransport(self.transport)
self.higherProtocol().connection_made(higherTransport)
