src/recyclix.c

   1
   2 // see flow chart: https://github.com/bAndie91/libyazzy-preload/blob/master/recyclix-flow.svg
   3
   4 #include <sys/stat.h>
   5 #include <bits/posix1_lim.h>
   6 #include <fcntl.h>
   7 #include <stdbool.h>
   8 #include <stdlib.h>
   9 #include <stdio.h>
  10 #include <dlfcn.h>
  11 #include <unistd.h>
  12 #include <string.h>
  13 #include <err.h>
  14 #include <errno.h>
  15 #include <libgen.h>
  16 #include <regex.h>
  17
  18 #define REGEXP_SZLIMIT "^([0-9]+)([BkMG]?)(-([0-9]+)([BkMG]?))?$"
  19 #define NMATCH_SZLIMIT 6
  20 #define REGEXP_EXCLUDE "^!(.*)$"
  21 #define NMATCH_EXCLUDE 2
  22
  23 off_t recyclix_tosize(const char * str, regoff_t num_start, int digits, regoff_t unit);
  24 int recyclix_clonepath_recursive(char * p_path, char * p_donor);
  25
  26
  27 int unlinkat(int dirfd, const char *pathname, int flags)
  28 {
  29         int (*real_unlinkat)(int dirfd, const char *pathname, int flags) = dlsym(RTLD_NEXT, "unlinkat");
  30         int retval;
  31
  32         char *recyclers;
  33         char *ptr, *tmp, *comma;
  34         char recycler[_POSIX_PATH_MAX];
  35         char recycled[_POSIX_PATH_MAX];
  36         char atdir[_POSIX_PATH_MAX];
  37         char fqpath[_POSIX_PATH_MAX];
  38         char mp_path[_POSIX_PATH_MAX];
  39         struct stat st1;
  40         struct stat st2;
  41         ino_t recycler_inode;
  42         char *txt_unset = "unset RECYCLER environment if you do not care about Recycle bin";
  43         off_t sz_min, sz_max;
  44         regex_t regex;
  45         regmatch_t pmatch[NMATCH_SZLIMIT];
  46         int regex_err;
  47         bool excluded;
  48
  49
  50         recyclers = getenv("RECYCLER");
  51         if(recyclers != NULL)
  52         {
  53                 retval = fstatat(dirfd, pathname, &st1, (flags & ~AT_REMOVEDIR /* fstatat hates AT_REMOVEDIR */) | AT_SYMLINK_NOFOLLOW /* we are about to move/unlink the symlink itself */);
  54                 if(retval != 0)
  55                 {
  56                         warn("%s", pathname);
  57                 }
  58                 else
  59                 {
  60                         while(1)
  61                         {
  62                                 ptr = strchrnul(recyclers, ':');
  63                                 strncpy(recycler, recyclers, ptr - recyclers);
  64                                 recycler[ptr - recyclers] = '\0';
  65
  66                                 if(strncmp(recycler, "~/", 2) == 0)
  67                                 {
  68                                         tmp = getenv("HOME");
  69                                         if(tmp == NULL)
  70                                         {
  71                                                 warnx("Could not resolve: %s", recycler);
  72                                                 recycler[0] = '\0';
  73                                         }
  74                                         else
  75                                         {
  76                                                 snprintf(recycler, strlen(tmp) + 1 /* slash */ + (ptr - recyclers - 2 /* tilde+slash*/) + 1 /* 0x00 */, "%s/%s", tmp, recyclers + 2);
  77                                         }
  78                                 }
  79
  80                                 if(strlen(recycler) > 0)
  81                                 {
  82                                         /* Found a Recycle Bin */
  83                                         #ifdef DEBUG
  84                                         warnx("RECYCLER %s", recycler);
  85                                         #endif
  86
  87                                         sz_min = 1;  // ignore empty files by default
  88                                         sz_max = 0;  // no upper size limit by default
  89                                         excluded = false;
  90
  91                                         /* Reading options for this Recycle Bin */
  92                                         comma = strchr(recycler, ',');
  93                                         if(comma != NULL)
  94                                         {
  95                                                 comma[0] = '\0';
  96                                                 comma++;
  97                                         }
  98                                         while(comma != NULL && strlen(comma) > 0)
  99                                         {
 100                                                 /* comma points to the rest of options */
 101                                                 tmp = strchr(comma, ',');
 102                                                 if(tmp != NULL)
 103                                                 {
 104                                                         tmp[0] = '\0';
 105                                                         /* comma now points to a single option */
 106                                                         tmp++;
 107                                                         /* tmp now points to the next option(s) */
 108                                                 }
 109
 110
 111                                                 regex_err = regcomp(&regex, REGEXP_SZLIMIT, REG_EXTENDED | REG_ICASE);
 112                                                 if(regex_err != 0)
 113                                                 {
 114                                                         goto regexp_error;
 115                                                 }
 116                                                 else if(regexec(&regex, comma, NMATCH_SZLIMIT, pmatch, 0) == 0)
 117                                                 {
 118                                                         #ifdef DEBUG
 119                                                         int i;
 120                                                         char *s;
 121                                                         char *e;
 122                                                         for(i=0; i<NMATCH_SZLIMIT; i++)
 123                                                         {
 124                                                                 if(pmatch[i].rm_so == -1) break;
 125                                                                 s = comma + pmatch[i].rm_so;
 126                                                                 e = comma + pmatch[i].rm_eo;
 127                                                                 if(i == 0) fprintf(stderr, "$& eq ");
 128                                                                 else fprintf(stderr, "$%d eq ", i);
 129                                                                 fprintf(stderr, "'%.*s' [%p:%p]\n", (e - s), s, s, e);
 130                                                         }
 131                                                         #endif
 132                                                         sz_min = recyclix_tosize(comma, pmatch[1].rm_so, pmatch[1].rm_eo - pmatch[1].rm_so, pmatch[2].rm_so);
 133                                                         sz_max = recyclix_tosize(comma, pmatch[4].rm_so, pmatch[4].rm_eo - pmatch[4].rm_so, pmatch[5].rm_so);
 134                                                         #ifdef DEBUG
 135                                                         warnx("size min %lu, size max %lu.", sz_min, sz_max);
 136                                                         #endif
 137                                                         if(sz_max != 0 && sz_min > sz_max)
 138                                                         {
 139                                                                 warnx("recyclix: Insane size limits: %lu-%lu", sz_min, sz_max);
 140                                                                 errno = ECANCELED;
 141                                                                 return -1;
 142                                                         }
 143                                                         goto next_option;
 144                                                 }
 145
 146                                                 regex_err = regcomp(&regex, REGEXP_EXCLUDE, REG_EXTENDED | REG_ICASE);
 147                                                 if(regex_err != 0)
 148                                                 {
 149                                                         goto regexp_error;
 150                                                 }
 151                                                 else if(regexec(&regex, comma, NMATCH_EXCLUDE, pmatch, 0) == 0)
 152                                                 {
 153                                                         strncpy(mp_path, comma + pmatch[1].rm_so, pmatch[1].rm_eo - pmatch[1].rm_so + 1);  /* mp_path is carrying user defined regex pattern */
 154                                                         regex_err = regcomp(&regex, mp_path, REG_EXTENDED);
 155                                                         if(regex_err != 0)
 156                                                         {
 157                                                                 goto regexp_error;
 158                                                         }
 159                                                         else
 160                                                         {
 161                                                                 regex_err = regexec(&regex, pathname, 0, pmatch, 0);
 162                                                                 #ifdef DEBUG
 163                                                                 warnx("exclude: '%s' %c~ /%s/", pathname, regex_err == 0 ? '=' : '!', comma+1);
 164                                                                 #endif
 165                                                                 excluded = regex_err == 0 ? true : false;
 166                                                         }
 167                                                         goto next_option;
 168                                                 }
 169
 170                                                 regexp_error:
 171                                                 regerror(regex_err, &regex, mp_path, sizeof(mp_path));  /* mp_path is carrying the regex error message */
 172                                                 warnx("recyclix: Unrecognized option: '%s' (%s)", comma, mp_path);
 173                                                 errno = ECANCELED;
 174                                                 return -1;
 175
 176                                                 next_option:
 177                                                 /* Read the next option (or end) */
 178                                                 comma = tmp;
 179                                         }
 180
 181                                         retval = stat(recycler, &st2);
 182                                         recycler_inode = st2.st_ino;
 183                                         if(retval != 0)
 184                                         {
 185                                                 warn("stat: %s", recycler);
 186                                         }
 187                                         else
 188                                         {
 189                                                 if(st2.st_dev != st1.st_dev)
 190                                                 {
 191                                                         /* Cross-device condition */
 192                                                         #ifdef DEBUG
 193                                                         warnx("xdev: %03u,%03u (looking for %03u,%03u)", major(st2.st_dev), minor(st2.st_dev), major(st1.st_dev), minor(st1.st_dev));
 194                                                         #endif
 195                                                 }
 196                                                 else if(st1.st_size < sz_min || (sz_max != 0 && st1.st_size > sz_max))
 197                                                 {
 198                                                         /* File size exceeds limit */
 199                                                         #ifdef DEBUG
 200                                                         warnx("filesize %lu, min %lu, max %lu (0=infinite)", st1.st_size, sz_min, sz_max);
 201                                                         #endif
 202                                                 }
 203                                                 else if(excluded)
 204                                                 {
 205                                                         /* pathname matched to exclude criteria */
 206                                                         #ifdef DEBUG
 207                                                         warnx("filename matched to exclude criteria");
 208                                                         #endif
 209                                                 }
 210                                                 else
 211                                                 {
 212                                                         /* Recycle Bin and the subject file are on the same fs */
 213                                                         /* ptr no longer points to the next RECYCLER */
 214
 215                                                         if(pathname[0] == '/')
 216                                                         {
 217                                                                 /* Absolute pathname given */
 218                                                                 strcpy(fqpath, pathname);
 219                                                         }
 220                                                         else
 221                                                         {
 222                                                                 /* Relative pathname given */
 223                                                                 if(dirfd == AT_FDCWD)
 224                                                                 {
 225                                                                         if(getcwd(atdir, _POSIX_PATH_MAX) == NULL)
 226                                                                         {
 227                                                                                 warn("getcwd");
 228                                                                                 retval = -1;
 229                                                                                 break;
 230                                                                         }
 231                                                                 }
 232                                                                 else
 233                                                                 {
 234                                                                         sprintf(fqpath, "/proc/self/fd/%d", dirfd);
 235                                                                         retval = readlink(fqpath, atdir, _POSIX_PATH_MAX);
 236                                                                         if(retval == -1)
 237                                                                         {
 238                                                                                 warn("readlink: %s", fqpath);
 239                                                                                 break;
 240                                                                         }
 241                                                                         atdir[retval] = '\0';
 242                                                                 }
 243
 244                                                                 sprintf(fqpath, "%s/%s", atdir, pathname);
 245                                                         }
 246
 247                                                         strcpy(atdir, fqpath);
 248                                                         tmp = dirname(atdir);  /* atdir got changed */
 249                                                         ptr = realpath(tmp, NULL);
 250                                                         if(ptr == NULL)
 251                                                         {
 252                                                                 warn("realpath: %s", tmp);
 253                                                                 free(ptr);
 254                                                                 break;
 255                                                         }
 256                                                         /* ptr now points to the resolved path name of fqpath's parent directory */
 257                                                         strcpy(atdir, fqpath);
 258                                                         tmp = (char*)basename(atdir);  /* atdir got changed */
 259                                                         sprintf(fqpath, "%s/%s", ptr, tmp);
 260                                                         free(ptr);
 261
 262                                                         retval = 0;
 263                                                         strcpy(mp_path, fqpath);
 264                                                         while(1)
 265                                                         {
 266                                                                 /* Looking for filesystem's root */
 267                                                                 strcpy(atdir, mp_path);
 268                                                                 tmp = dirname(atdir);  /* dirname will change atdir */
 269                                                                 if(strcmp(tmp, "//") == 0)
 270                                                                 {
 271                                                                         tmp[1] = '\0';
 272                                                                 }
 273                                                                 retval = stat(tmp, &st2);
 274                                                                 if(retval != 0)
 275                                                                 {
 276                                                                         warn("stat: %s", tmp);
 277                                                                         break;
 278                                                                 }
 279
 280                                                                 if(st2.st_ino == recycler_inode)
 281                                                                 {
 282                                                                         /* removing from under the Recycler really removes the file */
 283                                                                         goto real_unlink;
 284                                                                         break;
 285                                                                 }
 286
 287                                                                 if(strcmp(mp_path, "/") == 0 && strcmp(tmp, "/") == 0)
 288                                                                 {
 289                                                                         /* fqpath is on the root fs */
 290                                                                         break;
 291                                                                 }
 292                                                                 if(st1.st_dev != st2.st_dev)
 293                                                                 {
 294                                                                         /* mp_path is the mountpoint */
 295                                                                         break;
 296                                                                 }
 297                                                                 /* Check the parent directory */
 298                                                                 strcpy(mp_path, tmp);
 299                                                         }
 300                                                         if(retval != 0) break;
 301
 302                                                         sprintf(recycled, "%s/%s", recycler, fqpath + strlen(mp_path));
 303                                                         #ifdef DEBUG
 304                                                         warnx("Filesystem root: %s", mp_path);
 305                                                         warnx("Recycled file: %s", recycled);
 306                                                         #endif
 307
 308                                                         /* Copy directory path onto Recycler */
 309                                                         strcpy(atdir, recycled);
 310                                                         if(S_ISDIR(st1.st_mode))
 311                                                         {
 312                                                                 /* Clone the file (actually the directory) to be removed itself */
 313                                                                 tmp = atdir;
 314                                                                 ptr = fqpath;
 315                                                         }
 316                                                         else
 317                                                         {
 318                                                                 /* Clone the file's parent directory  */
 319                                                                 tmp = dirname(atdir);
 320                                                                 ptr = dirname(fqpath);
 321                                                         }
 322                                                         retval = recyclix_clonepath_recursive(tmp, ptr);
 323                                                         if(retval != 0)
 324                                                         {
 325                                                                 warn("mkdir: %s", tmp);
 326                                                                 break;
 327                                                         }
 328
 329                                                         if(S_ISDIR(st1.st_mode))
 330                                                         {
 331                                                                 goto real_unlink;
 332                                                         }
 333                                                         else
 334                                                         {
 335                                                                 retval = renameat(dirfd, pathname, 0, recycled);
 336                                                                 if(retval != 0)
 337                                                                 {
 338                                                                         warn("renameat");
 339                                                                         warnx("Failed to drop file to the Recycler, %s.", txt_unset);
 340                                                                 }
 341                                                         }
 342
 343                                                         /* ptr is unusable to continue */
 344                                                         break;
 345                                                 }
 346                                                 /* Looking for next Recycler ... */
 347                                         }
 348                                 }
 349
 350                                 if(ptr[0] == '\0')
 351                                 {
 352                                         #ifdef DEBUG
 353                                         warnx("There is no valid Recycler, removing file.");
 354                                         #endif
 355                                         goto real_unlink;
 356                                         break;
 357                                 }
 358                                 else
 359                                 {
 360                                         recyclers = ptr+1;
 361                                 }
 362                         }
 363                 }
 364         }
 365         else
 366         {
 367                 real_unlink:
 368                 retval = real_unlinkat(dirfd, pathname, flags);
 369         }
 370
 371         return retval;
 372 }
 373
 374 int recyclix_clonepath_recursive(char * p_path, char * p_donor)
 375 {
 376         int (*real_unlink)(const char *pathname) = dlsym(RTLD_NEXT, "unlink");
 377         int retval;
 378         char path[_POSIX_PATH_MAX];
 379         char donor[_POSIX_PATH_MAX];
 380         char * parent;
 381         char * dparent;
 382         struct stat st;
 383         struct stat donor_st;
 384
 385         #ifdef DEBUG
 386         warnx("%s: %s", __func__, p_path);
 387         #endif
 388
 389         /* save stats of directory being cloned */
 390         retval = stat(p_donor, &donor_st);
 391         if(retval == -1)
 392         {
 393                 warn("stat: %s", p_donor);
 394         }
 395         else
 396         {
 397                 try_mkdir:
 398                 retval = mkdir(p_path, donor_st.st_mode);
 399                 if(retval == -1)
 400                 {
 401                         if(errno == ENOENT || errno == ENOTDIR)
 402                         {
 403                                 strcpy(path, p_path);
 404                                 strcpy(donor, p_donor);
 405                                 parent = dirname(path);
 406                                 dparent = dirname(donor);
 407
 408                                 retval = real_unlink(parent);
 409                                 if(retval == 0)
 410                                 {
 411                                         goto try_mkdir;
 412                                 }
 413                                 else if(errno == ENOENT)
 414                                 {
 415                                         retval = recyclix_clonepath_recursive(parent, dparent);
 416                                         if(retval == 0)
 417                                         {
 418                                                 goto try_mkdir;
 419                                         }
 420                                 }
 421                                 else
 422                                 {
 423                                         warn("unlink: %s", parent);
 424                                 }
 425                         }
 426                         else if(errno == EEXIST)
 427                         {
 428                                 retval = stat(p_path, &st);
 429                                 if(retval == -1)
 430                                 {
 431                                         warn("stat: %s", p_path);
 432                                 }
 433                                 else
 434                                 {
 435                                         if(S_ISDIR(st.st_mode))
 436                                         {
 437                                                 chmod(p_path, donor_st.st_mode);
 438                                                 retval = 0;
 439                                         }
 440                                         else
 441                                         {
 442                                                 retval = real_unlink(p_path);
 443                                                 if(retval == 0)
 444                                                 {
 445                                                         goto try_mkdir;
 446                                                 }
 447                                                 else
 448                                                 {
 449                                                         warn("unlink: %s", p_path);
 450                                                 }
 451                                         }
 452                                 }
 453                         }
 454                         else
 455                         {
 456                                 warn("mkdir: %s", p_path);
 457                         }
 458                 }
 459         }
 460         if(retval == 0)
 461         {
 462                 chown(p_path, donor_st.st_uid, donor_st.st_gid);
 463         }
 464         return retval;
 465 }
 466
 467 off_t recyclix_tosize(const char * str, regoff_t num_start, int digits, regoff_t unit)
 468 {
 469         char number[16];
 470         off_t size;
 471
 472         if(num_start == -1)
 473         {
 474                 return 0;
 475         }
 476         else
 477         {
 478                 snprintf(number, 16>digits+1 ? digits+1 : 16, "%s", str+num_start);
 479                 size = atoi(number);
 480         }
 481         if(str[unit] == 'k' || str[unit] == 'K') size *= 1024;
 482         else if(str[unit] == 'm' || str[unit] == 'M') size *= 1024*1024;
 483         else if(str[unit] == 'g' || str[unit] == 'G') size *= 1024*1024*1024;
 484         return size;
 485 }
 486
 487 int unlink(const char *pathname)
 488 {
 489         return unlinkat(AT_FDCWD, pathname, 0);
 490 }
 491