compilers/linux86-0.16.17/tests/ft.c

   1 /* Copyright (C) 1995,1996 Robert de Bath <rdebath@cix.compulink.co.uk>
   2  * This program is distributed under the GNU General Public License.
   3  */
   4
   5 /*
   6  * File Tool, This program is a collection of basic file tools
   7  * it includes cat, cp, ln, mkdir, mknod, chmod, chown, mv, rm
   8  *
   9  * Links may be used to call it under any of these names.
  10  */
  11 #include <stdio.h>
  12 #ifdef __STDC__
  13 #include <unistd.h>
  14 #include <stdlib.h>
  15 #endif
  16 #include <sys/types.h>
  17 #include <sys/stat.h>
  18 #include <fcntl.h>
  19 #include <errno.h>
  20 #include <string.h>
  21 #include <dirent.h>
  22 #include <sys/param.h>
  23 #include <utime.h>
  24 #include <pwd.h>
  25 #include <grp.h>
  26
  27 #if defined(S_IFSOCK) && !defined(__BCC__)
  28 #define __HAS_SOCKETS
  29 #endif
  30 #ifndef S_IFLNK
  31 #define lstat stat
  32 #endif
  33
  34 #ifdef __HAS_SOCKETS
  35 #include <sys/socket.h>
  36 #endif
  37
  38 /* Ansi prototypes */
  39 #ifdef __STDC__
  40 #define PR(x) x
  41 #else
  42 #define PR(x) ()
  43 #endif
  44
  45 int main PR((int argc, char ** argv));
  46 int select_command PR((char * argv));
  47 void do_prep PR((void));
  48 void do_post PR((void));
  49 void execute PR((char * dname, char * fname));
  50 int exec_for_subdir PR((char * dname));
  51 void exec_for_item PR((int when, char * fname));
  52 void parse_perms PR((char * prefix, char * ustring));
  53 int edit_mode PR((int mode, char * mode_str));
  54 int cmd_ft PR((char * fname));
  55 int cmd_mkfifo PR((char * fname));
  56 int cmd_mksock PR((char * fname));
  57 int cmd_rm PR((char * fname));
  58 void build_dest PR((char * dest, char * name, char * newpath));
  59 int strisdigit PR((char * str));
  60 int cmd_mv PR((char * fname));
  61 int cmd_ln PR((char * fname));
  62 int cmd_cp PR((char * fname));
  63 int copy_modes PR((char * file));
  64 int copy_file PR((char * source, char * dest));
  65 void Usage PR((void));
  66 int cmd_mkdir PR((char * dirname));
  67 int cmd_mknod PR((void));
  68 int warning PR((int enumber, char * estr, char * eobj));
  69 int error PR((int enumber, char * estr, char * eobj));
  70
  71 #define DO_BDIR         0x0010  /* Do Dir before contents */
  72 #define DO_ADIR         0x0020  /* Do Dir after contents */
  73 #define DO_MCOPY        0x0040  /* Preserve modes flag forced */
  74 #define OK_DIR          0x0080  /* Directorys OK even if no flg_recurse */
  75 #define IGN_LNK         0x0100  /* Not interested in symlinks */
  76 #define NO_SOURCE       0x0200  /* Named files created */
  77 #define OK_NO_SOURCE    0x0400  /* Don't need the source */
  78
  79 #define CMD_FT          (0+OK_DIR+DO_BDIR)
  80 #define CMD_CAT         (1+IGN_LNK)
  81 #define CMD_CHGRP       (2+OK_DIR+IGN_LNK+DO_ADIR)
  82 #define CMD_CHMOD       (3+OK_DIR+IGN_LNK+DO_ADIR)
  83 #define CMD_CHOWN       (4+OK_DIR+IGN_LNK+DO_ADIR)
  84 #define CMD_CP          (5+IGN_LNK)
  85 #define CMD_EXTAR       (6+DO_MCOPY+DO_BDIR)
  86 #define CMD_INSTALL     (7+DO_MCOPY)
  87 #define CMD_LN          (8+IGN_LNK+DO_BDIR)
  88 #define CMD_MKDIR       (9+NO_SOURCE)
  89 #define CMD_MKFIFO      (10+NO_SOURCE)
  90 #define CMD_MKSOCK      (11+NO_SOURCE)
  91 #define CMD_MKNOD       (12+NO_SOURCE)
  92 #define CMD_MV          (13+DO_MCOPY+OK_DIR+DO_BDIR)
  93 #define CMD_RM          (14+DO_ADIR)
  94
  95 struct {
  96    char * name;
  97    int cmd;
  98    int argpat;
  99    char * opts;
 100 } command_list[] =
 101 {
 102    { "ft",      CMD_FT,       0, "-Rv" },
 103    { "cat",     CMD_CAT,      0, "uR" },
 104    { "chgrp",   CMD_CHGRP,    1, "vfR" },
 105    { "chmod",   CMD_CHMOD,    1, "vfR" },
 106    { "chown",   CMD_CHOWN,    1, "vfR" },
 107    { "cp",      CMD_CP,      -1, "vifRrpsda" },
 108    { "extar",   CMD_EXTAR,    1, "" },
 109    { "install", CMD_INSTALL, -1, "cdso:g:m:" },
 110    { "ln",      CMD_LN,      -1, "vifs" },
 111    { "mkdir",   CMD_MKDIR,    0, "m:" },
 112    { "mkfifo",  CMD_MKFIFO,   0, "m:" },
 113 #ifdef __HAS_SOCKETS
 114    { "mksock",  CMD_MKSOCK,   0, "m:" },
 115 #endif
 116    { "mknod",   CMD_MKNOD,    4, "m:" },
 117    { "mv",      CMD_MV,      -1, "vif"  },
 118    { "rm",      CMD_RM,       0, "vifr" },
 119    { 0 }
 120 };
 121
 122 int cmd_arg = 0;
 123 int cmd_tok = CMD_FT;
 124 char * cmd_opt = "-";
 125 char * cmd_string = 0;  /* the first (or last) arg where special */
 126 char * prog_name = "";
 127
 128 char ** flist = 0;
 129 int     fcount = 0;
 130 int     add_base=0;
 131 char *  or_name = 0;
 132 int     or_offset = 0;
 133
 134 int flg_recurse = 0;
 135 int flg_verbose = 1;
 136 int flg_preserve= 0;
 137 int flg_mkpdir  = 0;
 138 int flg_noderef = 0;
 139 int flg_symlink = 0;
 140 int flg_exestrip= 0;
 141
 142 int flg_r, flg_force;
 143 char *str_o, *str_g, *str_m;
 144
 145 /* Things to set on the new file */
 146 int set_user    = -1;
 147 int set_group   = -1;
 148 int set_mode    = -1;
 149 time_t set_time = -1;
 150 char mode_str[32] = "";
 151 int u_mask      = 0;    /* 07777 altered by umask() */
 152
 153 struct stat cur_file_stat;
 154 struct stat dest_item;
 155 struct stat access_stat;
 156
 157 int done_something = 0;
 158
 159 int
 160 main(argc, argv)
 161 int argc; char ** argv;
 162 {
 163    int ar;
 164    (void) select_command(argv[0]);
 165
 166    for(ar=1;
 167        argv[ar] && argv[ar][0] == '-' && argv[ar][1];
 168        ar++)
 169    {
 170       char * p = argv[ar]+1;
 171       /* For symbolic changes of the form -rwx */
 172       if( cmd_tok == CMD_CHMOD && strchr("rwx", *p) != 0 ) break;
 173       while(*p)
 174       {
 175          char * ap=0, *av=0;
 176          char ch;
 177          /* Is it a valid opt for this cmd */
 178          if(*p == ':' || (ap=strchr(cmd_opt, *p)) == 0) Usage();
 179
 180          /* Got an argument ? */
 181          if(ap[1] == ':')
 182          {
 183             if(!argv[ar+1]) Usage();
 184             av = argv[++ar];
 185          }
 186
 187          if( (ch = *p) == '-' )
 188          {
 189             if( (ch=select_command(p)) < 0 ) Usage();
 190          }
 191          switch(ch)
 192          {
 193          case '\0': break;
 194          case 'r':
 195          case 'R': flg_recurse++; break;
 196          case 'v': flg_verbose++; break;
 197          case 'p': if(cmd_tok == CMD_MKDIR) flg_mkpdir++;
 198                    else                     flg_preserve++;
 199                    break;
 200          case 'd': if(cmd_tok == CMD_INSTALL)
 201                    { flg_mkpdir++; cmd_arg=0; } /* Special mkdir */
 202                    else flg_noderef++;          /* cmd_copy */
 203                    break;
 204
 205          case 'f': flg_force++; flg_verbose=0; break;
 206          case 'o': str_o = av; break;
 207          case 'g': str_g = av; break;
 208          case 'm': str_m = av; break;
 209
 210          case 's': flg_symlink++;
 211                    if( cmd_tok == CMD_LN) cmd_tok |= OK_DIR+OK_NO_SOURCE;
 212                    break;
 213          case 'a': flg_recurse++; flg_preserve++; flg_noderef++;
 214                    break;
 215          }
 216          if(*p == '-') break;
 217          p++;
 218       }
 219    }
 220
 221    switch(cmd_arg)
 222    {
 223    case 1:
 224       if( ar >= argc ) Usage();
 225       cmd_string = argv[ar++];
 226       fcount = argc-ar;
 227       flist = argv+ar;
 228       break;
 229    case 0:
 230       fcount = argc-ar;
 231       flist = argv+ar;
 232       break;
 233    case -1:
 234       if( ar >= argc ) Usage();
 235       cmd_string = argv[argc-1];
 236       fcount = argc-ar-1;
 237       flist = argv+ar;
 238       break;
 239    default:
 240       if( ar != argc-cmd_arg ) Usage();
 241       fcount = argc-ar;
 242       flist = argv+ar;
 243       break;
 244    }
 245
 246    do_prep();
 247
 248    for(ar=0; ar<fcount; ar++)
 249    {
 250       done_something=1;
 251       or_name = flist[ar]; or_offset = strlen(or_name)+1;
 252       execute(flist[ar], (char*)0);
 253    }
 254
 255    do_post();
 256
 257    if( !done_something )
 258    {
 259       if( cmd_tok == CMD_CAT )
 260          execute("-", (char*)0);
 261       else
 262          Usage();
 263    }
 264    return 0;
 265 }
 266
 267 int select_command(argv)
 268 char * argv;
 269 {
 270    int ar;
 271    char *p, *s;
 272    prog_name = argv;
 273    for(ar=0; command_list[ar].name; ar++)
 274    {
 275       p = strrchr(argv, '-'); if(p) p++; else p=argv;
 276       s = strrchr(p, '/'); if(s) s++; else s=p;
 277       if( strcmp(s, command_list[ar].name) == 0 )
 278       {
 279          cmd_arg = command_list[ar].argpat;
 280          cmd_tok = command_list[ar].cmd;
 281          cmd_opt = command_list[ar].opts;
 282          return 0;
 283       }
 284    }
 285    return -1;
 286 }
 287
 288 void do_prep()
 289 {
 290    char * prefix = "::";
 291
 292    u_mask = umask(077);
 293    umask(u_mask);
 294    u_mask = (07777&(~u_mask));
 295
 296    if(cmd_tok&DO_MCOPY)    flg_preserve++;
 297    if(str_m) parse_perms(prefix,   str_m);
 298
 299    switch(cmd_tok)
 300    {
 301    /* mknod is very different */
 302    case CMD_MKNOD: cmd_mknod(); exit(0); break;
 303
 304    case CMD_CP:
 305                 if(strcmp(cmd_string, "-") == 0)
 306                 {
 307                    cmd_tok = CMD_CAT;
 308                    cmd_arg = 0;
 309                    break;
 310                 }
 311                 if(flg_symlink)
 312                 {
 313                    cmd_tok = CMD_LN+OK_DIR+OK_NO_SOURCE;
 314                    flg_preserve = 0;
 315                 }
 316                 break;
 317
 318    case CMD_CHOWN: prefix++;
 319    case CMD_CHGRP: prefix++;
 320    case CMD_CHMOD:
 321                    parse_perms(prefix, cmd_string);
 322                    set_time = 0;
 323                    break;
 324    case CMD_INSTALL:
 325                    flg_exestrip = flg_symlink;
 326                    flg_symlink = 0;
 327                    if(str_o) parse_perms(prefix+2, str_o);
 328                    if(str_g) parse_perms(prefix+1, str_g);
 329                    if(flg_mkpdir) cmd_tok = CMD_MKDIR;
 330                    else
 331                    {
 332                       cmd_tok = CMD_CP;
 333                       flg_preserve = 1;
 334                    }
 335                    break;
 336    }
 337
 338 #ifndef S_IFLNK
 339    if(flg_symlink)
 340    {
 341       error(0, "No support for symlinks available:", cmd_string);
 342       exit(1);
 343    }
 344 #endif
 345
 346    /* Are we transfering many to one ? Then it must be a directory */
 347    if(cmd_arg == -1)
 348    {
 349       if( stat(cmd_string, &dest_item) == -1)
 350       {
 351          if( fcount > 1 )
 352          {
 353             if( cmd_mkdir(cmd_string) < 0 )
 354                exit(1);
 355             stat(cmd_string, &dest_item);
 356             add_base = 1;
 357          }
 358       }
 359       else
 360       {
 361          if( !S_ISDIR(dest_item.st_mode) )
 362          {
 363             if( fcount > 1 )
 364             {
 365                error(0, "Destination must be a directory:", cmd_string);
 366                exit(1);
 367             }
 368          }
 369          else add_base = 1;
 370       }
 371    }
 372 }
 373
 374 void do_post()
 375 {
 376    /* Oh! It seems there's nothing to do, ah well. */
 377 }
 378
 379 void execute(dname, fname)
 380 char * dname; char * fname;
 381 {
 382    char * buf;
 383    if( strcmp(dname, "-") == 0 )
 384    {
 385       exec_for_item(0, dname);
 386       return;
 387    }
 388    if( fname )
 389    {
 390       buf = alloca(strlen(dname) + strlen(fname) + 4);
 391       if( buf == 0 )
 392       {
 393          error(errno, "Can't allocate memory for path beyond ", dname);
 394          return ;
 395       }
 396       strcpy(buf, dname);
 397       if(strcmp(dname, "/")) strcat(buf, "/");
 398       strcat(buf, fname);
 399    }
 400    else buf = dname;
 401
 402    if( lstat(buf, &cur_file_stat) == -1 )
 403    {
 404       if( cmd_tok&(NO_SOURCE|OK_NO_SOURCE) )
 405          exec_for_item(0, buf);
 406       else
 407          warning(errno, "", buf);
 408       return;
 409    }
 410    if( !flg_force && ( cmd_tok&NO_SOURCE ))
 411    {
 412       error(EEXIST, "", buf);
 413       return;
 414    }
 415
 416    if( S_ISDIR(cur_file_stat.st_mode))
 417    {
 418       if( (cmd_tok&OK_DIR) || flg_recurse )
 419          (void) exec_for_subdir(buf);
 420       else
 421          error(EISDIR, "", buf);
 422       return;
 423    }
 424
 425 #ifdef S_IFLNK
 426    if( S_ISLNK(cur_file_stat.st_mode))
 427    {
 428       /* Links are special */
 429       if( cmd_tok&IGN_LNK )
 430       {
 431          if( stat(buf, &cur_file_stat) == -1 )
 432          {
 433             warning(errno, "", buf);
 434             return;
 435          }
 436       }
 437    }
 438 #endif
 439    exec_for_item(0, buf);
 440 }
 441
 442 int exec_for_subdir(dname)
 443 char * dname;
 444 {
 445    DIR * dfd;
 446    struct dirent * ent;
 447    int  old_mode = -1;
 448
 449    if( cmd_tok&DO_BDIR ) exec_for_item(-1, dname);
 450
 451    if( flg_recurse )
 452    {
 453       dfd = opendir(dname);
 454       if( dfd == 0 && errno == EACCES && flg_force )
 455       {
 456          old_mode = (cur_file_stat.st_mode & 07777);
 457          if( chmod(dname, (0700|old_mode)) )
 458             return error(errno, "", dname);
 459
 460          dfd = opendir(dname);
 461       }
 462       if( dfd == 0 ) return error(errno, "", dname);
 463
 464       while((ent=readdir(dfd)))
 465       {
 466          if( strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0 )
 467             continue;
 468
 469          alloca(0);     /* Free up if using fake version */
 470          execute(dname, ent->d_name);
 471       }
 472       closedir(dfd);
 473       if( old_mode != -1 )
 474          chmod(dname, old_mode);
 475    }
 476
 477    if( cmd_tok&DO_ADIR )
 478    {
 479       lstat(dname, &cur_file_stat);
 480       exec_for_item(1, dname);
 481    }
 482    return 0;
 483 }
 484
 485 void exec_for_item(when, fname)
 486 int when; char * fname;
 487 {
 488    int rv = -1;
 489    switch(cmd_tok)
 490    {
 491    case CMD_FT:      rv = cmd_ft(fname); break;
 492
 493    case CMD_CAT:     rv = copy_file(fname, "-"); break;
 494
 495    case CMD_CHGRP:   /* And fall */
 496    case CMD_CHMOD:   /* And fall */
 497    case CMD_CHOWN:   rv = copy_modes(fname); break;
 498
 499    case CMD_CP:      rv = cmd_cp(fname); break;
 500    case CMD_MV:      rv = cmd_mv(fname); break;
 501    case CMD_RM:      rv = cmd_rm(fname); break;
 502
 503    case CMD_EXTAR:   error(EINVAL, "", "No code."); exit(1);
 504
 505    case CMD_LN+OK_DIR+OK_NO_SOURCE:
 506    case CMD_LN:      rv = cmd_ln(fname); break;
 507
 508    case CMD_INSTALL: error(EINVAL, "", ""); exit(1);
 509
 510    case CMD_MKDIR:   rv = cmd_mkdir(fname);  break;
 511    case CMD_MKFIFO:  rv = cmd_mkfifo(fname); break;
 512 #ifdef __HAS_SOCKETS
 513    case CMD_MKSOCK:  rv = cmd_mksock(fname); break;
 514 #endif
 515    case CMD_MKNOD:   break;
 516    }
 517 }
 518
 519 void parse_perms(prefix, ustring)
 520 char * prefix; char * ustring;
 521 {
 522    char * userstr;
 523    char * groupstr;
 524    char * modestr;
 525    char * cp;
 526    struct passwd * pwd = 0;
 527    struct group  * grp;
 528
 529    userstr = alloca(strlen(prefix) + strlen(ustring) + 2);
 530    strcpy(userstr, prefix);
 531    strcat(userstr, ustring);
 532
 533    /* Select User */
 534    cp = strchr(userstr, ':');
 535    if(!cp) cp = strchr(userstr, '.');
 536    if(cp) *cp = '\0';
 537
 538    /* If there's a user */
 539    if( *userstr != 0 )
 540    {
 541       pwd = getpwnam(userstr);
 542       if(pwd == NULL)
 543       {
 544          if(!strisdigit(userstr) )
 545          {
 546             error(EINVAL, "Unknown user ", userstr);
 547             exit(1);
 548          }
 549          set_user = atoi(userstr);
 550       }
 551       else set_user = pwd->pw_uid;
 552       endpwent();
 553    }
 554    if(cp)
 555    {
 556       groupstr = cp+1;
 557       cp = strchr(groupstr, ':');
 558       if(!cp) cp = strchr(groupstr, '.');
 559       if(cp) *cp = '\0';
 560       if( *groupstr != '\0' )
 561       {
 562          grp = getgrnam(groupstr);
 563          if(grp == NULL)
 564          {
 565             if(!strisdigit(groupstr) )
 566             {
 567                error(EINVAL, "Unknown group ", groupstr);
 568                exit(1);
 569             }
 570             set_group = atoi(groupstr);
 571          }
 572          else set_group = grp->gr_gid;
 573          endgrent();
 574       }
 575       else if( pwd )
 576          set_group = pwd->pw_gid;
 577    }
 578    if(cp)
 579    {
 580       modestr = cp+1;
 581       if(strisdigit(modestr))
 582          set_mode = strtol(modestr, NULL, 8);
 583       else
 584       {
 585          strncpy(mode_str, modestr, sizeof(mode_str)-1);
 586          /* This is the time that the mode change will fail on syn error */
 587          (void) edit_mode(u_mask, mode_str);
 588       }
 589    }
 590
 591    if( set_user == -1 && set_group == -1 && set_mode < 0 && *mode_str == 0)
 592    {
 593       error(EINVAL, "", "Permission string has no changes");
 594       exit(1);
 595    }
 596 }
 597
 598 int edit_mode(mode, mode_str)
 599 int mode; char * mode_str;
 600 {
 601    char * str=mode_str;
 602 static mtab[] = {0, 0111, 0222, 0333, 0444, 0555, 0666, 0777 };
 603
 604    int done_change = 0;
 605    int isdir = S_ISDIR(mode);
 606    int change_op   = 0;
 607    int change_mask = u_mask;
 608    int v=0, s=0, nm=0;
 609
 610    for(; *mode_str; mode_str++)
 611    {
 612       switch(*mode_str)
 613       {
 614       case ',': change_op = 0;
 615                 change_mask=u_mask; continue;
 616       case '=': change_op = 1;      if(0) {
 617       case '+': change_op = 2;    } if(0) {
 618       case '-': change_op = 3;    }
 619                 v=0; nm=0;
 620                 if(strchr(",=+-", mode_str[1]) == 0 ) continue;
 621                 break;
 622       case 'a': if(change_op) goto ch_error;
 623                 nm |= 07777;         if(0) {
 624       case 'u': nm |= 04700; s= 6; } if(0) {
 625       case 'g': nm |= 02070; s= 3; } if(0) {
 626       case 'o': nm |= 01007; s= 0; }
 627                 if(change_op==0) { change_mask=nm; continue; }
 628                 v |= mtab[(mode>>s)&7];
 629                 break;
 630       case 'r': v |= 0444; break;
 631       case 'w': v |= 0222; break;
 632       case 'x': v |= 0111; break;
 633       case 's': v |=06000; break;
 634       case 't': v |=01000; break;
 635       case 'X': v |= mtab[isdir]; break;
 636       default: goto ch_error;
 637       }
 638       switch(change_op)
 639       {
 640       case 0: goto ch_error;
 641       case 1: mode= ((mode&(~change_mask)) | (v&change_mask));
 642               break;
 643       case 2: mode= ( mode |  (v&change_mask));
 644               break;
 645       case 3: mode= ( mode & ~(v&change_mask));
 646               break;
 647       }
 648       done_change=1;
 649    }
 650    if(!done_change)
 651    {
 652 ch_error:
 653       error(EINVAL, "Invalid mode string ", str);
 654       exit(1);
 655    }
 656    return mode;
 657 }
 658
 659 int
 660 cmd_ft(fname)
 661 char * fname;
 662 {
 663 static char oldpath[2048] = "~";
 664 static int last_uid=-1, last_gid=-1, last_mode=-1;
 665    struct passwd * pptr;
 666    struct group  * gptr;
 667    int major, minor;
 668
 669    if( flg_verbose>1 )
 670    {
 671       char *p = 0;
 672       if( fname[1] ) p = strrchr(fname, '/');
 673       if( p )
 674       {
 675          *p = '\0';
 676          if( strcmp(fname, oldpath) != 0 )
 677          {
 678             strcpy(oldpath, fname);
 679             printf("%s/\n", oldpath);
 680          }
 681          *p = '/';
 682       }
 683       else if( *oldpath )
 684          *oldpath = '\0';
 685       if(p) printf("%s", p+1);
 686       else  printf("%s", fname);
 687
 688 #ifdef S_IFLNK
 689       if( S_ISLNK(cur_file_stat.st_mode))
 690       {
 691          char linkbuf[1024];
 692          int v;
 693          *linkbuf='\0';
 694          v = readlink(fname, linkbuf, sizeof(linkbuf));
 695          if(v>0) linkbuf[v] = '\0';
 696          printf("\t+%s", linkbuf);
 697       }
 698       else
 699 #endif
 700       if( cur_file_stat.st_mode != last_mode
 701        || cur_file_stat.st_uid != last_uid
 702        || cur_file_stat.st_gid != last_gid)
 703       {
 704          printf("\t");
 705          if( cur_file_stat.st_uid != last_uid )
 706          {
 707             pptr = getpwuid(cur_file_stat.st_uid);
 708             if( pptr )
 709                printf("%s", pptr->pw_name);
 710             else
 711                printf("%d", cur_file_stat.st_uid);
 712          }
 713          printf(":");
 714          if( cur_file_stat.st_gid != last_gid )
 715          {
 716             gptr = getgrgid(cur_file_stat.st_gid);
 717             if( gptr )
 718                printf("%s", gptr->gr_name);
 719             else
 720                printf("%d", cur_file_stat.st_gid);
 721          }
 722          if( (cur_file_stat.st_mode&07777) != (last_mode&07777) )
 723             printf(":%03o", cur_file_stat.st_mode & 07777);
 724
 725 #ifdef __linux__
 726          major = ((cur_file_stat.st_rdev >> 8) & 0xfff);
 727          if (sizeof(cur_file_stat.st_rdev) > 4)
 728             major |= ((cur_file_stat.st_rdev >> 32) & ~0xfff);
 729          minor = (cur_file_stat.st_rdev & 0xff) |
 730                  ((cur_file_stat.st_rdev >> 12) & ~0xff);
 731 #else
 732          major = ((cur_file_stat.st_rdev >> 8) & 0xFF);
 733          minor = (cur_file_stat.st_rdev&0xFF);
 734 #endif
 735          switch(cur_file_stat.st_mode & S_IFMT)
 736          {
 737          case S_IFDIR:  printf("\td"); break;
 738          case S_IFIFO:  printf("\tp"); break;
 739 #ifdef __HAS_SOCKETS
 740          case S_IFSOCK: printf("\ts"); break;
 741 #endif
 742          case S_IFBLK:  printf("\tb,%d,%d", major, minor);
 743                         break;
 744          case S_IFCHR:  printf("\tc,%d,%d", major, minor);
 745                         break;
 746          }
 747          last_mode = ((cur_file_stat.st_mode&07777)|S_IFREG);
 748          if( (cur_file_stat.st_mode&07000) ) last_mode = -1;
 749          last_uid = cur_file_stat.st_uid;
 750          last_gid = cur_file_stat.st_gid;
 751       }
 752       printf("\n");
 753    }
 754    else printf("%s\n", fname);
 755
 756    return 0;
 757 }
 758
 759 int
 760 cmd_mkfifo(fname)
 761 char * fname;
 762 {
 763    int rv;
 764    int mode=0666;
 765    if( set_mode >= 0 ) mode=set_mode;
 766    rv = mknod(fname, S_IFIFO|mode, 0);
 767    if(rv<0)
 768       warning(errno, "Cannot create fifo ", fname);
 769    return rv;
 770 }
 771
 772 #ifdef __HAS_SOCKETS
 773 int
 774 cmd_mksock(fname)
 775 char * fname;
 776 {
 777    int rv, fd, len;
 778    struct sockaddr *adr;
 779
 780    len = strlen(fname)+1 + sizeof(*adr) - sizeof(adr->sa_data);
 781    if( len < sizeof(*adr) ) len = sizeof(*adr);
 782
 783    adr = alloca(len+2);
 784    adr->sa_family = AF_UNIX;
 785    strcpy(adr->sa_data, fname);
 786
 787    rv = fd = socket(AF_UNIX, SOCK_STREAM, 0);
 788    if( fd>=0 ) rv = bind(fd, adr, len);
 789    if( fd>=0 ) close(fd);
 790    if(set_mode >= 0 && chmod(fname, set_mode&07777) < 0 )
 791       warning(errno, "Chmod ", fname);
 792
 793    if(rv<0)
 794       warning(errno, "Cannot create socket ", fname);
 795    return rv;
 796 }
 797 #endif
 798
 799 int
 800 cmd_rm(fname)
 801 char * fname;
 802 {
 803    struct stat dirstat;
 804    int rv;
 805    char * buf, * p;
 806
 807    if( S_ISDIR(cur_file_stat.st_mode) )
 808       if( !flg_recurse ) return error(EISDIR, "", fname);
 809
 810    if( S_ISDIR(cur_file_stat.st_mode) )
 811    {
 812       if( rmdir(fname) >= 0 ) return 0;
 813    }
 814    else
 815    {
 816       if( unlink(fname) >= 0 ) return 0;
 817    }
 818
 819    if( !flg_force )
 820       return error(errno, "", fname);
 821
 822    /* Try VERY hard */
 823    buf = alloca(strlen(fname)+4);
 824    strcpy(buf, fname);
 825    p = strrchr(buf, '/');
 826    if( p ) strcpy(p+1, "."); else strcpy(buf, ".");
 827
 828    if( stat(buf, &dirstat) < 0 ) return -1;
 829    if( chmod(buf, dirstat.st_mode|0700) < 0 ) return -1;
 830
 831    if( S_ISDIR(cur_file_stat.st_mode) )
 832       rv = rmdir(fname);
 833    else
 834       rv = unlink(fname);
 835
 836    chmod(buf, dirstat.st_mode);
 837
 838    return rv;
 839 }
 840
 841 void
 842 build_dest(dest, name, newpath)
 843 char * dest; char * name; char * newpath;
 844 {
 845    char * p;
 846    strcpy(dest, newpath);
 847    if( add_base )
 848    {
 849       strcat(dest, "/");
 850       p = strrchr(or_name, '/');
 851       if(p==0) strcat(dest, or_name);
 852       else     strcat(dest, p+1);
 853    }
 854    if(strlen(name) <= or_offset) return;
 855    strcat(dest, name+or_offset);
 856 }
 857
 858 int
 859 strisdigit(str)
 860 char * str;
 861 {
 862    if( str==0 || *str == 0 ) return 0;
 863
 864    for(;*str; str++)
 865       if(*str>'9'|| *str<'0') return 0;
 866    return 1;
 867 }
 868
 869 int
 870 cmd_mv(fname)
 871 char * fname;
 872 {
 873    char * destfile;
 874    destfile = alloca(strlen(fname)+strlen(cmd_string)+4);
 875
 876    build_dest(destfile, fname, cmd_string);
 877
 878    if( !flg_force && lstat(destfile, &access_stat) == 0 )
 879       return error(EEXIST, "", destfile);
 880
 881    if( rename(fname, destfile) == 0 ) return 0;
 882
 883    if( errno != EXDEV )
 884       return error(errno, "", fname);
 885
 886    if( S_ISDIR(cur_file_stat.st_mode) )
 887       return error(EISDIR, "Can't rename across devices ", fname);
 888
 889    if( copy_file(fname, destfile) != 0 ) return -1;
 890    copy_modes(destfile);
 891    return unlink(fname);
 892 }
 893
 894 int
 895 cmd_ln(fname)
 896 char * fname;
 897 {
 898    char * destfile;
 899    destfile = alloca(strlen(fname)+strlen(cmd_string)+4);
 900
 901    build_dest(destfile, fname, cmd_string);
 902
 903    if( lstat(destfile, &access_stat) != -1 )
 904    {
 905       if( !flg_force ) return error(EEXIST, "", destfile);
 906       cmd_rm(destfile);
 907    }
 908
 909 #ifdef S_IFLNK
 910    if( flg_symlink )
 911    {
 912       if( symlink(fname, destfile) == 0 ) return 0;
 913    }
 914    else
 915    {
 916 #endif
 917       if( link(fname, destfile) == 0 ) return 0;
 918 #ifdef S_IFLNK
 919    }
 920 #endif
 921
 922    return error(errno, "", destfile);
 923 }
 924
 925 int
 926 cmd_cp(fname)
 927 char * fname;
 928 {
 929    struct stat dest_stat;
 930    char * destfile;
 931    int no_dest = 0;
 932
 933    destfile = alloca(strlen(fname)+strlen(cmd_string)+4);
 934
 935    build_dest(destfile, fname, cmd_string);
 936
 937    if( stat(destfile, &dest_stat) >= 0 )
 938    {
 939       if( dest_stat.st_ino == cur_file_stat.st_ino
 940        && dest_stat.st_dev == cur_file_stat.st_dev )
 941       {
 942          warning(EPERM, "Can't copy file to itself ", fname);
 943          return -1;
 944       }
 945    }
 946    else no_dest = 1;
 947
 948    if( S_ISDIR(cur_file_stat.st_mode) )
 949    {
 950       if( !no_dest )
 951       {
 952          if( S_ISDIR(dest_stat.st_mode) ) return 0;
 953          if( unlink(destfile) < 0 )
 954             return error(errno, "Can't delete ", destfile);
 955       }
 956       return cmd_mkdir(destfile);
 957    }
 958    else if( S_ISDIR(dest_stat.st_mode) )
 959       return error(EPERM, "Can't copy non-directory to directory ", destfile);
 960    else if( S_ISREG(cur_file_stat.st_mode) )
 961    {
 962       /* Copy_ok - do we want to force a real file */;
 963       if( flg_force && !no_dest && !S_ISREG(dest_stat.st_mode) )
 964          cmd_rm(destfile);
 965    }
 966    else if( flg_recurse ) /* Don't copy other things while recursing */
 967    {
 968       return error(EPERM, "Can't copy ", fname);
 969    }
 970
 971    if( copy_file(fname, destfile) != 0 ) return -1;
 972    if( flg_preserve ) copy_modes(destfile);
 973    return 0;
 974 }
 975
 976 int
 977 copy_modes(file)
 978 char * file;
 979 {
 980   int user, group, mode;
 981   /* chown turns off set[ug]id bits for non-root,
 982      so do the chmod last.  */
 983
 984   /* Try to copy the old file's modtime and access time.  */
 985   if(set_time)
 986   {
 987     struct utimbuf tv;
 988
 989     tv.actime = cur_file_stat.st_atime;
 990     tv.modtime = cur_file_stat.st_mtime;
 991     if( set_time != -1 )
 992       tv.modtime = set_time;
 993     if (utime (file, &tv) && !flg_force)
 994         return error (errno, "", file);
 995   }
 996
 997   /* Try to preserve ownership.  For non-root it might fail, but that's ok.
 998      But root probably wants to know, e.g. if NFS disallows it.  */
 999   user  = cur_file_stat.st_uid; if(set_user != -1) user = set_user;
1000   group = cur_file_stat.st_gid; if(set_group != -1) group = set_group;
1001
1002   if (chown (file, user, group)
1003       && (errno != EPERM || geteuid() == 0 || (flg_preserve==0 && flg_force==0)))
1004       error (errno, "Can't change perms for ", file);
1005
1006   mode = cur_file_stat.st_mode;
1007   if(set_mode>=0) mode=set_mode;
1008   else if(*mode_str)
1009      mode = edit_mode(mode, mode_str);
1010
1011   if (chmod (file, mode & 07777))
1012       return error (errno, "", file);
1013
1014    return 0;
1015 }
1016
1017 /* This copies from something to a file or stdout */
1018 /* If the source has zero blocks (possibly holes) the destination
1019  * is built with holes (assuming it's a normal file) */
1020
1021 int
1022 copy_file(source, dest)
1023 char * source; char * dest;
1024 {
1025    char * buf;
1026    int sfd, dfd;
1027    struct stat st;
1028    int blksz = BUFSIZ;
1029    int cc;
1030    char * ptr;
1031    int hole_flag = 0;
1032    int retv = 0;
1033    int no_seek;
1034    int mmode = 0666;
1035
1036    if(flg_verbose>1) printf("%s -> %s\n", source, dest);
1037    if( strcmp(source, "-") == 0 )
1038       sfd = 0;
1039    else
1040    {
1041       sfd = open(source, O_RDONLY);
1042       if(sfd<0) return error(errno, "", source);
1043       mmode = (cur_file_stat.st_mode&0777);
1044    }
1045
1046    if( strcmp(dest, "-") == 0 )
1047       dfd = 1;
1048    else
1049    {
1050       dfd = open(dest, O_WRONLY|O_TRUNC|O_CREAT, mmode);
1051       if(dfd<0)
1052       {
1053          close(sfd);
1054          return error(errno, "Cannot create ", source);
1055       }
1056    }
1057
1058    if( fstat(dfd, &st) )
1059    {
1060       retv = error(errno, "", dest);
1061       no_seek = 1;
1062    }
1063    else
1064    {
1065 #ifndef __BCC__
1066       blksz = st.st_blksize;
1067 #endif
1068       no_seek = !S_ISREG(st.st_mode);
1069    }
1070    buf = alloca(blksz + sizeof(int));
1071    if( buf == 0 ) return error(0, "Out of memory", "");
1072
1073    for(;;)
1074    {
1075       cc = read(sfd, buf, blksz);
1076       if(cc<0)
1077       {
1078          retv = error(errno, "", source);
1079          goto exit_now;
1080       }
1081       if(cc==0) break;
1082       buf[cc] = 1;
1083       for(ptr=buf; *ptr==0 ; ptr++) ;
1084       if((hole_flag = (ptr == buf+cc)))
1085       { /* Make a hole */
1086          if( lseek(dfd, (off_t) cc, SEEK_CUR) < 0 )
1087          {
1088             retv = error(errno, "", dest);
1089             goto exit_now;
1090          }
1091       }
1092       else
1093       {
1094          if( cc != write(dfd, buf, cc))
1095          {
1096             retv = error(errno, "", dest);
1097             goto exit_now;
1098          }
1099       }
1100    }
1101    if( hole_flag )
1102    {
1103       if( lseek(dfd, (off_t) -1, SEEK_CUR) < 0
1104        || write(dfd, "", 1) != 1 )
1105       {
1106          retv = error(errno, "", dest);
1107          goto exit_now;
1108       }
1109    }
1110
1111 exit_now:
1112    if(sfd>2) close(sfd);
1113    if(dfd>2) close(dfd);
1114    return retv;
1115 }
1116
1117 void
1118 Usage()
1119 {
1120    int i;
1121
1122    printf("FileTool Usage: %s%s", prog_name[0]=='-'?"ft -":"", prog_name);
1123    if( cmd_tok == CMD_FT )
1124    {
1125       printf(" --[com_name] [-options] [files]\n");
1126       printf("\nAvailable commands are:\n");
1127    }
1128
1129    for(i=1; command_list[i].name; i++)
1130    {
1131       if( cmd_tok == CMD_FT )
1132          printf(" %s --%s", prog_name, command_list[i].name);
1133       else if( cmd_tok != command_list[i].cmd )
1134          continue;
1135
1136       if( *command_list[i].opts )
1137          printf(" [-%s]", command_list[i].opts);
1138       switch(command_list[i].argpat)
1139       {
1140       case 1:  printf(" <info> [files]"); break;
1141       case -1: printf(" [files] [dest]"); break;
1142       case 0:  printf(" [files]"); break;
1143       default: printf(" path [bcu] major minor"); break;
1144       }
1145       printf("\n");
1146    }
1147
1148    exit(99);
1149 }
1150
1151 int
1152 cmd_mkdir(dirname)
1153 char * dirname;
1154 {
1155    int retv;
1156    int mode = 0777;
1157    if( set_mode >= 0 ) mode = set_mode;
1158
1159    retv = mkdir(dirname, mode);
1160    if(retv<0)
1161    {
1162       if(flg_mkpdir && errno == ENOENT)
1163       {
1164          /* Create parents */
1165       }
1166    }
1167    if( retv>=0 && cmd_tok == CMD_MKDIR )
1168    {
1169       if( set_user != -1 || set_group != -1 )
1170       {
1171          if( chown(dirname, set_user, set_group) < 0)
1172             warning(errno, "Cannot change directory owner ", dirname);
1173          else if( chmod (dirname, mode & 07777) )
1174             warning(errno, "", dirname);
1175       }
1176    }
1177
1178    if(retv<0) error(errno, "Cannot create directory ", dirname);
1179    return retv;
1180 }
1181
1182 int
1183 cmd_mknod()
1184 {
1185    int device, major, minor;
1186    int rv = -1;
1187    int mode=0666;
1188    if( set_mode >= 0 ) mode=set_mode;
1189
1190    major = atoi(flist[2]);
1191    minor = atoi(flist[3]);
1192 #ifdef __linux__
1193    /* Linux 2.6+ uses an odd arrangment. */
1194    device = (major<<8) + (minor & 0xFF) + ((minor & 0xFFF00) << 12);
1195 #else
1196    device = (major<<8) + (minor & 0xFF);
1197 #endif
1198
1199    if(flist[1][0] == 'b')
1200       rv = mknod(flist[0], S_IFBLK|mode, device);
1201    else if(flist[1][0] == 'c' || flist[1][0] == 'u')
1202       rv = mknod(flist[0], S_IFCHR|mode, device);
1203    else Usage();
1204
1205    if(rv<0)
1206    {
1207       error(errno, "", flist[0]);
1208       exit(1);
1209    }
1210    return rv;
1211 }
1212
1213 int
1214 warning(enumber, estr, eobj)
1215 int enumber; char * estr; char * eobj;
1216 {
1217    if(flg_verbose)
1218       return error(enumber, estr, eobj);
1219    return 0;
1220 }
1221
1222 int
1223 error(enumber, estr, eobj)
1224 int enumber; char * estr; char * eobj;
1225 {
1226    fprintf(stderr, "%s%s: ", prog_name[0]=='-'?"ft":"", prog_name);
1227    fprintf(stderr, "%s%s: %s\n", estr, eobj, strerror(enumber));
1228    return -1;
1229 }