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