workbench/c/MakeDir.c

   1 /*
   2     Copyright © 1995-2014, 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.6 (3.4.2014)\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   result = RETURN_OK;
  74     LONG   error = 0;
  75     BPTR   lock;
  76
  77     rda = ReadArgs("NAME/M/A,ALL/S", args, NULL);
  78
  79     if(rda != NULL)
  80     {
  81         int      i = 0;
  82         STRPTR  *name = (STRPTR *)args[ARG_NAME];
  83
  84         if((name == NULL) || (*name == NULL))
  85         {
  86             error = ERROR_REQUIRED_ARG_MISSING;
  87             result = RETURN_FAIL;
  88         }
  89         else
  90         {
  91             for(i = 0; name[i] != NULL; i++)
  92             {
  93                 if (args[ARG_ALL])
  94                     lock = CreateDirAll(name[i]);
  95                 else
  96                     lock = CreateDir(name[i]);
  97
  98                 /* The AmigaDOS semantics are quite strange here. When it is
  99                    impossible to create a certain directory, MakeDir goes on
 100                    to try to create the rest of the specified directories and
 101                    returns the LAST return value for the operation. */
 102                 if(lock != BNULL)
 103                 {
 104                     UnLock(lock);
 105                     result = RETURN_OK;
 106                 }
 107                 else
 108                 {
 109                     error = IoErr();
 110                     PutStr("Cannot create directory ");
 111                     PutStr(name[i]);
 112                     PutStr("\n");
 113                     result = RETURN_ERROR;
 114                 }
 115             }
 116         }
 117
 118         FreeArgs(rda);
 119     }
 120     else
 121         result = RETURN_FAIL;
 122
 123     if(result != RETURN_OK)
 124         PrintFault(error, "MakeDir");
 125
 126     return result;
 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     LONG error = 0;
 147
 148     CurrentDir(oldcurdir = CurrentDir(0));
 149
 150     for (;;)
 151     {
 152         UBYTE c = *pt++;
 153
 154         if (c == ':' || c == '/' || c == '\0')
 155         {
 156             if (c == ':')
 157             {
 158                 skip = 0;
 159
 160                 if (!first)
 161                 {
 162                     error = ERROR_DEVICE_NOT_MOUNTED;
 163                     break;
 164                 }
 165                 first = FALSE;
 166                 oc = pt[skip];
 167                 pt[skip] = '\0';
 168                 //Printf("Lock \"%s\"\n", (LONG) name);
 169                 l = Lock(name, ACCESS_READ);
 170             }
 171             else
 172             {
 173                 skip = 0;
 174                 if (c == '/')
 175                 {
 176                     while (pt[skip] == '/')
 177                     {
 178                         skip++;
 179                     }
 180                 }
 181
 182                 oc = pt[skip];
 183                 pt[skip] = '\0';
 184                 //Printf("Lock \"%s\"\n", (LONG) name);
 185                 l = Lock(name, ACCESS_READ);
 186                 if (!l)
 187                 {
 188                     pt[skip] = oc;
 189                     skip = *name != '/' && c == '/' ? -1 : 0;
 190                     oc = pt[skip];
 191                     pt[skip] = '\0';
 192
 193                     //Printf("CreateDir \"%s\"\n", (LONG) name);
 194                     l = name[0] == '/' || name[0] == '\0' ? 0 : CreateDir(name);
 195                     if (l)
 196                     {
 197                         if (!ChangeMode(CHANGE_LOCK, l, ACCESS_READ))
 198                         {
 199                             UnLock(l);
 200                             l = Lock(name, ACCESS_READ);
 201                         }
 202                     }
 203                 }
 204                 else
 205                 {
 206                     LONG res;
 207
 208                     /* Make sure it's a directory */
 209                     if (!(res = Examine(l, fib)) || fib->fib_DirEntryType < 0)
 210                     {
 211                         UnLock(l);
 212                         if (res)
 213                         {
 214                             error = (c == '\0' ? ERROR_OBJECT_EXISTS : ERROR_OBJECT_WRONG_TYPE);
 215                         }
 216                         break;
 217                     }
 218                     pt += skip;
 219                     skip = 0;
 220                 }
 221             }
 222
 223             if (!l)
 224             {
 225                 break;
 226             }
 227
 228             o = CurrentDir(l);
 229             if (o != oldcurdir)
 230             {
 231                 UnLock(o);
 232             }
 233
 234             pt[skip] = oc;
 235             name = pt;
 236
 237             if (c == '\0')
 238             {
 239                 //Printf("return success\n");
 240                 return CurrentDir(oldcurdir);
 241             }
 242         }
 243     }
 244
 245     pt[skip] = oc;
 246
 247     o = CurrentDir(oldcurdir);
 248     if (o != oldcurdir)
 249     {
 250         UnLock(o);
 251     }
 252
 253     //Printf("return error\n");
 254     SetIoErr(error);
 255     return BNULL;
 256 }