commands/ftp101/file.c

   1 /* file.c Copyright 1992-2000 by Michael Temari All Rights Reserved
   2  *
   3  * This file is part of ftp.
   4  *
   5  *
   6  * 01/25/96 Initial Release     Michael Temari, <Michael@TemWare.Com>
   7  */
   8
   9 #include <sys/types.h>
  10 #include <sys/stat.h>
  11 #include <stdio.h>
  12 #include <unistd.h>
  13 #include <string.h>
  14 #include <stdlib.h>
  15 #include <fcntl.h>
  16 #include <errno.h>
  17 #include <time.h>
  18 #include <utime.h>
  19 #include <net/hton.h>
  20
  21 #include "ftp.h"
  22 #include "file.h"
  23 #include "net.h"
  24
  25 static char *dir(char *path, int full);
  26 static int asciisize(int fd, off_t *filesize);
  27 static off_t asciisetsize(int fd, off_t filesize);
  28 static int cloneit(char *file, int mode);
  29
  30 #if (__WORD_SIZE == 4)
  31 static char buffer[8192];
  32 #else
  33 static char buffer[2048];
  34 #endif
  35 static char line2[512];
  36
  37 static char *dir(path, full)
  38 char *path;
  39 int full;
  40 {
  41 char cmd[128];
  42 static char name[32];
  43
  44    tmpnam(name);
  45
  46    if(full)
  47         sprintf(cmd, "ls -l %s > %s", path, name);
  48    else
  49         sprintf(cmd, "ls -dA %s > %s", path, name);
  50
  51    system(cmd);
  52
  53    return(name);
  54 }
  55
  56 int DOascii()
  57 {
  58 int s;
  59
  60    if(DOcmdcheck())
  61         return(0);
  62
  63    s = DOcommand("TYPE", "A");
  64
  65    type = TYPE_A;
  66
  67    return(s);
  68 }
  69
  70 int DObinary()
  71 {
  72 int s;
  73
  74    if(DOcmdcheck())
  75         return(0);
  76
  77    s = DOcommand("TYPE", "I");
  78
  79    type = TYPE_I;
  80
  81    return(s);
  82 }
  83
  84 int DOblock()
  85 {
  86 int s;
  87
  88    if(DOcmdcheck())
  89         return(0);
  90
  91    s = DOcommand("MODE", "B");
  92
  93    mode = MODE_B;
  94
  95    return(s);
  96 }
  97
  98 int DOstream()
  99 {
 100 int s;
 101
 102    if(DOcmdcheck())
 103         return(0);
 104
 105    s = DOcommand("MODE", "S");
 106
 107    mode = MODE_S;
 108
 109    return(s);
 110 }
 111
 112 int DOpwd()
 113 {
 114 int s;
 115
 116    if(DOcmdcheck())
 117         return(0);
 118
 119    s = DOcommand("PWD", "");
 120
 121    if(s == 500 || s == 502)
 122         s = DOcommand("XPWD", "");
 123
 124    return(s);
 125 }
 126
 127 int DOcd()
 128 {
 129 char *path;
 130 int s;
 131
 132    if(DOcmdcheck())
 133         return(0);
 134
 135    path = cmdargv[1];
 136
 137    if(cmdargc < 2) {
 138         if(readline("Path: ", line2, sizeof(line2)) < 0)
 139                 return(-1);
 140         path = line2;
 141    }
 142
 143    if(!strcmp(path, ".."))
 144         s = DOcommand("CDUP", "");
 145    else
 146         s = DOcommand("CWD", path);
 147
 148    if(s == 500 || s == 502) {
 149         if(!strcmp(path, ".."))
 150                 s = DOcommand("XCUP", "");
 151         else
 152                 s = DOcommand("XCWD", path);
 153    }
 154
 155    return(s);
 156 }
 157
 158 int DOmkdir()
 159 {
 160 char *path;
 161 int s;
 162
 163    if(DOcmdcheck())
 164         return(0);
 165
 166    path = cmdargv[1];
 167
 168    if(cmdargc < 2) {
 169         if(readline("Directory: ", line2, sizeof(line2)) < 0)
 170                 return(-1);
 171         path = line2;
 172    }
 173
 174    s = DOcommand("MKD", path);
 175
 176    if(s == 500 || s == 502)
 177         s = DOcommand("XMKD", path);
 178
 179    return(s);
 180 }
 181
 182 int DOrmdir()
 183 {
 184 char *path;
 185 int s;
 186
 187    if(DOcmdcheck())
 188         return(0);
 189
 190    path = cmdargv[1];
 191
 192    if(cmdargc < 2) {
 193         if(readline("Directory: ", line2, sizeof(line2)) < 0)
 194                 return(-1);
 195         path = line2;
 196    }
 197
 198    s = DOcommand("RMD", path);
 199
 200    if(s == 500 || s == 502)
 201         s = DOcommand("XRMD", path);
 202
 203    return(s);
 204 }
 205
 206 int DOdelete()
 207 {
 208 char *file;
 209
 210    if(DOcmdcheck())
 211         return(0);
 212
 213    file = cmdargv[1];
 214
 215    if(cmdargc < 2) {
 216         if(readline("File: ", line2, sizeof(line2)) < 0)
 217                 return(-1);
 218         file = line2;
 219    }
 220
 221    return(DOcommand("DELE", file));
 222 }
 223
 224 int DOmdtm()
 225 {
 226 char *file;
 227
 228    if(DOcmdcheck())
 229         return(0);
 230
 231    file = cmdargv[1];
 232
 233    if(cmdargc < 2) {
 234         if(readline("File: ", line2, sizeof(line2)) < 0)
 235                 return(-1);
 236         file = line2;
 237    }
 238
 239    return(DOcommand("MDTM", file));
 240 }
 241
 242 int DOsize()
 243 {
 244 char *file;
 245
 246    if(DOcmdcheck())
 247         return(0);
 248
 249    file = cmdargv[1];
 250
 251    if(cmdargc < 2) {
 252         if(readline("File: ", line2, sizeof(line2)) < 0)
 253                 return(-1);
 254         file = line2;
 255    }
 256
 257    return(DOcommand("SIZE", file));
 258 }
 259
 260 int DOstat()
 261 {
 262 char *file;
 263
 264    if(cmdargc < 2) {
 265         if(!linkopen) {
 266                 printf("You must \"OPEN\" a connection first.\n");
 267                 return(0);
 268         } else {
 269                 return(DOcommand("STAT", ""));
 270         }
 271    }
 272    if(DOcmdcheck())
 273         return(0);
 274
 275    file = cmdargv[1];
 276
 277    if(cmdargc < 2) {
 278         if(readline("File: ", line2, sizeof(line2)) < 0)
 279                 return(-1);
 280         file = line2;
 281    }
 282
 283    return(DOcommand("STAT", file));
 284 }
 285
 286 int DOlist()
 287 {
 288 char *path;
 289 char *local;
 290 int fd;
 291 int s;
 292
 293    if(DOcmdcheck())
 294         return(0);
 295
 296    path = cmdargv[1];
 297
 298    if(cmdargc < 2)
 299         path = "";
 300
 301    if(cmdargc < 3)
 302         local = "";
 303    else
 304         local = cmdargv[2];
 305
 306    if(*local == '\0')
 307         fd = 1;
 308    else
 309         fd = open(local, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 310
 311    if(fd < 0) {
 312         printf("Could not open local file %s. Error %s\n", local, strerror(errno));
 313         return(0);
 314    }
 315
 316    s = DOdata("LIST", path, RETR, fd);
 317
 318    if(fd > 2)
 319         close(fd);
 320
 321    return(s);
 322 }
 323
 324 int DOnlst()
 325 {
 326 char *path;
 327 char *local;
 328 int fd;
 329 int s;
 330
 331    if(DOcmdcheck())
 332         return(0);
 333
 334    path = cmdargv[1];
 335
 336    if(cmdargc < 2)
 337         path = "";
 338
 339    if(cmdargc < 3)
 340         local = "";
 341    else
 342         local = cmdargv[2];
 343
 344    if(*local == '\0')
 345         fd = 1;
 346    else
 347         fd = open(local, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 348
 349    if(fd < 0) {
 350         printf("Could not open local file %s. Error %s\n", local, strerror(errno));
 351         return(0);
 352    }
 353
 354    s = DOdata("NLST", path, RETR, fd);
 355
 356    if(fd > 2)
 357         close(fd);
 358
 359    return(s);
 360 }
 361
 362 int DOretr()
 363 {
 364 char *file, *localfile;
 365 int fd;
 366 int s;
 367
 368    if(DOcmdcheck())
 369         return(0);
 370
 371    file = cmdargv[1];
 372
 373    if(cmdargc < 2) {
 374         if(readline("Remote File: ", line2, sizeof(line2)) < 0)
 375                 return(-1);
 376         file = line2;
 377    }
 378
 379    if(cmdargc < 3)
 380         localfile = file;
 381    else
 382         localfile = cmdargv[2];
 383
 384    fd = open(localfile, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 385
 386    if(fd < 0) {
 387         printf("Could not open local file %s. Error %s\n", localfile, strerror(errno));
 388         return(0);
 389    }
 390
 391    s = DOdata("RETR", file, RETR, fd);
 392
 393    close(fd);
 394
 395    return(s);
 396 }
 397
 398 int DOrretr()
 399 {
 400 char *file, *localfile;
 401 int fd;
 402 int s;
 403 off_t filesize;
 404 char restart[16];
 405
 406    if(DOcmdcheck())
 407         return(0);
 408
 409    file = cmdargv[1];
 410
 411    if(cmdargc < 2) {
 412         if(readline("Remote File: ", line2, sizeof(line2)) < 0)
 413                 return(-1);
 414         file = line2;
 415    }
 416
 417    if(cmdargc < 3)
 418         localfile = file;
 419    else
 420         localfile = cmdargv[2];
 421
 422    fd = open(localfile, O_RDWR);
 423
 424    if(fd < 0) {
 425         printf("Could not open local file %s. Error %s\n", localfile, strerror(errno));
 426         return(0);
 427    }
 428
 429    if(type == TYPE_A) {
 430         if(asciisize(fd, &filesize)) {
 431                 printf("Could not determine ascii file size of %s\n", localfile);
 432                 close(fd);
 433                 return(0);
 434         }
 435    } else
 436         filesize = lseek(fd, 0, SEEK_END);
 437
 438    sprintf(restart, "%u", filesize);
 439
 440    s = DOcommand("REST", restart);
 441
 442    if(s != 350) {
 443         close(fd);
 444         return(s);
 445    }
 446
 447    s = DOdata("RETR", file, RETR, fd);
 448
 449    close(fd);
 450
 451    return(s);
 452 }
 453
 454 char *ttime(time_t t)
 455 {
 456 struct tm *tm;
 457 static char tbuf[16];
 458
 459    tm = localtime(&t);
 460
 461    sprintf(tbuf, "%04d%02d%02d%02d%02d.%02d",
 462         tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
 463         tm->tm_hour, tm->tm_min, tm->tm_sec);
 464
 465    return(tbuf);
 466 }
 467
 468 static int cloneit(file, mode)
 469 char *file;
 470 int mode;
 471 {
 472 int opr;
 473 int s;
 474 int ss;
 475 struct stat st;
 476 static unsigned short lcrc;
 477 static unsigned short ccrc;
 478 static unsigned long csize;
 479 static char ft;
 480 static unsigned long maj;
 481 static unsigned long min;
 482 static unsigned long uid;
 483 static unsigned long gid;
 484 static unsigned long fmode;
 485 static unsigned long size;
 486 static unsigned long mtime;
 487 struct utimbuf ut;
 488 unsigned short crc(char *fname);
 489
 490    if(mode == 1) {
 491         /* see if file exists locally */
 492         ss = stat(file, &st);
 493
 494         opr = printreply;
 495         printreply = 0;
 496         s = DOcommand("SITE FDET", file);
 497         printreply = opr;
 498
 499         if((s / 100) != 2)
 500                 return(-1);
 501
 502         sscanf(reply, "%*d %c%lu%lu%lu%lu%lu%lu%lu",
 503                 &ft, &maj, &min, &uid, &gid, &fmode, &size, &mtime);
 504
 505         if(ft == 'f') {
 506                 opr = printreply;
 507                 printreply = 0;
 508                 s = DOcommand("SITE CCRC", file);
 509                 printreply = opr;
 510                 if((s / 100) != 2)
 511                         return(-1);
 512
 513                 sscanf(reply, "%*hu %*s%u%lu", &ccrc, &csize);
 514                 if(ss < 0) return(-1);
 515                 lcrc = crc(file);
 516                 if(size != csize || size != st.st_size || ccrc != lcrc)
 517                         return(-1);
 518         } else
 519         if(ss < 0 && ft == 'd') {
 520                 s = mkdir(file, fmode);
 521                 printf("mkdir %s\n", file);
 522         } else
 523         if((ss < 0) && (ft == 'b' || ft == 'c' || ft == 'p')) {
 524                 s = mknod(file, fmode, maj << 8 | min);
 525                 printf("mknod %s %lu %lu\n", file, maj, min);
 526         } else
 527                 return(0);
 528    }
 529    ss = stat(file, &st);
 530    if(ss < 0)
 531         return(-1);
 532    if(st.st_uid != uid || st.st_gid != gid) {
 533         s = chown(file, uid, gid);
 534         printf("chown %lu:%lu %s\n", uid, gid, file);
 535    }
 536    if(st.st_mode != fmode) {
 537         s = chmod(file, fmode);
 538         printf("chmod %04lo %s\n", fmode, file);
 539    }
 540    if(st.st_mtime != mtime) {
 541         ut.actime = mtime;
 542         ut.modtime = mtime;
 543         s = utime(file, &ut);
 544         printf("touch -m -t %s %s\n", ttime(mtime), file);
 545    }
 546
 547    return(0);
 548 }
 549
 550 int DOMretr()
 551 {
 552 char *files;
 553 int fd, s;
 554 char *p;
 555 FILE *fp;
 556 char name[32];
 557
 558    if(DOcmdcheck())
 559         return(0);
 560
 561    files = cmdargv[1];
 562
 563    if(cmdargc < 2) {
 564         if(readline("Files: ", line2, sizeof(line2)) < 0)
 565                 return(-1);
 566         files = line2;
 567    }
 568
 569    tmpnam(name);
 570
 571    fd = open(name, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 572
 573    if(fd < 0) {
 574         printf("Could not open local file %s. Error %s\n", name, strerror(errno));
 575         return(0);
 576    }
 577
 578    s = DOdata("NLST", files, RETR, fd);
 579
 580    close(fd);
 581
 582    if(s == 226 || s == 250) {
 583         fp = fopen(name, "r");
 584         unlink(name);
 585         if(fp == (FILE *)NULL) {
 586                 printf("Unable to open file listing.\n");
 587                 return(0);
 588         }
 589         while(fgets(line2, sizeof(line2), fp) != (char *)NULL) {
 590                 p = line2 + strlen(line2) - 1;
 591                 if(p >= line2 && (*p == '\r' || *p == '\n')) *p-- = '\0';
 592                 if(p >= line2 && (*p == '\r' || *p == '\n')) *p-- = '\0';
 593                 printf("Retrieving file: %s\n", line2); fflush(stdout);
 594                 fd = open(line2, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 595                 if(fd < 0)
 596                         printf("Unable to open local file %s\n", line2);
 597                 else {
 598                         s = DOdata("RETR", line2, RETR, fd);
 599                         close(fd);
 600                         if(s < 0) break;
 601                 }
 602         }
 603         fclose(fp);
 604    } else
 605         unlink(name);
 606
 607    return(s);
 608 }
 609
 610 int DOappe()
 611 {
 612 char *file, *remotefile;
 613 int fd;
 614 int s;
 615
 616    if(DOcmdcheck())
 617         return(0);
 618
 619    file = cmdargv[1];
 620
 621    if(cmdargc < 2) {
 622         if(readline("Local File: ", line2, sizeof(line2)) < 0)
 623                 return(-1);
 624         file = line2;
 625    }
 626
 627    if(cmdargc < 3)
 628         remotefile = file;
 629    else
 630         remotefile = cmdargv[2];
 631
 632    fd = open(file, O_RDONLY);
 633
 634    if(fd < 0) {
 635         printf("Could not open local file %s. Error %s\n", file, strerror(errno));
 636         return(0);
 637    }
 638
 639    s = DOdata("APPE", remotefile, STOR, fd);
 640
 641    close(fd);
 642
 643    return(s);
 644 }
 645
 646 int DOstor()
 647 {
 648 char *file, *remotefile;
 649 int fd;
 650 int s;
 651
 652    if(DOcmdcheck())
 653         return(0);
 654
 655    file = cmdargv[1];
 656
 657    if(cmdargc < 2) {
 658         if(readline("Local File: ", line2, sizeof(line2)) < 0)
 659                 return(-1);
 660         file = line2;
 661    }
 662
 663    if(cmdargc < 3)
 664         remotefile = file;
 665    else
 666         remotefile = cmdargv[2];
 667
 668    fd = open(file, O_RDONLY);
 669
 670    if(fd < 0) {
 671         printf("Could not open local file %s. Error %s\n", file, strerror(errno));
 672         return(0);
 673    }
 674
 675    s = DOdata("STOR", remotefile, STOR, fd);
 676
 677    close(fd);
 678
 679    return(s);
 680 }
 681
 682 int DOrstor()
 683 {
 684 char *file, *remotefile;
 685 int fd;
 686 int s;
 687 off_t filesize, rmtsize;
 688 char restart[16];
 689
 690    if(DOcmdcheck())
 691         return(0);
 692
 693    file = cmdargv[1];
 694
 695    if(cmdargc < 2) {
 696         if(readline("Local File: ", line2, sizeof(line2)) < 0)
 697                 return(-1);
 698         file = line2;
 699    }
 700
 701    if(cmdargc < 3)
 702         remotefile = file;
 703    else
 704         remotefile = cmdargv[2];
 705
 706    s = DOcommand("SIZE", remotefile);
 707
 708    if(s != 215)
 709         return(s);
 710
 711    rmtsize = atol(reply+4);
 712
 713    fd = open(file, O_RDONLY);
 714
 715    if(fd < 0) {
 716         printf("Could not open local file %s. Error %s\n", file, strerror(errno));
 717         return(0);
 718    }
 719
 720    if(type == TYPE_A)
 721         filesize = asciisetsize(fd, rmtsize);
 722    else
 723         filesize = lseek(fd, rmtsize, SEEK_SET);
 724
 725    if(filesize != rmtsize) {
 726         printf("Could not set file start of %s\n", file);
 727         close(fd);
 728         return(0);
 729    }
 730
 731    sprintf(restart, "%u", rmtsize);
 732
 733    s = DOcommand("REST", restart);
 734
 735    if(s != 350) {
 736         close(fd);
 737         return(s);
 738    }
 739
 740    s = DOdata("STOR", remotefile, STOR, fd);
 741
 742    close(fd);
 743
 744    return(s);
 745 }
 746
 747 int DOstou()
 748 {
 749 char *file, *remotefile;
 750 int fd;
 751 int s;
 752
 753    if(DOcmdcheck())
 754         return(0);
 755
 756    file = cmdargv[1];
 757
 758    if(cmdargc < 2) {
 759         if(readline("Local File: ", line2, sizeof(line2)) < 0)
 760                 return(-1);
 761         file = line2;
 762    }
 763
 764    if(cmdargc < 3)
 765         remotefile = file;
 766    else
 767         remotefile = cmdargv[2];
 768
 769    fd = open(file, O_RDONLY);
 770
 771    if(fd < 0) {
 772         printf("Could not open local file %s. Error %s\n", file, strerror(errno));
 773         return(0);
 774    }
 775
 776    s = DOdata("STOU", remotefile, STOR, fd);
 777
 778    close(fd);
 779
 780    return(s);
 781 }
 782
 783 int DOMstor()
 784 {
 785 char *files;
 786 char *name;
 787 char *p;
 788 int fd, s;
 789 FILE *fp;
 790
 791    if(DOcmdcheck())
 792         return(0);
 793
 794    files = cmdargv[1];
 795
 796    if(cmdargc < 2) {
 797         if(readline("Files: ", line2, sizeof(line2)) < 0)
 798                 return(-1);
 799         files = line2;
 800    }
 801
 802    name = dir(files, 0);
 803
 804    fp = fopen(name, "r");
 805
 806    if(fp == (FILE *)NULL) {
 807         printf("Unable to open listing file.\n");
 808         return(0);
 809    }
 810
 811    while(fgets(line2, sizeof(line2), fp) != (char *)NULL) {
 812         p = line2 + strlen(line2) - 1;
 813         if(p >= line2 && (*p == '\r' || *p == '\n')) *p-- = '\0';
 814         if(p >= line2 && (*p == '\r' || *p == '\n')) *p-- = '\0';
 815         printf("Sending file: %s\n", line2); fflush(stdout);
 816         fd = open(line2, O_RDONLY);
 817         if(fd < 0)
 818                 printf("Unable to open local file %s\n", line2);
 819         else {
 820                 s = DOdata("STOR", line2, STOR, fd);
 821                 close(fd);
 822                 if(s < 0) break;
 823         }
 824    }
 825    fclose(fp);
 826    unlink(name);
 827
 828    return(s);
 829 }
 830
 831 static int asciisize(fd, filesize)
 832 int fd;
 833 off_t *filesize;
 834 {
 835 unsigned long count;
 836 char *p, *pp;
 837 int cnt;
 838
 839    count = 0;
 840
 841    while((cnt = read(fd, buffer, sizeof(buffer))) > 0) {
 842         p = buffer; pp = buffer + cnt;
 843         count += cnt;
 844         while(p < pp)
 845                 if(*p++ == '\n')
 846                         count++;
 847    }
 848
 849    if(cnt == 0) {
 850         *filesize = count;
 851         return(0);
 852    }
 853
 854    return(-1);
 855 }
 856
 857 static off_t asciisetsize(fd, filesize)
 858 int fd;
 859 off_t filesize;
 860 {
 861 off_t sp;
 862 int s;
 863
 864    sp = 0;
 865
 866    while(sp < filesize) {
 867         s = read(fd, buffer, 1);
 868         if(s < 0)
 869                 return(-1);
 870         if(s == 0) break;
 871         sp++;
 872         if(*buffer == '\n')
 873                 sp++;
 874    }
 875
 876    return(sp);
 877 }
 878
 879 int DOclone()
 880 {
 881 char *files;
 882 int fd, s;
 883 char *p;
 884 FILE *fp;
 885 char name[32];
 886
 887    if(DOcmdcheck())
 888         return(0);
 889
 890    files = cmdargv[1];
 891
 892    tmpnam(name);
 893
 894    fd = open(name, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 895
 896    if(fd < 0) {
 897         printf("Could not open local file %s. Error %s\n", name, strerror(errno));
 898         return(0);
 899    }
 900
 901    s = DOdata("NLST", files, RETR, fd);
 902
 903    close(fd);
 904
 905    if(s == 226 || s == 250) {
 906         fp = fopen(name, "r");
 907         unlink(name);
 908         if(fp == (FILE *)NULL) {
 909                 printf("Unable to open file listing.\n");
 910                 return(0);
 911         }
 912         while(fgets(line2, sizeof(line2), fp) != (char *)NULL) {
 913                 p = line2 + strlen(line2) - 1;
 914                 if(p >= line2 && (*p == '\r' || *p == '\n')) *p-- = '\0';
 915                 if(p >= line2 && (*p == '\r' || *p == '\n')) *p-- = '\0';
 916                 cmdargv[1] = line2;
 917                 if(cloneit(line2, 1)) {
 918                         printf("Retrieving file: %s\n", line2); fflush(stdout);
 919                         fd = open(line2, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 920                         if(fd < 0)
 921                                 printf("Unable to open local file %s\n", line2);
 922                         else {
 923                                 s = DOdata("RETR", line2, RETR, fd);
 924                                 close(fd);
 925                                 if(s < 0) break;
 926                         }
 927                         s = cloneit(line2, 2);
 928                 }
 929         }
 930         fclose(fp);
 931    } else
 932         unlink(name);
 933
 934    return(s);
 935 }