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       CharLowerW (string);
  65       if (strstrW (string, extension_batch[i]) == NULL) strcatW (string, extension_batch[i]);
  66       h = CreateFileW (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       CharLowerW (string);
  72       if (strstrW (string, extension_exe) == NULL) strcatW (string, extension_exe);
  73       if (GetFileAttributesW (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       case '\t': /* Treat tabs as spaces */
 154         s++;
 155         break;
 156       case '"':
 157         if (where != NULL && i==n) *where = s;
 158         s++;
 159         while ((*s != '\0') && (*s != '"')) {
 160           *p++ = *s++;
 161         }
 162         if (i == n) {
 163           *p = '\0';
 164           return param;
 165         }
 166         if (*s == '"') s++;
 167           param[0] = '\0';
 168           i++;
 169         p = param;
 170         break;
 171       /* The code to handle bracketed parms is removed because it should no longer
 172          be necessary after the multiline support has been added and the for loop
 173          set of data is now parseable individually. */
 174       case '\0':
 175         return param;
 176       default:
 177         /* Only return where if it is for the right parameter */
 178         if (where != NULL && i==n) *where = s;
 179         while ((*s != '\0') && (*s != ' ') && (*s != ',') && (*s != '=') && (*s != '\t')) {
 180           *p++ = *s++;
 181         }
 182         if (i == n && (p!=param)) {
 183           *p = '\0';
 184           return param;
 185         }
 186         /* Skip double delimiters, eg. dir a.a,,,,,b.b */
 187         if (p != param) {
 188           param[0] = '\0';
 189           i++;
 190         } else {
 191           s++; /* Skip delimiter */
 192         }
 193         p = param;
 194     }
 195   }
 196 }
 197
 198 /****************************************************************************
 199  * WCMD_fgets
 200  *
 201  * Get one line from a batch file. We can't use the native f* functions because
 202  * of the filename syntax differences between DOS and Unix. Also need to lose
 203  * the LF (or CRLF) from the line.
 204  */
 205
 206 WCHAR *WCMD_fgets (WCHAR *s, int noChars, HANDLE h) {
 207
 208   DWORD bytes;
 209   BOOL status;
 210   WCHAR *p;
 211
 212   p = s;
 213   do {
 214     status = WCMD_ReadFile (h, s, 1, &bytes, NULL);
 215     if ((status == 0) || ((bytes == 0) && (s == p))) return NULL;
 216     if (*s == '\n') bytes = 0;
 217     else if (*s != '\r') {
 218       s++;
 219       noChars--;
 220     }
 221     *s = '\0';
 222   } while ((bytes == 1) && (noChars > 1));
 223   return p;
 224 }
 225
 226 /* WCMD_splitpath - copied from winefile as no obvious way to use it otherwise */
 227 void WCMD_splitpath(const WCHAR* path, WCHAR* drv, WCHAR* dir, WCHAR* name, WCHAR* ext)
 228 {
 229         const WCHAR* end; /* end of processed string */
 230         const WCHAR* p;  /* search pointer */
 231         const WCHAR* s;  /* copy pointer */
 232
 233         /* extract drive name */
 234         if (path[0] && path[1]==':') {
 235                 if (drv) {
 236                         *drv++ = *path++;
 237                         *drv++ = *path++;
 238                         *drv = '\0';
 239                 }
 240         } else if (drv)
 241                 *drv = '\0';
 242
 243         /* search for end of string or stream separator */
 244         for(end=path; *end && *end!=':'; )
 245                 end++;
 246
 247         /* search for begin of file extension */
 248         for(p=end; p>path && *--p!='\\' && *p!='/'; )
 249                 if (*p == '.') {
 250                         end = p;
 251                         break;
 252                 }
 253
 254         if (ext)
 255                 for(s=end; (*ext=*s++); )
 256                         ext++;
 257
 258         /* search for end of directory name */
 259         for(p=end; p>path; )
 260                 if (*--p=='\\' || *p=='/') {
 261                         p++;
 262                         break;
 263                 }
 264
 265         if (name) {
 266                 for(s=p; s<end; )
 267                         *name++ = *s++;
 268
 269                 *name = '\0';
 270         }
 271
 272         if (dir) {
 273                 for(s=path; s<p; )
 274                         *dir++ = *s++;
 275
 276                 *dir = '\0';
 277         }
 278 }
 279
 280 /****************************************************************************
 281  * WCMD_HandleTildaModifiers
 282  *
 283  * Handle the ~ modifiers when expanding %0-9 or (%a-z in for command)
 284  *    %~xxxxxV  (V=0-9 or A-Z)
 285  * Where xxxx is any combination of:
 286  *    ~ - Removes quotes
 287  *    f - Fully qualified path (assumes current dir if not drive\dir)
 288  *    d - drive letter
 289  *    p - path
 290  *    n - filename
 291  *    x - file extension
 292  *    s - path with shortnames
 293  *    a - attributes
 294  *    t - date/time
 295  *    z - size
 296  *    $ENVVAR: - Searches ENVVAR for (contents of V) and expands to fully
 297  *                   qualified path
 298  *
 299  *  To work out the length of the modifier:
 300  *
 301  *  Note: In the case of %0-9 knowing the end of the modifier is easy,
 302  *    but in a for loop, the for end WCHARacter may also be a modifier
 303  *    eg. for %a in (c:\a.a) do echo XXX
 304  *             where XXX = %~a    (just ~)
 305  *                         %~aa   (~ and attributes)
 306  *                         %~aaxa (~, attributes and extension)
 307  *                   BUT   %~aax  (~ and attributes followed by 'x')
 308  *
 309  *  Hence search forwards until find an invalid modifier, and then
 310  *  backwards until find for variable or 0-9
 311  */
 312 void WCMD_HandleTildaModifiers(WCHAR **start, WCHAR *forVariable, WCHAR *forValue, BOOL justFors) {
 313
 314 #define NUMMODIFIERS 11
 315   static const WCHAR validmodifiers[NUMMODIFIERS] = {
 316         '~', 'f', 'd', 'p', 'n', 'x', 's', 'a', 't', 'z', '$'
 317   };
 318   static const WCHAR space[] = {' ', '\0'};
 319
 320   WIN32_FILE_ATTRIBUTE_DATA fileInfo;
 321   WCHAR  outputparam[MAX_PATH];
 322   WCHAR  finaloutput[MAX_PATH];
 323   WCHAR  fullfilename[MAX_PATH];
 324   WCHAR  thisoutput[MAX_PATH];
 325   WCHAR  *pos            = *start+1;
 326   WCHAR  *firstModifier  = pos;
 327   WCHAR  *lastModifier   = NULL;
 328   int   modifierLen     = 0;
 329   BOOL  finished        = FALSE;
 330   int   i               = 0;
 331   BOOL  exists          = TRUE;
 332   BOOL  skipFileParsing = FALSE;
 333   BOOL  doneModifier    = FALSE;
 334
 335   /* Search forwards until find invalid character modifier */
 336   while (!finished) {
 337
 338     /* Work on the previous character */
 339     if (lastModifier != NULL) {
 340
 341       for (i=0; i<NUMMODIFIERS; i++) {
 342         if (validmodifiers[i] == *lastModifier) {
 343
 344           /* Special case '$' to skip until : found */
 345           if (*lastModifier == '$') {
 346             while (*pos != ':' && *pos) pos++;
 347             if (*pos == 0x00) return; /* Invalid syntax */
 348             pos++;                    /* Skip ':'       */
 349           }
 350           break;
 351         }
 352       }
 353
 354       if (i==NUMMODIFIERS) {
 355         finished = TRUE;
 356       }
 357     }
 358
 359     /* Save this one away */
 360     if (!finished) {
 361       lastModifier = pos;
 362       pos++;
 363     }
 364   }
 365
 366   while (lastModifier > firstModifier) {
 367     WINE_TRACE("Looking backwards for parameter id: %s / %s\n",
 368                wine_dbgstr_w(lastModifier), wine_dbgstr_w(forVariable));
 369
 370     if (!justFors && context && (*lastModifier >= '0' && *lastModifier <= '9')) {
 371       /* Its a valid parameter identifier - OK */
 372       break;
 373
 374     } else if (forVariable && *lastModifier == *(forVariable+1)) {
 375       /* Its a valid parameter identifier - OK */
 376       break;
 377
 378     } else {
 379       lastModifier--;
 380     }
 381   }
 382   if (lastModifier == firstModifier) return; /* Invalid syntax */
 383
 384   /* Extract the parameter to play with */
 385   if ((*lastModifier >= '0' && *lastModifier <= '9')) {
 386     strcpyW(outputparam, WCMD_parameter (context -> command,
 387                  *lastModifier-'0' + context -> shift_count[*lastModifier-'0'], NULL));
 388   } else {
 389     strcpyW(outputparam, forValue);
 390   }
 391
 392   /* So now, firstModifier points to beginning of modifiers, lastModifier
 393      points to the variable just after the modifiers. Process modifiers
 394      in a specific order, remembering there could be duplicates           */
 395   modifierLen = lastModifier - firstModifier;
 396   finaloutput[0] = 0x00;
 397
 398   /* Useful for debugging purposes: */
 399   /*printf("Modifier string '%*.*s' and variable is %c\n Param starts as '%s'\n",
 400              (modifierLen), (modifierLen), firstModifier, *lastModifier,
 401              outputparam);*/
 402
 403   /* 1. Handle '~' : Strip surrounding quotes */
 404   if (outputparam[0]=='"' &&
 405       memchrW(firstModifier, '~', modifierLen) != NULL) {
 406     int len = strlenW(outputparam);
 407     if (outputparam[len-1] == '"') {
 408         outputparam[len-1]=0x00;
 409         len = len - 1;
 410     }
 411     memmove(outputparam, &outputparam[1], (len * sizeof(WCHAR))-1);
 412   }
 413
 414   /* 2. Handle the special case of a $ */
 415   if (memchrW(firstModifier, '$', modifierLen) != NULL) {
 416     /* Special Case: Search envar specified in $[envvar] for outputparam
 417        Note both $ and : are guaranteed otherwise check above would fail */
 418     WCHAR *start = strchrW(firstModifier, '$') + 1;
 419     WCHAR *end   = strchrW(firstModifier, ':');
 420     WCHAR env[MAX_PATH];
 421     WCHAR fullpath[MAX_PATH];
 422
 423     /* Extract the env var */
 424     memcpy(env, start, (end-start) * sizeof(WCHAR));
 425     env[(end-start)] = 0x00;
 426
 427     /* If env var not found, return empty string */
 428     if ((GetEnvironmentVariableW(env, fullpath, MAX_PATH) == 0) ||
 429         (SearchPathW(fullpath, outputparam, NULL, 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 (GetFullPathNameW(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       GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &systime,
 483                         NULL, thisoutput, MAX_PATH);
 484       strcatW(thisoutput, space);
 485       datelen = strlenW(thisoutput);
 486       GetTimeFormatW(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       wsprintfW(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       GetShortPathNameW(outputparam, outputparam, sizeof(outputparam)/sizeof(outputparam[0]));
 510     }
 511
 512     /* 5. Handle 'f' : Fully qualified path (File doesn't have to exist) */
 513     /*      Note this overrides d,p,n,x                                 */
 514     if (memchrW(firstModifier, 'f', modifierLen) != NULL) {
 515       doneModifier = TRUE;
 516       if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
 517       strcatW(finaloutput, fullfilename);
 518     } else {
 519
 520       WCHAR drive[10];
 521       WCHAR dir[MAX_PATH];
 522       WCHAR fname[MAX_PATH];
 523       WCHAR ext[MAX_PATH];
 524       BOOL doneFileModifier = FALSE;
 525
 526       if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
 527
 528       /* Split into components */
 529       WCMD_splitpath(fullfilename, drive, dir, fname, ext);
 530
 531       /* 5. Handle 'd' : Drive Letter */
 532       if (memchrW(firstModifier, 'd', modifierLen) != NULL) {
 533         strcatW(finaloutput, drive);
 534         doneModifier = TRUE;
 535         doneFileModifier = TRUE;
 536       }
 537
 538       /* 6. Handle 'p' : Path */
 539       if (memchrW(firstModifier, 'p', modifierLen) != NULL) {
 540         strcatW(finaloutput, dir);
 541         doneModifier = TRUE;
 542         doneFileModifier = TRUE;
 543       }
 544
 545       /* 7. Handle 'n' : Name */
 546       if (memchrW(firstModifier, 'n', modifierLen) != NULL) {
 547         strcatW(finaloutput, fname);
 548         doneModifier = TRUE;
 549         doneFileModifier = TRUE;
 550       }
 551
 552       /* 8. Handle 'x' : Ext */
 553       if (memchrW(firstModifier, 'x', modifierLen) != NULL) {
 554         strcatW(finaloutput, ext);
 555         doneModifier = TRUE;
 556         doneFileModifier = TRUE;
 557       }
 558
 559       /* If 's' but no other parameter, dump the whole thing */
 560       if (!doneFileModifier &&
 561           memchrW(firstModifier, 's', modifierLen) != NULL) {
 562         doneModifier = TRUE;
 563         if (finaloutput[0] != 0x00) strcatW(finaloutput, space);
 564         strcatW(finaloutput, outputparam);
 565       }
 566     }
 567   }
 568
 569   /* If No other modifier processed,  just add in parameter */
 570   if (!doneModifier) strcpyW(finaloutput, outputparam);
 571
 572   /* Finish by inserting the replacement into the string */
 573   WCMD_strsubstW(*start, lastModifier+1, finaloutput, -1);
 574 }
 575
 576 /*******************************************************************
 577  * WCMD_call - processes a batch call statement
 578  *
 579  *      If there is a leading ':', calls within this batch program
 580  *      otherwise launches another program.
 581  */
 582 void WCMD_call (WCHAR *command) {
 583
 584   /* Run other program if no leading ':' */
 585   if (*command != ':') {
 586     WCMD_run_program(command, 1);
 587   } else {
 588
 589     WCHAR gotoLabel[MAX_PATH];
 590
 591     strcpyW(gotoLabel, param1);
 592
 593     if (context) {
 594
 595       LARGE_INTEGER li;
 596
 597       /* Save the current file position, call the same file,
 598          restore position                                    */
 599       li.QuadPart = 0;
 600       li.u.LowPart = SetFilePointer(context -> h, li.u.LowPart,
 601                      &li.u.HighPart, FILE_CURRENT);
 602
 603       WCMD_batch (param1, command, 1, gotoLabel, context->h);
 604
 605       SetFilePointer(context -> h, li.u.LowPart,
 606                      &li.u.HighPart, FILE_BEGIN);
 607     } else {
 608       WCMD_output_asis( WCMD_LoadMessage(WCMD_CALLINSCRIPT));
 609     }
 610   }
 611 }