def testfunc(child): port = generate_port_number() shutdown_event = threading.Event() server_handle = threading.Thread(target=tcp_server, args=(port, shutdown_event)) server_handle.start() target_addr = get_host_ll_addr( get_host_tap_device()) + '%' + get_riot_if_id(child) # Setup RIOT Node to connect to host systems TCP Server child.sendline('gnrc_tcp_tcb_init') child.sendline('gnrc_tcp_open_active AF_INET6 ' + target_addr + ' ' + str(port) + ' 0') child.expect_exact('gnrc_tcp_open_active: returns 0') # Close connection and verify that pktbuf is cleared shutdown_event.set() child.sendline('gnrc_tcp_close') server_handle.join() verify_pktbuf_empty(child) print(os.path.basename(sys.argv[0]) + ': success')
def testfunc(child): port = generate_port_number() shutdown_event = threading.Event() # Try to receive 10 bytes sent from the Host System. data = 'test_data_' data_len = len(data) assert (data_len % 2) == 0 # Verify that RIOT Applications internal buffer can hold test data. assert setup_internal_buffer(child) >= data_len server_handle = threading.Thread(target=tcp_server, args=(port, shutdown_event, data)) server_handle.start() target_addr = get_host_ll_addr( get_host_tap_device()) + '%' + get_riot_if_id(child) # Setup RIOT Node to connect to Hostsystems TCP Server child.sendline('gnrc_tcp_tcb_init') child.sendline('gnrc_tcp_open_active [{}]:{} 0'.format( target_addr, str(port))) child.expect_exact('gnrc_tcp_open_active: returns 0') # Initiate connection teardown from test host shutdown_event.set() half_data_len = int(data_len / 2) # Read half the test data with timeout. Verify Buffer contents child.sendline('gnrc_tcp_recv 1000000 ' + str(half_data_len)) child.expect_exact('gnrc_tcp_recv: received ' + str(half_data_len)) assert read_data_from_internal_buffer( child, half_data_len) == data[:half_data_len] # Read half the test data without timeout. Verify Buffer contents child.sendline('gnrc_tcp_recv 0 ' + str(half_data_len)) child.expect_exact('gnrc_tcp_recv: received ' + str(half_data_len)) assert read_data_from_internal_buffer( child, half_data_len) == data[half_data_len:] # Buffer should have been read entirely and the connection was closed, there can be no new data. # Reading with a timeout must return 0 not -ETIMEOUT child.sendline('gnrc_tcp_recv 1000000 ' + str(half_data_len)) child.expect_exact('gnrc_tcp_recv: returns 0') # Reading without a timeout must return 0 not -EAGAIN. child.sendline('gnrc_tcp_recv 0 ' + str(half_data_len)) child.expect_exact('gnrc_tcp_recv: returns 0') # Close connection child.sendline('gnrc_tcp_close') server_handle.join() verify_pktbuf_empty(child) # Verify received Data print(os.path.basename(sys.argv[0]) + ': success')
def test_send_ack_instead_of_syn(child, src_if, src_ll, dst_if, dst_l2, dst_ll, dst_port): # check if any debug output is generated during `@testfunc` decorator # execution. If so, send fewer packets to prevent the target node # from being overwhelmed by packets and output. debug = child.expect( [pexpect.TIMEOUT, r'GNRC_TCP: Enter "\S+", File: .+\(\d+\)\s'], timeout=1) if debug: count = 10 else: count = 1000 # see https://github.com/RIOT-OS/RIOT/pull/12001 provided_data = base64.b64decode("rwsQf2pekYLaU+exUBBwgPDKAAA=") tcp_hdr = TCP(provided_data) assert provided_data == raw(tcp_hdr) # set destination port to application specific port tcp_hdr.dport = dst_port sendp(Ether(dst=dst_l2) / IPv6(src=src_ll, dst=dst_ll) / tcp_hdr, iface=src_if, verbose=0, count=count) # check if server actually still works with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as sock: sock.settimeout(child.timeout) addr_info = socket.getaddrinfo(dst_ll + '%' + src_if, dst_port, type=socket.SOCK_STREAM) sock.connect(addr_info[0][-1]) child.expect_exact('gnrc_tcp_open_passive: returns 0') verify_pktbuf_empty(child)
def testfunc(child): port = generate_port_number() shutdown_event = threading.Event() # Try to send 2000 byte from RIOT to the Host System. data = '0123456789' * 200 data_len = len(data) # Verify that RIOT Applications internal buffer can hold test data. assert setup_internal_buffer(child) >= data_len server_handle = threading.Thread(target=tcp_server, args=(port, shutdown_event, data)) server_handle.start() target_addr = get_host_ll_addr(get_host_tap_device()) + '%' + get_riot_if_id(child) # Setup RIOT Node to connect to host systems TCP Server child.sendline('gnrc_tcp_tcb_init') child.sendline('gnrc_tcp_open_active AF_INET6 ' + target_addr + ' ' + str(port) + ' 0') child.expect_exact('gnrc_tcp_open_active: returns 0') # Send data from RIOT Node to Linux write_data_to_internal_buffer(child, data) child.sendline('gnrc_tcp_send 0') child.expect_exact('gnrc_tcp_send: sent ' + str(data_len)) # Close connection and verify that pktbuf is cleared shutdown_event.set() child.sendline('gnrc_tcp_close') server_handle.join() verify_pktbuf_empty(child) print(os.path.basename(sys.argv[0]) + ': success')
def test_short_payload(child, src_if, src_ll, dst_if, dst_l2, dst_ll, dst_port): # see https://github.com/RIOT-OS/RIOT/issues/11999 with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as sock: sock.settimeout(child.timeout) addr_info = socket.getaddrinfo(dst_ll + '%' + src_if, dst_port, type=socket.SOCK_STREAM) sock.connect(addr_info[0][-1]) child.expect_exact('gnrc_tcp_open_passive: returns 0') child.sendline('gnrc_tcp_recv 1000000 1') child.expect_exact('gnrc_tcp_recv: argc=3, ' 'argv[0] = gnrc_tcp_recv, ' 'argv[1] = 1000000, argv[2] = 1') assert 1 == sock.send(b"f") child.expect_exact('gnrc_tcp_recv: received 1', timeout=20) verify_pktbuf_empty(child)
def test_short_header(child, src_if, src_ll, dst_if, dst_l2, dst_ll, dst_port): # see https://github.com/RIOT-OS/RIOT/issues/12086 tcp_hdr = TCP(dport=dst_port, flags="S", sport=2342, seq=1, dataofs=6) # shorten header tcp_hdr = raw(tcp_hdr)[:-2] sendp(Ether(dst=dst_l2) / IPv6(src=src_ll, dst=dst_ll) / tcp_hdr, iface=src_if, verbose=0) # let server command return to later check packet buffer with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as sock: sock.settimeout(child.timeout) addr_info = socket.getaddrinfo(dst_ll + '%' + src_if, dst_port, type=socket.SOCK_STREAM) sock.connect(addr_info[0][-1]) child.expect_exact('gnrc_tcp_open_passive: returns 0') verify_pktbuf_empty(child)
def test_option_parsing_term(child, src_if, src_ll, dst_if, dst_l2, dst_ll, dst_port): # see https://github.com/RIOT-OS/RIOT/issues/12086 tcp_hdr = TCP(dport=dst_port, flags="S", sport=2342, seq=1, dataofs=6) sendp(Ether(dst=dst_l2) / IPv6(src=src_ll, dst=dst_ll) / tcp_hdr / b"\x50\x00\x00\x00", iface=src_if, verbose=0) # check if server actually still works with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as sock: sock.settimeout(child.timeout) addr_info = socket.getaddrinfo(dst_ll + '%' + src_if, dst_port, type=socket.SOCK_STREAM) sock.connect(addr_info[0][-1]) child.expect_exact('gnrc_tcp_open_passive: returns 0') verify_pktbuf_empty(child)
def testfunc(child): port = generate_port_number() shutdown_event = threading.Event() client_handle = threading.Thread(target=tcp_client, args=(get_riot_ll_addr(child), port, shutdown_event)) # Setup RIOT Node wait for incoming connections from host system child.sendline('gnrc_tcp_tcb_init') child.sendline('gnrc_tcp_open_passive [::]:{}'.format(str(port))) client_handle.start() child.expect_exact('gnrc_tcp_open_passive: returns 0') # Close connection and verify that pktbuf is cleared shutdown_event.set() child.sendline('gnrc_tcp_close') client_handle.join() verify_pktbuf_empty(child) print(os.path.basename(sys.argv[0]) + ': success')
def test_send_ack_instead_of_syn(child, src_if, src_ll, dst_if, dst_l2, dst_ll, dst_port): # see https://github.com/RIOT-OS/RIOT/pull/12001 provided_data = base64.b64decode("rwsQf2pekYLaU+exUBBwgPDKAAA=") tcp_hdr = TCP(provided_data) assert provided_data == raw(tcp_hdr) # set destination port to application specific port tcp_hdr.dport = dst_port sendp(Ether(dst=dst_l2) / IPv6(src=src_ll, dst=dst_ll) / tcp_hdr, iface=src_if, verbose=0, count=1000) # check if server actually still works with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as sock: sock.settimeout(child.timeout) addr_info = socket.getaddrinfo(dst_ll + '%' + src_if, dst_port, type=socket.SOCK_STREAM) sock.connect(addr_info[0][-1]) child.expect_exact('gnrc_tcp_open_passive: returns 0') verify_pktbuf_empty(child)
def testfunc(child): port = generate_port_number() shutdown_event = threading.Event() # Try to receive 2000 bytes sent from the Host System. data = '0123456789' * 200 data_len = len(data) # Verify that RIOT Applications internal buffer can hold test data. assert setup_internal_buffer(child) >= data_len server_handle = threading.Thread(target=tcp_server, args=(port, shutdown_event, data)) server_handle.start() target_addr = get_host_ll_addr( get_host_tap_device()) + '%' + get_riot_if_id(child) # Setup RIOT Node to connect to Hostsystems TCP Server child.sendline('gnrc_tcp_tcb_init') child.sendline('gnrc_tcp_open_active [{}]:{} 0'.format( target_addr, str(port))) child.expect_exact('gnrc_tcp_open_active: returns 0') # Accept Data sent by the host system child.sendline('gnrc_tcp_recv 1000000 ' + str(data_len)) child.expect_exact('gnrc_tcp_recv: received ' + str(data_len), timeout=20) # Close connection and verify that pktbuf is cleared shutdown_event.set() child.sendline('gnrc_tcp_close') server_handle.join() verify_pktbuf_empty(child) # Verify received Data assert read_data_from_internal_buffer(child, data_len) == data print(os.path.basename(sys.argv[0]) + ': success')