X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fsession%2Fsession_test.c;h=5c2993e3322d6f32bdf48071ea64ae2a29d1c614;hb=5665cedf57165c05d00f28de06b627047902ffce;hp=91ac351f86082e2bfdc2c247055bb78ca6a723a4;hpb=371ca50a74a9c4f1b74c4c1b65c6fdec610fcfc3;p=vpp.git

diff --git a/src/vnet/session/session_test.c b/src/vnet/session/session_test.c
index 91ac351f860..5c2993e3322 100644
--- a/src/vnet/session/session_test.c
+++ b/src/vnet/session/session_test.c
@@ -45,12 +45,18 @@ dummy_session_reset_callback (stream_session_t * s)
   clib_warning ("called...");
 }
 
+volatile u32 connected_session_index = ~0;
+volatile u32 connected_session_thread = ~0;
 int
 dummy_session_connected_callback (u32 app_index, u32 api_context,
 				  stream_session_t * s, u8 is_fail)
 {
-  clib_warning ("called...");
-  return -1;
+  if (s)
+    {
+      connected_session_index = s->session_index;
+      connected_session_thread = s->thread_index;
+    }
+  return 0;
 }
 
 static u32 dummy_segment_count;
@@ -76,11 +82,15 @@ dummy_session_disconnect_callback (stream_session_t * s)
 }
 
 static u32 dummy_accept;
+volatile u32 accepted_session_index;
+volatile u32 accepted_session_thread;
 
 int
 dummy_session_accept_callback (stream_session_t * s)
 {
   dummy_accept = 1;
+  accepted_session_index = s->session_index;
+  accepted_session_thread = s->thread_index;
   s->session_state = SESSION_STATE_READY;
   return 0;
 }
