qiurui/glibc
1
0
Fork 0
mirror of git://sourceware.org/git/glibc.git synced 2026-09-08 23:58:31 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
glibc/support/tst-support_format_nss.c
T
Florian Weimer c9c4ff0b77 support: Add missing NSS formatting and checking functions 
This change is largely auto-generated.  The function implementations
are mechanical and use the glibc-specific support framework, so this
should be low-risk and therefore acceptable.

The struct etherent type is currently internal-only (although it
can be used by NSS modules), which is why it is not included here.

Reviewed-by: DJ Delorie <dj@redhat.com>
2026-02-12 12:18:54 +01:00

418 lines
12 KiB
C
Raw Permalink Blame History

/* Tests for the support_format_* functions.
Copyright (C) 2026 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
#include <support/check.h>
#include <support/check_nss.h>
#include <support/format_nss.h>
#include <aliases.h>
#include <arpa/inet.h>
#include <grp.h>
#include <gshadow.h>
#include <netdb.h>
#include <netinet/ether.h>
#include <pwd.h>
#include <rpc/netdb.h>
#include <shadow.h>
static void
test_format_address_family (void)
{
support_check_nss ("AF_INET", "address_family",
support_format_address_family (AF_INET),
"INET");
support_check_nss ("AF_INET6", "address_family",
support_format_address_family (AF_INET6),
"INET6");
support_check_nss ("AF_LOCAL", "address_family",
support_format_address_family (AF_LOCAL),
"LOCAL");
support_check_nss ("AF_UNSPEC", "address_family",
support_format_address_family (AF_UNSPEC),
"UNSPEC");
support_check_nss ("unknown family", "address_family",
support_format_address_family (12345),
"<unknown address family 12345>");
}
static void
test_format_herrno (void)
{
support_check_nss ("HOST_NOT_FOUND", "herrno",
support_format_herrno (HOST_NOT_FOUND),
"HOST_NOT_FOUND");
support_check_nss ("NO_ADDRESS", "herrno",
support_format_herrno (NO_ADDRESS),
"NO_ADDRESS");
support_check_nss ("NO_RECOVERY", "herrno",
support_format_herrno (NO_RECOVERY),
"NO_RECOVERY");
support_check_nss ("TRY_AGAIN", "herrno",
support_format_herrno (TRY_AGAIN),
"TRY_AGAIN");
support_check_nss ("invalid herrno", "herrno",
support_format_herrno (12345),
"<invalid h_errno value 12345>\n");
}
static void
test_format_passwd (void)
{
struct passwd p =
{
.pw_name = (char *) "testuser",
.pw_passwd = (char *) "x",
.pw_uid = 1000,
.pw_gid = 1000,
.pw_gecos = (char *) "Test User",
.pw_dir = (char *) "/home/testuser",
.pw_shell = (char *) "/bin/bash"
};
support_check_nss ("passwd", "passwd",
support_format_passwd (&p),
"name: testuser\n"
"passwd: x\n"
"uid: 1000\n"
"gid: 1000\n"
"gecos: Test User\n"
"dir: /home/testuser\n"
"shell: /bin/bash\n");
}
static void
test_format_group (void)
{
char *members[] = { (char *) "user1", (char *) "user2", NULL };
struct group g =
{
.gr_name = (char *) "testgroup",
.gr_passwd = (char *) "x",
.gr_gid = 100,
.gr_mem = members
};
support_check_nss ("group with members", "group",
support_format_group (&g),
"name: testgroup\n"
"passwd: x\n"
"gid: 100\n"
"member: user1\n"
"member: user2\n");
char *no_members[] = { NULL };
struct group g_empty =
{
.gr_name = (char *) "emptygroup",
.gr_passwd = (char *) "",
.gr_gid = 200,
.gr_mem = no_members
};
support_check_nss ("group without members", "group",
support_format_group (&g_empty),
"name: emptygroup\n"
"passwd: \n"
"gid: 200\n");
}
static void
test_format_spwd (void)
{
struct spwd s =
{
.sp_namp = (char *) "testuser",
.sp_pwdp = (char *) "$6$rounds=5000$hash",
.sp_lstchg = 19000,
.sp_min = 0,
.sp_max = 99999,
.sp_warn = 7,
.sp_inact = -1,
.sp_expire = -1,
.sp_flag = 0
};
support_check_nss ("spwd", "spwd",
support_format_spwd (&s),
"sp_namp: testuser\n"
"sp_pwdp: $6$rounds=5000$hash\n"
"sp_lstchg: 19000\n"
"sp_min: 0\n"
"sp_max: 99999\n"
"sp_warn: 7\n"
"sp_inact: -1\n"
"sp_expire: -1\n"
"sp_flag: 0\n");
}
static void
test_format_sgrp (void)
{
char *admins[] = { (char *) "admin1", NULL };
char *members[] = { (char *) "user1", (char *) "user2", NULL };
struct sgrp s =
{
.sg_namp = (char *) "testgroup",
.sg_passwd = (char *) "!",
.sg_adm = admins,
.sg_mem = members
};
support_check_nss ("sgrp", "sgrp",
support_format_sgrp (&s),
"name: testgroup\n"
"passwd: !\n"
"admin: admin1\n"
"member: user1\n"
"member: user2\n");
char *no_admins[] = { NULL };
char *no_members[] = { NULL };
struct sgrp s_empty =
{
.sg_namp = (char *) "emptygroup",
.sg_passwd = (char *) "",
.sg_adm = no_admins,
.sg_mem = no_members
};
support_check_nss ("sgrp empty", "sgrp",
support_format_sgrp (&s_empty),
"name: emptygroup\n"
"passwd: \n");
}
static void
test_format_protoent (void)
{
char *aliases[] = { (char *) "ICMP", NULL };
struct protoent p =
{
.p_name = (char *) "icmp",
.p_aliases = aliases,
.p_proto = 1
};
support_check_nss ("protoent with alias", "protoent",
support_format_protoent (&p),
"name: icmp\n"
"alias: ICMP\n"
"proto: 1\n");
char *no_aliases[] = { NULL };
struct protoent p_no_alias =
{
.p_name = (char *) "tcp",
.p_aliases = no_aliases,
.p_proto = 6
};
support_check_nss ("protoent without alias", "protoent",
support_format_protoent (&p_no_alias),
"name: tcp\n"
"proto: 6\n");
}
static void
test_format_servent (void)
{
char *aliases[] = { (char *) "WWW", (char *) "www-http", NULL };
struct servent s =
{
.s_name = (char *) "http",
.s_aliases = aliases,
.s_port = htons (80),
.s_proto = (char *) "tcp"
};
support_check_nss ("servent", "servent",
support_format_servent (&s),
"name: http\n"
"alias: WWW\n"
"alias: www-http\n"
"port: 80\n"
"proto: tcp\n");
}
static void
test_format_rpcent (void)
{
char *aliases[] = { (char *) "portmap", (char *) "sunrpc", NULL };
struct rpcent r =
{
.r_name = (char *) "portmapper",
.r_aliases = aliases,
.r_number = 100000
};
support_check_nss ("rpcent", "rpcent",
support_format_rpcent (&r),
"name: portmapper\n"
"number: 100000\n"
"alias: portmap\n"
"alias: sunrpc\n");
}
static void
test_format_aliasent (void)
{
char *members[] =
{ (char *) "user1@example.com", (char *) "user2@example.com" };
struct aliasent a =
{
.alias_name = (char *) "staff",
.alias_members_len = 2,
.alias_members = members,
.alias_local = 0
};
support_check_nss ("aliasent", "aliasent",
support_format_aliasent (&a),
"name: staff\n"
"member: user1@example.com\n"
"member: user2@example.com\n"
"local: 0\n");
}
static void
test_format_ether_addr (void)
{
struct ether_addr e = { { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 } };
support_check_nss ("ether_addr", "ether_addr",
support_format_ether_addr (&e),
"address: 0:11:22:33:44:55\n");
}
static void
test_format_hostent (void)
{
char addr1[4] = { 192, 0, 2, 1 };
char addr2[4] = { 192, 0, 2, 2 };
char *addr_list[] = { addr1, addr2, NULL };
char *aliases[] = { (char *) "www.example", NULL };
struct hostent h =
{
.h_name = (char *) "example.com",
.h_aliases = aliases,
.h_addrtype = AF_INET,
.h_length = 4,
.h_addr_list = addr_list
};
support_check_nss ("hostent IPv4", "hostent",
support_format_hostent (&h),
"name: example.com\n"
"alias: www.example\n"
"address: 192.0.2.1\n"
"address: 192.0.2.2\n");
char addr6[16] = { 0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1 };
char *addr6_list[] = { addr6, NULL };
char *no_aliases[] = { NULL };
struct hostent h6 =
{
.h_name = (char *) "ipv6.example.com",
.h_aliases = no_aliases,
.h_addrtype = AF_INET6,
.h_length = 16,
.h_addr_list = addr6_list
};
support_check_nss ("hostent IPv6", "hostent",
support_format_hostent (&h6),
"name: ipv6.example.com\n"
"address: 2001:db8::1\n");
}
static void
test_format_netent (void)
{
char *aliases[] = { (char *) "localnet", NULL };
struct netent n =
{
.n_name = (char *) "loopback",
.n_aliases = aliases,
.n_addrtype = AF_INET,
.n_net = 0x7f000000
};
support_check_nss ("netent", "netent",
support_format_netent (&n),
"name: loopback\n"
"alias: localnet\n"
"net: 0x7f000000\n");
}
static void
test_format_addrinfo (void)
{
/* Test successful result with IPv4 address. */
struct sockaddr_in sin =
{
.sin_family = AF_INET,
.sin_port = htons (80),
.sin_addr = { htonl (0xc0000201) } /* 192.0.2.1 */
};
struct addrinfo ai =
{
.ai_flags = 0,
.ai_family = AF_INET,
.ai_socktype = SOCK_STREAM,
.ai_protocol = IPPROTO_TCP,
.ai_addrlen = sizeof (sin),
.ai_addr = (struct sockaddr *) &sin,
.ai_canonname = NULL,
.ai_next = NULL
};
support_check_nss ("addrinfo IPv4 STREAM/TCP", "addrinfo",
support_format_addrinfo (&ai, 0),
"address: STREAM/TCP 192.0.2.1 80\n");
/* Test with canonname. */
struct addrinfo ai_canon =
{
.ai_flags = AI_CANONNAME,
.ai_family = AF_INET,
.ai_socktype = SOCK_DGRAM,
.ai_protocol = IPPROTO_UDP,
.ai_addrlen = sizeof (sin),
.ai_addr = (struct sockaddr *) &sin,
.ai_canonname = (char *) "canonical.example.com",
.ai_next = NULL
};
support_check_nss ("addrinfo with canonname", "addrinfo",
support_format_addrinfo (&ai_canon, 0),
"flags: AI_CANONNAME\n"
"canonname: canonical.example.com\n"
"address: DGRAM/UDP 192.0.2.1 80\n");
/* Test error case. */
support_check_nss ("addrinfo EAI_NONAME", "addrinfo",
support_format_addrinfo (NULL, EAI_NONAME),
"error: Name or service not known\n");
}
static int
do_test (void)
{
test_format_address_family ();
test_format_herrno ();
test_format_passwd ();
test_format_group ();
test_format_spwd ();
test_format_sgrp ();
test_format_protoent ();
test_format_servent ();
test_format_rpcent ();
test_format_aliasent ();
test_format_ether_addr ();
test_format_hostent ();
test_format_netent ();
test_format_addrinfo ();
return 0;
}
#include <support/test-driver.c>
Reference in New Issue View Git Blame Copy Permalink