db/fileutil.c

   1 /* fileutil.c --- Utility functions used by file.c.
   2  * Copyright (C) 2002, 2003, 2004, 2007  Simon Josefsson
   3  *
   4  * This file is part of Shishi.
   5  *
   6  * Shishi is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Shishi is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with Shishi; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  */
  21
  22 #include "info.h"
  23
  24 /* For stat. */
  25 #include <sys/stat.h>
  26 #include <sys/types.h>
  27 #include <unistd.h>
  28
  29 /* For readdir. */
  30 #include <dirent.h>
  31
  32 #include <errno.h>
  33 #ifndef errno
  34 extern int errno;
  35 #endif
  36
  37 #include "xreadlink.h"
  38
  39 /* Get specification. */
  40 #include "fileutil.h"
  41
  42 #define ishex(c) ((c >= '0' || c <= '9') || (c >= 'a' || c <= 'f'))
  43 #define tohex(c1,c2) (((c1 - '0' > 9 ? c1 - 'a' + 10 : c1 - '0') << 4) | \
  44                       (c2 - '0' > 9 ? c2 - 'a' + 10 : c2 - '0'))
  45
  46 static char *
  47 unescape_filename (const char *path)
  48 {
  49   char *out = strdup (path);
  50   char *p = out;
  51
  52   while (*path)
  53     {
  54       if (path[0] == '%' &&
  55           path[1] && ishex (path[1]) && path[2] && ishex (path[2]))
  56         {
  57           *p++ = tohex (path[1], path[2]);
  58           path += 3;
  59         }
  60       else
  61         *p++ = *path++;
  62     }
  63   *p = '\0';
  64
  65   return out;
  66 }
  67
  68 static char *
  69 escape_filename (const char *path)
  70 {
  71   char *out = malloc (strlen (path) * 3 + 1);
  72   char *p = out;
  73
  74   while (*path)
  75     {
  76       if ((path[0] >= 'a' && path[0] <= 'z') ||
  77           (path[0] >= 'A' && path[0] <= 'Z') ||
  78           (path[0] >= '0' && path[0] <= '9') ||
  79           path[0] == '-' || path[0] == '.')
  80         *p++ = *path++;
  81       else
  82         {
  83           int i;
  84           *p++ = '%';
  85           i = (*path & 0xF0) >> 4;
  86           *p++ = i > 10 ? 'a' + i - 10 : '0' + i;
  87           i = (*path & 0x0f);
  88           *p++ = i > 10 ? 'a' + i - 10 : '0' + i;
  89           path++;
  90         }
  91     }
  92   *p = '\0';
  93
  94   return out;
  95 }
  96
  97 int
  98 _shisa_isdir (const char *path)
  99 {
 100   struct stat buf;
 101   int rc;
 102
 103   rc = stat (path, &buf);
 104   if (rc != 0 || !S_ISDIR (buf.st_mode))
 105     return 0;
 106
 107   return 1;
 108 }
 109
 110 static int
 111 isdir2 (const char *path1, const char *path2)
 112 {
 113   char *tmp;
 114   int rc;
 115
 116   asprintf (&tmp, "%s/%s", path1, path2);
 117
 118   rc = _shisa_isdir (tmp);
 119
 120   free (tmp);
 121
 122   return rc;
 123 }
 124
 125
 126 int
 127 _shisa_isdir2 (const char *path1, const char *realm)
 128 {
 129   char *saferealm = escape_filename (realm);
 130   char *tmp;
 131   int rc;
 132
 133   asprintf (&tmp, "%s/%s", path1, saferealm);
 134   free (saferealm);
 135
 136   rc = _shisa_isdir (tmp);
 137
 138   free (tmp);
 139
 140   return rc;
 141 }
 142
 143 int
 144 _shisa_isdir3 (const char *path1, const char *realm, const char *principal)
 145 {
 146   char *saferealm = escape_filename (realm);
 147   char *safeprincipal = escape_filename (principal);
 148   char *tmp;
 149   int rc;
 150
 151   asprintf (&tmp, "%s/%s/%s", path1, saferealm, safeprincipal);
 152   free (saferealm);
 153   free (safeprincipal);
 154
 155   rc = _shisa_isdir (tmp);
 156
 157   free (tmp);
 158
 159   return rc;
 160 }
 161
 162 int
 163 _shisa_isdir4 (const char *path1, const char *realm,
 164                const char *principal, const char *path4)
 165 {
 166   char *saferealm = escape_filename (realm);
 167   char *safeprincipal = escape_filename (principal);
 168   char *tmp;
 169   int rc;
 170
 171   asprintf (&tmp, "%s/%s/%s/%s", path1, saferealm, safeprincipal, path4);
 172   free (saferealm);
 173   free (safeprincipal);
 174
 175   rc = _shisa_isdir (tmp);
 176
 177   free (tmp);
 178
 179   return rc;
 180 }
 181
 182 int
 183 _shisa_mkdir (const char *file)
 184 {
 185   int rc;
 186
 187   rc = mkdir (file, S_IRUSR | S_IWUSR | S_IXUSR);
 188   if (rc != 0)
 189     {
 190       perror (file);
 191       return -1;
 192     }
 193
 194   return 0;
 195 }
 196
 197 int
 198 _shisa_mkdir2 (const char *path1, const char *realm)
 199 {
 200   char *saferealm = escape_filename (realm);
 201   char *tmp;
 202   int rc;
 203
 204   asprintf (&tmp, "%s/%s", path1, saferealm);
 205   free (saferealm);
 206
 207   rc = _shisa_mkdir (tmp);
 208
 209   free (tmp);
 210
 211   return rc;
 212 }
 213
 214 int
 215 _shisa_mkdir3 (const char *path1, const char *realm, const char *principal)
 216 {
 217   char *saferealm = escape_filename (realm);
 218   char *safeprincipal = escape_filename (principal);
 219   char *tmp;
 220   int rc;
 221
 222   asprintf (&tmp, "%s/%s/%s", path1, saferealm, safeprincipal);
 223   free (saferealm);
 224   free (safeprincipal);
 225
 226   rc = _shisa_mkdir (tmp);
 227
 228   free (tmp);
 229
 230   return rc;
 231 }
 232
 233 int
 234 _shisa_mkdir4 (const char *path1, const char *realm,
 235                const char *principal, const char *path4)
 236 {
 237   char *saferealm = escape_filename (realm);
 238   char *safeprincipal = escape_filename (principal);
 239   char *tmp;
 240   int rc;
 241
 242   asprintf (&tmp, "%s/%s/%s/%s", path1, saferealm, safeprincipal, path4);
 243   free (saferealm);
 244   free (safeprincipal);
 245
 246   rc = _shisa_mkdir (tmp);
 247
 248   free (tmp);
 249
 250   return rc;
 251 }
 252
 253 int
 254 _shisa_rmdir (const char *file)
 255 {
 256   int rc;
 257
 258   rc = rmdir (file);
 259   if (rc != 0)
 260     {
 261       perror (file);
 262       return -1;
 263     }
 264
 265   return 0;
 266 }
 267
 268 int
 269 _shisa_rmdir2 (const char *path1, const char *realm)
 270 {
 271   char *saferealm = escape_filename (realm);
 272   char *tmp;
 273   int rc;
 274
 275   asprintf (&tmp, "%s/%s", path1, saferealm);
 276   free (saferealm);
 277
 278   rc = _shisa_rmdir (tmp);
 279
 280   free (tmp);
 281
 282   return rc;
 283 }
 284
 285 int
 286 _shisa_rmdir3 (const char *path1, const char *realm, const char *principal)
 287 {
 288   char *saferealm = escape_filename (realm);
 289   char *safeprincipal = escape_filename (principal);
 290   char *tmp;
 291   int rc;
 292
 293   asprintf (&tmp, "%s/%s/%s", path1, saferealm, safeprincipal);
 294   free (saferealm);
 295   free (safeprincipal);
 296
 297   rc = _shisa_rmdir (tmp);
 298
 299   free (tmp);
 300
 301   return rc;
 302 }
 303
 304 int
 305 _shisa_rmdir4 (const char *path1, const char *realm,
 306                const char *principal, const char *path4)
 307 {
 308   char *saferealm = escape_filename (realm);
 309   char *safeprincipal = escape_filename (principal);
 310   char *tmp;
 311   int rc;
 312
 313   asprintf (&tmp, "%s/%s/%s/%s", path1, saferealm, safeprincipal, path4);
 314   free (saferealm);
 315   free (safeprincipal);
 316
 317   rc = _shisa_rmdir (tmp);
 318
 319   free (tmp);
 320
 321   return rc;
 322 }
 323
 324 static time_t
 325 mtime (const char *file)
 326 {
 327   struct stat buf;
 328   int rc;
 329
 330   rc = stat (file, &buf);
 331   if (rc != 0 || !S_ISREG (buf.st_mode))
 332     return (time_t) - 1;
 333
 334   return buf.st_atime;
 335 }
 336
 337 int
 338 _shisa_mtime4 (const char *path1,
 339                const char *realm, const char *principal, const char *path4)
 340 {
 341   char *saferealm = escape_filename (realm);
 342   char *safeprincipal = escape_filename (principal);
 343   char *tmp;
 344   int rc;
 345
 346   asprintf (&tmp, "%s/%s/%s/%s", path1, saferealm, safeprincipal, path4);
 347   free (saferealm);
 348   free (safeprincipal);
 349
 350   rc = mtime (tmp);
 351
 352   free (tmp);
 353
 354   return rc;
 355 }
 356
 357 static int
 358 isfile (const char *path)
 359 {
 360   struct stat buf;
 361   int rc;
 362
 363   rc = stat (path, &buf);
 364   if (rc != 0 || !S_ISREG (buf.st_mode))
 365     return 0;
 366
 367   return 1;
 368 }
 369
 370 int
 371 _shisa_isfile4 (const char *path1,
 372                 const char *realm, const char *principal, const char *path4)
 373 {
 374   char *saferealm = escape_filename (realm);
 375   char *safeprincipal = escape_filename (principal);
 376   char *tmp;
 377   int rc;
 378
 379   asprintf (&tmp, "%s/%s/%s/%s", path1, saferealm, safeprincipal, path4);
 380   free (saferealm);
 381   free (safeprincipal);
 382
 383   rc = isfile (tmp);
 384
 385   free (tmp);
 386
 387   return rc;
 388 }
 389
 390 static uint32_t
 391 uint32link (const char *file)
 392 {
 393   char *linkname;
 394
 395   linkname = xreadlink (file);
 396   if (linkname == NULL)
 397     return 0;
 398
 399   return atol (linkname);
 400 }
 401
 402 int
 403 _shisa_uint32link4 (const char *path1,
 404                     const char *realm,
 405                     const char *principal, const char *path4)
 406 {
 407   char *saferealm = escape_filename (realm);
 408   char *safeprincipal = escape_filename (principal);
 409   char *tmp;
 410   int rc;
 411
 412   asprintf (&tmp, "%s/%s/%s/%s", path1, saferealm, safeprincipal, path4);
 413   free (saferealm);
 414   free (safeprincipal);
 415
 416   rc = uint32link (tmp);
 417
 418   free (tmp);
 419
 420   return rc;
 421 }
 422
 423 static int
 424 ls_1 (const char *path, int onlydir, char ***files, size_t * nfiles,
 425       DIR * dir)
 426 {
 427   struct dirent *de;
 428
 429   while (errno = 0, (de = readdir (dir)) != NULL)
 430     {
 431       if (strcmp (de->d_name, ".") == 0 || strcmp (de->d_name, "..") == 0)
 432         continue;
 433       if (!onlydir || isdir2 (path, de->d_name))
 434         {
 435           if (files)
 436             {
 437               *files = xrealloc (*files, (*nfiles + 1) * sizeof (**files));
 438               (*files)[(*nfiles)] = unescape_filename (de->d_name);
 439             }
 440           (*nfiles)++;
 441         }
 442     }
 443
 444   if (errno != 0)
 445     {
 446       size_t i;
 447
 448       perror (path);
 449
 450       if (files)
 451         {
 452           for (i = 0; i < *nfiles; i++)
 453             free (**files);
 454           if (*nfiles > 0)
 455             free (*files);
 456         }
 457
 458       return -1;
 459     }
 460
 461   return 0;
 462 }
 463
 464 static int
 465 ls (const char *path, int onlydir, char ***files, size_t * nfiles)
 466 {
 467   DIR *dir;
 468   int rc;
 469
 470   dir = opendir (path);
 471   if (dir == NULL)
 472     {
 473       perror (path);
 474       return -1;
 475     }
 476
 477   if (ls_1 (path, onlydir, files, nfiles, dir) != 0)
 478     {
 479       rc = closedir (dir);
 480       if (rc != 0)
 481         perror (path);
 482       return -1;
 483     }
 484
 485   rc = closedir (dir);
 486   if (rc != 0)
 487     {
 488       size_t i;
 489
 490       perror (path);
 491
 492       if (files)
 493         {
 494           for (i = 0; i < *nfiles; i++)
 495             free (**files);
 496           if (*nfiles > 0)
 497             free (*files);
 498         }
 499
 500       return -1;
 501     }
 502
 503   return 0;
 504 }
 505
 506 int
 507 _shisa_ls (const char *path, char ***files, size_t * nfiles)
 508 {
 509   return ls (path, 0, files, nfiles);
 510 }
 511
 512 int
 513 _shisa_ls2 (const char *path, const char *realm,
 514             char ***files, size_t * nfiles)
 515 {
 516   char *saferealm = escape_filename (realm);
 517   char *tmp;
 518   int rc;
 519
 520   asprintf (&tmp, "%s/%s", path, saferealm);
 521   free (saferealm);
 522
 523   rc = _shisa_ls (tmp, files, nfiles);
 524
 525   free (tmp);
 526
 527   return rc;
 528 }
 529
 530 int
 531 _shisa_ls3 (const char *path, const char *realm,
 532             const char *principal, char ***files, size_t * nfiles)
 533 {
 534   char *saferealm = escape_filename (realm);
 535   char *safeprincipal = escape_filename (principal);
 536   char *tmp;
 537   int rc;
 538
 539   asprintf (&tmp, "%s/%s/%s", path, saferealm, safeprincipal);
 540   free (saferealm);
 541   free (safeprincipal);
 542
 543   rc = _shisa_ls (tmp, files, nfiles);
 544
 545   free (tmp);
 546
 547   return rc;
 548 }
 549
 550 int
 551 _shisa_ls4 (const char *path, const char *realm,
 552             const char *principal, const char *path4,
 553             char ***files, size_t * nfiles)
 554 {
 555   char *saferealm = escape_filename (realm);
 556   char *safeprincipal = escape_filename (principal);
 557   char *tmp;
 558   int rc;
 559
 560   asprintf (&tmp, "%s/%s/%s/%s", path, saferealm, safeprincipal, path4);
 561   free (saferealm);
 562   free (safeprincipal);
 563
 564   rc = _shisa_ls (tmp, files, nfiles);
 565
 566   free (tmp);
 567
 568   return rc;
 569 }
 570
 571 int
 572 _shisa_lsdir (const char *path, char ***files, size_t * nfiles)
 573 {
 574   return ls (path, 1, files, nfiles);
 575 }
 576
 577 int
 578 _shisa_lsdir2 (const char *path, const char *realm,
 579                char ***files, size_t * nfiles)
 580 {
 581   char *saferealm = escape_filename (realm);
 582   char *tmp;
 583   int rc;
 584
 585   asprintf (&tmp, "%s/%s", path, saferealm);
 586   free (saferealm);
 587
 588   rc = _shisa_lsdir (tmp, files, nfiles);
 589
 590   free (tmp);
 591
 592   return rc;
 593 }
 594
 595 static int
 596 rm (const char *path)
 597 {
 598   int rc;
 599
 600   rc = unlink (path);
 601   if (rc != 0)
 602     {
 603       perror (path);
 604       return -1;
 605     }
 606
 607   return 0;
 608 }
 609
 610 int
 611 _shisa_rm4 (const char *path1, const char *realm,
 612             const char *principal, const char *path4)
 613 {
 614   char *saferealm = escape_filename (realm);
 615   char *safeprincipal = escape_filename (principal);
 616   char *tmp;
 617   int rc;
 618
 619   asprintf (&tmp, "%s/%s/%s/%s", path1, saferealm, safeprincipal, path4);
 620   free (saferealm);
 621   free (safeprincipal);
 622
 623   rc = rm (tmp);
 624
 625   free (tmp);
 626
 627   return rc;
 628 }
 629
 630 int
 631 _shisa_rm5 (const char *path1, const char *realm, const char *principal,
 632             const char *path4, const char *path5)
 633 {
 634   char *saferealm = escape_filename (realm);
 635   char *safeprincipal = escape_filename (principal);
 636   char *tmp;
 637   int rc;
 638
 639   asprintf (&tmp, "%s/%s/%s/%s/%s", path1, saferealm, safeprincipal,
 640             path4, path5);
 641   free (saferealm);
 642   free (safeprincipal);
 643
 644   rc = rm (tmp);
 645
 646   free (tmp);
 647
 648   return rc;
 649 }
 650
 651 FILE *
 652 _shisa_fopen4 (const char *path1, const char *realm,
 653                const char *principal, const char *path4, const char *mode)
 654 {
 655   char *saferealm = escape_filename (realm);
 656   char *safeprincipal = escape_filename (principal);
 657   char *tmp;
 658   FILE *fh;
 659
 660   asprintf (&tmp, "%s/%s/%s/%s", path1, saferealm, safeprincipal, path4);
 661   free (saferealm);
 662   free (safeprincipal);
 663
 664   fh = fopen (tmp, mode);
 665
 666   free (tmp);
 667
 668   return fh;
 669 }