posix/tst-getopt-cancel.c

   1 /* Copyright (C) 2017-2023 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <https://www.gnu.org/licenses/>.  */
  17
  18 /* fprintf is a cancellation point, but getopt is not supposed to be a
  19    cancellation point, even when it prints error messages.  */
  20
  21 /* Note: getopt.h must be included first in this file, so we get the
  22    GNU getopt rather than the POSIX one.  */
  23 #include <getopt.h>
  24
  25 #include <stdbool.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28
  29 #include <fcntl.h>
  30 #include <pthread.h>
  31 #include <unistd.h>
  32
  33 #include <support/support.h>
  34 #include <support/temp_file.h>
  35 #include <support/xthread.h>
  36 #include <support/xunistd.h>
  37
  38 static bool
  39 check_stderr (bool expect_errmsg, FILE *stderr_trapped)
  40 {
  41   static char *lineptr = 0;
  42   static size_t linesz = 0;
  43
  44   bool got_errmsg = false;
  45   rewind (stderr_trapped);
  46   while (getline (&lineptr, &linesz, stderr_trapped) > 0)
  47     {
  48       got_errmsg = true;
  49       fputs (lineptr, stdout);
  50     }
  51   rewind (stderr_trapped);
  52   xftruncate (fileno (stderr_trapped), 0);
  53   return got_errmsg == expect_errmsg;
  54 }
  55
  56 struct test_short
  57 {
  58   const char *label;
  59   const char *opts;
  60   const char *const argv[8];
  61   int argc;
  62   bool expect_errmsg;
  63 };
  64
  65 struct test_long
  66 {
  67   const char *label;
  68   const char *opts;
  69   const struct option longopts[4];
  70   const char *const argv[8];
  71   int argc;
  72   bool expect_errmsg;
  73 };
  74
  75 #define DEFINE_TEST_DRIVER(test_type, getopt_call)                      \
  76   struct test_type##_tdata                                              \
  77   {                                                                     \
  78     pthread_mutex_t *sync;                                              \
  79     const struct test_type *tcase;                                      \
  80     bool ok;                                                            \
  81   };                                                                    \
  82                                                                         \
  83   static void *                                                         \
  84   test_type##_threadproc (void *data)                                   \
  85   {                                                                     \
  86     struct test_type##_tdata *tdata = data;                             \
  87     const struct test_type *tc = tdata->tcase;                          \
  88                                                                         \
  89     xpthread_mutex_lock (tdata->sync);                                  \
  90     xpthread_mutex_unlock (tdata->sync);                                \
  91                                                                         \
  92     /* At this point, this thread has a cancellation pending.           \
  93        We should still be able to get all the way through a getopt      \
  94        loop without being cancelled.                                    \
  95        Setting optind to 0 forces getopt to reinitialize itself.  */    \
  96     optind = 0;                                                         \
  97     opterr = 1;                                                         \
  98     optopt = 0;                                                         \
  99     while (getopt_call != -1)                                           \
 100       ;                                                                 \
 101     tdata->ok = true;                                                   \
 102                                                                         \
 103     pthread_testcancel();                                               \
 104     return 0;                                                           \
 105   }                                                                     \
 106                                                                         \
 107   static bool                                                           \
 108   do_##test_type (const struct test_type *tcase, FILE *stderr_trapped)  \
 109   {                                                                     \
 110     pthread_mutex_t sync;                                               \
 111     struct test_type##_tdata tdata;                                     \
 112                                                                         \
 113     printf("begin: %s\n", tcase->label);                                \
 114                                                                         \
 115     xpthread_mutex_init (&sync, 0);                                     \
 116     xpthread_mutex_lock (&sync);                                        \
 117                                                                         \
 118     tdata.sync = &sync;                                                 \
 119     tdata.tcase = tcase;                                                \
 120     tdata.ok = false;                                                   \
 121                                                                         \
 122     pthread_t thr = xpthread_create (0, test_type##_threadproc,         \
 123                                      (void *)&tdata);                   \
 124     xpthread_cancel (thr);                                              \
 125     xpthread_mutex_unlock (&sync);                                      \
 126     void *rv = xpthread_join (thr);                                     \
 127                                                                         \
 128     xpthread_mutex_destroy (&sync);                                     \
 129                                                                         \
 130     bool ok = true;                                                     \
 131     if (!check_stderr (tcase->expect_errmsg, stderr_trapped))           \
 132       {                                                                 \
 133         ok = false;                                                     \
 134         printf("FAIL: %s: stderr not as expected\n", tcase->label);     \
 135       }                                                                 \
 136     if (!tdata.ok)                                                      \
 137       {                                                                 \
 138         ok = false;                                                     \
 139         printf("FAIL: %s: did not complete loop\n", tcase->label);      \
 140       }                                                                 \
 141     if (rv != PTHREAD_CANCELED)                                         \
 142       {                                                                 \
 143         ok = false;                                                     \
 144         printf("FAIL: %s: thread was not cancelled\n", tcase->label);   \
 145       }                                                                 \
 146     if (ok)                                                             \
 147       printf ("pass: %s\n", tcase->label);                              \
 148     return ok;                                                          \
 149   }
 150
 151 DEFINE_TEST_DRIVER (test_short,
 152                     getopt (tc->argc, (char *const *)tc->argv, tc->opts))
 153 DEFINE_TEST_DRIVER (test_long,
 154                     getopt_long (tc->argc, (char *const *)tc->argv,
 155                                  tc->opts, tc->longopts, 0))
 156
 157 /* Caution: all option strings must begin with a '+' or '-' so that
 158    getopt does not attempt to permute the argument vector (which is in
 159    read-only memory).  */
 160 const struct test_short tests_short[] = {
 161   { "no errors",
 162     "+ab:c", { "program", "-ac", "-b", "x", 0 }, 4, false },
 163   { "invalid option",
 164     "+ab:c", { "program", "-d", 0 },             2, true },
 165   { "missing argument",
 166     "+ab:c", { "program", "-b", 0 },             2, true },
 167   { 0 }
 168 };
 169
 170 const struct test_long tests_long[] = {
 171   { "no errors (long)",
 172     "+ab:c", { { "alpha",   no_argument,       0, 'a' },
 173                { "bravo",   required_argument, 0, 'b' },
 174                { "charlie", no_argument,       0, 'c' },
 175                { 0 } },
 176     { "program", "-a", "--charlie", "--bravo=x", 0 }, 4, false },
 177
 178   { "invalid option (long)",
 179     "+ab:c", { { "alpha",   no_argument,       0, 'a' },
 180                { "bravo",   required_argument, 0, 'b' },
 181                { "charlie", no_argument,       0, 'c' },
 182                { 0 } },
 183     { "program", "-a", "--charlie", "--dingo", 0 }, 4, true },
 184
 185   { "unwanted argument",
 186     "+ab:c", { { "alpha",   no_argument,       0, 'a' },
 187                { "bravo",   required_argument, 0, 'b' },
 188                { "charlie", no_argument,       0, 'c' },
 189                { 0 } },
 190     { "program", "-a", "--charlie=dingo", "--bravo=x", 0 }, 4, true },
 191
 192   { "missing argument",
 193     "+ab:c", { { "alpha",   no_argument,       0, 'a' },
 194                { "bravo",   required_argument, 0, 'b' },
 195                { "charlie", no_argument,       0, 'c' },
 196                { 0 } },
 197     { "program", "-a", "--charlie", "--bravo", 0 }, 4, true },
 198
 199   { "ambiguous options",
 200     "+uvw", { { "veni", no_argument, 0, 'u' },
 201               { "vedi", no_argument, 0, 'v' },
 202               { "veci", no_argument, 0, 'w' } },
 203     { "program", "--ve", 0 }, 2, true },
 204
 205   { "no errors (long W)",
 206     "+ab:cW;", { { "alpha",   no_argument,       0, 'a' },
 207                  { "bravo",   required_argument, 0, 'b' },
 208                  { "charlie", no_argument,       0, 'c' },
 209                  { 0 } },
 210     { "program", "-a", "-W", "charlie", "-W", "bravo=x", 0 }, 6, false },
 211
 212   { "missing argument (W itself)",
 213     "+ab:cW;", { { "alpha",   no_argument,       0, 'a' },
 214                  { "bravo",   required_argument, 0, 'b' },
 215                  { "charlie", no_argument,       0, 'c' },
 216                  { 0 } },
 217     { "program", "-a", "-W", "charlie", "-W", 0 }, 5, true },
 218
 219   { "missing argument (W longopt)",
 220     "+ab:cW;", { { "alpha",   no_argument,       0, 'a' },
 221                  { "bravo",   required_argument, 0, 'b' },
 222                  { "charlie", no_argument,       0, 'c' },
 223                  { 0 } },
 224     { "program", "-a", "-W", "charlie", "-W", "bravo", 0 }, 6, true },
 225
 226   { "unwanted argument (W longopt)",
 227     "+ab:cW;", { { "alpha",   no_argument,       0, 'a' },
 228                  { "bravo",   required_argument, 0, 'b' },
 229                  { "charlie", no_argument,       0, 'c' },
 230                  { 0 } },
 231     { "program", "-a", "-W", "charlie=dingo", "-W", "bravo=x", 0 }, 6, true },
 232
 233   { "ambiguous options (W)",
 234     "+uvwW;", { { "veni", no_argument, 0, 'u' },
 235                 { "vedi", no_argument, 0, 'v' },
 236                 { "veci", no_argument, 0, 'w' } },
 237     { "program", "-W", "ve", 0 }, 3, true },
 238
 239   { 0 }
 240 };
 241
 242 static int
 243 do_test (void)
 244 {
 245   int stderr_trap = create_temp_file ("stderr", 0);
 246   if (stderr_trap < 0)
 247     {
 248       perror ("create_temp_file");
 249       return 1;
 250     }
 251   FILE *stderr_trapped = fdopen(stderr_trap, "r+");
 252   if (!stderr_trapped)
 253     {
 254       perror ("fdopen");
 255       return 1;
 256     }
 257   int old_stderr = dup (fileno (stderr));
 258   if (old_stderr < 0)
 259     {
 260       perror ("dup");
 261       return 1;
 262     }
 263   if (dup2 (stderr_trap, 2) < 0)
 264     {
 265       perror ("dup2");
 266       return 1;
 267     }
 268   rewind (stderr);
 269
 270   bool success = true;
 271
 272   for (const struct test_short *tcase = tests_short; tcase->label; tcase++)
 273     success = do_test_short (tcase, stderr_trapped) && success;
 274
 275   for (const struct test_long *tcase = tests_long; tcase->label; tcase++)
 276     success = do_test_long (tcase, stderr_trapped) && success;
 277
 278   dup2 (old_stderr, 2);
 279   close (old_stderr);
 280   fclose (stderr_trapped);
 281
 282   return success ? 0 : 1;
 283 }
 284
 285 #include <support/test-driver.c>