sysdeps/unix/sysv/linux/tst-ttyname-common.c

   1 /* Common definitions for ttyname tests.
   2    Copyright (C) 2017-2024 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public License as
   7    published by the Free Software Foundation; either version 2.1 of the
   8    License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If
  17    not, see <https://www.gnu.org/licenses/>.  */
  18
  19 #include <dirent.h>
  20 #include <errno.h>
  21 #include <fcntl.h>
  22 #include <limits.h>
  23 #include <stdbool.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <sys/mount.h>
  28 #include <sys/resource.h>
  29 #include <sys/stat.h>
  30 #include <unistd.h>
  31
  32 #include <support/check.h>
  33 #include <support/support.h>
  34 #include <support/temp_file.h>
  35 #include <support/test-driver.h>
  36 #include <support/xunistd.h>
  37
  38 /* generic utilities */
  39
  40 #define VERIFY(expr)                                                    \
  41   do {                                                                  \
  42     if (!(expr))                                                        \
  43       {                                                                 \
  44         printf ("error: %s:%d: %s: %m\n",                               \
  45                 __FILE__, __LINE__, #expr);                             \
  46         exit (1);                                                       \
  47       }                                                                 \
  48   } while (0)
  49
  50 static void
  51 touch (const char *path, mode_t mode)
  52 {
  53   xclose (xopen (path, O_WRONLY|O_CREAT|O_NOCTTY, mode));
  54 }
  55
  56 static size_t
  57 trim_prefix (char *str, size_t str_len, const char *prefix)
  58 {
  59   size_t prefix_len = strlen (prefix);
  60   if (str_len > prefix_len && memcmp (str, prefix, prefix_len) == 0)
  61     {
  62       memmove (str, str + prefix_len, str_len - prefix_len);
  63       return str_len - prefix_len;
  64     }
  65   return str_len;
  66 }
  67
  68 /* returns a pointer to static storage */
  69 static char *
  70 proc_fd_readlink (const char *linkname)
  71 {
  72   static char target[PATH_MAX+1];
  73   ssize_t target_len = readlink (linkname, target, PATH_MAX);
  74   VERIFY (target_len > 0);
  75   target_len = trim_prefix (target, target_len, "(unreachable)");
  76   target[target_len] = '\0';
  77   return target;
  78 }
  79
  80 /* plain ttyname runner */
  81
  82 struct result
  83 {
  84   const char *name;
  85   int err;
  86 };
  87
  88 /* strings in result structure are in static storage */
  89 static struct result
  90 run_ttyname (int fd)
  91 {
  92   struct result ret;
  93   errno = 0;
  94   ret.name = ttyname (fd);
  95   ret.err = errno;
  96   return ret;
  97 }
  98
  99 static bool
 100 eq_ttyname (struct result actual, struct result expected)
 101 {
 102   char *actual_name, *expected_name;
 103
 104   if ((actual.err == expected.err)
 105       && (!actual.name == !expected.name)
 106       && (actual.name ? strcmp (actual.name, expected.name) == 0 : true))
 107     {
 108       if (expected.name)
 109         expected_name = xasprintf ("\"%s\"", expected.name);
 110       else
 111         expected_name = xstrdup ("NULL");
 112
 113       printf ("info:      ttyname: PASS {name=%s, errno=%d}\n",
 114               expected_name, expected.err);
 115
 116       free (expected_name);
 117       return true;
 118     }
 119
 120   if (actual.name)
 121     actual_name = xasprintf ("\"%s\"", actual.name);
 122   else
 123     actual_name = xstrdup ("NULL");
 124
 125   if (expected.name)
 126     expected_name = xasprintf ("\"%s\"", expected.name);
 127   else
 128     expected_name = xstrdup ("NULL");
 129
 130   printf ("error:     ttyname: actual {name=%s, errno=%d} != expected {name=%s, errno=%d}\n",
 131           actual_name, actual.err,
 132           expected_name, expected.err);
 133
 134   free (actual_name);
 135   free (expected_name);
 136   return false;
 137 }
 138
 139 /* ttyname_r runner */
 140
 141 struct result_r
 142 {
 143   const char *name;
 144   int ret;
 145   int err;
 146 };
 147
 148 /* strings in result structure are in static storage */
 149 static struct result_r
 150 run_ttyname_r (int fd)
 151 {
 152   static char buf[TTY_NAME_MAX];
 153
 154   struct result_r ret;
 155   errno = 0;
 156   ret.ret = ttyname_r (fd, buf, TTY_NAME_MAX);
 157   ret.err = errno;
 158   if (ret.ret == 0)
 159     ret.name = buf;
 160   else
 161     ret.name = NULL;
 162   return ret;
 163 }
 164
 165 static bool
 166 eq_ttyname_r (struct result_r actual, struct result_r expected)
 167 {
 168   char *actual_name, *expected_name;
 169
 170   if ((actual.err == expected.err)
 171       && (actual.ret == expected.ret)
 172       && (!actual.name == !expected.name)
 173       && (actual.name ? strcmp (actual.name, expected.name) == 0 : true))
 174     {
 175       if (expected.name)
 176         expected_name = xasprintf ("\"%s\"", expected.name);
 177       else
 178         expected_name = xstrdup ("NULL");
 179
 180       printf ("info:      ttyname_r: PASS {name=%s, ret=%d, errno=%d}\n",
 181               expected_name, expected.ret, expected.err);
 182
 183       free (expected_name);
 184       return true;
 185     }
 186
 187   if (actual.name)
 188     actual_name = xasprintf ("\"%s\"", actual.name);
 189   else
 190     actual_name = xstrdup ("NULL");
 191
 192   if (expected.name)
 193     expected_name = xasprintf ("\"%s\"", expected.name);
 194   else
 195     expected_name = xstrdup ("NULL");
 196
 197   printf ("error:     ttyname_r: actual {name=%s, ret=%d, errno=%d} != expected {name=%s, ret=%d, errno=%d}\n",
 198           actual_name, actual.ret, actual.err,
 199           expected_name, expected.ret, expected.err);
 200
 201   free (actual_name);
 202   free (expected_name);
 203   return false;
 204 }
 205
 206 /* combined runner */
 207
 208 static bool
 209 doit (int fd, const char *testname, struct result_r expected_r)
 210 {
 211   struct result expected = {.name=expected_r.name, .err=expected_r.ret};
 212   bool ret = true;
 213
 214   printf ("info:    testcase: %s\n", testname);
 215
 216   if (!eq_ttyname (run_ttyname (fd), expected))
 217     ret = false;
 218   if (!eq_ttyname_r (run_ttyname_r (fd), expected_r))
 219     ret = false;
 220
 221   if (!ret)
 222     support_record_failure ();
 223
 224   return ret;
 225 }
 226
 227 /* chroot setup */
 228
 229 static char *chrootdir;
 230
 231 static void
 232 prepare (int argc, char **argv)
 233 {
 234   chrootdir = xasprintf ("%s/tst-ttyname-XXXXXX", test_dir);
 235   if (mkdtemp (chrootdir) == NULL)
 236     FAIL_EXIT1 ("mkdtemp (\"%s\"): %m", chrootdir);
 237   add_temp_file (chrootdir);
 238 }
 239 #define PREPARE prepare
 240
 241 /* Adjust the file limit so that we have a chance to open PTY.  */
 242 static void
 243 adjust_file_limit (const char *pty)
 244 {
 245   int number = -1;
 246   if (sscanf (pty, "/dev/pts/%d", &number) != 1 || number < 0)
 247     FAIL_EXIT1 ("invalid PTY name: \"%s\"", pty);
 248
 249   /* Add a few additional descriptors to cover standard I/O streams
 250      etc.  */
 251   rlim_t desired_limit = number + 10;
 252
 253   struct rlimit lim;
 254   if (getrlimit (RLIMIT_NOFILE, &lim) != 0)
 255     FAIL_EXIT1 ("getrlimit (RLIMIT_NOFILE): %m");
 256   if (lim.rlim_cur < desired_limit)
 257     {
 258       printf ("info: adjusting RLIMIT_NOFILE from %llu to %llu\n",
 259               (unsigned long long int) lim.rlim_cur,
 260               (unsigned long long int) desired_limit);
 261       lim.rlim_cur = desired_limit;
 262       if (setrlimit (RLIMIT_NOFILE, &lim) != 0)
 263         printf ("warning: setrlimit (RLIMIT_NOFILE) failed: %m\n");
 264     }
 265 }
 266
 267 /* main test */
 268
 269 static int
 270 run_chroot_tests (const char *slavename, int slave)
 271 {
 272   struct stat st;
 273   bool ok = true;
 274
 275   /* There are 3 groups of tests here.  The first group fairly
 276      generically does things known to mess up ttyname, and verifies
 277      that ttyname copes correctly.  The remaining groups are
 278      increasingly convoluted, as we target specific parts of ttyname
 279      to try to confuse.  */
 280
 281   /* Basic tests that it doesn't get confused by multiple devpts
 282      instances.  */
 283   {
 284     VERIFY (stat (slavename, &st) < 0); /* sanity check */
 285     if (!doit (slave, "no conflict, no match",
 286                (struct result_r){.name=NULL, .ret=ENODEV, .err=ENODEV}))
 287       ok = false;
 288     VERIFY (mount ("/console", "/dev/console", NULL, MS_BIND, NULL) == 0);
 289     if (!doit (slave, "no conflict, console",
 290                (struct result_r){.name="/dev/console", .ret=0, .err=0}))
 291       ok = false;
 292     VERIFY (umount ("/dev/console") == 0);
 293
 294     /* Keep creating PTYs until we we get a name collision.  */
 295     while (true)
 296       {
 297         if (stat (slavename, &st) == 0)
 298           break;
 299         if (posix_openpt (O_RDWR|O_NOCTTY|O_NONBLOCK) < 0)
 300           {
 301             if (errno == ENOSPC || errno == EMFILE || errno == ENFILE)
 302               FAIL_UNSUPPORTED ("cannot re-create PTY \"%s\" in chroot: %m"
 303                                 " (consider increasing limits)", slavename);
 304             else
 305               FAIL_EXIT1 ("cannot re-create PTY \"%s\" chroot: %m", slavename);
 306           }
 307       }
 308
 309     if (!doit (slave, "conflict, no match",
 310                (struct result_r){.name=NULL, .ret=ENODEV, .err=ENODEV}))
 311       ok = false;
 312     VERIFY (mount ("/console", "/dev/console", NULL, MS_BIND, NULL) == 0);
 313     if (!doit (slave, "conflict, console",
 314                (struct result_r){.name="/dev/console", .ret=0, .err=0}))
 315       ok = false;
 316     VERIFY (umount ("/dev/console") == 0);
 317   }
 318
 319   /* The first tests kinda assumed that they hit certain code-paths
 320      based on assuming that the readlink target is 'slavename', but
 321      that's not quite always true.  They're still a good preliminary
 322      sanity check, so keep them, but let's add tests that make sure
 323      that those code-paths are hit by doing a readlink ourself.  */
 324   {
 325     char *linkname = xasprintf ("/proc/self/fd/%d", slave);
 326     char *target = proc_fd_readlink (linkname);
 327     free (linkname);
 328     /* Depending on how we set up the chroot, the kernel may or may not
 329        trim the leading path to the target (it may give us "/6",
 330        instead of "/dev/pts/6").  We test it both ways (do_in_chroot_1
 331        and do_in_chroot_2).  This test group relies on the target
 332        existing, so guarantee that it does exist by creating it if
 333        necessary.  */
 334     if (stat (target, &st) < 0)
 335       {
 336         VERIFY (errno == ENOENT);
 337         touch (target, 0);
 338       }
 339
 340     VERIFY (mount ("/console", "/dev/console", NULL, MS_BIND, NULL) == 0);
 341     VERIFY (mount ("/console", target, NULL, MS_BIND, NULL) == 0);
 342     if (!doit (slave, "with readlink target",
 343                (struct result_r){.name=target, .ret=0, .err=0}))
 344       ok = false;
 345     VERIFY (umount (target) == 0);
 346     VERIFY (umount ("/dev/console") == 0);
 347
 348     VERIFY (mount ("/console", "/dev/console", NULL, MS_BIND, NULL) == 0);
 349     VERIFY (mount (slavename, target, NULL, MS_BIND, NULL) == 0);
 350     if (!doit (slave, "with readlink trap; fallback",
 351                (struct result_r){.name="/dev/console", .ret=0, .err=0}))
 352       ok = false;
 353     VERIFY (umount (target) == 0);
 354     VERIFY (umount ("/dev/console") == 0);
 355
 356     VERIFY (mount (slavename, target, NULL, MS_BIND, NULL) == 0);
 357     if (!doit (slave, "with readlink trap; no fallback",
 358                (struct result_r){.name=NULL, .ret=ENODEV, .err=ENODEV}))
 359       ok = false;
 360     VERIFY (umount (target) == 0);
 361   }
 362
 363   /* This test makes sure that everything still works OK if readdir
 364      finds a pseudo-match before and/or after the actual match.  Now,
 365      to do that, we need to control that readdir finds the
 366      pseudo-matches before and after the actual match; and there's no
 367      good way to control that order in absence of whitebox testing.
 368      So, just create 3 files, then use opendir/readdir to see what
 369      order they are in, and assign meaning based on that order, not by
 370      name; assigning the first to be a pseudo-match, the second to be
 371      the actual match, and the third to be a pseudo-match.  This
 372      assumes that (on tmpfs) ordering within the directory is stable
 373      in the absence of modification, which seems reasonably safe.  */
 374   {
 375     /* since we're testing the fallback search, disable the readlink
 376        happy-path */
 377     VERIFY (umount2 ("/proc", MNT_DETACH) == 0);
 378
 379     touch ("/dev/console1", 0);
 380     touch ("/dev/console2", 0);
 381     touch ("/dev/console3", 0);
 382
 383     char *c[3];
 384     int ci = 0;
 385     DIR *dirstream = opendir ("/dev");
 386     VERIFY (dirstream != NULL);
 387     struct dirent *d;
 388     while ((d = readdir (dirstream)) != NULL && ci < 3)
 389       {
 390         if (strcmp (d->d_name, "console1")
 391             && strcmp (d->d_name, "console2")
 392             && strcmp (d->d_name, "console3") )
 393           continue;
 394         c[ci++] = xasprintf ("/dev/%s", d->d_name);
 395       }
 396     VERIFY (ci == 3);
 397     VERIFY (closedir (dirstream) == 0);
 398
 399     VERIFY (mount (slavename, c[0], NULL, MS_BIND, NULL) == 0);
 400     VERIFY (mount ("/console", c[1], NULL, MS_BIND, NULL) == 0);
 401     VERIFY (mount (slavename, c[2], NULL, MS_BIND, NULL) == 0);
 402     VERIFY (umount2 ("/dev/pts", MNT_DETACH) == 0);
 403     if (!doit (slave, "with search-path trap",
 404                (struct result_r){.name=c[1], .ret=0, .err=0}))
 405       ok = false;
 406     for (int i = 0; i < 3; i++)
 407       {
 408         VERIFY (umount (c[i]) == 0);
 409         VERIFY (unlink (c[i]) == 0);
 410         free (c[i]);
 411       }
 412   }
 413
 414   return ok ? 0 : 1;
 415 }