programs/cmd/batch.c

   1 /*
   2  * CMD - Wine-compatible command line interface - batch interface.
   3  *
   4  * Copyright (C) 1999 D A Pickles
   5  * Copyright (C) 2007 J Edmeades
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "wcmd.h"
  23 #include "wine/debug.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(cmd);
  26
  27 extern int echo_mode;
  28 extern WCHAR quals[MAX_PATH], param1[MAX_PATH], param2[MAX_PATH];
  29 extern BATCH_CONTEXT *context;
  30 extern DWORD errorlevel;
  31
  32 /****************************************************************************
  33  * WCMD_batch
  34  *
  35  * Open and execute a batch file.
  36  * On entry *command includes the complete command line beginning with the name
  37  * of the batch file (if a CALL command was entered the CALL has been removed).
  38  * *file is the name of the file, which might not exist and may not have the
  39  * .BAT suffix on. Called is 1 for a CALL, 0 otherwise.
  40  *
  41  * We need to handle recursion correctly, since one batch program might call another.
  42  * So parameters for this batch file are held in a BATCH_CONTEXT structure.
  43  *
  44  * To support call within the same batch program, another input parameter is
  45  * a label to goto once opened.
  46  */
  47
  48 void WCMD_batch (WCHAR *file, WCHAR *command, int called, WCHAR *startLabel, HANDLE pgmHandle) {
  49
  50 #define WCMD_BATCH_EXT_SIZE 5
  51
  52   HANDLE h = INVALID_HANDLE_VALUE;
  53   WCHAR string[MAXSTRING];
  54   static const WCHAR extension_batch[][WCMD_BATCH_EXT_SIZE] = {{'.','b','a','t','\0'},
  55                                                                {'.','c','m','d','\0'}};
  56   static const WCHAR extension_exe[WCMD_BATCH_EXT_SIZE] = {'.','e','x','e','\0'};
  57   unsigned int  i;
  58   BATCH_CONTEXT *prev_context;
  59
  60   if (startLabel == NULL) {
  61     for(i=0; (i<sizeof(extension_batch)/(WCMD_BATCH_EXT_SIZE * sizeof(WCHAR))) &&
  62              (h == INVALID_HANDLE_VALUE); i++) {
  63       strcpyW (string, file);
  64       CharLower (string);
  65       if (strstrW (string, extension_batch[i]) == NULL) strcatW (string, extension_batch[i]);
  66       h = CreateFile (string, GENERIC_READ, FILE_SHARE_READ,
  67                       NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  68     }
  69     if (h == INVALID_HANDLE_VALUE) {
  70       strcpyW (string, file);
  71       CharLower (string);
  72       if (strstrW (string, extension_exe) == NULL) strcatW (string, extension_exe);
  73       if (GetFileAttributes (string) != INVALID_FILE_ATTRIBUTES) {
  74         WCMD_run_program (command, 0);
  75       } else {
  76         SetLastError (ERROR_FILE_NOT_FOUND);
  77         WCMD_print_error ();
  78       }
  79       return;
  80     }
  81   } else {
  82     DuplicateHandle(GetCurrentProcess(), pgmHandle,
  83                     GetCurrentProcess(), &h,
  84                     0, FALSE, DUPLICATE_SAME_ACCESS);
  85   }
  86
  87 /*
  88  *      Create a context structure for this batch file.
  89  */
  90
  91   prev_context = context;
  92   context = LocalAlloc (LMEM_FIXED, sizeof (BATCH_CONTEXT));
  93   context -> h = h;
  94   context -> command = command;
  95   memset(context -> shift_count, 0x00, sizeof(context -> shift_count));
  96   context -> prev_context = prev_context;
  97   context -> skip_rest = FALSE;
  98
  99   /* If processing a call :label, 'goto' the label in question */
 100   if (startLabel) {
 101     strcpyW(param1, startLabel);
 102     WCMD_goto(NULL);
 103   }
 104
 105 /*
 106  *      Work through the file line by line. Specific batch commands are processed here,
 107  *      the rest are handled by the main command processor.
 108  */
 109
 110   while (context -> skip_rest == FALSE) {
 111       CMD_LIST *toExecute = NULL;         /* Commands left to be executed */
 112       if (WCMD_ReadAndParseLine(NULL, &toExecute, h) == NULL)
 113         break;
 114       WCMD_process_commands(toExecute, FALSE, NULL, NULL);
 115       WCMD_free_commands(toExecute);
 116       toExecute = NULL;
 117   }
 118   CloseHandle (h);
 119
 120 /*
 121  *      If invoked by a CALL, we return to the context of our caller. Otherwise return
 122  *      to the caller's caller.
 123  */
 124
 125   LocalFree (context);
 126   if ((prev_context != NULL) && (!called)) {
 127     prev_context -> skip_rest = TRUE;
 128     context = prev_context;
 129   }
 130   context = prev_context;
 131 }
 132
 133 /*******************************************************************
 134  * WCMD_parameter - extract a parameter from a command line.
 135  *
 136  *      Returns the 'n'th delimited parameter on the command line (zero-based).
 137  *      Parameter is in static storage overwritten on the next call.
 138  *      Parameters in quotes (and brackets) are handled.
 139  *      Also returns a pointer to the location of the parameter in the command line.
 140  */
 141
 142 WCHAR *WCMD_parameter (WCHAR *s, int n, WCHAR **where) {
 143
 144   int i = 0;
 145   static WCHAR param[MAX_PATH];
 146   WCHAR *p;
 147
 148   if (where != NULL) *where = NULL;
 149   p = param;
 150   while (TRUE) {
 151     switch (*s) {
 152       case ' ': /* Skip leading spaces */
 153         s++;
 154         break;
 155       case '"':
 156         if (where != NULL && i==n) *where = s;
 157         s++;
 158         while ((*s != '\0') && (*s != '"')) {
 159           *p++ = *s++;
 160         }
 161         if (i == n) {
 162           *p = '\0';
 163           return param;
 164         }
 165         if (*s == '"') s++;
 166           param[0] = '\0';
 167           i++;
 168         p = param;
 169         break;
 170       /* The code to handle bracketed parms is removed because it should no longer
 171          be necessary after the multiline support has been added and the for loop
 172          set of data is now parseable individually. */
 173       case '\0':
 174         return param;
 175       default:
 176         /* Only return where if it is for the right parameter */
 177         if (where != NULL && i==n) *where = s;
 178         while ((*s != '\0') && (*s != ' ') && (*s != ',') && (*s != '=')) {
 179           *p++ = *s++;
 180         }
 181         if (i == n && (p!=param)) {
 182           *p = '\0';
 183           return param;
 184         }
 185         /* Skip double delimiters, eg. dir a.a,,,,,b.b */
 186         if (p != param) {
 187           param[0] = '\0';
 188           i++;
 189         } else {
 190           s++; /* Skip delimiter */
 191         }
 192         p = param;
 193     }
 194   }
 195 }
 196
 197 /****************************************************************************
 198  * WCMD_fgets
 199  *
 200  * Get one line from a batch file. We can't use the native f* functions because
 201  * of the filename syntax differences between DOS and Unix. Also need to lose
 202  * the LF (or CRLF) from the line.
 203  */
 204
 205 WCHAR *WCMD_fgets (WCHAR *s, int noChars, HANDLE h) {
 206
 207   DWORD bytes;
 208   BOOL status;
 209   WCHAR *p;
 210
 211   p = s;
 212   do {
 213     status = WCMD_ReadFile (h, s, 1, &bytes, NULL);
 214     if ((status == 0) || ((bytes == 0) && (s == p))) return NULL;
 215     if (*s == '\n') bytes = 0;
 216     else if (*s != '\r') {
 217       s++;
 218       noChars--;
 219     }
 220     *s = '\0';
 221   } while ((bytes == 1) && (noChars > 1));
 222   return p;
 223 }
 224
 225 /* WCMD_splitpath - copied from winefile as no obvious way to use it otherwise */
 226 void WCMD_splitpath(const WCHAR* path, WCHAR* drv, WCHAR* dir, WCHAR* name, WCHAR* ext)
 227 {
 228         const WCHAR* end; /* end of processed string */
 229         const WCHAR* p;  /* search pointer */
 230         const WCHAR* s;  /* copy pointer */
 231
 232         /* extract drive name */
 233         if (path[0] && path[1]==':') {
 234                 if (drv) {
 235                         *drv++ = *path++;
 236                         *drv++ = *path++;
 237                         *drv = '\0';
 238                 }
 239         } else if (drv)
 240                 *drv = '\0';
 241
 242         /* search for end of string or stream separator */
 243         for(end=path; *end && *end!=':'; )
 244                 end++;
 245
 246         /* search for begin of file extension */
 247         for(p=end; p>path && *--p!='\\' && *p!='/'; )
 248                 if (*p == '.') {
 249                         end = p;
 250                         break;
 251                 }
 252
 253         if (ext)
 254                 for(s=end; (*ext=*s++); )
 255                         ext++;
 256
 257         /* search for end of directory name */
 258         for(p=end; p>path; )
 259                 if (*--p=='\\' || *p=='/') {
 260                         p++;
 261                         break;
 262                 }
 263
 264         if (name) {
 265                 for(s=p; s<end; )
 266                         *name++ = *s++;
 267
 268                 *name = '\0';
 269         }
 270
 271         if (dir) {
 272                 for(s=path; s<p; )
 273                         *dir++ = *s++;
 274
 275                 *dir = '\0';
 276         }
 277 }
 278
 279 /****************************************************************************
 280  * WCMD_HandleTildaModifiers
 281  *
 282  * Handle the ~ modifiers when expanding %0-9 or (%a-z in for command)
 283  *    %~xxxxxV  (V=0-9 or A-Z)
 284  * Where xxxx is any combination of:
 285  *    ~ - Removes quotes
 286  *    f - Fully qualified path (assumes current dir if not drive\dir)
 287  *    d - drive letter
 288  *    p - path
 289  *    n - filename
 290  *    x - file extension
 291  *    s - path with shortnames
 292  *    a - attributes
 293  *    t - date/time
 294  *    z - size
 295  *    $ENVVAR: - Searches ENVVAR for (contents of V) and expands to fully
 296  *                   qualified path
 297  *
 298  *  To work out the length of the modifier:
 299  *
 300  *  Note: In the case of %0-9 knowing the end of the modifier is easy,
 301  *    but in a for loop, the for end WCHARacter may also be a modifier
 302  *    eg. for %a in (c:\a.a) do echo XXX
 303  *             where XXX = %~a    (just ~)
 304  *                         %~aa   (~ and attributes)
 305  *                         %~aaxa (~, attributes and extension)
 306  *                   BUT   %~aax  (~ and attributes followed by 'x')
 307  *
 308  *  Hence search forwards until find an invalid modifier, and then
 309  *  backwards until find for variable or 0-9
 310  */
 311 void WCMD_HandleTildaModifiers(WCHAR **start, WCHAR *forVariable, WCHAR *forValue, BOOL justFors) {
 312
 313 #define NUMMODIFIERS 11
 314   static const WCHAR validmodifiers[NUMMODIFIERS] = {
 315         '~', 'f', 'd', 'p', 'n', 'x', 's', 'a', 't', 'z', '$'
 316   };
 317   static const WCHAR space[] = {' ', '\0'};
 318
 319   WIN32_FILE_ATTRIBUTE_DATA fileInfo;
 320   WCHAR  outputparam[MAX_PATH];
 321   WCHAR  finaloutput[MAX_PATH];
 322   WCHAR  fullfilename[MAX_PATH];
 323   WCHAR  thisoutput[MAX_PATH];
 324   WCHAR  *pos            = *start+1;
 325   WCHAR  *firstModifier  = pos;
 326   WCHAR  *lastModifier   = NULL;
 327   int   modifierLen     = 0;
 328   BOOL  finished        = FALSE;
 329   int   i               = 0;
 330   BOOL  exists          = TRUE;
 331   BOOL  skipFileParsing = FALSE;
 332   BOOL  doneModifier    = FALSE;
 333
 334   /* Search forwards until find invalid character modifier */
 335   while (!finished) {
 336
 337     /* Work on the previous character */
 338     if (lastModifier != NULL) {
 339
 340       for (i=0; i<NUMMODIFIERS; i++) {
 341         if (validmodifiers[i] == *lastModifier) {
 342
 343           /* Special case '$' to skip until : found */
 344           if (*lastModifier == '$') {
 345             while (*pos != ':' && *pos) pos++;
 346             if (*pos == 0x00) return; /* Invalid syntax */
 347             pos++;                    /* Skip ':'       */
 348           }
 349           break;
 350         }
 351       }
 352
 353       if (i==NUMMODIFIERS) {
 354         finished = TRUE;
 355       }
 356     }
 357
 358     /* Save this one away */
 359     if (!finished) {
 360       lastModifier = pos;
 361       pos++;
 362     }
 363   }
 364
 365   while (lastModifier > firstModifier) {
 366     WINE_TRACE("Looking backwards for parameter id: %s / %s\n",
 367                wine_dbgstr_w(lastModifier), wine_dbgstr_w(forVariable));
 368
 369     if (!justFors && context && (*lastModifier >= '0' || *lastModifier <= '9')) {
 370       /* Its a valid parameter identifier - OK */
 371       break;
 372
 373     } else if (forVariable && *lastModifier == *(forVariable+1)) {
 374       /* Its a valid parameter identifier - OK */
 375       break;
 376
 377     } else {
 378       lastModifier--;
 379     }
 380   }
 381   if (lastModifier == firstModifier) return; /* Invalid syntax */
 382
 383   /* Extract the parameter to play with */
 384   if ((*lastModifier >= '0' && *lastModifier <= '9')) {
 385     strcpyW(outputparam, WCMD_parameter (context -> command,
 386                  *lastModifier-'0' + context -> shift_count[*lastModifier-'0'], NULL));
 387   } else {
 388     strcpyW(outputparam, forValue);
 389   }
 390
 391   /* So now, firstModifier points to beginning of modifiers, lastModifier
 392      points to the variable just after the modifiers. Process modifiers
 393      in a specific order, remembering there could be duplicates           */
 394   modifierLen = lastModifier - firstModifier;
 395   finaloutput[0] = 0x00;
 396
 397   /* Useful for debugging purposes: */
 398   /*printf("Modifier string '%*.*s' and variable is %c\n Param starts as '%s'\n",
 399              (modifierLen), (modifierLen), firstModifier, *lastModifier,
 400              outputparam);*/
 401
 402   /* 1. Handle '~' : Strip surrounding quotes */
 403   if (outputparam[0]=='"' &&
 404       memchrW(firstModifier, '~', modifierLen) != NULL) {
 405     int len = strlenW(outputparam);
 406     if (outputparam[len-1] == '"') {
 407         outputparam[len-1]=0x00;
 408         len = len - 1;
 409     }
 410     memmove(outputparam, &outputparam[1], (len * sizeof(WCHAR))-1);
 411   }
 412
 413   /* 2. Handle the special case of a $ */
 414   if (memchrW(firstModifier, '$', modifierLen) != NULL) {
 415     /* Special Case: Search envar specified in $[envvar] for outputparam
 416        Note both $ and : are guaranteed otherwise check above would fail */
 417     WCHAR *start = strchrW(firstModifier, '$') + 1;
 418     WCHAR *end   = strchrW(firstModifier, ':');
 419     WCHAR env[MAX_PATH];
 420     WCHAR fullpath[MAX_PATH];
 421
 422     /* Extract the env var */
 423     memcpy(env, start, (end-start) * sizeof(WCHAR));
 424     env[(end-start)] = 0x00;
 425
 426     /* If env var not found, return empty string */
 427     if ((GetEnvironmentVariable(env, fullpath, MAX_PATH) == 0) ||
 428         (SearchPath(fullpath, outputparam, NULL,
 429                     MAX_PATH, outputparam, NULL) == 0)) {
 430       finaloutput[0] = 0x00;
 431       outputparam[0] = 0x00;
 432       skipFileParsing = TRUE;
 433     }
 434   }
 435
 436   /* After this, we need full information on the file,
 437     which is valid not to exist.  */
 438   if (!skipFileParsing) {
 439     if (GetFullPathName(outputparam, MAX_PATH, fullfilename, NULL) == 0)
 440       return;
 441
 442     exists = GetFileAttributesExW(fullfilename, GetFileExInfoStandard,
 443                                   &fileInfo);
 444
 445     /* 2. Handle 'a' : Output attributes */
 446     if (exists &&
 447         memchrW(firstModifier, 'a', modifierLen) != NULL) {
 448
 449       WCHAR defaults[] = {'-','-','-','-','-','-','-','-','-','\0'};
 450       doneModifier = TRUE;
 451       strcpyW(thisoutput, defaults);
 452       if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 453         thisoutput[0]='d';
 454       if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
 455         thisoutput[1]='r';
 456       if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE)
 457         thisoutput[2]='a';
 458       if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
 459         thisoutput[3]='h';
 460       if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM)
 461         thisoutput[4]='s';
 462       if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED)
 463         thisoutput[5]='c';
 464       /* FIXME: What are 6 and 7? */
 465       if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
 466         thisoutput[8]='l';
 467       strcatW(finaloutput, thisoutput);
 468     }
 469
 470     /* 3. Handle 't' : Date+time */
 471     if (exists &&
 472         memchrW(firstModifier, 't', modifierLen) != NULL) {
 473
 474       SYSTEMTIME systime;
 475       int datelen;
 476
 477       doneModifier = TRUE;
 478       if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
 479
 480       /* Format the time */
 481       FileTimeToSystemTime(&fileInfo.ftLastWriteTime, &systime);
 482       GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &systime,
 483                         NULL, thisoutput, MAX_PATH);
 484       strcatW(thisoutput, space);
 485       datelen = strlenW(thisoutput);
 486       GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &systime,
 487                         NULL, (thisoutput+datelen), MAX_PATH-datelen);
 488       strcatW(finaloutput, thisoutput);
 489     }
 490
 491     /* 4. Handle 'z' : File length */
 492     if (exists &&
 493         memchrW(firstModifier, 'z', modifierLen) != NULL) {
 494       /* FIXME: Output full 64 bit size (sprintf does not support I64 here) */
 495       ULONG/*64*/ fullsize = /*(fileInfo.nFileSizeHigh << 32) +*/
 496                                   fileInfo.nFileSizeLow;
 497       static const WCHAR fmt[] = {'%','u','\0'};
 498
 499       doneModifier = TRUE;
 500       if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
 501       wsprintf(thisoutput, fmt, fullsize);
 502       strcatW(finaloutput, thisoutput);
 503     }
 504
 505     /* 4. Handle 's' : Use short paths (File doesn't have to exist) */
 506     if (memchrW(firstModifier, 's', modifierLen) != NULL) {
 507       if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
 508       /* Don't flag as doneModifier - %~s on its own is processed later */
 509       GetShortPathName(outputparam, outputparam,
 510                        sizeof(outputparam)/sizeof(outputparam[0]));
 511     }
 512
 513     /* 5. Handle 'f' : Fully qualified path (File doesn't have to exist) */
 514     /*      Note this overrides d,p,n,x                                 */
 515     if (memchrW(firstModifier, 'f', modifierLen) != NULL) {
 516       doneModifier = TRUE;
 517       if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
 518       strcatW(finaloutput, fullfilename);
 519     } else {
 520
 521       WCHAR drive[10];
 522       WCHAR dir[MAX_PATH];
 523       WCHAR fname[MAX_PATH];
 524       WCHAR ext[MAX_PATH];
 525       BOOL doneFileModifier = FALSE;
 526
 527       if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
 528
 529       /* Split into components */
 530       WCMD_splitpath(fullfilename, drive, dir, fname, ext);
 531
 532       /* 5. Handle 'd' : Drive Letter */
 533       if (memchrW(firstModifier, 'd', modifierLen) != NULL) {
 534         strcatW(finaloutput, drive);
 535         doneModifier = TRUE;
 536         doneFileModifier = TRUE;
 537       }
 538
 539       /* 6. Handle 'p' : Path */
 540       if (memchrW(firstModifier, 'p', modifierLen) != NULL) {
 541         strcatW(finaloutput, dir);
 542         doneModifier = TRUE;
 543         doneFileModifier = TRUE;
 544       }
 545
 546       /* 7. Handle 'n' : Name */
 547       if (memchrW(firstModifier, 'n', modifierLen) != NULL) {
 548         strcatW(finaloutput, fname);
 549         doneModifier = TRUE;
 550         doneFileModifier = TRUE;
 551       }
 552
 553       /* 8. Handle 'x' : Ext */
 554       if (memchrW(firstModifier, 'x', modifierLen) != NULL) {
 555         strcatW(finaloutput, ext);
 556         doneModifier = TRUE;
 557         doneFileModifier = TRUE;
 558       }
 559
 560       /* If 's' but no other parameter, dump the whole thing */
 561       if (!doneFileModifier &&
 562           memchrW(firstModifier, 's', modifierLen) != NULL) {
 563         doneModifier = TRUE;
 564         if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
 565         strcatW(finaloutput, outputparam);
 566       }
 567     }
 568   }
 569
 570   /* If No other modifier processed,  just add in parameter */
 571   if (!doneModifier) strcpyW(finaloutput, outputparam);
 572
 573   /* Finish by inserting the replacement into the string */
 574   pos = WCMD_strdupW(lastModifier+1);
 575   strcpyW(*start, finaloutput);
 576   strcatW(*start, pos);
 577   free(pos);
 578 }
 579
 580 /*******************************************************************
 581  * WCMD_call - processes a batch call statement
 582  *
 583  *      If there is a leading ':', calls within this batch program
 584  *      otherwise launches another program.
 585  */
 586 void WCMD_call (WCHAR *command) {
 587
 588   /* Run other program if no leading ':' */
 589   if (*command != ':') {
 590     WCMD_run_program(command, 1);
 591   } else {
 592
 593     WCHAR gotoLabel[MAX_PATH];
 594
 595     strcpyW(gotoLabel, param1);
 596
 597     if (context) {
 598
 599       LARGE_INTEGER li;
 600
 601       /* Save the current file position, call the same file,
 602          restore position                                    */
 603       li.QuadPart = 0;
 604       li.u.LowPart = SetFilePointer(context -> h, li.u.LowPart,
 605                      &li.u.HighPart, FILE_CURRENT);
 606
 607       WCMD_batch (param1, command, 1, gotoLabel, context->h);
 608
 609       SetFilePointer(context -> h, li.u.LowPart,
 610                      &li.u.HighPart, FILE_BEGIN);
 611     } else {
 612       WCMD_output_asis( WCMD_LoadMessage(WCMD_CALLINSCRIPT));
 613     }
 614   }
 615 }