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    if(DOcmdcheck())
 272         return(0);
 273
 274    file = cmdargv[1];
 275
 276    if(cmdargc < 2) {
 277         if(readline("File: ", line2, sizeof(line2)) < 0)
 278                 return(-1);
 279         file = line2;
 280    }
 281
 282    return(DOcommand("STAT", file));
 283 }
 284
 285 int DOlist()
 286 {
 287 char *path;
 288 char *local;
 289 int fd;
 290 int s;
 291
 292    if(DOcmdcheck())
 293         return(0);
 294
 295    path = cmdargv[1];
 296
 297    if(cmdargc < 2)
 298         path = "";
 299
 300    if(cmdargc < 3)
 301         local = "";
 302    else
 303         local = cmdargv[2];
 304
 305    if(*local == '\0')
 306         fd = 1;
 307    else
 308         fd = open(local, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 309
 310    if(fd < 0) {
 311         printf("Could not open local file %s. Error %s\n", local, strerror(errno));
 312         return(0);
 313    }
 314
 315    s = DOdata("LIST", path, RETR, fd);
 316
 317    if(fd > 2)
 318         close(fd);
 319
 320    return(s);
 321 }
 322
 323 int DOnlst()
 324 {
 325 char *path;
 326 char *local;
 327 int fd;
 328 int s;
 329
 330    if(DOcmdcheck())
 331         return(0);
 332
 333    path = cmdargv[1];
 334
 335    if(cmdargc < 2)
 336         path = "";
 337
 338    if(cmdargc < 3)
 339         local = "";
 340    else
 341         local = cmdargv[2];
 342
 343    if(*local == '\0')
 344         fd = 1;
 345    else
 346         fd = open(local, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 347
 348    if(fd < 0) {
 349         printf("Could not open local file %s. Error %s\n", local, strerror(errno));
 350         return(0);
 351    }
 352
 353    s = DOdata("NLST", path, RETR, fd);
 354
 355    if(fd > 2)
 356         close(fd);
 357
 358    return(s);
 359 }
 360
 361 int DOretr()
 362 {
 363 char *file, *localfile;
 364 int fd;
 365 int s;
 366
 367    if(DOcmdcheck())
 368         return(0);
 369
 370    file = cmdargv[1];
 371
 372    if(cmdargc < 2) {
 373         if(readline("Remote File: ", line2, sizeof(line2)) < 0)
 374                 return(-1);
 375         file = line2;
 376    }
 377
 378    if(cmdargc < 3)
 379         localfile = file;
 380    else
 381         localfile = cmdargv[2];
 382
 383    fd = open(localfile, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 384
 385    if(fd < 0) {
 386         printf("Could not open local file %s. Error %s\n", localfile, strerror(errno));
 387         return(0);
 388    }
 389
 390    s = DOdata("RETR", file, RETR, fd);
 391
 392    close(fd);
 393
 394    return(s);
 395 }
 396
 397 int DOrretr()
 398 {
 399 char *file, *localfile;
 400 int fd;
 401 int s;
 402 off_t filesize;
 403 char restart[16];
 404
 405    if(DOcmdcheck())
 406         return(0);
 407
 408    file = cmdargv[1];
 409
 410    if(cmdargc < 2) {
 411         if(readline("Remote File: ", line2, sizeof(line2)) < 0)
 412                 return(-1);
 413         file = line2;
 414    }
 415
 416    if(cmdargc < 3)
 417         localfile = file;
 418    else
 419         localfile = cmdargv[2];
 420
 421    fd = open(localfile, O_RDWR);
 422
 423    if(fd < 0) {
 424         printf("Could not open local file %s. Error %s\n", localfile, strerror(errno));
 425         return(0);
 426    }
 427
 428    if(type == TYPE_A) {
 429         if(asciisize(fd, &filesize)) {
 430                 printf("Could not determine ascii file size of %s\n", localfile);
 431                 close(fd);
 432                 return(0);
 433         }
 434    } else
 435         filesize = lseek(fd, 0, SEEK_END);
 436
 437    sprintf(restart, "%lu", filesize);
 438
 439    s = DOcommand("REST", restart);
 440
 441    if(s != 350) {
 442         close(fd);
 443         return(s);
 444    }
 445
 446    s = DOdata("RETR", file, RETR, fd);
 447
 448    close(fd);
 449
 450    return(s);
 451 }
 452
 453 char *ttime(time_t t)
 454 {
 455 struct tm *tm;
 456 static char tbuf[16];
 457
 458    tm = localtime(&t);
 459
 460    sprintf(tbuf, "%04d%02d%02d%02d%02d.%02d",
 461         tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
 462         tm->tm_hour, tm->tm_min, tm->tm_sec);
 463
 464    return(tbuf);
 465 }
 466
 467 static int cloneit(file, mode)
 468 char *file;
 469 int mode;
 470 {
 471 int opr;
 472 int s;
 473 int ss;
 474 struct stat st;
 475 static unsigned short lcrc;
 476 static unsigned short ccrc;
 477 static unsigned long csize;
 478 static char ft;
 479 static unsigned long maj;
 480 static unsigned long min;
 481 static unsigned long uid;
 482 static unsigned long gid;
 483 static unsigned long fmode;
 484 static unsigned long size;
 485 static unsigned long mtime;
 486 struct utimbuf ut;
 487 unsigned short crc(char *fname);
 488
 489    if(mode == 1) {
 490         /* see if file exists locally */
 491         ss = stat(file, &st);
 492
 493         opr = printreply;
 494         printreply = 0;
 495         s = DOcommand("SITE FDET", file);
 496         printreply = opr;
 497
 498         if((s / 100) != 2)
 499                 return(-1);
 500
 501         sscanf(reply, "%*d %c%lu%lu%lu%lu%lu%lu%lu",
 502                 &ft, &maj, &min, &uid, &gid, &fmode, &size, &mtime);
 503
 504         if(ft == 'f') {
 505                 opr = printreply;
 506                 printreply = 0;
 507                 s = DOcommand("SITE CCRC", file);
 508                 printreply = opr;
 509                 if((s / 100) != 2)
 510                         return(-1);
 511
 512                 sscanf(reply, "%*d %*s%u%lu", &ccrc, &csize);
 513                 if(ss < 0) return(-1);
 514                 lcrc = crc(file);
 515                 if(size != csize || size != st.st_size || ccrc != lcrc)
 516                         return(-1);
 517         } else
 518         if(ss < 0 && ft == 'd') {
 519                 s = mkdir(file, fmode);
 520                 printf("mkdir %s\n", file);
 521         } else
 522         if((ss < 0) && (ft == 'b' || ft == 'c' || ft == 'p')) {
 523                 s = mknod(file, fmode, maj << 8 | min);
 524                 printf("mknod %c %u %u\n", file, maj, min);
 525         } else
 526                 return(0);
 527    }
 528    ss = stat(file, &st);
 529    if(ss < 0)
 530         return(-1);
 531    if(st.st_uid != uid || st.st_gid != gid) {
 532         s = chown(file, uid, gid);
 533         printf("chown %u:%u %s\n", uid, gid, file);
 534    }
 535    if(st.st_mode != fmode) {
 536         s = chmod(file, fmode);
 537         printf("chmod %04o %s\n", fmode, file);
 538    }
 539    if(st.st_mtime != mtime) {
 540         ut.actime = mtime;
 541         ut.modtime = mtime;
 542         s = utime(file, &ut);
 543         printf("touch -m -t %s %s\n", ttime(mtime), file);
 544    }
 545
 546    return(0);
 547 }
 548
 549 int DOMretr()
 550 {
 551 char *files;
 552 int fd, s;
 553 char *p;
 554 FILE *fp;
 555 char name[32];
 556
 557    if(DOcmdcheck())
 558         return(0);
 559
 560    files = cmdargv[1];
 561
 562    if(cmdargc < 2) {
 563         if(readline("Files: ", line2, sizeof(line2)) < 0)
 564                 return(-1);
 565         files = line2;
 566    }
 567
 568    tmpnam(name);
 569
 570    fd = open(name, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 571
 572    if(fd < 0) {
 573         printf("Could not open local file %s. Error %s\n", name, strerror(errno));
 574         return(0);
 575    }
 576
 577    s = DOdata("NLST", files, RETR, fd);
 578
 579    close(fd);
 580
 581    if(s == 226 || s == 250) {
 582         fp = fopen(name, "r");
 583         unlink(name);
 584         if(fp == (FILE *)NULL) {
 585                 printf("Unable to open file listing.\n");
 586                 return(0);
 587         }
 588         while(fgets(line2, sizeof(line2), fp) != (char *)NULL) {
 589                 p = line2 + strlen(line2) - 1;
 590                 if(p >= line2 && (*p == '\r' || *p == '\n')) *p-- = '\0';
 591                 if(p >= line2 && (*p == '\r' || *p == '\n')) *p-- = '\0';
 592                 printf("Retrieving file: %s\n", line2); fflush(stdout);
 593                 fd = open(line2, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 594                 if(fd < 0)
 595                         printf("Unable to open local file %s\n", line2);
 596                 else {
 597                         s = DOdata("RETR", line2, RETR, fd);
 598                         close(fd);
 599                         if(s < 0) break;
 600                 }
 601         }
 602         fclose(fp);
 603    } else
 604         unlink(name);
 605
 606    return(s);
 607 }
 608
 609 int DOappe()
 610 {
 611 char *file, *remotefile;
 612 int fd;
 613 int s;
 614
 615    if(DOcmdcheck())
 616         return(0);
 617
 618    file = cmdargv[1];
 619
 620    if(cmdargc < 2) {
 621         if(readline("Local File: ", line2, sizeof(line2)) < 0)
 622                 return(-1);
 623         file = line2;
 624    }
 625
 626    if(cmdargc < 3)
 627         remotefile = file;
 628    else
 629         remotefile = cmdargv[2];
 630
 631    fd = open(file, O_RDONLY);
 632
 633    if(fd < 0) {
 634         printf("Could not open local file %s. Error %s\n", file, strerror(errno));
 635         return(0);
 636    }
 637
 638    s = DOdata("APPE", remotefile, STOR, fd);
 639
 640    close(fd);
 641
 642    return(s);
 643 }
 644
 645 int DOstor()
 646 {
 647 char *file, *remotefile;
 648 int fd;
 649 int s;
 650
 651    if(DOcmdcheck())
 652         return(0);
 653
 654    file = cmdargv[1];
 655
 656    if(cmdargc < 2) {
 657         if(readline("Local File: ", line2, sizeof(line2)) < 0)
 658                 return(-1);
 659         file = line2;
 660    }
 661
 662    if(cmdargc < 3)
 663         remotefile = file;
 664    else
 665         remotefile = cmdargv[2];
 666
 667    fd = open(file, O_RDONLY);
 668
 669    if(fd < 0) {
 670         printf("Could not open local file %s. Error %s\n", file, strerror(errno));
 671         return(0);
 672    }
 673
 674    s = DOdata("STOR", remotefile, STOR, fd);
 675
 676    close(fd);
 677
 678    return(s);
 679 }
 680
 681 int DOrstor()
 682 {
 683 char *file, *remotefile;
 684 int fd;
 685 int s;
 686 off_t filesize, rmtsize;
 687 char restart[16];
 688
 689    if(DOcmdcheck())
 690         return(0);
 691
 692    file = cmdargv[1];
 693
 694    if(cmdargc < 2) {
 695         if(readline("Local File: ", line2, sizeof(line2)) < 0)
 696                 return(-1);
 697         file = line2;
 698    }
 699
 700    if(cmdargc < 3)
 701         remotefile = file;
 702    else
 703         remotefile = cmdargv[2];
 704
 705    s = DOcommand("SIZE", remotefile);
 706
 707    if(s != 215)
 708         return(s);
 709
 710    rmtsize = atol(reply+4);
 711
 712    fd = open(file, O_RDONLY);
 713
 714    if(fd < 0) {
 715         printf("Could not open local file %s. Error %s\n", file, strerror(errno));
 716         return(0);
 717    }
 718
 719    if(type == TYPE_A)
 720         filesize = asciisetsize(fd, rmtsize);
 721    else
 722         filesize = lseek(fd, rmtsize, SEEK_SET);
 723
 724    if(filesize != rmtsize) {
 725         printf("Could not set file start of %s\n", file);
 726         close(fd);
 727         return(0);
 728    }
 729
 730    sprintf(restart, "%lu", rmtsize);
 731
 732    s = DOcommand("REST", restart);
 733
 734    if(s != 350) {
 735         close(fd);
 736         return(s);
 737    }
 738
 739    s = DOdata("STOR", remotefile, STOR, fd);
 740
 741    close(fd);
 742
 743    return(s);
 744 }
 745
 746 int DOstou()
 747 {
 748 char *file, *remotefile;
 749 int fd;
 750 int s;
 751
 752    if(DOcmdcheck())
 753         return(0);
 754
 755    file = cmdargv[1];
 756
 757    if(cmdargc < 2) {
 758         if(readline("Local File: ", line2, sizeof(line2)) < 0)
 759                 return(-1);
 760         file = line2;
 761    }
 762
 763    if(cmdargc < 3)
 764         remotefile = file;
 765    else
 766         remotefile = cmdargv[2];
 767
 768    fd = open(file, O_RDONLY);
 769
 770    if(fd < 0) {
 771         printf("Could not open local file %s. Error %s\n", file, strerror(errno));
 772         return(0);
 773    }
 774
 775    s = DOdata("STOU", remotefile, STOR, fd);
 776
 777    close(fd);
 778
 779    return(s);
 780 }
 781
 782 int DOMstor()
 783 {
 784 char *files;
 785 char *name;
 786 char *p;
 787 int fd, s;
 788 FILE *fp;
 789
 790    if(DOcmdcheck())
 791         return(0);
 792
 793    files = cmdargv[1];
 794
 795    if(cmdargc < 2) {
 796         if(readline("Files: ", line2, sizeof(line2)) < 0)
 797                 return(-1);
 798         files = line2;
 799    }
 800
 801    name = dir(files, 0);
 802
 803    fp = fopen(name, "r");
 804
 805    if(fp == (FILE *)NULL) {
 806         printf("Unable to open listing file.\n");
 807         return(0);
 808    }
 809
 810    while(fgets(line2, sizeof(line2), fp) != (char *)NULL) {
 811         p = line2 + strlen(line2) - 1;
 812         if(p >= line2 && (*p == '\r' || *p == '\n')) *p-- = '\0';
 813         if(p >= line2 && (*p == '\r' || *p == '\n')) *p-- = '\0';
 814         printf("Sending file: %s\n", line2); fflush(stdout);
 815         fd = open(line2, O_RDONLY);
 816         if(fd < 0)
 817                 printf("Unable to open local file %s\n", line2);
 818         else {
 819                 s = DOdata("STOR", line2, STOR, fd);
 820                 close(fd);
 821                 if(s < 0) break;
 822         }
 823    }
 824    fclose(fp);
 825    unlink(name);
 826
 827    return(s);
 828 }
 829
 830 static int asciisize(fd, filesize)
 831 int fd;
 832 off_t *filesize;
 833 {
 834 unsigned long count;
 835 char *p, *pp;
 836 int cnt;
 837
 838    count = 0;
 839
 840    while((cnt = read(fd, buffer, sizeof(buffer))) > 0) {
 841         p = buffer; pp = buffer + cnt;
 842         count += cnt;
 843         while(p < pp)
 844                 if(*p++ == '\n')
 845                         count++;
 846    }
 847
 848    if(cnt == 0) {
 849         *filesize = count;
 850         return(0);
 851    }
 852
 853    return(-1);
 854 }
 855
 856 static off_t asciisetsize(fd, filesize)
 857 int fd;
 858 off_t filesize;
 859 {
 860 off_t sp;
 861 int s;
 862
 863    sp = 0;
 864
 865    while(sp < filesize) {
 866         s = read(fd, buffer, 1);
 867         if(s < 0)
 868                 return(-1);
 869         if(s == 0) break;
 870         sp++;
 871         if(*buffer == '\n')
 872                 sp++;
 873    }
 874
 875    return(sp);
 876 }
 877
 878 int DOclone()
 879 {
 880 char *files;
 881 int fd, s;
 882 char *p;
 883 FILE *fp;
 884 char name[32];
 885
 886    if(DOcmdcheck())
 887         return(0);
 888
 889    files = cmdargv[1];
 890
 891    tmpnam(name);
 892
 893    fd = open(name, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 894
 895    if(fd < 0) {
 896         printf("Could not open local file %s. Error %s\n", name, strerror(errno));
 897         return(0);
 898    }
 899
 900    s = DOdata("NLST", files, RETR, fd);
 901
 902    close(fd);
 903
 904    if(s == 226 || s == 250) {
 905         fp = fopen(name, "r");
 906         unlink(name);
 907         if(fp == (FILE *)NULL) {
 908                 printf("Unable to open file listing.\n");
 909                 return(0);
 910         }
 911         while(fgets(line2, sizeof(line2), fp) != (char *)NULL) {
 912                 p = line2 + strlen(line2) - 1;
 913                 if(p >= line2 && (*p == '\r' || *p == '\n')) *p-- = '\0';
 914                 if(p >= line2 && (*p == '\r' || *p == '\n')) *p-- = '\0';
 915                 cmdargv[1] = line2;
 916                 if(cloneit(line2, 1)) {
 917                         printf("Retrieving file: %s\n", line2); fflush(stdout);
 918                         fd = open(line2, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 919                         if(fd < 0)
 920                                 printf("Unable to open local file %s\n", line2);
 921                         else {
 922                                 s = DOdata("RETR", line2, RETR, fd);
 923                                 close(fd);
 924                                 if(s < 0) break;
 925                         }
 926                         s = cloneit(line2, 2);
 927                 }
 928         }
 929         fclose(fp);
 930    } else
 931         unlink(name);
 932
 933    return(s);
 934 }