Signed-off-by: Huw Davies &lt;huw(a)codeweavers.com&gt; --- dlls/nsi/tests/nsi.c | 117 ++++++++++++ dlls/nsiproxy.sys/ip.c | 268 +++++++++++++++++++++++++++ dlls/nsiproxy.sys/nsiproxy_private.h | 38 ++++ include/netioapi.h | 2 + include/wine/nsi.h | 62 +++++++ 5 files changed, 487 insertions(+) diff --git a/dlls/nsi/tests/nsi.c b/dlls/nsi/tests/nsi.c index 869fa255bb2..9f6349bd0e7 100644 --- a/dlls/nsi/tests/nsi.c +++ b/dlls/nsi/tests/nsi.c @@ -485,6 +485,121 @@ static void test_ip_unicast( int family ) winetest_pop_context(); } +static void test_ip_forward( int family ) +{ + DWORD rw_sizes[] = { FIELD_OFFSET(struct nsi_ip_forward_rw, unk), + FIELD_OFFSET(struct nsi_ip_forward_rw, unk2), sizeof(struct nsi_ip_forward_rw) }; + DWORD dyn_sizes4[] = { sizeof(struct nsi_ipv4_forward_dynamic) - 3 * sizeof(DWORD), + sizeof(struct nsi_ipv4_forward_dynamic) }; + DWORD dyn_sizes6[] = { sizeof(struct nsi_ipv6_forward_dynamic) - 3 * sizeof(DWORD), + sizeof(struct nsi_ipv6_forward_dynamic) }; + DWORD *dyn_sizes = family == AF_INET ? dyn_sizes4 : dyn_sizes6; + struct nsi_ipv4_forward_key *key_tbl, *key4; + struct nsi_ipv6_forward_key *key6; + struct nsi_ip_forward_rw *rw_tbl, *rw; + struct nsi_ipv4_forward_dynamic *dyn_tbl, *dyn4; + struct nsi_ipv6_forward_dynamic *dyn6; + struct nsi_ip_forward_static *stat_tbl, *stat; + MIB_IPFORWARD_TABLE2 *table; + const NPI_MODULEID *mod = (family == AF_INET) ? &NPI_MS_IPV4_MODULEID : &NPI_MS_IPV6_MODULEID; + DWORD key_size = (family == AF_INET) ? sizeof(*key4) : sizeof(*key6); + DWORD err, count, i, rw_size, dyn_size; + + winetest_push_context( family == AF_INET ? "AF_INET" : "AF_INET6" ); + + for (i = 0; i < ARRAY_SIZE(rw_sizes); i++) + { + err = NsiAllocateAndGetTable( 1, mod, NSI_IP_FORWARD_TABLE, (void **)&key_tbl, key_size, + (void **)&rw_tbl, rw_sizes[i], NULL, 0, + NULL, 0, &count, 0 ); + if (!err) break; + } +todo_wine_if (family == AF_INET6) + ok( !err, "got %d\n", err ); + if (err) { winetest_pop_context(); return; } + rw_size = rw_sizes[i]; + NsiFreeTable( key_tbl, rw_tbl, NULL, NULL ); + + for (i = 0; i < ARRAY_SIZE(dyn_sizes4); i++) + { + err = NsiAllocateAndGetTable( 1, mod, NSI_IP_FORWARD_TABLE, (void **)&key_tbl, key_size, + (void **)&rw_tbl, rw_size, (void **)&dyn_tbl, dyn_sizes[i], + (void **)&stat_tbl, sizeof(*stat_tbl), &count, 0 ); + if (!err) break; + } + ok( !err, "got %d\n", err ); + dyn_size = dyn_sizes[i]; + + err = GetIpForwardTable2( family, &table ); +todo_wine + ok( !err, "got %d\n", err ); + if (err) { winetest_pop_context(); return; } + ok( table->NumEntries == count, "table entries %d count %d\n", table->NumEntries, count ); + + for (i = 0; i < count; i++) + { + MIB_IPFORWARD_ROW2 *row = table->Table + i; + rw = (struct nsi_ip_forward_rw *)((BYTE *)rw_tbl + i * rw_size); + stat = stat_tbl + i; + winetest_push_context( "%d", i ); + + ok( row->DestinationPrefix.Prefix.si_family == family, "mismatch\n" ); + + if (family == AF_INET) + { + key4 = key_tbl + i; + dyn4 = (struct nsi_ipv4_forward_dynamic *)((BYTE *)dyn_tbl + i * dyn_size); + + ok( row->InterfaceLuid.Value == key4->luid.Value, "mismatch\n" ); + ok( row->InterfaceLuid.Value == key4->luid2.Value, "mismatch\n" ); + ok( row->DestinationPrefix.Prefix.Ipv4.sin_addr.s_addr == key4->prefix.s_addr, "mismatch\n" ); + ok( row->DestinationPrefix.Prefix.Ipv4.sin_port == 0, "mismatch\n" ); + ok( row->DestinationPrefix.PrefixLength == key4->prefix_len, "mismatch\n" ); + ok( row->NextHop.Ipv4.sin_addr.s_addr == key4->next_hop.s_addr, "mismatch\n" ); + ok( row->NextHop.Ipv4.sin_port == 0, "mismatch\n" ); + ok( row->Age == dyn4->age, "mismatch\n" ); + } + else + { + key6 = (struct nsi_ipv6_forward_key *)key_tbl + i; + dyn6 = (struct nsi_ipv6_forward_dynamic *)((BYTE *)dyn_tbl + i * dyn_size); + + ok( row->InterfaceLuid.Value == key6->luid.Value, "mismatch\n" ); + ok( row->InterfaceLuid.Value == key6->luid2.Value, "mismatch\n" ); + ok( !memcmp( &row->DestinationPrefix.Prefix.Ipv6.sin6_addr, &key6->prefix, sizeof(key6->prefix) ), + "mismatch\n" ); + ok( row->DestinationPrefix.Prefix.Ipv6.sin6_port == 0, "mismatch\n" ); + ok( row->DestinationPrefix.Prefix.Ipv6.sin6_flowinfo == 0, "mismatch\n" ); + ok( row->DestinationPrefix.Prefix.Ipv6.sin6_scope_id == 0, "mismatch\n" ); + ok( row->DestinationPrefix.PrefixLength == key6->prefix_len, "mismatch\n" ); + ok( !memcmp( &row->NextHop.Ipv6.sin6_addr, &key6->next_hop, sizeof(key6->next_hop) ), "mismatch\n" ); + ok( row->NextHop.Ipv6.sin6_port == 0, "mismatch\n" ); + ok( row->NextHop.Ipv6.sin6_flowinfo == 0, "mismatch\n" ); + ok( row->NextHop.Ipv6.sin6_scope_id == 0, "mismatch\n" ); + ok( row->Age == dyn6->age, "mismatch\n" ); + } + + ok( row->InterfaceIndex == stat->if_index, "mismatch\n" ); + ok( row->SitePrefixLength == rw->site_prefix_len, "mismatch\n" ); + ok( row->ValidLifetime == rw->valid_lifetime, "mismatch\n" ); + ok( row->PreferredLifetime == rw->preferred_lifetime, "mismatch\n" ); + + ok( row->Metric == rw->metric, "mismatch\n" ); + ok( row->Protocol == rw->protocol, "mismatch\n" ); + ok( row->Loopback == rw->loopback, "mismatch\n" ); + ok( row->AutoconfigureAddress == rw->autoconf, "mismatch\n" ); + ok( row->Publish == rw->publish, "mismatch\n" ); + ok( row->Immortal == rw->immortal, "mismatch\n" ); + ok( row->Origin == stat->origin, "mismatch\n" ); + + winetest_pop_context(); + } + + FreeMibTable( table ); + NsiFreeTable( key_tbl, rw_tbl, dyn_tbl, stat_tbl ); + winetest_pop_context(); +} + START_TEST( nsi ) { test_nsi_api(); @@ -494,4 +609,6 @@ START_TEST( nsi ) test_ip_unicast( AF_INET ); test_ip_unicast( AF_INET6 ); + test_ip_forward( AF_INET ); + test_ip_forward( AF_INET6 ); } diff --git a/dlls/nsiproxy.sys/ip.c b/dlls/nsiproxy.sys/ip.c index 93fdefa24cc..dbd019c8442 100644 --- a/dlls/nsiproxy.sys/ip.c +++ b/dlls/nsiproxy.sys/ip.c @@ -25,6 +25,14 @@ #include <sys/socket.h> #endif +#ifdef HAVE_NET_ROUTE_H +#include <net/route.h> +#endif + +#ifdef HAVE_SYS_SYSCTL_H +#include <sys/sysctl.h> +#endif + #ifdef HAVE_NETINET_IN_H #include <netinet/in.h> #endif @@ -45,6 +53,7 @@ #include "nldef.h" #include "ifdef.h" #include "netiodef.h" +#include "wine/heap.h" #include "wine/nsi.h" #include "wine/debug.h" @@ -221,6 +230,249 @@ static NTSTATUS ip_unicast_get_all_parameters( const void *key, DWORD key_size, return status; } +struct ipv4_route_data +{ + NET_LUID luid; + DWORD if_index; + struct in_addr prefix; + DWORD prefix_len; + struct in_addr next_hop; + DWORD metric; + DWORD protocol; + BYTE loopback; +}; + +static void ipv4_forward_fill_entry( struct ipv4_route_data *entry, struct nsi_ipv4_forward_key *key, + struct nsi_ip_forward_rw *rw, struct nsi_ipv4_forward_dynamic *dyn, + struct nsi_ip_forward_static *stat ) +{ + if (key) + { + key->unk = 0; + key->prefix.WS_s_addr = entry->prefix.s_addr; + key->prefix_len = entry->prefix_len; + memset( key->unk2, 0, sizeof(key->unk2) ); + memset( key->unk3, 0, sizeof(key->unk3) ); + key->luid = entry->luid; + key->luid2 = entry->luid; + key->next_hop.WS_s_addr = entry->next_hop.s_addr; + key->pad = 0; + } + + if (rw) + { + rw->site_prefix_len = 0; + rw->valid_lifetime = ~0u; + rw->preferred_lifetime = ~0u; + rw->metric = entry->metric; + rw->protocol = entry->protocol; + rw->loopback = entry->loopback; + rw->autoconf = 1; + rw->publish = 0; + rw->immortal = 1; + memset( rw->unk, 0, sizeof(rw->unk) ); + rw->unk2 = 0; + } + + if (dyn) + { + memset( dyn, 0, sizeof(*dyn) ); + } + + if (stat) + { + stat->origin = NlroManual; + stat->if_index = entry->if_index; + } +} + +static NTSTATUS ipv4_forward_enumerate_all( void *key_data, DWORD key_size, void *rw_data, DWORD rw_size, + void *dynamic_data, DWORD dynamic_size, + void *static_data, DWORD static_size, DWORD_PTR *count ) +{ + DWORD num = 0; + NTSTATUS status = STATUS_SUCCESS; + BOOL want_data = key_size || rw_size || dynamic_size || static_size; + struct ipv4_route_data entry; + + TRACE( "%p %d %p %d %p %d %p %d %p\n", key_data, key_size, rw_data, rw_size, + dynamic_data, dynamic_size, static_data, static_size, count ); + +#ifdef __linux__ + { + char buf[512], *ptr; + struct in_addr mask; + DWORD rtf_flags; + FILE *fp; + + if (!(fp = fopen( "/proc/net/route", "r" ))) return STATUS_NOT_SUPPORTED; + + /* skip header line */ + fgets( buf, sizeof(buf), fp ); + while ((ptr = fgets( buf, sizeof(buf), fp ))) + { + while (!isspace( *ptr )) ptr++; + *ptr++ = '\0'; + + if (!convert_unix_name_to_luid( buf, &entry.luid )) continue; + if (!convert_luid_to_index( &entry.luid, &entry.if_index )) continue; + + entry.prefix.s_addr = strtoul( ptr, &ptr, 16 ); + entry.next_hop.s_addr = strtoul( ptr + 1, &ptr, 16 ); + rtf_flags = strtoul( ptr + 1, &ptr, 16 ); + strtoul( ptr + 1, &ptr, 16 ); /* refcount, skip */ + strtoul( ptr + 1, &ptr, 16 ); /* use, skip */ + entry.metric = strtoul( ptr + 1, &ptr, 16 ); + mask.s_addr = strtoul( ptr + 1, &ptr, 16 ); + entry.prefix_len = mask_v4_to_prefix( &mask ); + entry.protocol = (rtf_flags & RTF_GATEWAY) ? MIB_IPPROTO_NETMGMT : MIB_IPPROTO_LOCAL; + entry.loopback = entry.protocol == MIB_IPPROTO_LOCAL && entry.prefix_len == 32; + + if (num < *count) + { + ipv4_forward_fill_entry( &entry, key_data, rw_data, dynamic_data, static_data ); + key_data = (BYTE *)key_data + key_size; + rw_data = (BYTE *)rw_data + rw_size; + dynamic_data = (BYTE *)dynamic_data + dynamic_size; + static_data = (BYTE *)static_data + static_size; + } + num++; + } + fclose( fp ); + } +#elif defined(HAVE_SYS_SYSCTL_H) && defined(NET_RT_DUMP) + { + int mib[6] = { CTL_NET, PF_ROUTE, 0, PF_INET, NET_RT_DUMP, 0 }; + size_t needed; + char *buf = NULL, *lim, *next, *addr_ptr; + struct rt_msghdr *rtm; + + if (sysctl( mib, ARRAY_SIZE(mib), NULL, &needed, NULL, 0 ) < 0) return STATUS_NOT_SUPPORTED; + + buf = heap_alloc( needed ); + if (!buf) return STATUS_NO_MEMORY; + + if (sysctl( mib, 6, buf, &needed, NULL, 0 ) < 0) + { + heap_free( buf ); + return STATUS_NOT_SUPPORTED; + } + + lim = buf + needed; + for (next = buf; next < lim; next += rtm->rtm_msglen) + { + int i; + sa_family_t dst_family = AF_UNSPEC; + + rtm = (struct rt_msghdr *)next; + + if (rtm->rtm_type != RTM_GET) + { + WARN( "Got unexpected message type 0x%x!\n", rtm->rtm_type ); + continue; + } + + /* Ignore gateway routes which are multicast */ + if ((rtm->rtm_flags & RTF_GATEWAY) && (rtm->rtm_flags & RTF_MULTICAST)) continue; + + entry.if_index = rtm->rtm_index; + if (!convert_index_to_luid( entry.if_index, &entry.luid )) continue; + entry.protocol = (rtm->rtm_flags & RTF_GATEWAY) ? MIB_IPPROTO_NETMGMT : MIB_IPPROTO_LOCAL; + entry.metric = rtm->rtm_rmx.rmx_hopcount; + + addr_ptr = (char *)(rtm + 1); + + for (i = 1; i; i <<= 1) + { + struct sockaddr *sa; + struct in_addr addr; + + if (!(i & rtm->rtm_addrs)) continue; + + sa = (struct sockaddr *)addr_ptr; + if (addr_ptr + sa->sa_len > next + rtm->rtm_msglen) + { + ERR( "struct sockaddr extends beyond the route message, %p > %p\n", + addr_ptr + sa->sa_len, next + rtm->rtm_msglen ); + } + + if (sa->sa_len) addr_ptr += (sa->sa_len + sizeof(int)-1) & ~(sizeof(int)-1); + else addr_ptr += sizeof(int); + /* Apple's netstat prints the netmask together with the destination + * and only looks at the destination's address family. The netmask's + * sa_family sometimes contains the non-existent value 0xff. */ + switch (i == RTA_NETMASK ? dst_family : sa->sa_family) + { + case AF_INET: + { + /* Netmasks (and possibly other addresses) have only enough size + * to represent the non-zero bits, e.g. a netmask of 255.0.0.0 has + * 5 bytes (1 sa_len, 1 sa_family, 2 sa_port and 1 for the first + * byte of sin_addr). */ + struct sockaddr_in sin = {0}; + memcpy( &sin, sa, sa->sa_len ); + addr = sin.sin_addr; + break; + } +#ifdef AF_LINK + case AF_LINK: + if (i == RTA_GATEWAY && entry.protocol == MIB_IPPROTO_NETMGMT) + { + /* For direct route we may simply use dest addr as next hop */ + C_ASSERT(RTA_DST < RTA_GATEWAY); + addr = entry.prefix; + break; + } + /* fallthrough */ +#endif + default: + WARN( "Received unsupported sockaddr family 0x%x\n", sa->sa_family ); + addr.s_addr = 0; + } + switch (i) + { + case RTA_DST: + entry.prefix = addr; + dst_family = sa->sa_family; + break; + case RTA_GATEWAY: entry.next_hop = addr; break; + case RTA_NETMASK: entry.prefix_len = mask_v4_to_prefix( &addr ); break; + default: + WARN( "Unexpected address type 0x%x\n", i ); + } + } + + if (num < *count) + { + ipv4_forward_fill_entry( &entry, key_data, rw_data, dynamic_data, static_data ); + key_data = (BYTE *)key_data + key_size; + rw_data = (BYTE *)rw_data + rw_size; + dynamic_data = (BYTE *)dynamic_data + dynamic_size; + static_data = (BYTE *)static_data + static_size; + } + num++; + } + HeapFree( GetProcessHeap (), 0, buf ); + } +#else + FIXME( "not implemented\n" ); + return STATUS_NOT_IMPLEMENTED; +#endif + + if (!want_data || num <= *count) *count = num; + else status = STATUS_MORE_ENTRIES; + + return status; +} + +static NTSTATUS ipv6_forward_enumerate_all( void *key_data, DWORD key_size, void *rw_data, DWORD rw_size, + void *dynamic_data, DWORD dynamic_size, + void *static_data, DWORD static_size, DWORD_PTR *count ) +{ + FIXME( "not implemented\n" ); + return STATUS_NOT_IMPLEMENTED; +} + static struct module_table ipv4_tables[] = { { @@ -232,6 +484,14 @@ static struct module_table ipv4_tables[] = ip_unicast_enumerate_all, ip_unicast_get_all_parameters, }, + { + NSI_IP_FORWARD_TABLE, + { + sizeof(struct nsi_ipv4_forward_key), sizeof(struct nsi_ip_forward_rw), + sizeof(struct nsi_ipv4_forward_dynamic), sizeof(struct nsi_ip_forward_static) + }, + ipv4_forward_enumerate_all, + }, { ~0u } @@ -254,6 +514,14 @@ static struct module_table ipv6_tables[] = ip_unicast_enumerate_all, ip_unicast_get_all_parameters, }, + { + NSI_IP_FORWARD_TABLE, + { + sizeof(struct nsi_ipv6_forward_key), sizeof(struct nsi_ip_forward_rw), + sizeof(struct nsi_ipv6_forward_dynamic), sizeof(struct nsi_ip_forward_static) + }, + ipv6_forward_enumerate_all, + }, { ~0u } diff --git a/dlls/nsiproxy.sys/nsiproxy_private.h b/dlls/nsiproxy.sys/nsiproxy_private.h index 0f6e7b05c59..44409ae159e 100644 --- a/dlls/nsiproxy.sys/nsiproxy_private.h +++ b/dlls/nsiproxy.sys/nsiproxy_private.h @@ -25,6 +25,44 @@ NTSTATUS nsi_get_parameter_ex( struct nsi_get_parameter_ex *params ) DECLSPEC_HI BOOL convert_luid_to_unix_name( const NET_LUID *luid, const char **unix_name ) DECLSPEC_HIDDEN; BOOL convert_unix_name_to_luid( const char *unix_name, NET_LUID *luid ) DECLSPEC_HIDDEN; +static inline BOOL convert_luid_to_index( const NET_LUID *luid, DWORD *index ) +{ + struct nsi_get_parameter_ex params; + params.unknown[0] = 0; + params.unknown[1] = 0; + params.first_arg = 1; + params.unknown2 = 0; + params.module = &NPI_MS_NDIS_MODULEID; + params.table = NSI_NDIS_IFINFO_TABLE; + params.key = luid; + params.key_size = sizeof(*luid); + params.param_type = NSI_PARAM_TYPE_STATIC; + params.data = index; + params.data_size = sizeof(*index); + params.data_offset = FIELD_OFFSET(struct nsi_ndis_ifinfo_static, if_index); + + return !nsi_get_parameter_ex( &params ); +} + +static inline BOOL convert_index_to_luid( DWORD index, NET_LUID *luid ) +{ + struct nsi_get_parameter_ex params; + params.unknown[0] = 0; + params.unknown[1] = 0; + params.first_arg = 1; + params.unknown2 = 0; + params.module = &NPI_MS_NDIS_MODULEID; + params.table = NSI_NDIS_INDEX_LUID_TABLE; + params.key = &index; + params.key_size = sizeof(index); + params.param_type = NSI_PARAM_TYPE_STATIC; + params.data = luid; + params.data_size = sizeof(*luid); + params.data_offset = 0; + + return !nsi_get_parameter_ex( &params ); +} + struct module_table { DWORD table; diff --git a/include/netioapi.h b/include/netioapi.h index 4735620dedb..44d877ae3c3 100644 --- a/include/netioapi.h +++ b/include/netioapi.h @@ -254,6 +254,8 @@ DWORD WINAPI GetIfEntry2(MIB_IF_ROW2*); DWORD WINAPI GetIfEntry2Ex(MIB_IF_TABLE_LEVEL,MIB_IF_ROW2*); DWORD WINAPI GetIfTable2(MIB_IF_TABLE2**); DWORD WINAPI GetIfTable2Ex(MIB_IF_TABLE_LEVEL,MIB_IF_TABLE2**); +DWORD WINAPI GetIpForwardEntry2(MIB_IPFORWARD_ROW2*); +DWORD WINAPI GetIpForwardTable2(ADDRESS_FAMILY,MIB_IPFORWARD_TABLE2**); DWORD WINAPI GetIpInterfaceTable(ADDRESS_FAMILY,MIB_IPINTERFACE_TABLE**); DWORD WINAPI GetUnicastIpAddressEntry(MIB_UNICASTIPADDRESS_ROW*); DWORD WINAPI GetUnicastIpAddressTable(ADDRESS_FAMILY,MIB_UNICASTIPADDRESS_TABLE**); diff --git a/include/wine/nsi.h b/include/wine/nsi.h index bba5be11e50..dd18c7c7511 100644 --- a/include/wine/nsi.h +++ b/include/wine/nsi.h @@ -98,6 +98,7 @@ struct nsi_ndis_ifinfo_static /* Undocumented NSI IP tables */ #define NSI_IP_UNICAST_TABLE 10 +#define NSI_IP_FORWARD_TABLE 16 struct nsi_ipv4_unicast_key { @@ -133,6 +134,67 @@ struct nsi_ip_unicast_static ULONG64 creation_time; }; +struct nsi_ipv4_forward_key +{ + DWORD unk; + IN_ADDR prefix; + BYTE prefix_len; + BYTE unk2[3]; + DWORD unk3[3]; + NET_LUID luid; + NET_LUID luid2; + IN_ADDR next_hop; + DWORD pad; +}; + +struct nsi_ipv6_forward_key +{ + DWORD unk; + IN6_ADDR prefix; + BYTE prefix_len; + BYTE unk2[3]; + DWORD unk3[3]; + DWORD pad; + NET_LUID luid; + NET_LUID luid2; + IN6_ADDR next_hop; +}; + +struct nsi_ip_forward_rw +{ + DWORD site_prefix_len; + DWORD valid_lifetime; + DWORD preferred_lifetime; + DWORD metric; + DWORD protocol; + BYTE loopback; + BYTE autoconf; + BYTE publish; + BYTE immortal; + BYTE unk[4]; + DWORD unk2; +}; + +struct nsi_ipv4_forward_dynamic +{ + DWORD age; + DWORD unk[3]; + IN_ADDR addr2; /* often a repeat of prefix */ +}; + +struct nsi_ipv6_forward_dynamic +{ + DWORD age; + DWORD unk[3]; + IN6_ADDR addr2; /* often a repeat of prefix */ +}; + +struct nsi_ip_forward_static +{ + DWORD origin; + DWORD if_index; +}; + /* Wine specific ioctl interface */ #define IOCTL_NSIPROXY_WINE_ENUMERATE_ALL CTL_CODE(FILE_DEVICE_NETWORK, 0x400, METHOD_BUFFERED, 0) -- 2.23.0