workbench/c/shellcommands/Assign.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Assign CLI command
   6     Lang: English
   7 */
   8
   9 #define  DEBUG  0
  10 #include <aros/debug.h>
  11 #include <aros/config.h>
  12
  13 #include <exec/types.h>
  14 #include <exec/memory.h>
  15 #include <exec/execbase.h>
  16 #include <dos/dos.h>
  17 #include <dos/dosextens.h>
  18 #include <proto/dos.h>
  19 #include <proto/exec.h>
  20 #include <utility/tagitem.h>
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24
  25 #include <aros/shcommands.h>
  26
  27 /******************************************************************************
  28
  29
  30     NAME
  31
  32         Assign [(name):] [{(target)}] [LIST] [EXISTS] [DISMOUNT] [DEFER]
  33                [PATH] [ADD] [REMOVE] [VOLS] [DIRS] [DEVICES]
  34
  35     SYNOPSIS
  36
  37         NAME, TARGET/M, LIST/S, EXISTS/S, DISMOUNT/S, DEFER/S, PATH/S, ADD/S,
  38         REMOVE/S, VOLS/S, DIRS/S, DEVICES/S
  39
  40     LOCATION
  41
  42         Workbench:C
  43
  44     FUNCTION
  45
  46         ASSIGN creates a reference to a file or directory. The reference
  47         is a logical device name which makes it very convenient to specify
  48         assigned objects using the reference instead of their paths.
  49
  50         If the NAME and TARGET arguments are given, ASSIGN assigns the
  51         given logical name to the specified target. If the NAME given is
  52         already assigned to a file or directory the new target replaces the
  53         previous target. A colon must be included after the NAME argument.
  54
  55         If only the NAME argument is given, any assigns to that NAME are
  56         removed. If no arguments whatsoever are given, all logical
  57         assigns are listed.
  58
  59     INPUTS
  60
  61         NAME      --  the name that should be assigned to a file or directory
  62         TARGET    --  one or more files or directories to assign the NAME to
  63         LIST      --  list all assigns made
  64         EXISTS    --  if NAME is already assigned, set the condition flag to
  65                       WARN
  66         DISMOUNT  --  remove the volume or device NAME from the dos list
  67         DEFER     --  make an ASSIGN to a path or directory that not need to
  68                       exist at the time of assignment. The first time the
  69                       NAME is referenced the NAME is bound to the object
  70         PATH      --  path to assign with a non-binding assign. This means
  71                       that the assign is re-evaluated each time a reference
  72                       to NAME is done. Like for DEFER, the path doesn't have
  73                       to exist when the ASSIGN command is executed
  74         ADD       --  don't replace an assign but add another object for a
  75                       NAME (multi-assigns)
  76         REMOVE    --  remove an ASSIGN
  77         VOLS      --  show assigned volumes if in LIST mode
  78         DIRS      --  show assigned directories if in LIST mode
  79         DEVICES   --  show assigned devices if in LIST mode
  80
  81
  82     RESULT
  83
  84     NOTES
  85
  86     EXAMPLE
  87
  88     BUGS
  89
  90     SEE ALSO
  91
  92     INTERNALS
  93
  94         The assign command has many switches. This together with the somewhat
  95         messy handling of DosList:s by dos.library makes the operation rather
  96         complicated.
  97
  98         There are some fundamental building blocks that defines the semantics
  99         of the Assign command.
 100
 101         Only one of the switches ADD, REMOVE, PATH and DEFER may be specified.
 102
 103         If EXISTS is specified, only the name parameter is important.
 104
 105         The implementation is split up in two fundamental procedures.
 106
 107         doAssign()     --  make [a number of] assigns
 108         showAssigns()  --  show the available assigns
 109         checkAssign()  --  check if a particular assign exists
 110
 111     HISTORY
 112
 113 ******************************************************************************/
 114 /* Prototypes */
 115
 116 static int checkAssign(struct ExecBase *SysBase, struct DosLibrary *DOSBase, STRPTR name);
 117 static int doAssign(struct DosLibrary *DOSBase, STRPTR name, STRPTR *target,
 118                     BOOL dismount, BOOL defer, BOOL path,
 119                     BOOL add, BOOL remove);
 120 static void showAssigns(struct ExecBase *SysBase, struct DosLibrary *DOSBase,
 121                         BOOL vols, BOOL dirs, BOOL devices);
 122 static int removeAssign(struct DosLibrary *DOSBase, STRPTR name);
 123 static STRPTR GetFullPath(struct ExecBase *SysBase, struct DosLibrary *DOSBase,
 124                           BPTR lock);
 125
 126 AROS_SH12(Assign, 41.5,
 127 AROS_SHA(STRPTR, ,NAME, ,NULL),
 128 AROS_SHA(STRPTR *, ,TARGET,/M,NULL),
 129 AROS_SHA(BOOL, ,LIST,/S,FALSE),
 130 AROS_SHA(BOOL, ,EXISTS,/S,FALSE),
 131 AROS_SHA(BOOL, ,DISMOUNT,/S,FALSE),
 132 AROS_SHA(BOOL, ,DEFER,/S,FALSE),
 133 AROS_SHA(BOOL, ,PATH,/S,FALSE),
 134 AROS_SHA(BOOL, ,ADD,/S,FALSE),
 135 AROS_SHA(BOOL, ,REMOVE,/S,FALSE),
 136 AROS_SHA(BOOL, ,VOLS,/S,FALSE),
 137 AROS_SHA(BOOL, ,DIRS,/S,FALSE),
 138 AROS_SHA(BOOL, ,DEVICES,/S,FALSE))
 139 {
 140     AROS_SHCOMMAND_INIT
 141     int error = RETURN_OK;
 142
 143     if (SHArg(ADD) + SHArg(REMOVE) + SHArg(PATH) + SHArg(DEFER) > 1)
 144     {
 145         PutStr("Only one of ADD, REMOVE, PATH or DEFER is allowed\n");
 146
 147         return RETURN_FAIL;
 148     }
 149
 150     /* Check device name
 151      */
 152     if (SHArg(NAME))
 153     {
 154         char *pos;
 155
 156         /* Correct assign name construction? The rule is that the device name
 157          * should end with a colon at the same time as no other colon may be
 158          * in the name.
 159          */
 160         pos = strchr(SHArg(NAME), ':');
 161         if (!pos || pos[1])
 162         {
 163                 VPrintf("Invalid device name %s\n", &SHArg(NAME));
 164                 return RETURN_FAIL;
 165         }
 166     }
 167     /* If the EXISTS keyword is specified, we only care about NAME */
 168     if (SHArg(EXISTS))
 169     {
 170         error = checkAssign(SysBase, DOSBase, SHArg(NAME));
 171     }
 172     else if (SHArg(NAME) != NULL)
 173     {
 174         /* If a NAME is specified, our primary task is to add or
 175            remove an assign */
 176
 177         error = doAssign(DOSBase, SHArg(NAME), SHArg(TARGET), SHArg(DISMOUNT),
 178                          SHArg(DEFER), SHArg(PATH), SHArg(ADD), SHArg(REMOVE));
 179
 180         if (SHArg(LIST))
 181         {
 182             /* With the LIST keyword, the current assigns will be
 183                displayed also when (after) making an assign */
 184
 185             showAssigns(SysBase, DOSBase, SHArg(VOLS), SHArg(DIRS),
 186                         SHArg(DEVICES));
 187         }
 188     }
 189     else
 190     {
 191         /* If no NAME was given, we just show the current assigns
 192            as specified by the user (VOLS, DIRS, DEVICES) */
 193
 194         showAssigns(SysBase, DOSBase, SHArg(VOLS), SHArg(DIRS),
 195                     SHArg(DEVICES));
 196     }
 197
 198     return error;
 199
 200     AROS_SHCOMMAND_EXIT
 201 }
 202
 203
 204 static void showAssigns(struct ExecBase *SysBase, struct DosLibrary *DOSBase,
 205                         BOOL vols, BOOL dirs, BOOL devices)
 206 {
 207     ULONG           lockBits = LDF_READ;
 208     struct DosList *dl;
 209
 210     /* If none of the parameters are specified, everything should be
 211        displayed */
 212     if (!(vols || dirs || devices))
 213     {
 214         vols    = TRUE;
 215         dirs    = TRUE;
 216         devices = TRUE;
 217     }
 218
 219     lockBits |= vols    ? LDF_VOLUMES : 0;
 220     lockBits |= dirs    ? LDF_ASSIGNS : 0;
 221     lockBits |= devices ? LDF_DEVICES : 0;
 222
 223     dl = LockDosList(lockBits);
 224
 225     if (vols)
 226     {
 227         struct DosList *tdl = dl;       /* Loop variable */
 228
 229         PutStr("Volumes:\n");
 230
 231         /* Print all mounted volumes */
 232         while ((tdl = NextDosEntry(tdl, LDF_VOLUMES)) != NULL)
 233         {
 234             VPrintf("%s [Mounted]\n", (IPTR *)&tdl->dol_DevName);
 235         }
 236     }
 237
 238     if (dirs)
 239     {
 240         struct DosList *tdl = dl;       /* Loop variable */
 241         int             count;          /* Loop variable */
 242
 243         PutStr("Directories:\n");
 244
 245         /* Print all assigned directories */
 246         while ((tdl = NextDosEntry(tdl, LDF_ASSIGNS)) != NULL)
 247         {
 248             PutStr(tdl->dol_DevName);
 249
 250             for(count = 14 - strlen(tdl->dol_DevName); count > 0; count--)
 251             {
 252                 PutStr(" ");
 253             }
 254
 255             switch (tdl->dol_Type)
 256             {
 257             case DLT_LATE:
 258                 VPrintf("<%s>\n",
 259                         (IPTR *)&tdl->dol_misc.dol_assign.dol_AssignName);
 260                 break;
 261
 262             case DLT_NONBINDING:
 263                 VPrintf("[%s]\n",
 264                         (IPTR *)&tdl->dol_misc.dol_assign.dol_AssignName);
 265                 break;
 266
 267             default:
 268                 {
 269                     STRPTR             dirName;     /* For NameFromLock() */
 270                     struct AssignList *nextAssign;  /* For multiassigns */
 271
 272                     dirName = GetFullPath(SysBase, DOSBase, tdl->dol_Lock);
 273
 274                     if (dirName != NULL)
 275                     {
 276                         VPrintf("%s\n", (IPTR *)&dirName);
 277                         FreeVec(dirName);
 278                     }
 279                     else
 280                     {
 281                         PutStr("\n");
 282                     }
 283
 284                     nextAssign = tdl->dol_misc.dol_assign.dol_List;
 285
 286                     while (nextAssign != NULL)
 287                     {
 288                         dirName = GetFullPath(SysBase, DOSBase,
 289                                               nextAssign->al_Lock);
 290
 291                         if (dirName != NULL)
 292                         {
 293                             VPrintf("             + %s\n", (IPTR *)&dirName);
 294                             FreeVec(dirName);
 295                         }
 296
 297                         nextAssign = nextAssign->al_Next;
 298                     }
 299                 }
 300
 301                 break;
 302             }
 303         } /* while(NextDosEntry() != NULL) */
 304     }
 305
 306     if (devices)
 307     {
 308         struct DosList *tdl = dl;     /* Loop variable */
 309         int             count = 0;    /* Used to make sure that as most 5
 310                                          entries are printed per line */
 311
 312         PutStr("Devices:\n");
 313
 314         /* Print all assigned devices */
 315         while ((tdl = NextDosEntry(tdl, LDF_DEVICES)) != NULL)
 316         {
 317             VPrintf("%s ", (IPTR *)&tdl->dol_DevName);
 318             count++;
 319
 320             if (count == 5)
 321             {
 322                 PutStr("\n");
 323                 count = 0;
 324             }
 325         }
 326
 327         if (count <  5)
 328         {
 329             PutStr("\n");
 330         }
 331     }
 332
 333     UnLockDosList(lockBits);
 334 }
 335
 336
 337 static STRPTR GetFullPath(struct ExecBase *SysBase, struct DosLibrary *DOSBase,
 338                           BPTR lock)
 339 {
 340     UBYTE  *buf;       /* Pointer to the memory allocated for the string */
 341     ULONG   size;      /* Holder of the (growing) size of the string */
 342
 343     for (size = 512; ; size += 512)
 344     {
 345         buf = AllocVec(size, MEMF_ANY);
 346
 347         if (buf == NULL)
 348         {
 349             break;
 350         }
 351
 352         if (NameFromLock(lock, buf, size))
 353         {
 354             return (STRPTR)buf;
 355         }
 356
 357         FreeVec(buf);
 358
 359         if (IoErr() != ERROR_LINE_TOO_LONG)
 360         {
 361             break;
 362         }
 363     }
 364
 365     return NULL;
 366 }
 367
 368
 369 static int doAssign(struct DosLibrary *DOSBase, STRPTR name, STRPTR *target,
 370                     BOOL dismount, BOOL defer, BOOL path, BOOL add,
 371                     BOOL remove)
 372 {
 373     STRPTR colon;
 374     BPTR   lock = NULL;
 375     int    i;                   /* Loop variable */
 376
 377     int  error = RETURN_OK;
 378     LONG ioerr = 0;
 379     BOOL cancel = FALSE;
 380     BOOL success = TRUE;
 381
 382     colon = strchr(name, ':');
 383     *colon = 0;               /* Remove trailing colon; name[] is changed! */
 384
 385     /* This is a little bit messy... We first remove the 'name' assign
 386        and later in the loop the target assigns. */
 387     if (dismount)
 388     {
 389
 390         struct DosList *dl;
 391         struct DosList *fdl;
 392
 393         dl = LockDosList(LDF_VOLUMES | LDF_DEVICES | LDF_WRITE);
 394
 395         fdl = FindDosEntry(dl, name, LDF_VOLUMES | LDF_DEVICES);
 396
 397         /* Note the ! for conversion to boolean value */
 398         if (fdl)
 399                 success = RemDosEntry(fdl);
 400
 401         UnLockDosList(LDF_VOLUMES | LDF_DEVICES | LDF_WRITE);
 402     }
 403     else
 404     {
 405         if(target == NULL || *target == NULL || remove)
 406         {
 407                 error = removeAssign(DOSBase, name);
 408                 if (error)
 409                 {
 410                         ioerr = IoErr();
 411                         cancel = TRUE;
 412                 }
 413         }
 414     }
 415     /* AmigaDOS doesn't use RETURN_WARN here... but it should? */
 416     error = success ? error : RETURN_WARN;
 417
 418     // The Loop over multiple targets starts here
 419
 420     if (target)
 421     {
 422         for (i = 0; target[i] != NULL; i++)
 423         {
 424                 cancel = FALSE;
 425                 if (!(path || defer || dismount))
 426                 {
 427                         lock = Lock(target[i], SHARED_LOCK);
 428
 429                         if (lock == NULL)
 430                         {
 431                                 VPrintf("Can't find %s\n", (IPTR *)&target[i]);
 432
 433                                 return RETURN_FAIL;
 434                         }
 435                 }
 436
 437                 if (remove)
 438                 {
 439                         AssignLock(target[i], NULL);
 440                         UnLock(lock);
 441                 }
 442                 else if (path)
 443                 {
 444                         if (!AssignPath(name, target[i]))
 445                         {
 446                                 ioerr = IoErr();
 447                                 error = RETURN_FAIL;
 448                         }
 449                 }
 450                 else if (add)
 451                 {
 452                         if (AssignAdd(name, lock) == DOSFALSE)
 453                         {
 454                                 struct DosList *dl;
 455
 456                                 error = RETURN_FAIL;
 457                                 ioerr = IoErr();
 458                                 /* Check if the assign doesn't exist at all. If so, create it.
 459                                  * This fix bug id 145. - Piru
 460                                  */
 461                                 dl = LockDosList(LDF_ASSIGNS | LDF_READ);
 462                                 dl = FindDosEntry(dl, name, LDF_ASSIGNS);
 463                                 UnLockDosList(LDF_ASSIGNS | LDF_READ);
 464
 465                                 if (!dl)
 466                                 {
 467                                         if (AssignLock(name, lock))
 468                                         {
 469                                                 error = RETURN_OK;
 470                                                 lock = NULL;
 471                                         }
 472                                         else
 473                                         {
 474                                                 ioerr = IoErr();
 475                                         }
 476                                 }
 477
 478                                 if (lock)
 479                                         UnLock(lock);
 480
 481                                 if (error && ioerr != ERROR_OBJECT_EXISTS)
 482                                 {
 483                                         STRPTR Args[] = {target[i], name};
 484                                         VPrintf("Can't add %s to %s\n", Args);
 485                                 }
 486                         }
 487                 }
 488                 else if (defer)
 489                 {
 490                         if (AssignLate(name, target[i]) == DOSFALSE)
 491                         {
 492                                 ioerr = IoErr();
 493                                 UnLock(lock);
 494                                 error = RETURN_FAIL;
 495                         }
 496                 }
 497                 else
 498                 {
 499                         /* If no extra parameters are specified we just do a regular
 500                            assign (replacing any possible previous assign with that
 501                            name. The case of target being NULL is taken care of above. */
 502                         if (AssignLock(name, lock) == DOSFALSE)
 503                         {
 504                                 ioerr = IoErr();
 505                                 cancel = TRUE;
 506                                 UnLock(lock);
 507                                 error = RETURN_FAIL;
 508                         }
 509
 510                         /* If there are several targets, the next ones have to be added. */
 511                         add = TRUE;
 512                 }
 513
 514                 /* We break as soon as we get a serious error */
 515                 if (error >= RETURN_FAIL)
 516                 {
 517                         return error;
 518                 }
 519
 520         } /* loop through all targets */
 521     }
 522     if (error)
 523     {
 524         if (ioerr == ERROR_OBJECT_EXISTS)
 525         {
 526                 STRPTR Args[] = {cancel ? "cancel" : "assign", name};
 527                 VPrintf("Can't %s %s\n", Args);
 528         }
 529         else
 530         {
 531                 PrintFault(ioerr, NULL);
 532         }
 533     }
 534     return error;
 535 }
 536
 537 static int removeAssign(struct DosLibrary *DOSBase, STRPTR name)
 538 {
 539         /* In case no target is given, the 'name' assign should be removed.
 540          * The AmigaDOS semantics for this is apparently that the error
 541          * code is never set even if the assign didn't exist.
 542          */
 543
 544         if (!AssignLock(name, NULL))
 545         {
 546                 return RETURN_FAIL;
 547         }
 548         return RETURN_OK;
 549 }
 550
 551 static int checkAssign(struct ExecBase *SysBase, struct DosLibrary *DOSBase, STRPTR name)
 552 {
 553     STRPTR colon;
 554     struct DosList *dl;
 555     int             error = RETURN_OK;
 556
 557     if (!name)
 558         name = "";
 559
 560     colon = strchr(name, ':');
 561     if (colon)
 562     {
 563         *colon = '\0';
 564     }
 565
 566     dl = LockDosList(LDF_DEVICES | LDF_ASSIGNS | LDF_VOLUMES | LDF_READ);
 567     dl = FindDosEntry(dl, name, LDF_DEVICES | LDF_ASSIGNS | LDF_VOLUMES);
 568     if (dl)
 569     {
 570         struct DosList *tdl = dl;
 571         int             count;
 572
 573         switch (dl->dol_Type)
 574         {
 575         case DLT_DEVICE:
 576                 VPrintf("%s\n", &tdl->dol_OldName);
 577                 break;
 578
 579         case DLT_VOLUME:
 580                 VPrintf("%s [Mounted]\n", &tdl->dol_OldName);
 581                 break;
 582
 583         case DLT_DIRECTORY:
 584         case DLT_LATE:
 585         case DLT_NONBINDING:
 586
 587                 VPrintf("%s ", &tdl->dol_OldName);
 588
 589                 for (count = 14 - *((UBYTE*)tdl->dol_OldName); count > 0; count--)
 590                 {
 591                         PutStr(" ");
 592                 }
 593
 594                 switch (tdl->dol_Type)
 595                 {
 596                 case DLT_LATE:
 597                         VPrintf("<%s>\n", (IPTR) &tdl->dol_misc.dol_assign.dol_AssignName);
 598                         break;
 599
 600                 case DLT_NONBINDING:
 601                         VPrintf("[%s]\n", (IPTR) &tdl->dol_misc.dol_assign.dol_AssignName);
 602                         break;
 603
 604                 default:
 605                         {
 606                                 STRPTR             dirName;     /* For NameFromLock() */
 607                                 struct AssignList *nextAssign;  /* For multiassigns */
 608
 609                                 dirName = GetFullPath(SysBase, DOSBase, tdl->dol_Lock);
 610
 611                                 if (dirName)
 612                                 {
 613                                         PutStr(dirName);
 614                                         FreeVec(dirName);
 615                                 }
 616                                 PutStr("\n");
 617
 618                                 nextAssign = tdl->dol_misc.dol_assign.dol_List;
 619
 620                                 while (nextAssign)
 621                                 {
 622                                         dirName = GetFullPath(SysBase, DOSBase, nextAssign->al_Lock);
 623
 624                                         if (dirName)
 625                                         {
 626                                                 VPrintf("             + %s\n", (IPTR) &dirName);
 627                                                 FreeVec(dirName);
 628                                         }
 629
 630                                         nextAssign = nextAssign->al_Next;
 631                                 }
 632                         }
 633                 }
 634                 break;
 635         }
 636     }
 637     else
 638     {
 639         VPrintf("%s: not assigned\n", &name);
 640
 641         error = RETURN_WARN;
 642     }
 643     UnLockDosList(LDF_DEVICES | LDF_ASSIGNS | LDF_VOLUMES | LDF_READ);
 644     if (colon)
 645         *colon = ':';
 646     return error;
 647 }
 648