src/test/test-socket-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd
   4
   5   Copyright 2014 Ronny Chevalier
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <sys/types.h>
  22 #include <unistd.h>
  23 #include <grp.h>
  24
  25 #include "alloc-util.h"
  26 #include "async.h"
  27 #include "fd-util.h"
  28 #include "in-addr-util.h"
  29 #include "log.h"
  30 #include "macro.h"
  31 #include "process-util.h"
  32 #include "socket-util.h"
  33 #include "string-util.h"
  34 #include "util.h"
  35
  36 static void test_ifname_valid(void) {
  37         assert(ifname_valid("foo"));
  38         assert(ifname_valid("eth0"));
  39
  40         assert(!ifname_valid("0"));
  41         assert(!ifname_valid("99"));
  42         assert(ifname_valid("a99"));
  43         assert(ifname_valid("99a"));
  44
  45         assert(!ifname_valid(NULL));
  46         assert(!ifname_valid(""));
  47         assert(!ifname_valid(" "));
  48         assert(!ifname_valid(" foo"));
  49         assert(!ifname_valid("bar\n"));
  50         assert(!ifname_valid("."));
  51         assert(!ifname_valid(".."));
  52         assert(ifname_valid("foo.bar"));
  53         assert(!ifname_valid("x:y"));
  54
  55         assert(ifname_valid("xxxxxxxxxxxxxxx"));
  56         assert(!ifname_valid("xxxxxxxxxxxxxxxx"));
  57 }
  58
  59 static void test_socket_address_parse(void) {
  60         SocketAddress a;
  61
  62         assert_se(socket_address_parse(&a, "junk") < 0);
  63         assert_se(socket_address_parse(&a, "192.168.1.1") < 0);
  64         assert_se(socket_address_parse(&a, ".168.1.1") < 0);
  65         assert_se(socket_address_parse(&a, "989.168.1.1") < 0);
  66         assert_se(socket_address_parse(&a, "192.168.1.1:65536") < 0);
  67         assert_se(socket_address_parse(&a, "192.168.1.1:0") < 0);
  68         assert_se(socket_address_parse(&a, "0") < 0);
  69         assert_se(socket_address_parse(&a, "65536") < 0);
  70
  71         assert_se(socket_address_parse(&a, "65535") >= 0);
  72
  73         /* The checks below will pass even if ipv6 is disabled in
  74          * kernel. The underlying glibc's inet_pton() is just a string
  75          * parser and doesn't make any syscalls. */
  76
  77         assert_se(socket_address_parse(&a, "[::1]") < 0);
  78         assert_se(socket_address_parse(&a, "[::1]8888") < 0);
  79         assert_se(socket_address_parse(&a, "::1") < 0);
  80         assert_se(socket_address_parse(&a, "[::1]:0") < 0);
  81         assert_se(socket_address_parse(&a, "[::1]:65536") < 0);
  82         assert_se(socket_address_parse(&a, "[a:b:1]:8888") < 0);
  83
  84         assert_se(socket_address_parse(&a, "8888") >= 0);
  85         assert_se(a.sockaddr.sa.sa_family == (socket_ipv6_is_supported() ? AF_INET6 : AF_INET));
  86
  87         assert_se(socket_address_parse(&a, "[2001:0db8:0000:85a3:0000:0000:ac1f:8001]:8888") >= 0);
  88         assert_se(a.sockaddr.sa.sa_family == AF_INET6);
  89
  90         assert_se(socket_address_parse(&a, "[::1]:8888") >= 0);
  91         assert_se(a.sockaddr.sa.sa_family == AF_INET6);
  92
  93         assert_se(socket_address_parse(&a, "192.168.1.254:8888") >= 0);
  94         assert_se(a.sockaddr.sa.sa_family == AF_INET);
  95
  96         assert_se(socket_address_parse(&a, "/foo/bar") >= 0);
  97         assert_se(a.sockaddr.sa.sa_family == AF_UNIX);
  98
  99         assert_se(socket_address_parse(&a, "@abstract") >= 0);
 100         assert_se(a.sockaddr.sa.sa_family == AF_UNIX);
 101
 102         assert_se(socket_address_parse(&a, "vsock::1234") >= 0);
 103         assert_se(a.sockaddr.sa.sa_family == AF_VSOCK);
 104         assert_se(socket_address_parse(&a, "vsock:2:1234") >= 0);
 105         assert_se(a.sockaddr.sa.sa_family == AF_VSOCK);
 106         assert_se(socket_address_parse(&a, "vsock:2:1234x") < 0);
 107         assert_se(socket_address_parse(&a, "vsock:2x:1234") < 0);
 108         assert_se(socket_address_parse(&a, "vsock:2") < 0);
 109 }
 110
 111 static void test_socket_address_parse_netlink(void) {
 112         SocketAddress a;
 113
 114         assert_se(socket_address_parse_netlink(&a, "junk") < 0);
 115         assert_se(socket_address_parse_netlink(&a, "") < 0);
 116
 117         assert_se(socket_address_parse_netlink(&a, "route") >= 0);
 118         assert_se(socket_address_parse_netlink(&a, "route 10") >= 0);
 119         assert_se(a.sockaddr.sa.sa_family == AF_NETLINK);
 120         assert_se(a.protocol == NETLINK_ROUTE);
 121
 122         /* With spaces and tabs */
 123         assert_se(socket_address_parse_netlink(&a, " kobject-uevent ") >= 0);
 124         assert_se(socket_address_parse_netlink(&a, " \t kobject-uevent \t 10 \t") >= 0);
 125         assert_se(a.sockaddr.sa.sa_family == AF_NETLINK);
 126         assert_se(a.protocol == NETLINK_KOBJECT_UEVENT);
 127
 128         assert_se(socket_address_parse_netlink(&a, "kobject-uevent\t10") >= 0);
 129         assert_se(a.sockaddr.sa.sa_family == AF_NETLINK);
 130         assert_se(a.protocol == NETLINK_KOBJECT_UEVENT);
 131
 132         /* oss-fuzz #6884 */
 133         assert_se(socket_address_parse_netlink(&a, "\xff") < 0);
 134 }
 135
 136 static void test_socket_address_equal(void) {
 137         SocketAddress a;
 138         SocketAddress b;
 139
 140         assert_se(socket_address_parse(&a, "192.168.1.1:8888") >= 0);
 141         assert_se(socket_address_parse(&b, "192.168.1.1:888") >= 0);
 142         assert_se(!socket_address_equal(&a, &b));
 143
 144         assert_se(socket_address_parse(&a, "192.168.1.1:8888") >= 0);
 145         assert_se(socket_address_parse(&b, "192.16.1.1:8888") >= 0);
 146         assert_se(!socket_address_equal(&a, &b));
 147
 148         assert_se(socket_address_parse(&a, "192.168.1.1:8888") >= 0);
 149         assert_se(socket_address_parse(&b, "8888") >= 0);
 150         assert_se(!socket_address_equal(&a, &b));
 151
 152         assert_se(socket_address_parse(&a, "192.168.1.1:8888") >= 0);
 153         assert_se(socket_address_parse(&b, "/foo/bar/") >= 0);
 154         assert_se(!socket_address_equal(&a, &b));
 155
 156         assert_se(socket_address_parse(&a, "192.168.1.1:8888") >= 0);
 157         assert_se(socket_address_parse(&b, "192.168.1.1:8888") >= 0);
 158         assert_se(socket_address_equal(&a, &b));
 159
 160         assert_se(socket_address_parse(&a, "/foo/bar") >= 0);
 161         assert_se(socket_address_parse(&b, "/foo/bar") >= 0);
 162         assert_se(socket_address_equal(&a, &b));
 163
 164         assert_se(socket_address_parse(&a, "[::1]:8888") >= 0);
 165         assert_se(socket_address_parse(&b, "[::1]:8888") >= 0);
 166         assert_se(socket_address_equal(&a, &b));
 167
 168         assert_se(socket_address_parse(&a, "@abstract") >= 0);
 169         assert_se(socket_address_parse(&b, "@abstract") >= 0);
 170         assert_se(socket_address_equal(&a, &b));
 171
 172         assert_se(socket_address_parse_netlink(&a, "firewall") >= 0);
 173         assert_se(socket_address_parse_netlink(&b, "firewall") >= 0);
 174         assert_se(socket_address_equal(&a, &b));
 175
 176         assert_se(socket_address_parse(&a, "vsock:2:1234") >= 0);
 177         assert_se(socket_address_parse(&b, "vsock:2:1234") >= 0);
 178         assert_se(socket_address_equal(&a, &b));
 179         assert_se(socket_address_parse(&b, "vsock:2:1235") >= 0);
 180         assert_se(!socket_address_equal(&a, &b));
 181         assert_se(socket_address_parse(&b, "vsock:3:1234") >= 0);
 182         assert_se(!socket_address_equal(&a, &b));
 183 }
 184
 185 static void test_socket_address_get_path(void) {
 186         SocketAddress a;
 187
 188         assert_se(socket_address_parse(&a, "192.168.1.1:8888") >= 0);
 189         assert_se(!socket_address_get_path(&a));
 190
 191         assert_se(socket_address_parse(&a, "@abstract") >= 0);
 192         assert_se(!socket_address_get_path(&a));
 193
 194         assert_se(socket_address_parse(&a, "[::1]:8888") >= 0);
 195         assert_se(!socket_address_get_path(&a));
 196
 197         assert_se(socket_address_parse(&a, "/foo/bar") >= 0);
 198         assert_se(streq(socket_address_get_path(&a), "/foo/bar"));
 199
 200         assert_se(socket_address_parse(&a, "vsock:2:1234") >= 0);
 201         assert_se(!socket_address_get_path(&a));
 202 }
 203
 204 static void test_socket_address_is(void) {
 205         SocketAddress a;
 206
 207         assert_se(socket_address_parse(&a, "192.168.1.1:8888") >= 0);
 208         assert_se(socket_address_is(&a, "192.168.1.1:8888", SOCK_STREAM));
 209         assert_se(!socket_address_is(&a, "route", SOCK_STREAM));
 210         assert_se(!socket_address_is(&a, "192.168.1.1:8888", SOCK_RAW));
 211 }
 212
 213 static void test_socket_address_is_netlink(void) {
 214         SocketAddress a;
 215
 216         assert_se(socket_address_parse_netlink(&a, "route 10") >= 0);
 217         assert_se(socket_address_is_netlink(&a, "route 10"));
 218         assert_se(!socket_address_is_netlink(&a, "192.168.1.1:8888"));
 219         assert_se(!socket_address_is_netlink(&a, "route 1"));
 220 }
 221
 222 static void test_in_addr_is_null(void) {
 223
 224         union in_addr_union i = {};
 225
 226         assert_se(in_addr_is_null(AF_INET, &i) == true);
 227         assert_se(in_addr_is_null(AF_INET6, &i) == true);
 228
 229         i.in.s_addr = 0x1000000;
 230         assert_se(in_addr_is_null(AF_INET, &i) == false);
 231         assert_se(in_addr_is_null(AF_INET6, &i) == false);
 232
 233         assert_se(in_addr_is_null(-1, &i) == -EAFNOSUPPORT);
 234 }
 235
 236 static void test_in_addr_prefix_intersect_one(unsigned f, const char *a, unsigned apl, const char *b, unsigned bpl, int result) {
 237         union in_addr_union ua, ub;
 238
 239         assert_se(in_addr_from_string(f, a, &ua) >= 0);
 240         assert_se(in_addr_from_string(f, b, &ub) >= 0);
 241
 242         assert_se(in_addr_prefix_intersect(f, &ua, apl, &ub, bpl) == result);
 243 }
 244
 245 static void test_in_addr_prefix_intersect(void) {
 246
 247         test_in_addr_prefix_intersect_one(AF_INET, "255.255.255.255", 32, "255.255.255.254", 32, 0);
 248         test_in_addr_prefix_intersect_one(AF_INET, "255.255.255.255", 0, "255.255.255.255", 32, 1);
 249         test_in_addr_prefix_intersect_one(AF_INET, "0.0.0.0", 0, "47.11.8.15", 32, 1);
 250
 251         test_in_addr_prefix_intersect_one(AF_INET, "1.1.1.1", 24, "1.1.1.1", 24, 1);
 252         test_in_addr_prefix_intersect_one(AF_INET, "2.2.2.2", 24, "1.1.1.1", 24, 0);
 253
 254         test_in_addr_prefix_intersect_one(AF_INET, "1.1.1.1", 24, "1.1.1.127", 25, 1);
 255         test_in_addr_prefix_intersect_one(AF_INET, "1.1.1.1", 24, "1.1.1.127", 26, 1);
 256         test_in_addr_prefix_intersect_one(AF_INET, "1.1.1.1", 25, "1.1.1.127", 25, 1);
 257         test_in_addr_prefix_intersect_one(AF_INET, "1.1.1.1", 25, "1.1.1.255", 25, 0);
 258
 259         test_in_addr_prefix_intersect_one(AF_INET6, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 128, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe", 128, 0);
 260         test_in_addr_prefix_intersect_one(AF_INET6, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 0, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 128, 1);
 261         test_in_addr_prefix_intersect_one(AF_INET6, "::", 0, "beef:beef:beef:beef:beef:beef:beef:beef", 128, 1);
 262
 263         test_in_addr_prefix_intersect_one(AF_INET6, "1::2", 64, "1::2", 64, 1);
 264         test_in_addr_prefix_intersect_one(AF_INET6, "2::2", 64, "1::2", 64, 0);
 265
 266         test_in_addr_prefix_intersect_one(AF_INET6, "1::1", 120, "1::007f", 121, 1);
 267         test_in_addr_prefix_intersect_one(AF_INET6, "1::1", 120, "1::007f", 122, 1);
 268         test_in_addr_prefix_intersect_one(AF_INET6, "1::1", 121, "1::007f", 121, 1);
 269         test_in_addr_prefix_intersect_one(AF_INET6, "1::1", 121, "1::00ff", 121, 0);
 270 }
 271
 272 static void test_in_addr_prefix_next_one(unsigned f, const char *before, unsigned pl, const char *after) {
 273         union in_addr_union ubefore, uafter, t;
 274
 275         assert_se(in_addr_from_string(f, before, &ubefore) >= 0);
 276
 277         t = ubefore;
 278         assert_se((in_addr_prefix_next(f, &t, pl) > 0) == !!after);
 279
 280         if (after) {
 281                 assert_se(in_addr_from_string(f, after, &uafter) >= 0);
 282                 assert_se(in_addr_equal(f, &t, &uafter) > 0);
 283         }
 284 }
 285
 286 static void test_in_addr_prefix_next(void) {
 287
 288         test_in_addr_prefix_next_one(AF_INET, "192.168.0.0", 24, "192.168.1.0");
 289         test_in_addr_prefix_next_one(AF_INET, "192.168.0.0", 16, "192.169.0.0");
 290         test_in_addr_prefix_next_one(AF_INET, "192.168.0.0", 20, "192.168.16.0");
 291
 292         test_in_addr_prefix_next_one(AF_INET, "0.0.0.0", 32, "0.0.0.1");
 293         test_in_addr_prefix_next_one(AF_INET, "255.255.255.255", 32, NULL);
 294         test_in_addr_prefix_next_one(AF_INET, "255.255.255.0", 24, NULL);
 295
 296         test_in_addr_prefix_next_one(AF_INET6, "4400::", 128, "4400::0001");
 297         test_in_addr_prefix_next_one(AF_INET6, "4400::", 120, "4400::0100");
 298         test_in_addr_prefix_next_one(AF_INET6, "4400::", 127, "4400::0002");
 299         test_in_addr_prefix_next_one(AF_INET6, "4400::", 8, "4500::");
 300         test_in_addr_prefix_next_one(AF_INET6, "4400::", 7, "4600::");
 301
 302         test_in_addr_prefix_next_one(AF_INET6, "::", 128, "::1");
 303
 304         test_in_addr_prefix_next_one(AF_INET6, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 128, NULL);
 305         test_in_addr_prefix_next_one(AF_INET6, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff00", 120, NULL);
 306
 307 }
 308
 309 static void test_in_addr_to_string_one(int f, const char *addr) {
 310         union in_addr_union ua;
 311         _cleanup_free_ char *r = NULL;
 312
 313         assert_se(in_addr_from_string(f, addr, &ua) >= 0);
 314         assert_se(in_addr_to_string(f, &ua, &r) >= 0);
 315         printf("test_in_addr_to_string_one: %s == %s\n", addr, r);
 316         assert_se(streq(addr, r));
 317 }
 318
 319 static void test_in_addr_to_string(void) {
 320         test_in_addr_to_string_one(AF_INET, "192.168.0.1");
 321         test_in_addr_to_string_one(AF_INET, "10.11.12.13");
 322         test_in_addr_to_string_one(AF_INET6, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
 323         test_in_addr_to_string_one(AF_INET6, "::1");
 324         test_in_addr_to_string_one(AF_INET6, "fe80::");
 325 }
 326
 327 static void test_in_addr_ifindex_to_string_one(int f, const char *a, int ifindex, const char *b) {
 328         _cleanup_free_ char *r = NULL;
 329         union in_addr_union ua, uuaa;
 330         int ff, ifindex2;
 331
 332         assert_se(in_addr_from_string(f, a, &ua) >= 0);
 333         assert_se(in_addr_ifindex_to_string(f, &ua, ifindex, &r) >= 0);
 334         printf("test_in_addr_ifindex_to_string_one: %s == %s\n", b, r);
 335         assert_se(streq(b, r));
 336
 337         assert_se(in_addr_ifindex_from_string_auto(b, &ff, &uuaa, &ifindex2) >= 0);
 338         assert_se(ff == f);
 339         assert_se(in_addr_equal(f, &ua, &uuaa));
 340         assert_se(ifindex2 == ifindex || ifindex2 == 0);
 341 }
 342
 343 static void test_in_addr_ifindex_to_string(void) {
 344         test_in_addr_ifindex_to_string_one(AF_INET, "192.168.0.1", 7, "192.168.0.1");
 345         test_in_addr_ifindex_to_string_one(AF_INET, "10.11.12.13", 9, "10.11.12.13");
 346         test_in_addr_ifindex_to_string_one(AF_INET6, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 10, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
 347         test_in_addr_ifindex_to_string_one(AF_INET6, "::1", 11, "::1");
 348         test_in_addr_ifindex_to_string_one(AF_INET6, "fe80::", 12, "fe80::%12");
 349         test_in_addr_ifindex_to_string_one(AF_INET6, "fe80::", 0, "fe80::");
 350         test_in_addr_ifindex_to_string_one(AF_INET6, "fe80::14", 12, "fe80::14%12");
 351         test_in_addr_ifindex_to_string_one(AF_INET6, "fe80::15", -7, "fe80::15");
 352         test_in_addr_ifindex_to_string_one(AF_INET6, "fe80::16", LOOPBACK_IFINDEX, "fe80::16%1");
 353 }
 354
 355 static void test_in_addr_ifindex_from_string_auto(void) {
 356         int family, ifindex;
 357         union in_addr_union ua;
 358
 359         /* Most in_addr_ifindex_from_string_auto() invocations have already been tested above, but let's test some more */
 360
 361         assert_se(in_addr_ifindex_from_string_auto("fe80::17", &family, &ua, &ifindex) >= 0);
 362         assert_se(family == AF_INET6);
 363         assert_se(ifindex == 0);
 364
 365         assert_se(in_addr_ifindex_from_string_auto("fe80::18%19", &family, &ua, &ifindex) >= 0);
 366         assert_se(family == AF_INET6);
 367         assert_se(ifindex == 19);
 368
 369         assert_se(in_addr_ifindex_from_string_auto("fe80::18%lo", &family, &ua, &ifindex) >= 0);
 370         assert_se(family == AF_INET6);
 371         assert_se(ifindex == LOOPBACK_IFINDEX);
 372
 373         assert_se(in_addr_ifindex_from_string_auto("fe80::19%thisinterfacecantexist", &family, &ua, &ifindex) == -ENODEV);
 374 }
 375
 376 static void test_sockaddr_equal(void) {
 377         union sockaddr_union a = {
 378                 .in.sin_family = AF_INET,
 379                 .in.sin_port = 0,
 380                 .in.sin_addr.s_addr = htobe32(INADDR_ANY),
 381         };
 382         union sockaddr_union b = {
 383                 .in.sin_family = AF_INET,
 384                 .in.sin_port = 0,
 385                 .in.sin_addr.s_addr = htobe32(INADDR_ANY),
 386         };
 387         union sockaddr_union c = {
 388                 .in.sin_family = AF_INET,
 389                 .in.sin_port = 0,
 390                 .in.sin_addr.s_addr = htobe32(1234),
 391         };
 392         union sockaddr_union d = {
 393                 .in6.sin6_family = AF_INET6,
 394                 .in6.sin6_port = 0,
 395                 .in6.sin6_addr = IN6ADDR_ANY_INIT,
 396         };
 397         union sockaddr_union e = {
 398                 .vm.svm_family = AF_VSOCK,
 399                 .vm.svm_port = 0,
 400                 .vm.svm_cid = VMADDR_CID_ANY,
 401         };
 402         assert_se(sockaddr_equal(&a, &a));
 403         assert_se(sockaddr_equal(&a, &b));
 404         assert_se(sockaddr_equal(&d, &d));
 405         assert_se(sockaddr_equal(&e, &e));
 406         assert_se(!sockaddr_equal(&a, &c));
 407         assert_se(!sockaddr_equal(&b, &c));
 408         assert_se(!sockaddr_equal(&a, &e));
 409 }
 410
 411 static void test_sockaddr_un_len(void) {
 412         static const struct sockaddr_un fs = {
 413                 .sun_family = AF_UNIX,
 414                 .sun_path = "/foo/bar/waldo",
 415         };
 416
 417         static const struct sockaddr_un abstract = {
 418                 .sun_family = AF_UNIX,
 419                 .sun_path = "\0foobar",
 420         };
 421
 422         assert_se(SOCKADDR_UN_LEN(fs) == offsetof(struct sockaddr_un, sun_path) + strlen(fs.sun_path));
 423         assert_se(SOCKADDR_UN_LEN(abstract) == offsetof(struct sockaddr_un, sun_path) + 1 + strlen(abstract.sun_path + 1));
 424 }
 425
 426 static void test_in_addr_is_multicast(void) {
 427         union in_addr_union a, b;
 428         int f;
 429
 430         assert_se(in_addr_from_string_auto("192.168.3.11", &f, &a) >= 0);
 431         assert_se(in_addr_is_multicast(f, &a) == 0);
 432
 433         assert_se(in_addr_from_string_auto("224.0.0.1", &f, &a) >= 0);
 434         assert_se(in_addr_is_multicast(f, &a) == 1);
 435
 436         assert_se(in_addr_from_string_auto("FF01:0:0:0:0:0:0:1", &f, &b) >= 0);
 437         assert_se(in_addr_is_multicast(f, &b) == 1);
 438
 439         assert_se(in_addr_from_string_auto("2001:db8::c:69b:aeff:fe53:743e", &f, &b) >= 0);
 440         assert_se(in_addr_is_multicast(f, &b) == 0);
 441 }
 442
 443 static void test_getpeercred_getpeergroups(void) {
 444         int r;
 445
 446         r = safe_fork("(getpeercred)", FORK_DEATHSIG|FORK_LOG|FORK_WAIT, NULL);
 447         assert_se(r >= 0);
 448
 449         if (r == 0) {
 450                 static const gid_t gids[] = { 3, 4, 5, 6, 7 };
 451                 gid_t *test_gids;
 452                 _cleanup_free_ gid_t *peer_groups = NULL;
 453                 size_t n_test_gids;
 454                 uid_t test_uid;
 455                 gid_t test_gid;
 456                 struct ucred ucred;
 457                 int pair[2];
 458
 459                 if (geteuid() == 0) {
 460                         test_uid = 1;
 461                         test_gid = 2;
 462                         test_gids = (gid_t*) gids;
 463                         n_test_gids = ELEMENTSOF(gids);
 464
 465                         assert_se(setgroups(n_test_gids, test_gids) >= 0);
 466                         assert_se(setresgid(test_gid, test_gid, test_gid) >= 0);
 467                         assert_se(setresuid(test_uid, test_uid, test_uid) >= 0);
 468
 469                 } else {
 470                         long ngroups_max;
 471
 472                         test_uid = getuid();
 473                         test_gid = getgid();
 474
 475                         ngroups_max = sysconf(_SC_NGROUPS_MAX);
 476                         assert(ngroups_max > 0);
 477
 478                         test_gids = newa(gid_t, ngroups_max);
 479
 480                         r = getgroups(ngroups_max, test_gids);
 481                         assert_se(r >= 0);
 482                         n_test_gids = (size_t) r;
 483                 }
 484
 485                 assert_se(socketpair(AF_UNIX, SOCK_STREAM, 0, pair) >= 0);
 486
 487                 assert_se(getpeercred(pair[0], &ucred) >= 0);
 488
 489                 assert_se(ucred.uid == test_uid);
 490                 assert_se(ucred.gid == test_gid);
 491                 assert_se(ucred.pid == getpid_cached());
 492
 493                 r = getpeergroups(pair[0], &peer_groups);
 494                 assert_se(r >= 0 || IN_SET(r, -EOPNOTSUPP, -ENOPROTOOPT));
 495
 496                 if (r >= 0) {
 497                         assert_se((size_t) r == n_test_gids);
 498                         assert_se(memcmp(peer_groups, test_gids, sizeof(gid_t) * n_test_gids) == 0);
 499                 }
 500
 501                 safe_close_pair(pair);
 502         }
 503 }
 504
 505 int main(int argc, char *argv[]) {
 506
 507         log_set_max_level(LOG_DEBUG);
 508
 509         test_ifname_valid();
 510
 511         test_socket_address_parse();
 512         test_socket_address_parse_netlink();
 513         test_socket_address_equal();
 514         test_socket_address_get_path();
 515         test_socket_address_is();
 516         test_socket_address_is_netlink();
 517
 518         test_in_addr_is_null();
 519         test_in_addr_prefix_intersect();
 520         test_in_addr_prefix_next();
 521         test_in_addr_to_string();
 522         test_in_addr_ifindex_to_string();
 523         test_in_addr_ifindex_from_string_auto();
 524
 525         test_sockaddr_equal();
 526
 527         test_sockaddr_un_len();
 528
 529         test_in_addr_is_multicast();
 530
 531         test_getpeercred_getpeergroups();
 532
 533         return 0;
 534 }