workbench/c/MakeDir.c

   1 /*
   2     Copyright © 1995-2008, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     MakeDir CLI command.
   6 */
   7
   8 #include <exec/memory.h>
   9 #include <exec/execbase.h>
  10 #include <proto/exec.h>
  11 #include <dos/dos.h>
  12 #include <proto/dos.h>
  13 #include <utility/tagitem.h>
  14
  15 const TEXT version[] = "$VER: MakeDir 42.5 (15.12.2007)\n";
  16
  17 /******************************************************************************
  18
  19     NAME
  20
  21         MakeDir
  22
  23     SYNOPSIS
  24
  25         NAME/M/A,ALL/S
  26
  27     LOCATION
  28
  29         C:
  30
  31     FUNCTION
  32
  33         Create new empty directories with specified names.
  34
  35     INPUTS
  36
  37         NAME  --  names of the directories that should be created
  38         ALL   --  creates intermediate directories
  39
  40     RESULT
  41
  42     NOTES
  43
  44         MakeDir does not create an icon for a new directory.
  45
  46     EXAMPLE
  47
  48     BUGS
  49
  50     SEE ALSO
  51
  52     INTERNALS
  53
  54 ******************************************************************************/
  55
  56
  57 enum
  58 {
  59     ARG_NAME = 0,
  60     ARG_ALL,
  61     NOOFARGS
  62 };
  63
  64 BPTR CreateDirAll(STRPTR name);
  65
  66 int __nocommandline;
  67
  68 int main(void)
  69 {
  70     IPTR           args[NOOFARGS] = { (IPTR) NULL };
  71     struct RDArgs *rda;
  72
  73     LONG   error = RETURN_OK;
  74     BPTR   lock;
  75
  76     rda = ReadArgs("NAME/M/A,ALL/S", args, NULL);
  77
  78     if(rda != NULL)
  79     {
  80         int      i = 0;
  81         STRPTR  *name = (STRPTR *)args[ARG_NAME];
  82
  83         if((name == NULL) || (*name == NULL))
  84         {
  85             SetIoErr(ERROR_REQUIRED_ARG_MISSING);
  86             error = RETURN_FAIL;
  87         }
  88         else
  89         {
  90             for(i = 0; name[i] != NULL; i++)
  91             {
  92                 if (args[ARG_ALL])
  93                     lock = CreateDirAll(name[i]);
  94                 else
  95                     lock = CreateDir(name[i]);
  96
  97                 /* The AmigaDOS semantics are quite strange here. When it is
  98                    impossible to create a certain directory, MakeDir goes on
  99                    to try to create the rest of the specified directories and
 100                    returns the LAST return value for the operation. */
 101                 if(lock != BNULL)
 102                 {
 103                     UnLock(lock);
 104                     error = RETURN_OK;
 105                 }
 106                 else
 107                 {
 108                     LONG lasterr = IoErr(); // We don't want error from PutStr()
 109                     PutStr("Cannot create directory ");
 110                     PutStr(name[i]);
 111                     PutStr("\n");
 112                     SetIoErr(lasterr);
 113                     error = RETURN_ERROR;
 114                 }
 115             }
 116         }
 117
 118         FreeArgs(rda);
 119     }
 120     else
 121         error = RETURN_FAIL;
 122
 123     if(error != RETURN_OK)
 124         PrintFault(IoErr(), "MakeDir");
 125
 126     return error;
 127 }
 128
 129 /* CreateDirAll
 130  *
 131  * Walk path from left to right, Lock()ing each element. If locking fails,
 132  * try CreateDir.
 133  * This routine is smart enough to try optimize multiple '/'s.
 134  */
 135
 136 BPTR CreateDirAll(STRPTR name)
 137 {
 138     STRPTR pt = name;
 139     BOOL first = TRUE;
 140     BPTR oldcurdir;
 141     BPTR l, o;
 142     UBYTE oc = 0;
 143     int skip = 0;
 144     UBYTE _fib[sizeof(struct FileInfoBlock) + 3];
 145     struct FileInfoBlock *fib = (APTR) ((((IPTR) _fib) + 3) & ~3);
 146
 147     CurrentDir(oldcurdir = CurrentDir(0));
 148
 149     for (;;)
 150     {
 151         UBYTE c = *pt++;
 152
 153         if (c == ':' || c == '/' || c == '\0')
 154         {
 155             if (c == ':')
 156             {
 157                 skip = 0;
 158
 159                 if (!first)
 160                 {
 161                     SetIoErr(ERROR_DEVICE_NOT_MOUNTED);
 162                     break;
 163                 }
 164                 first = FALSE;
 165                 oc = pt[skip];
 166                 pt[skip] = '\0';
 167                 //Printf("Lock \"%s\"\n", (LONG) name);
 168                 l = Lock(name, ACCESS_READ);
 169             }
 170             else
 171             {
 172                 skip = 0;
 173                 if (c == '/')
 174                 {
 175                     while (pt[skip] == '/')
 176                     {
 177                         skip++;
 178                     }
 179                 }
 180
 181                 oc = pt[skip];
 182                 pt[skip] = '\0';
 183                 //Printf("Lock \"%s\"\n", (LONG) name);
 184                 l = Lock(name, ACCESS_READ);
 185                 if (!l)
 186                 {
 187                     pt[skip] = oc;
 188                     skip = *name != '/' && c == '/' ? -1 : 0;
 189                     oc = pt[skip];
 190                     pt[skip] = '\0';
 191
 192                     //Printf("CreateDir \"%s\"\n", (LONG) name);
 193                     l = name[0] == '/' || name[0] == '\0' ? 0 : CreateDir(name);
 194                     if (l)
 195                     {
 196                         if (!ChangeMode(CHANGE_LOCK, l, ACCESS_READ))
 197                         {
 198                             UnLock(l);
 199                             l = Lock(name, ACCESS_READ);
 200                         }
 201                     }
 202                 }
 203                 else
 204                 {
 205                     LONG res;
 206
 207                     /* Make sure it's a directory */
 208                     if (!(res = Examine(l, fib)) || fib->fib_DirEntryType < 0)
 209                     {
 210                         UnLock(l);
 211                         if (res)
 212                         {
 213                             SetIoErr(c == '\0' ? ERROR_OBJECT_EXISTS : ERROR_OBJECT_WRONG_TYPE);
 214                         }
 215                         break;
 216                     }
 217                     pt += skip;
 218                     skip = 0;
 219                 }
 220             }
 221
 222             if (!l)
 223             {
 224                 break;
 225             }
 226
 227             o = CurrentDir(l);
 228             if (o != oldcurdir)
 229             {
 230                 UnLock(o);
 231             }
 232
 233             pt[skip] = oc;
 234             name = pt;
 235
 236             if (c == '\0')
 237             {
 238                 //Printf("return success\n");
 239                 return CurrentDir(oldcurdir);
 240             }
 241         }
 242     }
 243
 244     pt[skip] = oc;
 245
 246     o = CurrentDir(oldcurdir);
 247     if (o != oldcurdir)
 248     {
 249         UnLock(o);
 250     }
 251
 252     //Printf("return error\n");
 253     return BNULL;
 254 }