tests/test-canonicalize.c

   1 /* Test of execution of file name canonicalization.
   2    Copyright (C) 2007-2009 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program 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
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Bruno Haible <bruno@clisp.org>, 2007.  */
  18
  19 #include <config.h>
  20
  21 #include "canonicalize.h"
  22
  23 #include <errno.h>
  24 #include <fcntl.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <sys/stat.h>
  29 #include <unistd.h>
  30
  31 #include "same-inode.h"
  32
  33 #define ASSERT(expr) \
  34   do                                                                         \
  35     {                                                                        \
  36       if (!(expr))                                                           \
  37         {                                                                    \
  38           fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
  39           fflush (stderr);                                                   \
  40           abort ();                                                          \
  41         }                                                                    \
  42     }                                                                        \
  43   while (0)
  44
  45 #define BASE "t-can.tmp"
  46
  47 int
  48 main (void)
  49 {
  50   /* Setup some hierarchy to be used by this test.  Start by removing
  51      any leftovers from a previous partial run.  */
  52   {
  53     int fd;
  54     ASSERT (system ("rm -rf " BASE " ise") == 0);
  55     ASSERT (mkdir (BASE, 0700) == 0);
  56     fd = creat (BASE "/tra", 0600);
  57     ASSERT (0 <= fd);
  58     ASSERT (close (fd) == 0);
  59   }
  60
  61   /* Check for ., .., intermediate // handling, and for error cases.  */
  62   {
  63     char *result1 = canonicalize_file_name (BASE "//./..//" BASE "/tra");
  64     char *result2 = canonicalize_filename_mode (BASE "//./..//" BASE "/tra",
  65                                                 CAN_EXISTING);
  66     ASSERT (result1 != NULL);
  67     ASSERT (result2 != NULL);
  68     ASSERT (strcmp (result1, result2) == 0);
  69     ASSERT (strstr (result1, "/" BASE "/tra")
  70             == result1 + strlen (result1) - strlen ("/" BASE "/tra"));
  71     free (result1);
  72     free (result2);
  73     errno = 0;
  74     result1 = canonicalize_file_name ("");
  75     ASSERT (result1 == NULL);
  76     ASSERT (errno == ENOENT);
  77     errno = 0;
  78     result2 = canonicalize_filename_mode ("", CAN_EXISTING);
  79     ASSERT (result2 == NULL);
  80     ASSERT (errno == ENOENT);
  81     errno = 0;
  82     result1 = canonicalize_file_name (NULL);
  83     ASSERT (result1 == NULL);
  84     ASSERT (errno == EINVAL);
  85     errno = 0;
  86     result2 = canonicalize_filename_mode (NULL, CAN_EXISTING);
  87     ASSERT (result2 == NULL);
  88     ASSERT (errno == EINVAL);
  89   }
  90
  91   /* Check that a non-directory with trailing slash yields NULL.  */
  92   {
  93     char *result1;
  94     char *result2;
  95     errno = 0;
  96     result1 = canonicalize_file_name (BASE "/tra/");
  97     ASSERT (result1 == NULL);
  98     ASSERT (errno == ENOTDIR);
  99     errno = 0;
 100     result2 = canonicalize_filename_mode (BASE "/tra/", CAN_EXISTING);
 101     ASSERT (result2 == NULL);
 102     ASSERT (errno == ENOTDIR);
 103   }
 104
 105   /* Check that a missing directory yields NULL.  */
 106   {
 107     char *result1;
 108     char *result2;
 109     errno = 0;
 110     result1 = canonicalize_file_name (BASE "/zzz/..");
 111     ASSERT (result1 == NULL);
 112     ASSERT (errno == ENOENT);
 113     errno = 0;
 114     result2 = canonicalize_filename_mode (BASE "/zzz/..", CAN_EXISTING);
 115     ASSERT (result2 == NULL);
 116     ASSERT (errno == ENOENT);
 117   }
 118
 119   /* From here on out, tests involve symlinks.  */
 120   if (symlink (BASE "/ket", "ise") != 0)
 121     {
 122       ASSERT (remove (BASE "/tra") == 0);
 123       ASSERT (rmdir (BASE) == 0);
 124       fputs ("skipping test: symlinks not supported on this file system\n",
 125              stderr);
 126       return 77;
 127     }
 128   ASSERT (symlink ("bef", BASE "/plo") == 0);
 129   ASSERT (symlink ("tra", BASE "/huk") == 0);
 130   ASSERT (symlink ("lum", BASE "/bef") == 0);
 131   ASSERT (symlink ("wum", BASE "/ouk") == 0);
 132   ASSERT (symlink ("../ise", BASE "/ket") == 0);
 133   ASSERT (mkdir (BASE "/lum", 0700) == 0);
 134   ASSERT (symlink ("s", BASE "/p") == 0);
 135   ASSERT (symlink ("d", BASE "/s") == 0);
 136   ASSERT (mkdir (BASE "/d", 0700) == 0);
 137   ASSERT (close (creat (BASE "/d/2", 0600)) == 0);
 138   ASSERT (symlink ("../s/2", BASE "/d/1") == 0);
 139   ASSERT (symlink ("//.//../..", BASE "/droot") == 0);
 140
 141   /* Check that the symbolic link to a file can be resolved.  */
 142   {
 143     char *result1 = canonicalize_file_name (BASE "/huk");
 144     char *result2 = canonicalize_file_name (BASE "/tra");
 145     char *result3 = canonicalize_filename_mode (BASE "/huk", CAN_EXISTING);
 146     ASSERT (result1 != NULL);
 147     ASSERT (result2 != NULL);
 148     ASSERT (result3 != NULL);
 149     ASSERT (strcmp (result1, result2) == 0);
 150     ASSERT (strcmp (result2, result3) == 0);
 151     ASSERT (strcmp (result1 + strlen (result1) - strlen ("/" BASE "/tra"),
 152                     "/" BASE "/tra") == 0);
 153     free (result1);
 154     free (result2);
 155     free (result3);
 156   }
 157
 158   /* Check that the symbolic link to a directory can be resolved.  */
 159   {
 160     char *result1 = canonicalize_file_name (BASE "/plo");
 161     char *result2 = canonicalize_file_name (BASE "/bef");
 162     char *result3 = canonicalize_file_name (BASE "/lum");
 163     char *result4 = canonicalize_filename_mode (BASE "/plo", CAN_EXISTING);
 164     ASSERT (result1 != NULL);
 165     ASSERT (result2 != NULL);
 166     ASSERT (result3 != NULL);
 167     ASSERT (result4 != NULL);
 168     ASSERT (strcmp (result1, result2) == 0);
 169     ASSERT (strcmp (result2, result3) == 0);
 170     ASSERT (strcmp (result3, result4) == 0);
 171     ASSERT (strcmp (result1 + strlen (result1) - strlen ("/" BASE "/lum"),
 172                     "/" BASE "/lum") == 0);
 173     free (result1);
 174     free (result2);
 175     free (result3);
 176     free (result4);
 177   }
 178
 179   /* Check that a symbolic link to a nonexistent file yields NULL.  */
 180   {
 181     char *result1;
 182     char *result2;
 183     errno = 0;
 184     result1 = canonicalize_file_name (BASE "/ouk");
 185     ASSERT (result1 == NULL);
 186     ASSERT (errno == ENOENT);
 187     errno = 0;
 188     result2 = canonicalize_filename_mode (BASE "/ouk", CAN_EXISTING);
 189     ASSERT (result2 == NULL);
 190     ASSERT (errno == ENOENT);
 191   }
 192
 193   /* Check that a non-directory symlink with trailing slash yields NULL.  */
 194   {
 195     char *result1;
 196     char *result2;
 197     errno = 0;
 198     result1 = canonicalize_file_name (BASE "/huk/");
 199     ASSERT (result1 == NULL);
 200     ASSERT (errno == ENOTDIR);
 201     errno = 0;
 202     result2 = canonicalize_filename_mode (BASE "/huk/", CAN_EXISTING);
 203     ASSERT (result2 == NULL);
 204     ASSERT (errno == ENOTDIR);
 205   }
 206
 207   /* Check that a missing directory via symlink yields NULL.  */
 208   {
 209     char *result1;
 210     char *result2;
 211     errno = 0;
 212     result1 = canonicalize_file_name (BASE "/ouk/..");
 213     ASSERT (result1 == NULL);
 214     ASSERT (errno == ENOENT);
 215     errno = 0;
 216     result2 = canonicalize_filename_mode (BASE "/ouk/..", CAN_EXISTING);
 217     ASSERT (result2 == NULL);
 218     ASSERT (errno == ENOENT);
 219   }
 220
 221   /* Check that a loop of symbolic links is detected.  */
 222   {
 223     char *result1;
 224     char *result2;
 225     errno = 0;
 226     result1 = canonicalize_file_name ("ise");
 227     ASSERT (result1 == NULL);
 228     ASSERT (errno == ELOOP);
 229     errno = 0;
 230     result2 = canonicalize_filename_mode ("ise", CAN_EXISTING);
 231     ASSERT (result2 == NULL);
 232     ASSERT (errno == ELOOP);
 233   }
 234
 235   /* Check that alternate modes can resolve missing basenames.  */
 236   {
 237     char *result1 = canonicalize_filename_mode (BASE "/zzz", CAN_ALL_BUT_LAST);
 238     char *result2 = canonicalize_filename_mode (BASE "/zzz", CAN_MISSING);
 239     char *result3 = canonicalize_filename_mode (BASE "/zzz/", CAN_ALL_BUT_LAST);
 240     char *result4 = canonicalize_filename_mode (BASE "/zzz/", CAN_MISSING);
 241     ASSERT (result1 != NULL);
 242     ASSERT (result2 != NULL);
 243     ASSERT (result3 != NULL);
 244     ASSERT (result4 != NULL);
 245     ASSERT (strcmp (result1, result2) == 0);
 246     ASSERT (strcmp (result2, result3) == 0);
 247     ASSERT (strcmp (result3, result4) == 0);
 248     ASSERT (strcmp (result1 + strlen (result1) - strlen ("/" BASE "/zzz"),
 249                     "/" BASE "/zzz") == 0);
 250     free (result1);
 251     free (result2);
 252     free (result3);
 253     free (result4);
 254   }
 255
 256   /* Check that alternate modes can resolve broken symlink basenames.  */
 257   {
 258     char *result1 = canonicalize_filename_mode (BASE "/ouk", CAN_ALL_BUT_LAST);
 259     char *result2 = canonicalize_filename_mode (BASE "/ouk", CAN_MISSING);
 260     char *result3 = canonicalize_filename_mode (BASE "/ouk/", CAN_ALL_BUT_LAST);
 261     char *result4 = canonicalize_filename_mode (BASE "/ouk/", CAN_MISSING);
 262     ASSERT (result1 != NULL);
 263     ASSERT (result2 != NULL);
 264     ASSERT (result3 != NULL);
 265     ASSERT (result4 != NULL);
 266     ASSERT (strcmp (result1, result2) == 0);
 267     ASSERT (strcmp (result2, result3) == 0);
 268     ASSERT (strcmp (result3, result4) == 0);
 269     ASSERT (strcmp (result1 + strlen (result1) - strlen ("/" BASE "/wum"),
 270                     "/" BASE "/wum") == 0);
 271     free (result1);
 272     free (result2);
 273     free (result3);
 274     free (result4);
 275   }
 276
 277   /* Check that alternate modes can handle missing dirnames.  */
 278   {
 279     char *result1 = canonicalize_filename_mode ("t-can.zzz/zzz", CAN_ALL_BUT_LAST);
 280     char *result2 = canonicalize_filename_mode ("t-can.zzz/zzz", CAN_MISSING);
 281     ASSERT (result1 == NULL);
 282     ASSERT (result2 != NULL);
 283     ASSERT (strcmp (result2 + strlen (result2) - 14, "/t-can.zzz/zzz") == 0);
 284     free (result2);
 285   }
 286
 287   /* Ensure that the following is resolved properly.
 288      Before 2007-09-27, it would mistakenly report a loop.  */
 289   {
 290     char *result1 = canonicalize_filename_mode (BASE, CAN_EXISTING);
 291     char *result2 = canonicalize_filename_mode (BASE "/p/1", CAN_EXISTING);
 292     ASSERT (result1 != NULL);
 293     ASSERT (result2 != NULL);
 294     ASSERT (strcmp (result2 + strlen (result1), "/d/2") == 0);
 295     free (result1);
 296     free (result2);
 297   }
 298
 299   /* Check that leading // is honored correctly.  */
 300   {
 301     struct stat st1;
 302     struct stat st2;
 303     char *result1 = canonicalize_file_name ("//.");
 304     char *result2 = canonicalize_filename_mode ("//.", CAN_EXISTING);
 305     char *result3 = canonicalize_file_name (BASE "/droot");
 306     char *result4 = canonicalize_filename_mode (BASE "/droot", CAN_EXISTING);
 307     ASSERT (result1);
 308     ASSERT (result2);
 309     ASSERT (result3);
 310     ASSERT (result4);
 311     ASSERT (stat ("/", &st1) == 0);
 312     ASSERT (stat ("//", &st2) == 0);
 313     if (SAME_INODE (st1, st2))
 314       {
 315         ASSERT (strcmp (result1, "/") == 0);
 316         ASSERT (strcmp (result2, "/") == 0);
 317         ASSERT (strcmp (result3, "/") == 0);
 318         ASSERT (strcmp (result4, "/") == 0);
 319       }
 320     else
 321       {
 322         ASSERT (strcmp (result1, "//") == 0);
 323         ASSERT (strcmp (result2, "//") == 0);
 324         ASSERT (strcmp (result3, "//") == 0);
 325         ASSERT (strcmp (result4, "//") == 0);
 326       }
 327     free (result1);
 328     free (result2);
 329     free (result3);
 330     free (result4);
 331   }
 332
 333   /* Cleanup.  */
 334   ASSERT (remove (BASE "/droot") == 0);
 335   ASSERT (remove (BASE "/d/1") == 0);
 336   ASSERT (remove (BASE "/d/2") == 0);
 337   ASSERT (remove (BASE "/d") == 0);
 338   ASSERT (remove (BASE "/s") == 0);
 339   ASSERT (remove (BASE "/p") == 0);
 340   ASSERT (remove (BASE "/plo") == 0);
 341   ASSERT (remove (BASE "/huk") == 0);
 342   ASSERT (remove (BASE "/bef") == 0);
 343   ASSERT (remove (BASE "/ouk") == 0);
 344   ASSERT (remove (BASE "/ket") == 0);
 345   ASSERT (remove (BASE "/lum") == 0);
 346   ASSERT (remove (BASE "/tra") == 0);
 347   ASSERT (remove (BASE) == 0);
 348   ASSERT (remove ("ise") == 0);
 349
 350   return 0;
 351 }