@@ -110,7 +120,7 @@ session_create_lookpback (u32 table_id, u32 * sw_if_index,
 {
   u8 intf_mac[6];
 
-  memset (intf_mac, 0, sizeof (intf_mac));
+  clib_memset (intf_mac, 0, sizeof (intf_mac));
 
   if (vnet_create_loopback_interface (sw_if_index, intf_mac, 0, 0))
     {
@@ -119,7 +129,10 @@ session_create_lookpback (u32 table_id, u32 * sw_if_index,
     }
 
   if (table_id != 0)
-    ip_table_bind (FIB_PROTOCOL_IP4, *sw_if_index, table_id, 0);
+    {
+      ip_table_create (FIB_PROTOCOL_IP4, table_id, 0, 0);
+      ip_table_bind (FIB_PROTOCOL_IP4, *sw_if_index, table_id, 0);
+    }
 
   vnet_sw_interface_set_flags (vnet_get_main (), *sw_if_index,
 			       VNET_SW_INTERFACE_FLAG_ADMIN_UP);
@@ -150,7 +163,7 @@ session_test_basic (vlib_main_t * vm, unformat_input_t * input)
   clib_error_t *error = 0;
   u32 server_index;
 
-  memset (options, 0, sizeof (options));
+  clib_memset (options, 0, sizeof (options));
   options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;
   options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
   options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
@@ -159,11 +172,13 @@ session_test_basic (vlib_main_t * vm, unformat_input_t * input)
     .options = options,
     .namespace_id = 0,
     .session_cb_vft = &dummy_session_cbs,
+    .name = format (0, "session_test"),
   };
 
   error = vnet_application_attach (&attach_args);
   SESSION_TEST ((error == 0), "app attached");
   server_index = attach_args.app_index;
+  vec_free (attach_args.name);
 
   server_sep.is_ip4 = 1;
   vnet_bind_args_t bind_args = {
@@ -205,12 +220,195 @@ session_test_basic (vlib_main_t * vm, unformat_input_t * input)
   return 0;
 }
 
+static void
+session_add_del_route_via_lookup_in_table (u32 in_table_id, u32 via_table_id,
+					   ip4_address_t * ip, u8 mask,
+					   u8 is_add)
+{
+  fib_route_path_t *rpaths = 0, *rpath;
+  u32 in_fib_index, via_fib_index;
+
+  fib_prefix_t prefix = {
+    .fp_addr.ip4.as_u32 = ip->as_u32,
+    .fp_len = mask,
+    .fp_proto = FIB_PROTOCOL_IP4,
+  };
+
+  via_fib_index = fib_table_find (FIB_PROTOCOL_IP4, via_table_id);
+  if (via_fib_index == ~0)
+    {
+      clib_warning ("couldn't resolve via table id to index");
+      return;
+    }
+  in_fib_index = fib_table_find (FIB_PROTOCOL_IP4, in_table_id);
+  if (in_fib_index == ~0)
+    {
+      clib_warning ("couldn't resolve in table id to index");
+      return;
+    }
+
+  vec_add2 (rpaths, rpath, 1);
+  clib_memset (rpath, 0, sizeof (*rpath));
+  rpath->frp_weight = 1;
+  rpath->frp_fib_index = via_fib_index;
+  rpath->frp_proto = DPO_PROTO_IP4;
+  rpath->frp_sw_if_index = ~0;
+  rpath->frp_flags |= FIB_ROUTE_PATH_DEAG;
+
+  if (is_add)
+    fib_table_entry_path_add2 (in_fib_index, &prefix, FIB_SOURCE_CLI,
+			       FIB_ENTRY_FLAG_NONE, rpath);
+  else
+    fib_table_entry_path_remove2 (in_fib_index, &prefix, FIB_SOURCE_CLI,
+				  rpath);
+  vec_free (rpaths);
+}
+
+static int
+session_test_endpoint_cfg (vlib_main_t * vm, unformat_input_t * input)
+{
+  session_endpoint_cfg_t client_sep = SESSION_ENDPOINT_CFG_NULL;
+  u64 options[APP_OPTIONS_N_OPTIONS], dummy_secret = 1234;
+  u16 dummy_server_port = 1234, dummy_client_port = 5678;
+  session_endpoint_t server_sep = SESSION_ENDPOINT_NULL;
+  u32 server_index, client_index, sw_if_index[2];
+  ip4_address_t intf_addr[3];
+  transport_connection_t *tc;
+  stream_session_t *s;
+  clib_error_t *error;
+  u8 *appns_id;
+
+  /*
+   * Create the loopbacks
+   */
+  intf_addr[0].as_u32 = clib_host_to_net_u32 (0x01010101),
+    session_create_lookpback (0, &sw_if_index[0], &intf_addr[0]);
+
+  intf_addr[1].as_u32 = clib_host_to_net_u32 (0x02020202),
+    session_create_lookpback (1, &sw_if_index[1], &intf_addr[1]);
+
+  session_add_del_route_via_lookup_in_table (0, 1, &intf_addr[1], 32,
+					     1 /* is_add */ );
+  session_add_del_route_via_lookup_in_table (1, 0, &intf_addr[0], 32,
+					     1 /* is_add */ );
+
+  /*
+   * Insert namespace
+   */
+  appns_id = format (0, "appns1");
+  vnet_app_namespace_add_del_args_t ns_args = {
+    .ns_id = appns_id,
+    .secret = dummy_secret,
+    .sw_if_index = sw_if_index[1],
+    .ip4_fib_id = 0,
+    .is_add = 1
+  };
+  error = vnet_app_namespace_add_del (&ns_args);
+  SESSION_TEST ((error == 0), "app ns insertion should succeed: %d",
+		clib_error_get_code (error));
+
+  /*
+   * Attach client/server
+   */
+  clib_memset (options, 0, sizeof (options));
+  options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;
+  options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
+
+  vnet_app_attach_args_t attach_args = {
+    .api_client_index = ~0,
+    .options = options,
+    .namespace_id = 0,
+    .session_cb_vft = &dummy_session_cbs,
+    .name = format (0, "session_test_client"),
+  };
+
+  error = vnet_application_attach (&attach_args);
+  SESSION_TEST ((error == 0), "client app attached");
+  client_index = attach_args.app_index;
+  vec_free (attach_args.name);
+
+  attach_args.name = format (0, "session_test_server");
+  attach_args.namespace_id = appns_id;
+  attach_args.options[APP_OPTIONS_NAMESPACE_SECRET] = dummy_secret;
+  error = vnet_application_attach (&attach_args);
+  SESSION_TEST ((error == 0), "server app attached: %U", format_clib_error,
+		error);
+  vec_free (attach_args.name);
+  server_index = attach_args.app_index;
+
+  server_sep.is_ip4 = 1;
+  server_sep.port = dummy_server_port;
+  vnet_bind_args_t bind_args = {
+    .sep = server_sep,
+    .app_index = server_index,
+  };
+  error = vnet_bind (&bind_args);
+  SESSION_TEST ((error == 0), "server bind should work");
+
+  /*
+   * Connect and force lcl ip
+   */
+  client_sep.is_ip4 = 1;
+  client_sep.ip.ip4.as_u32 = clib_host_to_net_u32 (0x02020202);
+  client_sep.port = dummy_server_port;
+  client_sep.peer.is_ip4 = 1;
+  client_sep.peer.ip.ip4.as_u32 = clib_host_to_net_u32 (0x01010101);
+  client_sep.peer.port = dummy_client_port;
+  client_sep.transport_proto = TRANSPORT_PROTO_TCP;
+
+  vnet_connect_args_t connect_args = {
+    .sep_ext = client_sep,
+    .app_index = client_index,
+  };
+
+  error = vnet_connect (&connect_args);
+  SESSION_TEST ((error == 0), "connect should work");
+
+  /* wait for stuff to happen */
+  vlib_process_suspend (vm, 10e-3);
+
+  SESSION_TEST ((connected_session_index != ~0), "session should exist");
+  s = session_get (connected_session_index, connected_session_thread);
+  tc = session_get_transport (s);
+  SESSION_TEST ((tc != 0), "transport should exist");
+  SESSION_TEST ((memcmp (&tc->lcl_ip, &client_sep.peer.ip,
+			 sizeof (tc->lcl_ip)) == 0), "ips should be equal");
+  SESSION_TEST ((tc->lcl_port == dummy_client_port), "ports should be equal");
+
+  /* These sessions, because of the way they're established are pinned to
+   * main thread, even when we have workers and we avoid polling main thread,
+   * i.e., we can't cleanup pending disconnects, so force cleanup for both
+   */
+  stream_session_cleanup (s);
+  s = session_get (accepted_session_index, accepted_session_thread);
+  stream_session_cleanup (s);
+
+  vnet_app_detach_args_t detach_args = {
+    .app_index = server_index,
+  };
+  vnet_application_detach (&detach_args);
+  detach_args.app_index = client_index;
+  vnet_application_detach (&detach_args);
+
+  /* Allow the disconnects to finish before removing the routes. */
+  vlib_process_suspend (vm, 10e-3);
+
+  session_add_del_route_via_lookup_in_table (0, 1, &intf_addr[1], 32,
+					     0 /* is_add */ );
+  session_add_del_route_via_lookup_in_table (1, 0, &intf_addr[0], 32,
+					     0 /* is_add */ );
+
+  session_delete_loopback (sw_if_index[0]);
+  session_delete_loopback (sw_if_index[1]);
+  return 0;
+}
+
 static int
 session_test_namespace (vlib_main_t * vm, unformat_input_t * input)
 {
   u64 options[APP_OPTIONS_N_OPTIONS], dummy_secret = 1234;
   u32 server_index, server_st_index, server_local_st_index;
-  u32 dummy_port = 1234, client_index;
+  u32 dummy_port = 1234, client_index, server_wrk_index;
   u32 dummy_api_context = 4321, dummy_client_api_index = 1234;
   u32 dummy_server_api_index = ~0, sw_if_index = 0;
   session_endpoint_t server_sep = SESSION_ENDPOINT_NULL;
@@ -228,7 +426,7 @@ session_test_namespace (vlib_main_t * vm, unformat_input_t * input)
   server_sep.port = dummy_port;
   client_sep.is_ip4 = 1;
   client_sep.port = dummy_port;
-  memset (options, 0, sizeof (options));
+  clib_memset (options, 0, sizeof (options));
 
   options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;
   vnet_app_attach_args_t attach_args = {
@@ -236,6 +434,7 @@ session_test_namespace (vlib_main_t * vm, unformat_input_t * input)
     .options = options,
     .namespace_id = 0,
     .session_cb_vft = &dummy_session_cbs,
+    .name = format (0, "session_test"),
   };
 
   vnet_bind_args_t bind_args = {
@@ -244,10 +443,10 @@ session_test_namespace (vlib_main_t * vm, unformat_input_t * input)
   };
 
   vnet_connect_args_t connect_args = {
-    .sep = client_sep,
     .app_index = 0,
     .api_context = 0,
   };
+  clib_memcpy (&connect_args.sep, &client_sep, sizeof (client_sep));
 
   vnet_unbind_args_t unbind_args = {
     .handle = bind_args.handle,
@@ -259,7 +458,7 @@ session_test_namespace (vlib_main_t * vm, unformat_input_t * input)
   };
 
   ip4_address_t intf_addr = {
-    .as_u32 = clib_host_to_net_u32 (0x06000105),
+    .as_u32 = clib_host_to_net_u32 (0x07000105),
   };
 
   intf_sep.ip.ip4 = intf_addr;
@@ -315,6 +514,7 @@ session_test_namespace (vlib_main_t * vm, unformat_input_t * input)
   SESSION_TEST ((error == 0), "server attachment should work");
   server_index = attach_args.app_index;
   server = application_get (server_index);
+  server_wrk_index = application_get_default_worker (server)->wrk_index;
   SESSION_TEST ((server->ns_index == 0),
 		"server should be in the default ns");
 
@@ -325,8 +525,8 @@ session_test_namespace (vlib_main_t * vm, unformat_input_t * input)
   server_st_index = application_session_table (server, FIB_PROTOCOL_IP4);
   s = session_lookup_listener (server_st_index, &server_sep);
   SESSION_TEST ((s != 0), "listener should exist in global table");
-  SESSION_TEST ((s->app_index == server_index), "app_index should be that of "
-		"the server");
+  SESSION_TEST ((s->app_wrk_index == server_wrk_index), "app_index should be"
+		" that of the server");
   server_local_st_index = application_local_session_table (server);
   SESSION_TEST ((server_local_st_index == APP_INVALID_INDEX),
 		"server shouldn't have access to local table");
@@ -354,6 +554,7 @@ session_test_namespace (vlib_main_t * vm, unformat_input_t * input)
   SESSION_TEST ((error == 0), "server attachment should work");
   server_index = attach_args.app_index;
   server = application_get (server_index);
+  server_wrk_index = application_get_default_worker (server)->wrk_index;
   SESSION_TEST ((server->ns_index == app_namespace_index (app_ns)),
 		"server should be in the right ns");
 
@@ -363,8 +564,8 @@ session_test_namespace (vlib_main_t * vm, unformat_input_t * input)
   server_st_index = application_session_table (server, FIB_PROTOCOL_IP4);
   s = session_lookup_listener (server_st_index, &server_sep);
   SESSION_TEST ((s != 0), "listener should exist in global table");
-  SESSION_TEST ((s->app_index == server_index), "app_index should be that of "
-		"the server");
+  SESSION_TEST ((s->app_wrk_index == server_wrk_index), "app_index should be"
+		" that of the server");
   server_local_st_index = application_local_session_table (server);
   handle = session_lookup_local_endpoint (server_local_st_index, &server_sep);
   SESSION_TEST ((handle != SESSION_INVALID_HANDLE),
@@ -503,6 +704,8 @@ session_test_namespace (vlib_main_t * vm, unformat_input_t * input)
   error = vnet_application_attach (&attach_args);
   SESSION_TEST ((error == 0), "server attachment should work");
   server_index = attach_args.app_index;
+  server = application_get (server_index);
+  server_wrk_index = application_get_default_worker (server)->wrk_index;
 
   bind_args.app_index = server_index;
   error = vnet_bind (&bind_args);
@@ -512,8 +715,8 @@ session_test_namespace (vlib_main_t * vm, unformat_input_t * input)
 
   s = session_lookup_listener (server_st_index, &intf_sep);
   SESSION_TEST ((s != 0), "intf listener should exist in global table");
-  SESSION_TEST ((s->app_index == server_index), "app_index should be that of "
-		"the server");
+  SESSION_TEST ((s->app_wrk_index == server_wrk_index), "app_index should be "
+		"that of the server");
   server_local_st_index = application_local_session_table (server);
   handle = session_lookup_local_endpoint (server_local_st_index, &server_sep);
   SESSION_TEST ((handle != SESSION_INVALID_HANDLE),
@@ -524,6 +727,7 @@ session_test_namespace (vlib_main_t * vm, unformat_input_t * input)
   /*
    * Cleanup
    */
+  vec_free (attach_args.name);
   vec_free (ns_id);
   session_delete_loopback (sw_if_index);
   return 0;
@@ -551,7 +755,7 @@ session_test_rule_table (vlib_main_t * vm, unformat_input_t * input)
 	}
     }
 
-  memset (srt, 0, sizeof (*srt));
+  clib_memset (srt, 0, sizeof (*srt));
   session_rules_table_init (srt);
 
   ip4_address_t lcl_ip = {
@@ -831,13 +1035,14 @@ session_test_rules (vlib_main_t * vm, unformat_input_t * input)
 
   server_sep.is_ip4 = 1;
   server_sep.port = dummy_port;
-  memset (options, 0, sizeof (options));
+  clib_memset (options, 0, sizeof (options));
 
   vnet_app_attach_args_t attach_args = {
     .api_client_index = ~0,
     .options = options,
     .namespace_id = 0,
     .session_cb_vft = &dummy_session_cbs,
+    .name = format (0, "session_test"),
   };
 
   vnet_bind_args_t bind_args = {
@@ -1032,10 +1237,10 @@ session_test_rules (vlib_main_t * vm, unformat_input_t * input)
 		" 5.6.7.9/32 4321 in local table should return deny");
 
   vnet_connect_args_t connect_args = {
-    .sep = sep,
     .app_index = attach_args.app_index,
     .api_context = 0,
   };
+  clib_memcpy (&connect_args.sep, &sep, sizeof (sep));
 
   /* Try connecting */
   error = vnet_connect (&connect_args);
@@ -1312,7 +1517,7 @@ session_test_rules (vlib_main_t * vm, unformat_input_t * input)
 
 
   connect_args.app_index = server_index;
-  connect_args.sep = sep;
+  clib_memcpy (&connect_args.sep, &sep, sizeof (sep));
 
   error = vnet_connect (&connect_args);
   SESSION_TEST ((error != 0), "connect should fail");
@@ -1356,6 +1561,7 @@ session_test_rules (vlib_main_t * vm, unformat_input_t * input)
   vnet_application_detach (&detach_args);
 
   vec_free (ns_id);
+  vec_free (attach_args.name);
   return 0;
 }
 
@@ -1369,7 +1575,7 @@ session_test_proxy (vlib_main_t * vm, unformat_input_t * input)
   u32 server_index, app_index;
   u32 dummy_server_api_index = ~0, sw_if_index = 0;
   clib_error_t *error = 0;
-  u8 sst, is_filtered = 0;
+  u8 is_filtered = 0;
   stream_session_t *s;
   transport_connection_t *tc;
   u16 lcl_port = 1234, rmt_port = 4321;
@@ -1414,7 +1620,7 @@ session_test_proxy (vlib_main_t * vm, unformat_input_t * input)
   app_ns = app_namespace_get_default ();
   app_ns->sw_if_index = sw_if_index;
 
-  memset (options, 0, sizeof (options));
+  clib_memset (options, 0, sizeof (options));
   options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;
   options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_ACCEPT_REDIRECT;
   options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_IS_PROXY;
@@ -1426,6 +1632,7 @@ session_test_proxy (vlib_main_t * vm, unformat_input_t * input)
     .options = options,
     .namespace_id = 0,
     .session_cb_vft = &dummy_session_cbs,
+    .name = format (0, "session_test"),
   };
 
   attach_args.api_client_index = dummy_server_api_index;
@@ -1447,10 +1654,9 @@ session_test_proxy (vlib_main_t * vm, unformat_input_t * input)
 				      TRANSPORT_PROTO_TCP, 0, &is_filtered);
   SESSION_TEST ((tc != 0), "lookup 1.2.3.4 1234 5.6.7.8 4321 should be "
 		"successful");
-  sst = session_type_from_proto_and_ip (TRANSPORT_PROTO_TCP, 1);
-  s = listen_session_get (sst, tc->s_index);
-  SESSION_TEST ((s->app_index == server_index), "lookup should return the"
-		" server");
+  s = listen_session_get (tc->s_index);
+  SESSION_TEST ((s->app_index == server_index), "lookup should return"
+		" the server");
 
   tc = session_lookup_connection_wt4 (0, &rmt_ip, &rmt_ip, lcl_port, rmt_port,
 				      TRANSPORT_PROTO_TCP, 0, &is_filtered);
@@ -1481,6 +1687,7 @@ session_test_proxy (vlib_main_t * vm, unformat_input_t * input)
 		"local session endpoint lookup should not work after detach");
   if (verbose)
     unformat_free (&tmp_input);
+  vec_free (attach_args.name);
   return 0;
 }
 
@@ -1504,6 +1711,8 @@ session_test (vlib_main_t * vm,
 	res = session_test_rules (vm, input);
       else if (unformat (input, "proxy"))
 	res = session_test_proxy (vm, input);
+      else if (unformat (input, "endpt-cfg"))
+	res = session_test_endpoint_cfg (vm, input);
       else if (unformat (input, "all"))
 	{
 	  if ((res = session_test_basic (vm, input)))
@@ -1516,6 +1725,8 @@ session_test (vlib_main_t * vm,
 	    goto done;
 	  if ((res = session_test_proxy (vm, input)))
 	    goto done;
+	  if ((res = session_test_endpoint_cfg (vm, input)))
+	    goto done;
 	}
       else
 	break;