tools/copytoafs/copytoafs.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <dirent.h>
   7 #include <errno.h>
   8 #include <fcntl.h>
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <unistd.h>
  13 #include <sys/stat.h>
  14 #include "os.h"
  15 #include "filehandles1.h"
  16 #include "filehandles2.h"
  17 #include "misc.h"
  18 #include "volumes.h"
  19
  20 SIPTR error;
  21
  22 struct PathElement {
  23         struct PathElement *next;
  24         char *path;
  25 };
  26
  27 struct Config {
  28         char *image;
  29         struct PathElement *first;
  30         char *name;
  31         unsigned int size;
  32         unsigned int bootblocks;
  33         unsigned int reserved;
  34         unsigned int type;
  35 };
  36
  37 char *filepart(char *path) {
  38 char *ptr;
  39
  40         ptr = path+strlen(path);
  41         while ((ptr != path) && (*ptr != '/'))
  42                 ptr--;
  43         if (ptr != path)
  44                 ptr++;
  45         return ptr;
  46 }
  47
  48 int copyFile(char *srcpath, char *dstpath, struct Volume *volume) {
  49 int fd;
  50 char buffer[2048];
  51 int retval = 1;
  52 char *filename;
  53 struct AfsHandle *ah;
  54 struct AfsHandle *fah;
  55 int len;
  56 int written;
  57 int size;
  58 struct stat st;
  59
  60         stat(srcpath, &st);
  61         filename = filepart(srcpath);
  62         printf("Copying %s to %s ...", filename, dstpath);
  63         ah = openf(NULL, &volume->ah, dstpath, MODE_OLDFILE, &error);
  64         if (ah != NULL)
  65         {
  66                 fd = open(srcpath, O_RDONLY);
  67                 if (fd != -1)
  68                 {
  69                         fah = openfile(NULL, ah, filename, MODE_NEWFILE, 0, &error);
  70                         if (fah != NULL)
  71                         {
  72                                 written=0;
  73                                 while ((len=read(fd, buffer, 2048))>0)
  74                                 {
  75                                         size = writef(NULL, fah, buffer, len, &error);
  76                                         written += size;
  77                                         if (size<len)
  78                                         {
  79                                                 retval = 2;
  80                                                 break;
  81                                         }
  82                                 }
  83                                 if (retval == 2)
  84                                 {
  85                                         retval = 1;
  86                                         if (error == ERROR_NO_FREE_STORE)
  87                                                 printf("No more space left on device!\nNeed %ld more bytes to write file.\n", st.st_size-written);
  88                                         else
  89                                                 printf("%s: error %ld\n", filename, (long int)error);
  90                                 }
  91                                 else
  92                                 {
  93                                         printf("done\n");
  94                                         retval = 0;
  95                                 }
  96                                 closef(NULL, fah);
  97                         }
  98                         else
  99                                 printf("error %ld\n", (long int)error);
 100                         close(fd);
 101                 }
 102                 else
 103                         perror(srcpath);
 104                 closef(NULL, ah);
 105         }
 106         else
 107                 printf("%s: error %ld\n", dstpath, (long int)error);
 108         return retval;
 109 }
 110
 111 int makeDir(char *dirname, struct Volume *volume) {
 112 int retval = 1;
 113 struct AfsHandle *ah;
 114 struct AfsHandle *dah;
 115
 116         printf("Creating directory %s ...", dirname);
 117         ah = openf(NULL, &volume->ah, "", MODE_OLDFILE, &error);
 118         if (ah != NULL)
 119         {
 120                 dah = createDir(NULL, ah, dirname, 0, &error);
 121                 if (dah != NULL)
 122                 {
 123                         closef(NULL, dah);
 124                         printf("done\n");
 125                         retval = 0;
 126                 }
 127                 else
 128                 {
 129                         if (error == ERROR_OBJECT_EXISTS)
 130                         {
 131                                 printf("was already there\n");
 132                                 retval = 0;
 133                         }
 134                         else
 135                                 printf("error %ld\n", (long)error);
 136                 }
 137                 closef(NULL, ah);
 138         }
 139         else
 140                 printf("error %ld\n", (long)error);
 141         return retval;
 142 }
 143
 144 int copyDir(char *path, char *dstpath, struct Volume *volume) {
 145 int retval = 1;
 146 int error;
 147 DIR *dir;
 148 struct dirent *de;
 149 char *ndpath;
 150 char *nrpath;
 151
 152         dir = opendir(path);
 153         if (dir != NULL)
 154         {
 155                 while ((de=readdir(dir)) != NULL)
 156                 {
 157                         if ((strcmp(de->d_name, ".")!=0) && (strcmp(de->d_name, "..")!=0))
 158                         {
 159                                 ndpath = malloc(strlen(path)+1+strlen(de->d_name)+1);
 160                                 if (ndpath != NULL)
 161                                 {
 162                                         struct stat st;
 163                                         sprintf(ndpath, "%s/%s", path, de->d_name);
 164                                         if (stat(ndpath, &st) == 0)
 165                                         {
 166                                                 if (S_ISDIR(st.st_mode))
 167                                                 {
 168                                                         nrpath = malloc(strlen(path)+1+strlen(de->d_name)+1);
 169                                                         if (nrpath != NULL)
 170                                                         {
 171                                                                 if (*dstpath == 0)
 172                                                                         strcpy(nrpath, de->d_name);
 173                                                                 else
 174                                                                         sprintf(nrpath, "%s/%s", dstpath, de->d_name);
 175                                                                 error = makeDir(nrpath, volume);
 176                                                                 if (error == 0)
 177                                                                         error = copyDir(ndpath, nrpath, volume);
 178                                                                 free(nrpath);
 179                                                                 if (error != 0)
 180                                                                 {
 181                                                                         retval = 2;
 182                                                                         break;
 183                                                                 }
 184                                                         }
 185                                                         else
 186                                                         {
 187                                                                 printf("No memory!\n");
 188                                                                 retval = 2;
 189                                                                 break;
 190                                                         }
 191                                                 }
 192                                                 else if (S_ISREG(st.st_mode))
 193                                                 {
 194                                                         error = copyFile(ndpath, dstpath, volume);
 195                                                         if (error != 0)
 196                                                         {
 197                                                                 retval = 2;
 198                                                                 break;
 199                                                         }
 200                                                 }
 201                                                 else
 202                                                 {
 203                                                         printf("%s: Unknown file type\n", ndpath);
 204                                                         retval = 2;
 205                                                         break;
 206                                                 }
 207                                         }
 208                                         else
 209                                         {
 210                                                 perror(ndpath);
 211                                                 retval = 2;
 212                                                 break;
 213                                         }
 214                                         free(ndpath);
 215                                 }
 216                                 else
 217                                 {
 218                                         printf("No memory!\n");
 219                                         retval = 2;
 220                                         break;
 221                                 }
 222                         }
 223                 }
 224                 if (retval == 2)
 225                         retval = 1;
 226                 else
 227                         retval = 0;
 228                 closedir(dir);
 229         }
 230         else
 231                 perror(path);
 232         return retval;
 233 }
 234
 235 int copyPath(char *path, struct Volume *volume) {
 236 struct stat st;
 237
 238         if (stat(path, &st) == 0)
 239         {
 240                 if (S_ISDIR(st.st_mode))
 241                 {
 242                         return copyDir(path, "", volume);
 243                 }
 244                 else if (S_ISREG(st.st_mode))
 245                 {
 246                         /* for now always copy to root */
 247                         return copyFile(path, "", volume);
 248                 }
 249                 else
 250                         printf("Unknown file type\n");
 251         }
 252         else
 253                 perror(NULL);
 254         return 1;
 255 }
 256
 257 int copyData(struct Config *cfg, struct Volume *volume) {
 258 struct PathElement *pe;
 259
 260         pe = cfg->first;
 261         while (pe != NULL)
 262         {
 263                 if (copyPath(pe->path, volume) != 0)
 264                         return 1;
 265                 pe = pe->next;
 266         }
 267         return 0;
 268 }
 269
 270 int fillFile(char *image, unsigned int size) {
 271 char buffer[512]={0};
 272 FILE *fh;
 273 int retval=0;
 274 int i;
 275
 276         fh = fopen(image, "w");
 277         if (fh != NULL)
 278         {
 279                 for (i=0;i<size;i++)
 280                 {
 281                         if (fwrite(buffer, 512, 1, fh) != 1)
 282                         {
 283                                 retval = 1;
 284                                 break;
 285                         }
 286                 }
 287                 fclose(fh);
 288         }
 289         else
 290                 retval = 1;
 291         if (retval == 1)
 292                 perror(image);
 293         return retval;
 294 }
 295
 296 int createFile(struct Config *cfg) {
 297 struct stat st;
 298 int retval = 1;
 299
 300         if (stat(cfg->image, &st) == 0)
 301         {
 302 //              printf("type=%d blocks=%ld blocksize=%ld\n", st.st_rdev, st.st_blocks, st.st_blksize);
 303                 if (S_ISBLK(st.st_mode))
 304                 {
 305                         printf("block device\n");
 306                         retval=0;
 307                 }
 308                 else if (S_ISREG(st.st_mode))
 309                 {
 310                         if (st.st_size == 0)
 311                         {
 312                                 if (fillFile(cfg->image, cfg->size) == 0)
 313                                         retval = 0;
 314                         }
 315                         else if (st.st_size/512 < cfg->size)
 316                         {
 317                                 printf("%s: File already exists and is too small\n", cfg->image);
 318                         }
 319                         else
 320                                 retval = 0;
 321                 }
 322                 else
 323                 {
 324                         printf("%s: This is not a regular file or blockdevice!\n", cfg->image);
 325                 }
 326         }
 327         else
 328         {
 329                 if (errno == ENOENT)
 330                 {
 331                         if (fillFile(cfg->image, cfg->size) == 0)
 332                                 retval = 0;
 333                 }
 334                 else
 335                 {
 336                         perror(cfg->image);
 337                 }
 338         }
 339         return retval;
 340 }
 341
 342 int doWork(struct Config *cfg) {
 343 int retval = 1;
 344 struct PathElement *pe;
 345 struct AFSBase *afsbase=NULL;
 346 struct DosEnvec de={0};
 347 LONG error;
 348 struct Volume *volume;
 349
 350         printf("Image: %s\n", cfg->image);
 351         printf("Size: %d 512 byte sectors\n", cfg->size);
 352         printf("Name: %s\n", cfg->name);
 353         printf("Type: ");
 354         switch (cfg->type)
 355         {
 356         case 0:
 357                 printf("Old Filesystem\n");
 358                 cfg->type = ID_DOS_DISK;
 359                 break;
 360         case 1:
 361                 printf("Fast Filesystem\n");
 362                 cfg->type = ID_FFS_DISK;
 363                 break;
 364         case 2:
 365                 printf("International Old Filesystem\n");
 366                 cfg->type = ID_INTER_DOS_DISK;
 367                 break;
 368         case 3:
 369                 printf("International Fast Filesystem\n");
 370                 cfg->type = ID_INTER_FFS_DISK;
 371                 break;
 372         }
 373         printf("Path:\n");
 374         pe = cfg->first;
 375         while (pe != NULL)
 376         {
 377                 printf("\t%s\n", pe->path);
 378                 pe = pe->next;
 379         }
 380         de.de_SizeBlock = 512>>2;
 381         de.de_TableSize = 20;
 382         de.de_BootBlocks = cfg->bootblocks;
 383         de.de_Reserved = cfg->reserved;
 384         de.de_NumBuffers = 20;
 385         de.de_Surfaces=1;
 386         de.de_SectorPerBlock = 1;
 387         de.de_BlocksPerTrack=1;
 388         de.de_LowCyl = 0;
 389         de.de_HighCyl = cfg->size-1;
 390         if (createFile(cfg) == 0)
 391         {
 392                 volume = initVolume(afsbase, NULL, cfg->image, 0, 0, &de, &error);
 393                 if (volume != NULL)
 394                 {
 395                         if ((error == 0) || (error == ERROR_NOT_A_DOS_DISK))
 396                         {
 397                                 if (error == ERROR_NOT_A_DOS_DISK)
 398                                 {
 399                                         printf("Initialising disk ...");
 400                                         format(afsbase, volume, cfg->name, cfg->type);
 401                                         newMedium(NULL, volume);
 402                                         printf("done\n");
 403                                 }
 404                                 retval = copyData(cfg, volume);
 405                                 flush(afsbase, volume);
 406                         }
 407                         else
 408                                 printf("Error %ld!\n", (long)error);
 409                         uninitVolume(afsbase, volume);
 410                 }
 411                 else
 412                         printf("Error %ld!\n", (long)error);
 413         }
 414         return retval;
 415 }
 416
 417 void printUsage(char *prg) {
 418         printf("Usage: %s [options] <imagefile> <path1> [path2 ...] \n", prg);
 419         printf("\t--size\timage size\n"
 420                         "\t\tThis is either of type int (a multiple of 512) or the special\n"
 421                         "\t\tvalue 'floppy1440'.\n");
 422         printf("\t--reserved\tnumber of reserved blocks (default: 2)\n");
 423         printf("\t--bootblock\tnumber of bootblocks (default: 2)\n");
 424         printf("\t--name\tlabel of the FS image\n");
 425         printf("\t--type\tFS type (OFS, IOFS, FFS, IFFS(default))\n");
 426         printf("\t--help\tthis help message\n");
 427 }
 428
 429 void addPathElement(struct Config *cfg, struct PathElement *pe) {
 430 struct PathElement *next;
 431
 432         next = (struct PathElement *)&cfg->first;
 433         while (next->next != NULL)
 434                 next = next->next;
 435         next->next = pe;
 436         pe->next = NULL;
 437 }
 438
 439 int parseCommandLine(int argc, char *argv[], struct Config *cfg) {
 440 int i;
 441 int have_image=0;
 442 struct PathElement *pe;
 443
 444         cfg->first = NULL;
 445         cfg->name = NULL;
 446         cfg->type = 3;
 447         cfg->reserved = 2;
 448         cfg->bootblocks = 2;
 449         for (i=1;i<argc;i++)
 450         {
 451                 if ((argv[i][0] == '-') && (argv[i][0] == argv[i][1]))
 452                 {
 453                         if (strcasecmp(argv[i]+2, "help") == 0)
 454                         {
 455                                 printUsage(argv[0]);
 456                                 return 1;
 457                         }
 458                         else if (strcasecmp(argv[i]+2, "size") == 0)
 459                         {
 460                                 i++;
 461                                 if (i<argc)
 462                                 {
 463                                         if (strcasecmp(argv[i], "floppy1440") == 0)
 464                                                 cfg->size = 2880;
 465                                         else
 466                                         {
 467                                                 char *end;
 468                                                 cfg->size = strtoul(argv[i], &end, 10);
 469                                                 if (end[0] != 0)
 470                                                 {
 471                                                         printf("%s: Integer error\n", argv[i-1]);
 472                                                         return 2;
 473                                                 }
 474                                                 if (cfg->size < 8)
 475                                                 {
 476                                                         printf("%s: Value must be at least 8\n", argv[i-1]);
 477                                                         return 2;
 478                                                 }
 479                                         }
 480                                 }
 481                                 else
 482                                 {
 483                                         printf("%s: Missing argument to option\n", argv[i-1]);
 484                                         return 2;
 485                                 }
 486                         }
 487                         else if (strcasecmp(argv[i]+2, "reserved") == 0)
 488                         {
 489                                 i++;
 490                                 if (i<argc)
 491                                 {
 492                                         char *end;
 493                                         cfg->reserved = strtoul(argv[i], &end, 10);
 494                                         if (end[0] != 0)
 495                                         {
 496                                                 printf("%s: Integer error\n", argv[i-1]);
 497                                                 return 2;
 498                                         }
 499                                 }
 500                                 else
 501                                 {
 502                                         printf("%s: Missing argument to option\n", argv[i-1]);
 503                                         return 2;
 504                                 }
 505                         }
 506                         else if (strcasecmp(argv[i]+2, "bootblocks") == 0)
 507                         {
 508                                 i++;
 509                                 if (i<argc)
 510                                 {
 511                                         char *end;
 512                                         cfg->bootblocks = strtoul(argv[i], &end, 10);
 513                                         if (end[0] != 0)
 514                                         {
 515                                                 printf("%s: Integer error\n", argv[i-1]);
 516                                                 return 2;
 517                                         }
 518                                 }
 519                                 else
 520                                 {
 521                                         printf("%s: Missing argument to option\n", argv[i-1]);
 522                                         return 2;
 523                                 }
 524                         }
 525                         else if (strcasecmp(argv[i]+2, "name") == 0)
 526                         {
 527                                 i++;
 528                                 if (i<argc)
 529                                         cfg->name = argv[i];
 530                                 else
 531                                 {
 532                                         printf("%s: Missing argument to option\n", argv[i-1]);
 533                                         return 2;
 534                                 }
 535                         }
 536                         else if (strcasecmp(argv[i]+2, "type") == 0)
 537                         {
 538                                 i++;
 539                                 if (i<argc)
 540                                 {
 541                                         if (strcasecmp(argv[i], "OFS") == 0)
 542                                                 cfg->type = 0;
 543                                         else if (strcasecmp(argv[i], "IOFS") == 0)
 544                                                 cfg->type = 2;
 545                                         else if (strcasecmp(argv[i], "FFS") == 0)
 546                                                 cfg->type = 1;
 547                                         else if (strcasecmp(argv[i], "IFFS") == 0)
 548                                                 cfg->type = 3;
 549                                         else
 550                                         {
 551                                                 printf("%s: Unknown fs type\n", argv[i-1]);
 552                                                 return 5;
 553                                         }
 554                                 }
 555                                 else
 556                                 {
 557                                         printf("%s: Missing argument to option\n", argv[i-1]);
 558                                         return 2;
 559                                 }
 560                         }
 561                         else
 562                         {
 563                                 printf("%s: Unknown option\n", argv[i]);
 564                                 return 4;
 565                         }
 566                 }
 567                 else
 568                 {
 569                         if (have_image==0)
 570                         {
 571                                 cfg->image = argv[i];
 572                                 have_image = 1;
 573                         }
 574                         else
 575                         {
 576                                 pe = malloc(sizeof(struct PathElement));
 577                                 if (pe == NULL)
 578                                 {
 579                                         printf("Not enough memory\n");
 580                                         return 3;
 581                                 }
 582                                 pe->path = argv[i];
 583                                 addPathElement(cfg, pe);
 584                         }
 585                 }
 586         }
 587         if (cfg->name == NULL)
 588                 cfg->name = "SomeDisk";
 589         return 0;
 590 }
 591
 592 int main(int argc, char *argv[]) {
 593 int error;
 594 struct Config cfg;
 595
 596         if (argc<3)
 597         {
 598                 printUsage(argv[0]);
 599                 return 1;
 600         }
 601         else
 602         {
 603                 error = parseCommandLine(argc, argv, &cfg);
 604                 if (error == 0)
 605                 {
 606                         error = doWork(&cfg);
 607                 }
 608                 else if (error > 1)
 609                 {
 610                         error = 1;
 611                 }
 612         }
 613         return error;
 614 }