workbench/c/Assign.c

   1 /*
   2
   3     (C) 1995-2011 The AROS Development Team
   4     (C) 2002-2005 Harry Sintonen
   5     (C) 2005-2007 Pavel Fedin
   6     $Id$
   7
   8     Desc: Assign CLI command
   9     Lang: English
  10 */
  11
  12 #define AROS_ALMOST_COMPATIBLE
  13
  14 #ifdef __AROS__
  15 #include <aros/asmcall.h>
  16 #include <proto/arossupport.h>
  17 #include <aros/debug.h>
  18 #else
  19 #include <clib/debug_protos.h>
  20 #endif
  21
  22 #include <exec/types.h>
  23 #include <exec/lists.h>
  24 #include <exec/memory.h>
  25 #include <exec/execbase.h>
  26 #include <dos/dos.h>
  27 #include <dos/dosextens.h>
  28 #include <dos/exall.h>
  29 #include <utility/tagitem.h>
  30 #include <proto/dos.h>
  31 #include <proto/exec.h>
  32
  33 #include <string.h>
  34
  35 #define DEBUG_ASSIGN(x)
  36
  37 /******************************************************************************
  38
  39
  40     NAME
  41
  42         Assign [(name):] [{(target)}] [LIST] [EXISTS] [DISMOUNT] [DEFER]
  43                [PATH] [ADD] [REMOVE] [VOLS] [DIRS] [DEVICES]
  44
  45     SYNOPSIS
  46
  47         NAME, TARGET/M, LIST/S, EXISTS/S, DISMOUNT/S, DEFER/S, PATH/S, ADD/S,
  48         REMOVE/S, VOLS/S, DIRS/S, DEVICES/S
  49
  50     LOCATION
  51
  52         C:
  53
  54     FUNCTION
  55
  56         ASSIGN creates a reference to a file or directory. The reference
  57         is a logical device name which makes it very convenient to specify
  58         assigned objects using the reference instead of their paths.
  59
  60         If the NAME and TARGET arguments are given, ASSIGN assigns the
  61         given logical name to the specified target. If the NAME given is
  62         already assigned to a file or directory the new target replaces the
  63         previous target. A colon must be included after the NAME argument.
  64
  65         If only the NAME argument is given, any assigns to that NAME are
  66         removed. If no arguments whatsoever are given, all logical
  67         assigns are listed.
  68
  69     INPUTS
  70
  71         NAME      --  the name that should be assigned to a file or directory
  72         TARGET    --  one or more files or directories to assign the NAME to
  73         LIST      --  list all assigns made
  74         EXISTS    --  display the target of the specified assign. If NAME is
  75                       not assigned, set the condition flag to WARN
  76         DISMOUNT  --  remove the volume or device NAME from the dos list
  77         DEFER     --  make an ASSIGN to a path or directory that not need to
  78                       exist at the time of assignment. The first time the
  79                       NAME is referenced the NAME is bound to the object
  80         PATH      --  path is assigned with a non-binding assign. This means
  81                       that the assign is re-evaluated each time a reference
  82                       to NAME is done. Like for DEFER, the path doesn't have
  83                       to exist when the ASSIGN command is executed
  84         ADD       --  don't replace an assign but add another object for a
  85                       NAME (multi-assigns)
  86         REMOVE    --  remove an ASSIGN
  87         VOLS      --  show assigned volumes if in LIST mode
  88         DIRS      --  show assigned directories if in LIST mode
  89         DEVICES   --  show assigned devices if in LIST mode
  90
  91
  92     RESULT
  93
  94     NOTES
  95
  96     EXAMPLE
  97
  98     BUGS
  99
 100     SEE ALSO
 101
 102     INTERNALS
 103
 104         The assign command has many switches. This together with the somewhat
 105         messy handling of DosList:s by dos.library makes the operation rather
 106         complicated.
 107
 108         There are some fundamental building blocks that defines the semantics
 109         of the Assign command.
 110
 111         Only one of the switches ADD, REMOVE, PATH and DEFER may be specified.
 112
 113         If EXISTS is specified, only the name parameter is important.
 114
 115         The implementation is split up in two fundamental procedures.
 116
 117         doAssign()     --  make [a number of] assigns
 118         showAssigns()  --  show the available assigns
 119         checkAssign()  --  check if a particular assign exists
 120
 121 ******************************************************************************/
 122
 123 #ifndef __AROS__
 124 #define AROS_BSTR_strlen(s) *((UBYTE *)BADDR(s))
 125 #endif
 126
 127 #ifdef __MORPHOS__
 128 #define AROS_ASMSYMNAME(s) (&s)
 129
 130 static const int __abox__ = 1;
 131 static const char version[] = "\0$VER: Assign unofficial 50.9 (18.10.07) © AROS" ;
 132 #else
 133 static const char version[] = "\0$VER: Assign 50.9 (18.10.07) © AROS" ;
 134 #endif
 135
 136 struct localdata
 137 {
 138         struct ExecBase     *ld_SysBase;
 139         struct DosLibrary   *ld_DOSBase;
 140         struct MinList      ld_DeferList;
 141 };
 142
 143 /* FIXME: Remove these #define xxxBase hacks
 144    Do not use this in new code !
 145 */
 146 #define SysBase   ld->ld_SysBase
 147 #define DOSBase   ld->ld_DOSBase
 148 #define DeferList ld->ld_DeferList
 149
 150
 151 /* Prototypes */
 152
 153 static int Main(struct ExecBase *sBase);
 154 static int checkAssign(struct localdata *ld, STRPTR name);
 155 static int doAssign(struct localdata *ld, STRPTR name, STRPTR *target, BOOL dismount, BOOL defer, BOOL path,
 156              BOOL add, BOOL remove);
 157 static void showAssigns(struct localdata *ld, BOOL vols, BOOL dirs, BOOL devices);
 158 static int removeAssign(struct localdata *ld, STRPTR name);
 159 static STRPTR GetFullPath(struct localdata *ld, BPTR lock);
 160
 161 static void _DeferPutStr(struct localdata *ld, CONST_STRPTR str);
 162 static void _DeferVPrintf(struct localdata *ld, CONST_STRPTR fmt, IPTR *args);
 163 static void _DeferFlush(struct localdata *ld, BPTR fh);
 164
 165 #define DeferPutStr(str) _DeferPutStr(ld,str)
 166 #define DeferPrintf(fmt,...) \
 167   DEBUG_ASSIGN(kprintf(fmt, __VA_ARGS__);) \
 168   do { IPTR __args[] = {0 , AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) };  \
 169       _DeferVPrintf(ld, fmt, __args + 1); } while (0)
 170 #define DeferFlush(fh) _DeferFlush(ld,fh)
 171
 172
 173 static
 174 const UBYTE template[] =
 175 "NAME,"
 176 "TARGET/M,"
 177 "LIST/S,"
 178 "EXISTS/S,"
 179 "DISMOUNT/S,"
 180 "DEFER/S,"
 181 "PATH/S,"
 182 "ADD/S,"
 183 "REMOVE/S,"
 184 "VOLS/S,"
 185 "DIRS/S,"
 186 "DEVICES/S";
 187
 188 struct ArgList
 189 {
 190     STRPTR name;
 191     STRPTR *target;
 192     IPTR list;
 193     IPTR exists;
 194     IPTR dismount;
 195     IPTR defer;
 196     IPTR path;
 197     IPTR add;
 198     IPTR remove;
 199     IPTR vols;
 200     IPTR dirs;
 201     IPTR devices;
 202 };
 203
 204 AROS_ENTRY(__startup static int, Start,
 205           AROS_UFHA(char *, argstr, A0),
 206           AROS_UFHA(ULONG, argsize, D0),
 207           struct ExecBase *, sBase)
 208 {
 209         AROS_USERFUNC_INIT
 210         return Main(sBase);
 211         AROS_USERFUNC_EXIT
 212 }
 213
 214 static int Main(struct ExecBase *sBase)
 215 {
 216         struct localdata _ld, *ld = &_ld;
 217         struct RDArgs *readarg;
 218         struct ArgList arglist;
 219         struct ArgList *MyArgList = &arglist;
 220         int error = RETURN_OK;
 221
 222         SysBase = sBase;
 223         DOSBase = (struct DosLibrary *) OpenLibrary("dos.library",37);
 224         if (DOSBase)
 225         {
 226                 memset(&arglist, 0, sizeof(arglist));
 227
 228                 NEWLIST(&DeferList);
 229
 230                 readarg = ReadArgs(template, (IPTR *)MyArgList, NULL);
 231                 if (readarg)
 232                 {
 233                         /* Verify mutually exclusive args
 234                          */
 235                         if ((MyArgList->add!=0) + (MyArgList->remove!=0) + (MyArgList->path!=0) + (MyArgList->defer!=0) > 1)
 236                         {
 237                                 PutStr("Only one of ADD, REMOVE, PATH or DEFER is allowed\n");
 238                                 FreeArgs(readarg);
 239                                 CloseLibrary((struct Library *) DOSBase);
 240                                 return RETURN_FAIL;
 241                         }
 242
 243                         /* Check device name
 244                          */
 245                         if (MyArgList->name)
 246                         {
 247                                 char *pos;
 248
 249                                 /* Correct assign name construction? The rule is that the device name
 250                                  * should end with a colon at the same time as no other colon may be
 251                                  * in the name.
 252                                  */
 253                                 pos = strchr(MyArgList->name, ':');
 254                                 if (!pos || pos[1])
 255                                 {
 256                                         Printf("Invalid device name %s\n", (IPTR)MyArgList->name);
 257                                         FreeArgs(readarg);
 258                                         CloseLibrary((struct Library *) DOSBase);
 259                                         return RETURN_FAIL;
 260                                 }
 261                         }
 262
 263                         /* If the EXISTS keyword is specified, we only care about NAME */
 264                         if (MyArgList->exists)
 265                         {
 266                                 error = checkAssign(ld, MyArgList->name);
 267                                 DEBUG_ASSIGN(Printf("checkassign error %ld\n",error));
 268                         }
 269                         else if (MyArgList->name)
 270                         {
 271                                 /* If a NAME is specified, our primary task is to add or
 272                                    remove an assign */
 273
 274                                 error = doAssign(ld, MyArgList->name, MyArgList->target, MyArgList->dismount, MyArgList->defer,
 275                                                  MyArgList->path, MyArgList->add, MyArgList->remove);
 276                                 DEBUG_ASSIGN(Printf("doassign error %ld\n",error));
 277                                 if (MyArgList->list)
 278                                 {
 279                                         /* With the LIST keyword, the current assigns will be
 280                                            displayed also when (after) making an assign */
 281
 282                                         showAssigns(ld, MyArgList->vols, MyArgList->dirs, MyArgList->devices);
 283                                 }
 284                         }
 285                         else
 286                         {
 287                                 /* If no NAME was given, we just show the current assigns
 288                                    as specified by the user (VOLS, DIRS, DEVICES) */
 289
 290                                 showAssigns(ld, MyArgList->vols, MyArgList->dirs, MyArgList->devices);
 291                         }
 292
 293                         FreeArgs(readarg);
 294                 }
 295
 296                 CloseLibrary((struct Library *) DOSBase);
 297         }
 298
 299         DEBUG_ASSIGN(Printf("error %ld\n", error));
 300
 301         return error;
 302 }
 303
 304
 305 static
 306 void showAssigns(struct localdata *ld, BOOL vols, BOOL dirs, BOOL devices)
 307 {
 308         ULONG           lockBits = LDF_READ;
 309         struct DosList *dl;
 310
 311         /* If none of the parameters are specified, everything should be
 312            displayed */
 313         if (!(vols || dirs || devices))
 314         {
 315                 vols    = TRUE;
 316                 dirs    = TRUE;
 317                 devices = TRUE;
 318         }
 319
 320         lockBits |= vols    ? LDF_VOLUMES : 0;
 321         lockBits |= dirs    ? LDF_ASSIGNS : 0;
 322         lockBits |= devices ? LDF_DEVICES : 0;
 323
 324         dl = LockDosList(lockBits);
 325
 326         /* FIXME: GetFullPath() breaks LockDosList()'s Forbid()! */
 327         /* Note: This should be ok as long as we don't have ks 1.x compatibility.
 328          */
 329
 330         if (vols)
 331         {
 332                 struct DosList *tdl = dl;
 333
 334                 DeferPutStr("Volumes:\n");
 335
 336                 /* Print all mounted volumes */
 337                 while ((tdl = NextDosEntry(tdl, LDF_VOLUMES)))
 338                 {
 339                         DeferPrintf("%b [Mounted]\n", tdl->dol_Name);
 340                 }
 341         }
 342
 343         if (dirs)
 344         {
 345                 struct DosList *tdl = dl;
 346                 int             count;
 347
 348                 DeferPutStr("\nDirectories:\n");
 349
 350                 /* Print all assigned directories */
 351                 while ((tdl = NextDosEntry(tdl, LDF_ASSIGNS)))
 352                 {
 353                         DeferPrintf("%b ", tdl->dol_Name);
 354
 355                         for (count = 14 - AROS_BSTR_strlen(tdl->dol_Name); count > 0; count--)
 356                         {
 357                                 DeferPutStr(" ");
 358                         }
 359
 360                         switch (tdl->dol_Type)
 361                         {
 362                         case DLT_LATE:
 363                                 DeferPrintf("<%s>\n", (IPTR)tdl->dol_misc.dol_assign.dol_AssignName);
 364                                 break;
 365
 366                         case DLT_NONBINDING:
 367                                 DeferPrintf("[%s]\n", (IPTR)tdl->dol_misc.dol_assign.dol_AssignName);
 368                                 break;
 369
 370                         default:
 371                                 {
 372                                         STRPTR             dirName;     /* For NameFromLock() */
 373                                         struct AssignList *nextAssign;  /* For multiassigns */
 374
 375                                         dirName = GetFullPath(ld, tdl->dol_Lock);
 376
 377                                         if (dirName)
 378                                         {
 379                                                 DeferPutStr(dirName);
 380                                                 FreeVec(dirName);
 381                                         }
 382                                         DeferPutStr("\n");
 383
 384                                         nextAssign = tdl->dol_misc.dol_assign.dol_List;
 385
 386                                         while (nextAssign)
 387                                         {
 388                                                 dirName = GetFullPath(ld, nextAssign->al_Lock);
 389
 390                                                 if (dirName)
 391                                                 {
 392                                                         DeferPrintf("             + %s\n", (IPTR)dirName);
 393                                                         FreeVec(dirName);
 394                                                 }
 395
 396                                                 nextAssign = nextAssign->al_Next;
 397                                         }
 398                                 }
 399
 400                                 break;
 401                         }
 402                 } /* while (NextDosEntry()) */
 403         }
 404
 405         if (devices)
 406         {
 407                 struct DosList *tdl = dl;
 408                 int             count = 0; /* Used to make sure that as most 5 entries are printed per line */
 409
 410                 DeferPutStr("\nDevices:\n");
 411
 412                 /* Print all assigned devices */
 413                 while ((tdl = NextDosEntry(tdl, LDF_DEVICES)))
 414                 {
 415                         DeferPrintf("%b%lc", tdl->dol_Name, ++count % 5 ? ' ' : '\n');
 416                 }
 417
 418                 if (count % 5)
 419                 {
 420                         DeferPutStr("\n");
 421                 }
 422         }
 423
 424         UnLockDosList(lockBits);
 425
 426         DeferFlush(Output());
 427 }
 428
 429
 430 static
 431 STRPTR GetFullPath(struct localdata *ld, BPTR lock)
 432 {
 433         STRPTR buf;       /* Pointer to the memory allocated for the string */
 434         ULONG  size;      /* Holder of the (growing) size of the string */
 435
 436         for (size = 512; ; size += 512)
 437         {
 438                 buf = AllocVec(size, MEMF_ANY);
 439                 if (!buf)
 440                 {
 441                         break;
 442                 }
 443
 444                 if (NameFromLock(lock, buf, size))
 445                 {
 446                         return buf;
 447                 }
 448
 449                 FreeVec(buf);
 450
 451                 if (IoErr() != ERROR_LINE_TOO_LONG)
 452                 {
 453                         break;
 454                 }
 455         }
 456
 457         return NULL;
 458 }
 459
 460
 461 static
 462 int doAssign(struct localdata *ld, STRPTR name, STRPTR *target, BOOL dismount, BOOL defer, BOOL path,
 463              BOOL add, BOOL remove)
 464 {
 465         STRPTR colon;
 466         BPTR   lock = BNULL;
 467         int    i;
 468
 469         int  error = RETURN_OK;
 470         LONG ioerr = 0;
 471         BOOL cancel = FALSE;
 472         BOOL success = TRUE;
 473
 474         if (dismount)
 475         {
 476                 struct MsgPort *dp;
 477                 struct Process *tp;
 478
 479                 tp=(struct Process *)FindTask(NULL);
 480                 tp->pr_WindowPtr = (APTR)-1;
 481                 dp = DeviceProc(name);
 482                 DEBUG_ASSIGN(Printf("doassign: dp <%08X>\n",dp));
 483                 if (dp)
 484                 {
 485                         success = DoPkt(dp,ACTION_DIE,0,0,0,0,0);
 486                         ioerr = IoErr();
 487                         DEBUG_ASSIGN(Printf("doassign: ACTION_DIE returned %ld\n",success));
 488                 }
 489         }
 490
 491         colon = strchr(name, ':');
 492
 493         *colon = '\0';        /* Remove trailing colon; name[] is changed! */
 494
 495         DEBUG_ASSIGN(Printf("doassign: name <%s>\n", name));
 496
 497         /* This is a little bit messy... We first remove the 'name' assign
 498          * and later in the loop the target assigns.
 499          */
 500
 501         if (dismount)
 502         {
 503                 if ((!success) && (ioerr == ERROR_ACTION_NOT_KNOWN))
 504                 {
 505                         struct DosList *dl;
 506                         struct DosList *fdl;
 507
 508                         DEBUG_ASSIGN(PutStr("Removing device node\n"));
 509                         dl = LockDosList(LDF_VOLUMES | LDF_DEVICES | LDF_WRITE);
 510
 511                         fdl = FindDosEntry(dl, name, LDF_VOLUMES | LDF_DEVICES);
 512
 513                         /* Note the ! for conversion to boolean value */
 514                         if (fdl)
 515                         {
 516                                 success = RemDosEntry(fdl);
 517                                 if (success)
 518                                         FreeDosEntry(fdl);
 519                                 else
 520                                         ioerr = ERROR_OBJECT_IN_USE;
 521                         } else
 522                                 ioerr = ERROR_OBJECT_NOT_FOUND;
 523
 524                         UnLockDosList(LDF_VOLUMES | LDF_DEVICES | LDF_WRITE);
 525                 }
 526         }
 527         else
 528         {
 529                 if (target == NULL || *target == NULL)
 530                 {
 531                         error = removeAssign(ld, name);
 532                         if (error)
 533                         {
 534                                 ioerr = IoErr();
 535                                 cancel = TRUE;
 536                         }
 537                 }
 538         }
 539
 540         /* AmigaDOS doesn't use RETURN_WARN here... but it should? */
 541         error = success ? error : RETURN_WARN;
 542         DEBUG_ASSIGN(Printf("error: %d\n", error));
 543
 544         // The Loop over multiple targets starts here
 545
 546         if (target)
 547         {
 548                 for (i = 0; target[i]; i++)
 549                 {
 550                         cancel = FALSE;
 551
 552                         DEBUG_ASSIGN(Printf("doassign: target <%s>\n", target[i]));
 553                         if (!(path || defer || dismount))
 554                         {
 555                                 lock = Lock(target[i], SHARED_LOCK);
 556
 557                                 if (!lock)
 558                                 {
 559                                         Printf("Can't find %s\n", (IPTR)target[i]);
 560                                         return RETURN_FAIL;
 561                                 }
 562                         }
 563
 564                         if (remove)
 565                         {
 566                                 if (!RemAssignList(name, lock))
 567                                 {
 568                                         Printf("Can't subtract %s from %s\n", (IPTR)target[i], (IPTR)name);
 569                                         error = RETURN_FAIL;
 570                                 }
 571                                 UnLock(lock);
 572                         }
 573                         else if (path)
 574                         {
 575                                 if (!AssignPath(name, target[i]))
 576                                 {
 577                                         ioerr = IoErr();
 578                                         error = RETURN_FAIL;
 579                                         DEBUG_ASSIGN(Printf("doassign AssignPath error %ld\n",error));
 580                                 }
 581                         }
 582                         else if (add)
 583                         {
 584                                 if (!AssignAdd(name, lock))
 585                                 {
 586                                         struct DosList *dl;
 587
 588                                         error = RETURN_FAIL;
 589                                         ioerr = IoErr();
 590                                         DEBUG_ASSIGN(Printf("doassign AssignAdd error %ld\n",error));
 591
 592                                         /* Check if the assign doesn't exist at all. If so, create it.
 593                                          * This fix bug id 145. - Piru
 594                                          */
 595                                         dl = LockDosList(LDF_ASSIGNS | LDF_READ);
 596                                         dl = FindDosEntry(dl, name, LDF_ASSIGNS);
 597                                         UnLockDosList(LDF_ASSIGNS | LDF_READ);
 598
 599                                         if (!dl)
 600                                         {
 601                                                 if (AssignLock(name, lock))
 602                                                 {
 603                                                         error = RETURN_OK;
 604                                                         lock = BNULL;
 605                                                 }
 606                                                 else
 607                                                 {
 608                                                         ioerr = IoErr();
 609                                                         DEBUG_ASSIGN(Printf("doassign AssignLock error %ld\n", error));
 610                                                 }
 611                                         }
 612
 613                                         if (lock)
 614                                                 UnLock(lock);
 615
 616                                         if (error && ioerr != ERROR_OBJECT_EXISTS)
 617                                         {
 618                                                 Printf("Can't add %s to %s\n", (IPTR)target[i], (IPTR)name);
 619                                         }
 620                                 }
 621                         }
 622                         else if (defer)
 623                         {
 624                                 if (!AssignLate(name, target[i]))
 625                                 {
 626                                         ioerr = IoErr();
 627                                         UnLock(lock);
 628                                         error = RETURN_FAIL;
 629                                         DEBUG_ASSIGN(Printf("doassign AssignLate error %ld\n",error));
 630                                 }
 631                         }
 632                         else
 633                         {
 634                                 /* If no extra parameters are specified we just do a regular
 635                                    assign (replacing any possible previous assign with that
 636                                    name. The case of target being NULL is taken care of above.
 637                                 */
 638                                 if (!AssignLock(name, lock))
 639                                 {
 640                                         ioerr = IoErr();
 641                                         cancel = TRUE;
 642                                         UnLock(lock);
 643                                         error = RETURN_FAIL;
 644                                         DEBUG_ASSIGN(Printf("doassign AssignLock error %ld\n",error));
 645                                 }
 646                                 /* If there are several targets, the next ones have to be added. */
 647                                 add = TRUE;
 648                         }
 649
 650                         /* We break as soon as we get a serious error */
 651                         if (error >= RETURN_FAIL)
 652                         {
 653                                 break;
 654                         }
 655
 656                 } /* loop through all targets */
 657         }
 658
 659         if (error)
 660         {
 661                 if (ioerr == ERROR_OBJECT_EXISTS)
 662                 {
 663                         Printf("Can't %s %s\n", (IPTR)(cancel ? "cancel" : "assign"), (IPTR)name);
 664                 }
 665                 else
 666                 {
 667                         PrintFault(ioerr, NULL);
 668                 }
 669         }
 670
 671         return error;
 672 }
 673
 674
 675 static
 676 int removeAssign(struct localdata *ld, STRPTR name)
 677 {
 678         /* In case no target is given, the 'name' assign should be removed.
 679          * The AmigaDOS semantics for this is apparently that the error
 680          * code is never set even if the assign didn't exist.
 681          */
 682
 683         if (!AssignLock(name, BNULL))
 684         {
 685                 return RETURN_FAIL;
 686         }
 687         return RETURN_OK;
 688 }
 689
 690
 691 static
 692 int checkAssign(struct localdata *ld, STRPTR name)
 693 {
 694         STRPTR colon;
 695         struct DosList *dl;
 696         int             error = RETURN_OK;
 697
 698         if (!name)
 699                 name = "";
 700
 701         colon = strchr(name, ':');
 702         if (colon)
 703         {
 704                 *colon = '\0';
 705         }
 706
 707         dl = LockDosList(LDF_DEVICES | LDF_ASSIGNS | LDF_VOLUMES | LDF_READ);
 708
 709         /* FIXME: GetFullPath() breaks LockDosList()'s Forbid()! */
 710         /* Note: This should be ok as long as we don't have ks 1.x compatibility.
 711          */
 712
 713         dl = FindDosEntry(dl, name, LDF_DEVICES | LDF_ASSIGNS | LDF_VOLUMES);
 714         if (dl)
 715         {
 716                 struct DosList *tdl = dl;
 717                 int             count;
 718
 719                 switch (dl->dol_Type)
 720                 {
 721                 case DLT_DEVICE:
 722                         DeferPrintf("%b\n", tdl->dol_Name);
 723                         break;
 724
 725                 case DLT_VOLUME:
 726                         DeferPrintf("%b [Mounted]\n", tdl->dol_Name);
 727                         break;
 728
 729                 case DLT_DIRECTORY:
 730                 case DLT_LATE:
 731                 case DLT_NONBINDING:
 732
 733                         DeferPrintf("%b ", tdl->dol_Name);
 734
 735                         for (count = 14 - *((UBYTE*)BADDR(tdl->dol_Name)); count > 0; count--)
 736                         {
 737                                 DeferPutStr(" ");
 738                         }
 739
 740                         switch (tdl->dol_Type)
 741                         {
 742                         case DLT_LATE:
 743                                 DeferPrintf("<%s>\n", (IPTR)tdl->dol_misc.dol_assign.dol_AssignName);
 744                                 break;
 745
 746                         case DLT_NONBINDING:
 747                                 DeferPrintf("[%s]\n", (IPTR)tdl->dol_misc.dol_assign.dol_AssignName);
 748                                 break;
 749
 750                         default:
 751                                 {
 752                                         STRPTR             dirName;     /* For NameFromLock() */
 753                                         struct AssignList *nextAssign;  /* For multiassigns */
 754
 755                                         dirName = GetFullPath(ld, tdl->dol_Lock);
 756
 757                                         if (dirName)
 758                                         {
 759                                                 DeferPutStr(dirName);
 760                                                 FreeVec(dirName);
 761                                         }
 762                                         DeferPutStr("\n");
 763
 764                                         nextAssign = tdl->dol_misc.dol_assign.dol_List;
 765
 766                                         while (nextAssign)
 767                                         {
 768                                                 dirName = GetFullPath(ld, nextAssign->al_Lock);
 769
 770                                                 if (dirName)
 771                                                 {
 772                                                         DeferPrintf("             + %s\n", (IPTR)dirName);
 773                                                         FreeVec(dirName);
 774                                                 }
 775
 776                                                 nextAssign = nextAssign->al_Next;
 777                                         }
 778                                 }
 779                         }
 780
 781                         break;
 782                 }
 783         }
 784         else
 785         {
 786                 DeferPrintf("%s: not assigned\n", (IPTR)name);
 787
 788                 error = RETURN_WARN;
 789         }
 790
 791         UnLockDosList(LDF_DEVICES | LDF_ASSIGNS | LDF_VOLUMES | LDF_READ);
 792
 793         DeferFlush(Output());
 794
 795         if (colon)
 796                 *colon = ':';
 797
 798         return error;
 799 }
 800
 801
 802 /* Feferred printing routines - Piru
 803 */
 804
 805 #define MAXDEFERBUF 4096
 806 #define MAXOUTPUT   128
 807 struct deferbufnode
 808 {
 809         struct MinList node;
 810         LONG           pos;
 811         UBYTE          buf[MAXDEFERBUF];
 812 };
 813
 814 static void deferputch(UBYTE ch, struct localdata *ld)
 815 {
 816         struct deferbufnode *cur;
 817
 818         if (!ch)
 819                 return;
 820
 821         cur = (struct deferbufnode *) GetTail(&DeferList);
 822
 823         if (!cur || cur->pos >= MAXDEFERBUF)
 824         {
 825                 cur = AllocMem(sizeof(struct deferbufnode), MEMF_ANY);
 826                 if (!cur)
 827                         return;
 828
 829                 cur->pos = 0;
 830
 831                 ADDTAIL(&DeferList, cur);
 832         }
 833
 834         cur->buf[cur->pos] = ch;
 835         cur->pos++;
 836 }
 837
 838 static
 839 void _DeferPutStr(struct localdata *ld, CONST_STRPTR str)
 840 {
 841         UBYTE c;
 842
 843         DEBUG_ASSIGN(kprintf(str));
 844         while ((c = *str++))
 845         {
 846                 deferputch(c, ld);
 847         }
 848 }
 849
 850 #ifdef __AROS__
 851 AROS_UFH2S(void, deferputch_gate,
 852           AROS_UFHA(UBYTE, ch, D0),
 853           AROS_UFHA(struct localdata *, ld, A3))
 854 {
 855         AROS_USERFUNC_INIT
 856         deferputch(ch, ld);
 857         AROS_USERFUNC_EXIT
 858 }
 859 #endif
 860
 861 #ifdef __MORPHOS__
 862 static
 863 void deferputch_trampoline(void)
 864 {
 865         UBYTE ch = (UBYTE) REG_D0;
 866         struct localdata *ld = (struct localdata *) REG_A3;
 867
 868         deferputch(ch, ld);
 869 }
 870
 871 static
 872 const struct EmulLibEntry deferputch_gate =
 873 {
 874         TRAP_LIBNR, 0, (void (*)(void)) deferputch_trampoline
 875 };
 876 #endif
 877
 878 static
 879 void _DeferVPrintf(struct localdata *ld, CONST_STRPTR fmt, IPTR *args)
 880 {
 881         RawDoFmt(fmt, args, (void (*)(void))AROS_ASMSYMNAME(deferputch_gate), ld);
 882 }
 883
 884 static
 885 void _DeferFlush(struct localdata *ld, BPTR fh)
 886 {
 887         struct deferbufnode *node;
 888         BOOL broken = FALSE;
 889
 890         Flush(fh);
 891
 892         while ((node = (struct deferbufnode *)REMHEAD(&DeferList)))
 893         {
 894                 LONG offs = 0;
 895                 LONG left = node->pos;
 896
 897                 while (!broken && left)
 898                 {
 899                         LONG len;
 900
 901                         if (SetSignal(0, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C)
 902                         {
 903                                 broken = TRUE;
 904                                 break;
 905                         }
 906
 907                         len = left > MAXOUTPUT ? MAXOUTPUT : left;
 908
 909                         Write(fh, node->buf + offs, len);
 910                         offs += len;
 911                         left -= len;
 912                 }
 913
 914                 FreeMem(node, sizeof(struct deferbufnode));
 915         }
 916
 917         Flush(fh);
 918
 919         if (broken)
 920         {
 921                 PrintFault(ERROR_BREAK, NULL);
 922         }
 923 }
 924