def _handle_request(self, spkt): if spkt.get_payload() != PayloadRaw(self.data): logging.error("Payload verification failed:\n%s", spkt) return False logging.debug('SRV: request received, sending response.') spkt.reverse() spkt.set_payload(PayloadRaw(b"response")) self._send_pkt(spkt) self.success = True self.finished.set() return True
def from_values(cls, cmn_hdr, addr_hdr, path_hdr, payload=None): inst = cls() inst._inner_from_values(cmn_hdr, addr_hdr, path_hdr) if payload is None: payload = PayloadRaw() inst.set_payload(payload) inst.update() return inst
def _handle_request(self, spkt): logging.debug("Received:\n%s", spkt) spkt.reverse() pld = PayloadRaw(("pong %d" % self.count).encode("ascii")) spkt.set_payload(pld) self._send_pkt(spkt) self.count += 1 self.success = True return True
def test(self): inst = SCIONBasePacket() inst.path = "path" inst.cmn_hdr = create_mock(["validate"]) inst.addrs = create_mock(["validate"]) inst._validate_of_idxes = create_mock() inst._payload = PayloadRaw() # Call inst.validate("pkt len") # Tests inst.cmn_hdr.validate.assert_called_once_with("pkt len", 4) inst.addrs.validate.assert_called_once_with() inst._validate_of_idxes.assert_called_once_with()
def _build_packet(self, dst_host=None, path=None, ext_hdrs=(), dst_ia=None, payload=None, dst_port=0): if dst_host is None: dst_host = HostAddrNone() if dst_ia is None: dst_ia = self.addr.isd_as if path is None: path = SCIONPath() if payload is None: payload = PayloadRaw() dst_addr = SCIONAddr.from_values(dst_ia, dst_host) cmn_hdr, addr_hdr = build_base_hdrs(dst_addr, self.addr) udp_hdr = SCIONUDPHeader.from_values( self.addr, self._port, dst_addr, dst_port) return SCIONL4Packet.from_values( cmn_hdr, addr_hdr, path, ext_hdrs, udp_hdr, payload)
def test(self): """ Bandwidth test method. Obtains a path to (2, 26) and sends PACKETS_NO packets (each with PAYLOAD_SIZE long payload) to a host in (2, 26). """ addr = haddr_parse("IPV4", "127.1.19.254") conf_dir = "%s/ISD1/AD19/endhost" % GEN_PATH sender = SCIONDaemon.start(conf_dir, addr) paths = sender.get_paths(2, 26) self.assertTrue(paths) rcv_sock = UDPSocket(bind=("127.2.26.254", 0, "Bw test receiver"), addr_type=AddrType.IPV4) logging.info("Starting the receiver.") recv_t = threading.Thread( target=thread_safety_net, args=(self.receiver, rcv_sock), name="BwT.receiver") recv_t.start() payload = PayloadRaw(b"A" * PAYLOAD_SIZE) spkt = sender._build_packet( haddr_parse("IPV4", "127.2.26.254"), dst_isd=2, dst_ad=26, dst_port=rcv_sock.port, payload=payload, path=paths[0]) (next_hop, port) = sender.get_first_hop(spkt) assert next_hop is not None logging.info("Sending %d payload bytes (%d packets x %d bytes )" % (PACKETS_NO * PAYLOAD_SIZE, PACKETS_NO, PAYLOAD_SIZE)) for _ in range(PACKETS_NO): sender.send(spkt, next_hop, port) time.sleep(SLEEP) logging.info("Sending finished") recv_t.join() if self.rate < 10.0: sys.exit(0) else: sys.exit(int(self.rate))
def _parse(self, raw): data = Raw(raw, self.NAME, self.MIN_LEN, min_=True) self._inner_parse(data) self.set_payload(PayloadRaw(data.get()))
def _create_payload(self, spkt): return PayloadRaw(self.data)
def _gen_max_pld(self, data, pld_len): padding = pld_len - len(data) return PayloadRaw(data + bytes(padding))
def _create_payload(self, spkt): old_pld = spkt.get_payload() data = b"pong " + self.data padding = len(old_pld) - len(data) return PayloadRaw(data + bytes(padding))