programs/cmd/builtins.c

   1 /*
   2  * CMD - Wine-compatible command line interface - built-in functions.
   3  *
   4  * Copyright (C) 1999 D A Pickles
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 /*
  22  * NOTES:
  23  * On entry to each function, global variables quals, param1, param2 contain
  24  * the qualifiers (uppercased and concatenated) and parameters entered, with
  25  * environment-variable and batch parameter substitution already done.
  26  */
  27
  28 /*
  29  * FIXME:
  30  * - No support for pipes, shell parameters
  31  * - Lots of functionality missing from builtins
  32  * - Messages etc need international support
  33  */
  34
  35 #define WIN32_LEAN_AND_MEAN
  36
  37 #include "wcmd.h"
  38 #include <shellapi.h>
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(cmd);
  42
  43 void WCMD_execute (char *orig_command, char *parameter, char *substitution);
  44
  45 struct env_stack *saved_environment;
  46 struct env_stack *pushd_directories;
  47
  48 extern HINSTANCE hinst;
  49 extern char *inbuilt[];
  50 extern int echo_mode, verify_mode;
  51 extern char quals[MAX_PATH], param1[MAX_PATH], param2[MAX_PATH];
  52 extern BATCH_CONTEXT *context;
  53 extern DWORD errorlevel;
  54
  55
  56
  57 /****************************************************************************
  58  * WCMD_clear_screen
  59  *
  60  * Clear the terminal screen.
  61  */
  62
  63 void WCMD_clear_screen (void) {
  64
  65   /* Emulate by filling the screen from the top left to bottom right with
  66         spaces, then moving the cursor to the top left afterwards */
  67   CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
  68   HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
  69
  70   if (GetConsoleScreenBufferInfo(hStdOut, &consoleInfo))
  71   {
  72       COORD topLeft;
  73       DWORD screenSize;
  74
  75       screenSize = consoleInfo.dwSize.X * (consoleInfo.dwSize.Y + 1);
  76
  77       topLeft.X = 0;
  78       topLeft.Y = 0;
  79       FillConsoleOutputCharacter(hStdOut, ' ', screenSize, topLeft, &screenSize);
  80       SetConsoleCursorPosition(hStdOut, topLeft);
  81   }
  82 }
  83
  84 /****************************************************************************
  85  * WCMD_change_tty
  86  *
  87  * Change the default i/o device (ie redirect STDin/STDout).
  88  */
  89
  90 void WCMD_change_tty (void) {
  91
  92   WCMD_output (nyi);
  93
  94 }
  95
  96 /****************************************************************************
  97  * WCMD_copy
  98  *
  99  * Copy a file or wildcarded set.
 100  * FIXME: No wildcard support
 101  */
 102
 103 void WCMD_copy (void) {
 104
 105   DWORD count;
 106   WIN32_FIND_DATA fd;
 107   HANDLE hff;
 108   BOOL force, status;
 109   static const char overwrite[] = "Overwrite file (Y/N)?";
 110   char string[8], outpath[MAX_PATH], inpath[MAX_PATH], *infile, copycmd[3];
 111   DWORD len;
 112
 113   if (param1[0] == 0x00) {
 114     WCMD_output ("Argument missing\n");
 115     return;
 116   }
 117
 118   if ((strchr(param1,'*') != NULL) && (strchr(param1,'%') != NULL)) {
 119     WCMD_output ("Wildcards not yet supported\n");
 120     return;
 121   }
 122
 123   /* If no destination supplied, assume current directory */
 124   if (param2[0] == 0x00) {
 125       strcpy(param2, ".");
 126   }
 127
 128   GetFullPathName (param2, sizeof(outpath), outpath, NULL);
 129   if (outpath[strlen(outpath) - 1] == '\\')
 130       outpath[strlen(outpath) - 1] = '\0';
 131   hff = FindFirstFile (outpath, &fd);
 132   if (hff != INVALID_HANDLE_VALUE) {
 133     if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
 134       GetFullPathName (param1, sizeof(inpath), inpath, &infile);
 135       strcat (outpath, "\\");
 136       strcat (outpath, infile);
 137     }
 138     FindClose (hff);
 139   }
 140
 141   /* /-Y has the highest priority, then /Y and finally the COPYCMD env. variable */
 142   if (strstr (quals, "/-Y"))
 143     force = FALSE;
 144   else if (strstr (quals, "/Y"))
 145     force = TRUE;
 146   else {
 147     len = GetEnvironmentVariable ("COPYCMD", copycmd, sizeof(copycmd));
 148     force = (len && len < sizeof(copycmd) && ! lstrcmpi (copycmd, "/Y"));
 149   }
 150
 151   if (!force) {
 152     hff = FindFirstFile (outpath, &fd);
 153     if (hff != INVALID_HANDLE_VALUE) {
 154       FindClose (hff);
 155       WCMD_output (overwrite);
 156       ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
 157       if (toupper(string[0]) == 'Y') force = TRUE;
 158     }
 159     else force = TRUE;
 160   }
 161   if (force) {
 162     status = CopyFile (param1, outpath, FALSE);
 163     if (!status) WCMD_print_error ();
 164   }
 165 }
 166
 167 /****************************************************************************
 168  * WCMD_create_dir
 169  *
 170  * Create a directory.
 171  *
 172  * this works recursivly. so mkdir dir1\dir2\dir3 will create dir1 and dir2 if
 173  * they do not already exist.
 174  */
 175
 176 BOOL create_full_path(CHAR* path)
 177 {
 178     int len;
 179     CHAR *new_path;
 180     BOOL ret = TRUE;
 181
 182     new_path = HeapAlloc(GetProcessHeap(),0,strlen(path)+1);
 183     strcpy(new_path,path);
 184
 185     while ((len = strlen(new_path)) && new_path[len - 1] == '\\')
 186         new_path[len - 1] = 0;
 187
 188     while (!CreateDirectory(new_path,NULL))
 189     {
 190         CHAR *slash;
 191         DWORD last_error = GetLastError();
 192         if (last_error == ERROR_ALREADY_EXISTS)
 193             break;
 194
 195         if (last_error != ERROR_PATH_NOT_FOUND)
 196         {
 197             ret = FALSE;
 198             break;
 199         }
 200
 201         if (!(slash = strrchr(new_path,'\\')) && ! (slash = strrchr(new_path,'/')))
 202         {
 203             ret = FALSE;
 204             break;
 205         }
 206
 207         len = slash - new_path;
 208         new_path[len] = 0;
 209         if (!create_full_path(new_path))
 210         {
 211             ret = FALSE;
 212             break;
 213         }
 214         new_path[len] = '\\';
 215     }
 216     HeapFree(GetProcessHeap(),0,new_path);
 217     return ret;
 218 }
 219
 220 void WCMD_create_dir (void) {
 221
 222     if (param1[0] == 0x00) {
 223         WCMD_output ("Argument missing\n");
 224         return;
 225     }
 226     if (!create_full_path(param1)) WCMD_print_error ();
 227 }
 228
 229 /****************************************************************************
 230  * WCMD_delete
 231  *
 232  * Delete a file or wildcarded set.
 233  *
 234  * Note on /A:
 235  *  - Testing shows /A is repeatable, eg. /a-r /ar matches all files
 236  *  - Each set is a pattern, eg /ahr /as-r means
 237  *         readonly+hidden OR nonreadonly system files
 238  *  - The '-' applies to a single field, ie /a:-hr means read only
 239  *         non-hidden files
 240  */
 241
 242 void WCMD_delete (char *command) {
 243
 244     int   argno         = 0;
 245     int   argsProcessed = 0;
 246     char *argN          = command;
 247
 248     /* Loop through all args */
 249     while (argN) {
 250       char *thisArg = WCMD_parameter (command, argno++, &argN);
 251       if (argN && argN[0] != '/') {
 252
 253         WIN32_FIND_DATA fd;
 254         HANDLE hff;
 255         char fpath[MAX_PATH];
 256         char *p;
 257
 258
 259         WINE_TRACE("del: Processing arg %s (quals:%s)\n", thisArg, quals);
 260         argsProcessed++;
 261
 262         /* If filename part of parameter is * or *.*, prompt unless
 263            /Q supplied.                                            */
 264         if ((strstr (quals, "/Q") == NULL) && (strstr (quals, "/P") == NULL)) {
 265
 266           char drive[10];
 267           char dir[MAX_PATH];
 268           char fname[MAX_PATH];
 269           char ext[MAX_PATH];
 270
 271           /* Convert path into actual directory spec */
 272           GetFullPathName (thisArg, sizeof(fpath), fpath, NULL);
 273           WCMD_splitpath(fpath, drive, dir, fname, ext);
 274
 275           /* Only prompt for * and *.*, not *a, a*, *.a* etc */
 276           if ((strcmp(fname, "*") == 0) &&
 277               (*ext == 0x00 || (strcmp(ext, ".*") == 0))) {
 278             BOOL  ok;
 279             char  question[MAXSTRING];
 280
 281             /* Ask for confirmation */
 282             sprintf(question, "%s, ", fpath);
 283             ok = WCMD_ask_confirm(question, TRUE);
 284
 285             /* Abort if answer is 'N' */
 286             if (!ok) continue;
 287           }
 288         }
 289
 290         hff = FindFirstFile (thisArg, &fd);
 291         if (hff == INVALID_HANDLE_VALUE) {
 292           WCMD_output ("%s :File Not Found\n", thisArg);
 293           continue;
 294         }
 295         /* Support del <dirname> by just deleting all files dirname\* */
 296         if ((strchr(thisArg,'*') == NULL) && (strchr(thisArg,'?') == NULL)
 297                 && (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
 298           char modifiedParm[MAX_PATH];
 299           strcpy(modifiedParm, thisArg);
 300           strcat(modifiedParm, "\\*");
 301           FindClose(hff);
 302           WCMD_delete(modifiedParm);
 303           continue;
 304
 305         } else {
 306
 307           /* Build the filename to delete as <supplied directory>\<findfirst filename> */
 308           strcpy (fpath, thisArg);
 309           do {
 310             p = strrchr (fpath, '\\');
 311             if (p != NULL) {
 312               *++p = '\0';
 313               strcat (fpath, fd.cFileName);
 314             }
 315             else strcpy (fpath, fd.cFileName);
 316             if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
 317               BOOL  ok = TRUE;
 318               char *nextA = strstr (quals, "/A");
 319
 320               /* Handle attribute matching (/A) */
 321               if (nextA != NULL) {
 322                 ok = FALSE;
 323                 while (nextA != NULL && !ok) {
 324
 325                   char *thisA = (nextA+2);
 326                   BOOL  stillOK = TRUE;
 327
 328                   /* Skip optional : */
 329                   if (*thisA == ':') thisA++;
 330
 331                   /* Parse each of the /A[:]xxx in turn */
 332                   while (*thisA && *thisA != '/') {
 333                     BOOL negate    = FALSE;
 334                     BOOL attribute = FALSE;
 335
 336                     /* Match negation of attribute first */
 337                     if (*thisA == '-') {
 338                       negate=TRUE;
 339                       thisA++;
 340                     }
 341
 342                     /* Match attribute */
 343                     switch (*thisA) {
 344                     case 'R': attribute = (fd.dwFileAttributes & FILE_ATTRIBUTE_READONLY);
 345                               break;
 346                     case 'H': attribute = (fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN);
 347                               break;
 348                     case 'S': attribute = (fd.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM);
 349                               break;
 350                     case 'A': attribute = (fd.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE);
 351                               break;
 352                     default:
 353                         WCMD_output ("Syntax error\n");
 354                     }
 355
 356                     /* Now check result, keeping a running boolean about whether it
 357                        matches all parsed attribues so far                         */
 358                     if (attribute && !negate) {
 359                         stillOK = stillOK;
 360                     } else if (!attribute && negate) {
 361                         stillOK = stillOK;
 362                     } else {
 363                         stillOK = FALSE;
 364                     }
 365                     thisA++;
 366                   }
 367
 368                   /* Save the running total as the final result */
 369                   ok = stillOK;
 370
 371                   /* Step on to next /A set */
 372                   nextA = strstr (nextA+1, "/A");
 373                 }
 374               }
 375
 376               /* /P means prompt for each file */
 377               if (ok && strstr (quals, "/P") != NULL) {
 378                 char  question[MAXSTRING];
 379
 380                 /* Ask for confirmation */
 381                 sprintf(question, "%s, Delete", fpath);
 382                 ok = WCMD_ask_confirm(question, FALSE);
 383               }
 384
 385               /* Only proceed if ok to */
 386               if (ok) {
 387
 388                 /* If file is read only, and /F supplied, delete it */
 389                 if (fd.dwFileAttributes & FILE_ATTRIBUTE_READONLY &&
 390                     strstr (quals, "/F") != NULL) {
 391                     SetFileAttributes(fpath, fd.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY);
 392                 }
 393
 394                 /* Now do the delete */
 395                 if (!DeleteFile (fpath)) WCMD_print_error ();
 396               }
 397
 398             }
 399           } while (FindNextFile(hff, &fd) != 0);
 400           FindClose (hff);
 401         }
 402       }
 403     }
 404
 405     /* Handle no valid args */
 406     if (argsProcessed == 0) {
 407       WCMD_output ("Argument missing\n");
 408       return;
 409     }
 410 }
 411
 412 /****************************************************************************
 413  * WCMD_echo
 414  *
 415  * Echo input to the screen (or not). We don't try to emulate the bugs
 416  * in DOS (try typing "ECHO ON AGAIN" for an example).
 417  */
 418
 419 void WCMD_echo (const char *command) {
 420
 421   static const char eon[] = "Echo is ON\n", eoff[] = "Echo is OFF\n";
 422   int count;
 423
 424   if ((command[0] == '.') && (command[1] == 0)) {
 425     WCMD_output (newline);
 426     return;
 427   }
 428   if (command[0]==' ')
 429     command++;
 430   count = strlen(command);
 431   if (count == 0) {
 432     if (echo_mode) WCMD_output (eon);
 433     else WCMD_output (eoff);
 434     return;
 435   }
 436   if (lstrcmpi(command, "ON") == 0) {
 437     echo_mode = 1;
 438     return;
 439   }
 440   if (lstrcmpi(command, "OFF") == 0) {
 441     echo_mode = 0;
 442     return;
 443   }
 444   WCMD_output_asis (command);
 445   WCMD_output (newline);
 446
 447 }
 448
 449 /**************************************************************************
 450  * WCMD_for
 451  *
 452  * Batch file loop processing.
 453  * FIXME: We don't exhaustively check syntax. Any command which works in MessDOS
 454  * will probably work here, but the reverse is not necessarily the case...
 455  */
 456
 457 void WCMD_for (char *p) {
 458
 459   WIN32_FIND_DATA fd;
 460   HANDLE hff;
 461   char *cmd, *item;
 462   char set[MAX_PATH], param[MAX_PATH];
 463   int i;
 464
 465   if (lstrcmpi (WCMD_parameter (p, 1, NULL), "in")
 466         || lstrcmpi (WCMD_parameter (p, 3, NULL), "do")
 467         || (param1[0] != '%')) {
 468     WCMD_output ("Syntax error\n");
 469     return;
 470   }
 471   lstrcpyn (set, WCMD_parameter (p, 2, NULL), sizeof(set));
 472   WCMD_parameter (p, 4, &cmd);
 473   lstrcpy (param, param1);
 474
 475 /*
 476  *      If the parameter within the set has a wildcard then search for matching files
 477  *      otherwise do a literal substitution.
 478  */
 479
 480   i = 0;
 481   while (*(item = WCMD_parameter (set, i, NULL))) {
 482     if (strpbrk (item, "*?")) {
 483       hff = FindFirstFile (item, &fd);
 484       if (hff == INVALID_HANDLE_VALUE) {
 485         return;
 486       }
 487       do {
 488         WCMD_execute (cmd, param, fd.cFileName);
 489       } while (FindNextFile(hff, &fd) != 0);
 490       FindClose (hff);
 491 }
 492     else {
 493       WCMD_execute (cmd, param, item);
 494     }
 495     i++;
 496   }
 497 }
 498
 499 /*****************************************************************************
 500  * WCMD_Execute
 501  *
 502  *      Execute a command after substituting variable text for the supplied parameter
 503  */
 504
 505 void WCMD_execute (char *orig_cmd, char *param, char *subst) {
 506
 507   char *new_cmd, *p, *s, *dup;
 508   int size;
 509
 510   size = lstrlen (orig_cmd);
 511   new_cmd = (char *) LocalAlloc (LMEM_FIXED | LMEM_ZEROINIT, size);
 512   dup = s = strdup (orig_cmd);
 513
 514   while ((p = strstr (s, param))) {
 515     *p = '\0';
 516     size += lstrlen (subst);
 517     new_cmd = (char *) LocalReAlloc ((HANDLE)new_cmd, size, 0);
 518     strcat (new_cmd, s);
 519     strcat (new_cmd, subst);
 520     s = p + lstrlen (param);
 521   }
 522   strcat (new_cmd, s);
 523   WCMD_process_command (new_cmd);
 524   free (dup);
 525   LocalFree ((HANDLE)new_cmd);
 526 }
 527
 528
 529 /**************************************************************************
 530  * WCMD_give_help
 531  *
 532  *      Simple on-line help. Help text is stored in the resource file.
 533  */
 534
 535 void WCMD_give_help (char *command) {
 536
 537   int i;
 538   char buffer[2048];
 539
 540   command = WCMD_strtrim_leading_spaces(command);
 541   if (lstrlen(command) == 0) {
 542     LoadString (hinst, 1000, buffer, sizeof(buffer));
 543     WCMD_output_asis (buffer);
 544   }
 545   else {
 546     for (i=0; i<=WCMD_EXIT; i++) {
 547       if (CompareString (LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
 548           param1, -1, inbuilt[i], -1) == 2) {
 549         LoadString (hinst, i, buffer, sizeof(buffer));
 550         WCMD_output_asis (buffer);
 551         return;
 552       }
 553     }
 554     WCMD_output ("No help available for %s\n", param1);
 555   }
 556   return;
 557 }
 558
 559 /****************************************************************************
 560  * WCMD_go_to
 561  *
 562  * Batch file jump instruction. Not the most efficient algorithm ;-)
 563  * Prints error message if the specified label cannot be found - the file pointer is
 564  * then at EOF, effectively stopping the batch file.
 565  * FIXME: DOS is supposed to allow labels with spaces - we don't.
 566  */
 567
 568 void WCMD_goto (void) {
 569
 570   char string[MAX_PATH];
 571
 572   if (param1[0] == 0x00) {
 573     WCMD_output ("Argument missing\n");
 574     return;
 575   }
 576   if (context != NULL) {
 577     char *paramStart = param1;
 578
 579     /* Handle special :EOF label */
 580     if (lstrcmpi (":eof", param1) == 0) {
 581       context -> skip_rest = TRUE;
 582       return;
 583     }
 584
 585     /* Support goto :label as well as goto label */
 586     if (*paramStart == ':') paramStart++;
 587
 588     SetFilePointer (context -> h, 0, NULL, FILE_BEGIN);
 589     while (WCMD_fgets (string, sizeof(string), context -> h)) {
 590       if ((string[0] == ':') && (lstrcmpi (&string[1], paramStart) == 0)) return;
 591     }
 592     WCMD_output ("Target to GOTO not found\n");
 593   }
 594   return;
 595 }
 596
 597 /*****************************************************************************
 598  * WCMD_pushd
 599  *
 600  *      Push a directory onto the stack
 601  */
 602
 603 void WCMD_pushd (void) {
 604     struct env_stack *curdir;
 605     BOOL   status;
 606     WCHAR *thisdir;
 607
 608     curdir  = LocalAlloc (LMEM_FIXED, sizeof (struct env_stack));
 609     thisdir = LocalAlloc (LMEM_FIXED, 1024 * sizeof(WCHAR));
 610     if( !curdir || !thisdir ) {
 611       LocalFree(curdir);
 612       LocalFree(thisdir);
 613       WCMD_output ("out of memory\n");
 614       return;
 615     }
 616
 617     GetCurrentDirectoryW (1024, thisdir);
 618     status = SetCurrentDirectoryA (param1);
 619     if (!status) {
 620       WCMD_print_error ();
 621       LocalFree(curdir);
 622       LocalFree(thisdir);
 623       return;
 624     } else {
 625       curdir -> next    = pushd_directories;
 626       curdir -> strings = thisdir;
 627       if (pushd_directories == NULL) {
 628         curdir -> stackdepth = 1;
 629       } else {
 630         curdir -> stackdepth = pushd_directories -> stackdepth + 1;
 631       }
 632       pushd_directories = curdir;
 633     }
 634 }
 635
 636
 637 /*****************************************************************************
 638  * WCMD_popd
 639  *
 640  *      Pop a directory from the stack
 641  */
 642
 643 void WCMD_popd (void) {
 644     struct env_stack *temp = pushd_directories;
 645
 646     if (!pushd_directories)
 647       return;
 648
 649     /* pop the old environment from the stack, and make it the current dir */
 650     pushd_directories = temp->next;
 651     SetCurrentDirectoryW(temp->strings);
 652     LocalFree (temp->strings);
 653     LocalFree (temp);
 654 }
 655
 656 /****************************************************************************
 657  * WCMD_if
 658  *
 659  * Batch file conditional.
 660  * FIXME: Much more syntax checking needed!
 661  */
 662
 663 void WCMD_if (char *p) {
 664
 665   int negate = 0, test = 0;
 666   char condition[MAX_PATH], *command, *s;
 667
 668   if (!lstrcmpi (param1, "not")) {
 669     negate = 1;
 670     lstrcpy (condition, param2);
 671   }
 672   else {
 673     lstrcpy (condition, param1);
 674   }
 675   if (!lstrcmpi (condition, "errorlevel")) {
 676     if (errorlevel >= atoi(WCMD_parameter (p, 1+negate, NULL))) test = 1;
 677     WCMD_parameter (p, 2+negate, &command);
 678   }
 679   else if (!lstrcmpi (condition, "exist")) {
 680     if (GetFileAttributesA(WCMD_parameter (p, 1+negate, NULL)) != INVALID_FILE_ATTRIBUTES) {
 681         test = 1;
 682     }
 683     WCMD_parameter (p, 2+negate, &command);
 684   }
 685   else if (!lstrcmpi (condition, "defined")) {
 686     if (GetEnvironmentVariableA(WCMD_parameter (p, 1+negate, NULL), NULL, 0) > 0) {
 687         test = 1;
 688     }
 689     WCMD_parameter (p, 2+negate, &command);
 690   }
 691   else if ((s = strstr (p, "=="))) {
 692     s += 2;
 693     if (!lstrcmpi (condition, WCMD_parameter (s, 0, NULL))) test = 1;
 694     WCMD_parameter (s, 1, &command);
 695   }
 696   else {
 697     WCMD_output ("Syntax error\n");
 698     return;
 699   }
 700   if (test != negate) {
 701     command = strdup (command);
 702     WCMD_process_command (command);
 703     free (command);
 704   }
 705 }
 706
 707 /****************************************************************************
 708  * WCMD_move
 709  *
 710  * Move a file, directory tree or wildcarded set of files.
 711  * FIXME: Needs input and output files to be fully specified.
 712  */
 713
 714 void WCMD_move (void) {
 715
 716   int status;
 717   char outpath[MAX_PATH], inpath[MAX_PATH], *infile;
 718   WIN32_FIND_DATA fd;
 719   HANDLE hff;
 720
 721   if (param1[0] == 0x00) {
 722     WCMD_output ("Argument missing\n");
 723     return;
 724   }
 725
 726   if ((strchr(param1,'*') != NULL) || (strchr(param1,'%') != NULL)) {
 727     WCMD_output ("Wildcards not yet supported\n");
 728     return;
 729   }
 730
 731   /* If no destination supplied, assume current directory */
 732   if (param2[0] == 0x00) {
 733       strcpy(param2, ".");
 734   }
 735
 736   /* If 2nd parm is directory, then use original filename */
 737   GetFullPathName (param2, sizeof(outpath), outpath, NULL);
 738   if (outpath[strlen(outpath) - 1] == '\\')
 739       outpath[strlen(outpath) - 1] = '\0';
 740   hff = FindFirstFile (outpath, &fd);
 741   if (hff != INVALID_HANDLE_VALUE) {
 742     if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
 743       GetFullPathName (param1, sizeof(inpath), inpath, &infile);
 744       strcat (outpath, "\\");
 745       strcat (outpath, infile);
 746     }
 747     FindClose (hff);
 748   }
 749
 750   status = MoveFile (param1, outpath);
 751   if (!status) WCMD_print_error ();
 752 }
 753
 754 /****************************************************************************
 755  * WCMD_pause
 756  *
 757  * Wait for keyboard input.
 758  */
 759
 760 void WCMD_pause (void) {
 761
 762   DWORD count;
 763   char string[32];
 764
 765   WCMD_output (anykey);
 766   ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
 767 }
 768
 769 /****************************************************************************
 770  * WCMD_remove_dir
 771  *
 772  * Delete a directory.
 773  */
 774
 775 void WCMD_remove_dir (char *command) {
 776
 777   int   argno         = 0;
 778   int   argsProcessed = 0;
 779   char *argN          = command;
 780
 781   /* Loop through all args */
 782   while (argN) {
 783     char *thisArg = WCMD_parameter (command, argno++, &argN);
 784     if (argN && argN[0] != '/') {
 785       WINE_TRACE("rd: Processing arg %s (quals:%s)\n", thisArg, quals);
 786       argsProcessed++;
 787
 788       /* If subdirectory search not supplied, just try to remove
 789          and report error if it fails (eg if it contains a file) */
 790       if (strstr (quals, "/S") == NULL) {
 791         if (!RemoveDirectory (thisArg)) WCMD_print_error ();
 792
 793       /* Otherwise use ShFileOp to recursively remove a directory */
 794       } else {
 795
 796         SHFILEOPSTRUCT lpDir;
 797
 798         /* Ask first */
 799         if (strstr (quals, "/Q") == NULL) {
 800           BOOL  ok;
 801           char  question[MAXSTRING];
 802
 803           /* Ask for confirmation */
 804           sprintf(question, "%s, ", thisArg);
 805           ok = WCMD_ask_confirm(question, TRUE);
 806
 807           /* Abort if answer is 'N' */
 808           if (!ok) return;
 809         }
 810
 811         /* Do the delete */
 812         lpDir.hwnd   = NULL;
 813         lpDir.pTo    = NULL;
 814         lpDir.pFrom  = thisArg;
 815         lpDir.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI;
 816         lpDir.wFunc  = FO_DELETE;
 817         if (SHFileOperationA(&lpDir)) WCMD_print_error ();
 818       }
 819     }
 820   }
 821
 822   /* Handle no valid args */
 823   if (argsProcessed == 0) {
 824     WCMD_output ("Argument missing\n");
 825     return;
 826   }
 827
 828 }
 829
 830 /****************************************************************************
 831  * WCMD_rename
 832  *
 833  * Rename a file.
 834  * FIXME: Needs input and output files to be fully specified.
 835  */
 836
 837 void WCMD_rename (void) {
 838
 839   int status;
 840
 841   if (param1[0] == 0x00 || param2[0] == 0x00) {
 842     WCMD_output ("Argument missing\n");
 843     return;
 844   }
 845   if ((strchr(param1,'*') != NULL) || (strchr(param1,'%') != NULL)) {
 846     WCMD_output ("Wildcards not yet supported\n");
 847     return;
 848   }
 849   status = MoveFile (param1, param2);
 850   if (!status) WCMD_print_error ();
 851 }
 852
 853 /*****************************************************************************
 854  * WCMD_dupenv
 855  *
 856  * Make a copy of the environment.
 857  */
 858 static WCHAR *WCMD_dupenv( const WCHAR *env )
 859 {
 860   WCHAR *env_copy;
 861   int len;
 862
 863   if( !env )
 864     return NULL;
 865
 866   len = 0;
 867   while ( env[len] )
 868     len += (lstrlenW(&env[len]) + 1);
 869
 870   env_copy = LocalAlloc (LMEM_FIXED, (len+1) * sizeof (WCHAR) );
 871   if (!env_copy)
 872   {
 873     WCMD_output ("out of memory\n");
 874     return env_copy;
 875   }
 876   memcpy (env_copy, env, len*sizeof (WCHAR));
 877   env_copy[len] = 0;
 878
 879   return env_copy;
 880 }
 881
 882 /*****************************************************************************
 883  * WCMD_setlocal
 884  *
 885  *  setlocal pushes the environment onto a stack
 886  *  Save the environment as unicode so we don't screw anything up.
 887  */
 888 void WCMD_setlocal (const char *s) {
 889   WCHAR *env;
 890   struct env_stack *env_copy;
 891
 892   /* DISABLEEXTENSIONS ignored */
 893
 894   env_copy = LocalAlloc (LMEM_FIXED, sizeof (struct env_stack));
 895   if( !env_copy )
 896   {
 897     WCMD_output ("out of memory\n");
 898     return;
 899   }
 900
 901   env = GetEnvironmentStringsW ();
 902
 903   env_copy->strings = WCMD_dupenv (env);
 904   if (env_copy->strings)
 905   {
 906     env_copy->next = saved_environment;
 907     saved_environment = env_copy;
 908   }
 909   else
 910     LocalFree (env_copy);
 911
 912   FreeEnvironmentStringsW (env);
 913 }
 914
 915 /*****************************************************************************
 916  * WCMD_strchrW
 917  */
 918 static inline WCHAR *WCMD_strchrW(WCHAR *str, WCHAR ch)
 919 {
 920    while(*str)
 921    {
 922      if(*str == ch)
 923        return str;
 924      str++;
 925    }
 926    return NULL;
 927 }
 928
 929 /*****************************************************************************
 930  * WCMD_endlocal
 931  *
 932  *  endlocal pops the environment off a stack
 933  */
 934 void WCMD_endlocal (void) {
 935   WCHAR *env, *old, *p;
 936   struct env_stack *temp;
 937   int len, n;
 938
 939   if (!saved_environment)
 940     return;
 941
 942   /* pop the old environment from the stack */
 943   temp = saved_environment;
 944   saved_environment = temp->next;
 945
 946   /* delete the current environment, totally */
 947   env = GetEnvironmentStringsW ();
 948   old = WCMD_dupenv (GetEnvironmentStringsW ());
 949   len = 0;
 950   while (old[len]) {
 951     n = lstrlenW(&old[len]) + 1;
 952     p = WCMD_strchrW(&old[len], '=');
 953     if (p)
 954     {
 955       *p++ = 0;
 956       SetEnvironmentVariableW (&old[len], NULL);
 957     }
 958     len += n;
 959   }
 960   LocalFree (old);
 961   FreeEnvironmentStringsW (env);
 962
 963   /* restore old environment */
 964   env = temp->strings;
 965   len = 0;
 966   while (env[len]) {
 967     n = lstrlenW(&env[len]) + 1;
 968     p = WCMD_strchrW(&env[len], '=');
 969     if (p)
 970     {
 971       *p++ = 0;
 972       SetEnvironmentVariableW (&env[len], p);
 973     }
 974     len += n;
 975   }
 976   LocalFree (env);
 977   LocalFree (temp);
 978 }
 979
 980 /*****************************************************************************
 981  * WCMD_setshow_attrib
 982  *
 983  * Display and optionally sets DOS attributes on a file or directory
 984  *
 985  * FIXME: Wine currently uses the Unix stat() function to get file attributes.
 986  * As a result only the Readonly flag is correctly reported, the Archive bit
 987  * is always set and the rest are not implemented. We do the Right Thing anyway.
 988  *
 989  * FIXME: No SET functionality.
 990  *
 991  */
 992
 993 void WCMD_setshow_attrib (void) {
 994
 995   DWORD count;
 996   HANDLE hff;
 997   WIN32_FIND_DATA fd;
 998   char flags[9] = {"        "};
 999
1000   if (param1[0] == '-') {
1001     WCMD_output (nyi);
1002     return;
1003   }
1004
1005   if (lstrlen(param1) == 0) {
1006     GetCurrentDirectory (sizeof(param1), param1);
1007     strcat (param1, "\\*");
1008   }
1009
1010   hff = FindFirstFile (param1, &fd);
1011   if (hff == INVALID_HANDLE_VALUE) {
1012     WCMD_output ("%s: File Not Found\n",param1);
1013   }
1014   else {
1015     do {
1016       if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
1017         if (fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) {
1018           flags[0] = 'H';
1019         }
1020         if (fd.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) {
1021           flags[1] = 'S';
1022         }
1023         if (fd.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE) {
1024           flags[2] = 'A';
1025         }
1026         if (fd.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
1027           flags[3] = 'R';
1028         }
1029         if (fd.dwFileAttributes & FILE_ATTRIBUTE_TEMPORARY) {
1030           flags[4] = 'T';
1031         }
1032         if (fd.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED) {
1033           flags[5] = 'C';
1034         }
1035         WCMD_output ("%s   %s\n", flags, fd.cFileName);
1036         for (count=0; count < 8; count++) flags[count] = ' ';
1037       }
1038     } while (FindNextFile(hff, &fd) != 0);
1039   }
1040   FindClose (hff);
1041 }
1042
1043 /*****************************************************************************
1044  * WCMD_setshow_default
1045  *
1046  *      Set/Show the current default directory
1047  */
1048
1049 void WCMD_setshow_default (void) {
1050
1051   BOOL status;
1052   char string[1024];
1053
1054   if (strlen(param1) == 0) {
1055     GetCurrentDirectory (sizeof(string), string);
1056     strcat (string, "\n");
1057     WCMD_output (string);
1058   }
1059   else {
1060     status = SetCurrentDirectory (param1);
1061     if (!status) {
1062       WCMD_print_error ();
1063       return;
1064     }
1065    }
1066   return;
1067 }
1068
1069 /****************************************************************************
1070  * WCMD_setshow_date
1071  *
1072  * Set/Show the system date
1073  * FIXME: Can't change date yet
1074  */
1075
1076 void WCMD_setshow_date (void) {
1077
1078   char curdate[64], buffer[64];
1079   DWORD count;
1080
1081   if (lstrlen(param1) == 0) {
1082     if (GetDateFormat (LOCALE_USER_DEFAULT, 0, NULL, NULL,
1083                 curdate, sizeof(curdate))) {
1084       WCMD_output ("Current Date is %s\nEnter new date: ", curdate);
1085       ReadFile (GetStdHandle(STD_INPUT_HANDLE), buffer, sizeof(buffer), &count, NULL);
1086       if (count > 2) {
1087         WCMD_output (nyi);
1088       }
1089     }
1090     else WCMD_print_error ();
1091   }
1092   else {
1093     WCMD_output (nyi);
1094   }
1095 }
1096
1097 /****************************************************************************
1098  * WCMD_compare
1099  */
1100 static int WCMD_compare( const void *a, const void *b )
1101 {
1102     int r;
1103     const char * const *str_a = a, * const *str_b = b;
1104     r = CompareString( LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
1105           *str_a, -1, *str_b, -1 );
1106     if( r == CSTR_LESS_THAN ) return -1;
1107     if( r == CSTR_GREATER_THAN ) return 1;
1108     return 0;
1109 }
1110
1111 /****************************************************************************
1112  * WCMD_setshow_sortenv
1113  *
1114  * sort variables into order for display
1115  * Optionally only display those who start with a stub
1116  * returns the count displayed
1117  */
1118 static int WCMD_setshow_sortenv(const char *s, const char *stub)
1119 {
1120   UINT count=0, len=0, i, displayedcount=0, stublen=0;
1121   const char **str;
1122
1123   if (stub) stublen = strlen(stub);
1124
1125   /* count the number of strings, and the total length */
1126   while ( s[len] ) {
1127     len += (lstrlen(&s[len]) + 1);
1128     count++;
1129   }
1130
1131   /* add the strings to an array */
1132   str = LocalAlloc (LMEM_FIXED | LMEM_ZEROINIT, count * sizeof (char*) );
1133   if( !str )
1134     return 0;
1135   str[0] = s;
1136   for( i=1; i<count; i++ )
1137     str[i] = str[i-1] + lstrlen(str[i-1]) + 1;
1138
1139   /* sort the array */
1140   qsort( str, count, sizeof (char*), WCMD_compare );
1141
1142   /* print it */
1143   for( i=0; i<count; i++ ) {
1144     if (!stub || CompareString (LOCALE_USER_DEFAULT,
1145                                 NORM_IGNORECASE | SORT_STRINGSORT,
1146                                 str[i], stublen, stub, -1) == 2) {
1147       WCMD_output_asis(str[i]);
1148       WCMD_output_asis("\n");
1149       displayedcount++;
1150     }
1151   }
1152
1153   LocalFree( str );
1154   return displayedcount;
1155 }
1156
1157 /****************************************************************************
1158  * WCMD_setshow_env
1159  *
1160  * Set/Show the environment variables
1161  */
1162
1163 void WCMD_setshow_env (char *s) {
1164
1165   LPVOID env;
1166   char *p;
1167   int status;
1168
1169   if (strlen(param1) == 0) {
1170     env = GetEnvironmentStrings ();
1171     WCMD_setshow_sortenv( env, NULL );
1172   }
1173   else {
1174     p = strchr (s, '=');
1175     if (p == NULL) {
1176       env = GetEnvironmentStrings ();
1177       if (WCMD_setshow_sortenv( env, s ) == 0) {
1178         WCMD_output ("Environment variable %s not defined\n", s);
1179       }
1180       return;
1181     }
1182     *p++ = '\0';
1183
1184     if (strlen(p) == 0) p = NULL;
1185     status = SetEnvironmentVariable (s, p);
1186     if ((!status) & (GetLastError() != ERROR_ENVVAR_NOT_FOUND)) WCMD_print_error();
1187   }
1188 }
1189
1190 /****************************************************************************
1191  * WCMD_setshow_path
1192  *
1193  * Set/Show the path environment variable
1194  */
1195
1196 void WCMD_setshow_path (char *command) {
1197
1198   char string[1024];
1199   DWORD status;
1200
1201   if (strlen(param1) == 0) {
1202     status = GetEnvironmentVariable ("PATH", string, sizeof(string));
1203     if (status != 0) {
1204       WCMD_output_asis ( "PATH=");
1205       WCMD_output_asis ( string);
1206       WCMD_output_asis ( "\n");
1207     }
1208     else {
1209       WCMD_output ("PATH not found\n");
1210     }
1211   }
1212   else {
1213     if (*command == '=') command++; /* Skip leading '=' */
1214     status = SetEnvironmentVariable ("PATH", command);
1215     if (!status) WCMD_print_error();
1216   }
1217 }
1218
1219 /****************************************************************************
1220  * WCMD_setshow_prompt
1221  *
1222  * Set or show the command prompt.
1223  */
1224
1225 void WCMD_setshow_prompt (void) {
1226
1227   char *s;
1228
1229   if (strlen(param1) == 0) {
1230     SetEnvironmentVariable ("PROMPT", NULL);
1231   }
1232   else {
1233     s = param1;
1234     while ((*s == '=') || (*s == ' ')) s++;
1235     if (strlen(s) == 0) {
1236       SetEnvironmentVariable ("PROMPT", NULL);
1237     }
1238     else SetEnvironmentVariable ("PROMPT", s);
1239   }
1240 }
1241
1242 /****************************************************************************
1243  * WCMD_setshow_time
1244  *
1245  * Set/Show the system time
1246  * FIXME: Can't change time yet
1247  */
1248
1249 void WCMD_setshow_time (void) {
1250
1251   char curtime[64], buffer[64];
1252   DWORD count;
1253   SYSTEMTIME st;
1254
1255   if (strlen(param1) == 0) {
1256     GetLocalTime(&st);
1257     if (GetTimeFormat (LOCALE_USER_DEFAULT, 0, &st, NULL,
1258                 curtime, sizeof(curtime))) {
1259       WCMD_output ("Current Time is %s\nEnter new time: ", curtime);
1260       ReadFile (GetStdHandle(STD_INPUT_HANDLE), buffer, sizeof(buffer), &count, NULL);
1261       if (count > 2) {
1262         WCMD_output (nyi);
1263       }
1264     }
1265     else WCMD_print_error ();
1266   }
1267   else {
1268     WCMD_output (nyi);
1269   }
1270 }
1271
1272 /****************************************************************************
1273  * WCMD_shift
1274  *
1275  * Shift batch parameters.
1276  */
1277
1278 void WCMD_shift (void) {
1279
1280   if (context != NULL) context -> shift_count++;
1281
1282 }
1283
1284 /****************************************************************************
1285  * WCMD_title
1286  *
1287  * Set the console title
1288  */
1289 void WCMD_title (char *command) {
1290   SetConsoleTitle(command);
1291 }
1292
1293 /****************************************************************************
1294  * WCMD_type
1295  *
1296  * Copy a file to standard output.
1297  */
1298
1299 void WCMD_type (void) {
1300
1301   HANDLE h;
1302   char buffer[512];
1303   DWORD count;
1304
1305   if (param1[0] == 0x00) {
1306     WCMD_output ("Argument missing\n");
1307     return;
1308   }
1309   h = CreateFile (param1, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
1310                 FILE_ATTRIBUTE_NORMAL, NULL);
1311   if (h == INVALID_HANDLE_VALUE) {
1312     WCMD_print_error ();
1313     return;
1314   }
1315   while (ReadFile (h, buffer, sizeof(buffer), &count, NULL)) {
1316     if (count == 0) break;      /* ReadFile reports success on EOF! */
1317     buffer[count] = 0;
1318     WCMD_output_asis (buffer);
1319   }
1320   CloseHandle (h);
1321 }
1322
1323 /****************************************************************************
1324  * WCMD_verify
1325  *
1326  * Display verify flag.
1327  * FIXME: We don't actually do anything with the verify flag other than toggle
1328  * it...
1329  */
1330
1331 void WCMD_verify (char *command) {
1332
1333   static const char von[] = "Verify is ON\n", voff[] = "Verify is OFF\n";
1334   int count;
1335
1336   count = strlen(command);
1337   if (count == 0) {
1338     if (verify_mode) WCMD_output (von);
1339     else WCMD_output (voff);
1340     return;
1341   }
1342   if (lstrcmpi(command, "ON") == 0) {
1343     verify_mode = 1;
1344     return;
1345   }
1346   else if (lstrcmpi(command, "OFF") == 0) {
1347     verify_mode = 0;
1348     return;
1349   }
1350   else WCMD_output ("Verify must be ON or OFF\n");
1351 }
1352
1353 /****************************************************************************
1354  * WCMD_version
1355  *
1356  * Display version info.
1357  */
1358
1359 void WCMD_version (void) {
1360
1361   WCMD_output (version_string);
1362
1363 }
1364
1365 /****************************************************************************
1366  * WCMD_volume
1367  *
1368  * Display volume info and/or set volume label. Returns 0 if error.
1369  */
1370
1371 int WCMD_volume (int mode, char *path) {
1372
1373   DWORD count, serial;
1374   char string[MAX_PATH], label[MAX_PATH], curdir[MAX_PATH];
1375   BOOL status;
1376
1377   if (lstrlen(path) == 0) {
1378     status = GetCurrentDirectory (sizeof(curdir), curdir);
1379     if (!status) {
1380       WCMD_print_error ();
1381       return 0;
1382     }
1383     status = GetVolumeInformation (NULL, label, sizeof(label), &serial, NULL,
1384         NULL, NULL, 0);
1385   }
1386   else {
1387     if ((path[1] != ':') || (lstrlen(path) != 2)) {
1388       WCMD_output_asis("Syntax Error\n\n");
1389       return 0;
1390     }
1391     wsprintf (curdir, "%s\\", path);
1392     status = GetVolumeInformation (curdir, label, sizeof(label), &serial, NULL,
1393         NULL, NULL, 0);
1394   }
1395   if (!status) {
1396     WCMD_print_error ();
1397     return 0;
1398   }
1399   WCMD_output ("Volume in drive %c is %s\nVolume Serial Number is %04x-%04x\n\n",
1400         curdir[0], label, HIWORD(serial), LOWORD(serial));
1401   if (mode) {
1402     WCMD_output ("Volume label (11 characters, ENTER for none)?");
1403     ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
1404     if (count > 1) {
1405       string[count-1] = '\0';           /* ReadFile output is not null-terminated! */
1406       if (string[count-2] == '\r') string[count-2] = '\0'; /* Under Windoze we get CRLF! */
1407     }
1408     if (lstrlen(path) != 0) {
1409       if (!SetVolumeLabel (curdir, string)) WCMD_print_error ();
1410     }
1411     else {
1412       if (!SetVolumeLabel (NULL, string)) WCMD_print_error ();
1413     }
1414   }
1415   return 1;
1416 }
1417
1418 /**************************************************************************
1419  * WCMD_exit
1420  *
1421  * Exit either the process, or just this batch program
1422  *
1423  */
1424
1425 void WCMD_exit (void) {
1426
1427     int rc = atoi(param1); /* Note: atoi of empty parameter is 0 */
1428
1429     if (context && lstrcmpi(quals, "/B") == 0) {
1430         errorlevel = rc;
1431         context -> skip_rest = TRUE;
1432     } else {
1433         ExitProcess(rc);
1434     }
1435 }
1436
1437 /**************************************************************************
1438  * WCMD_ask_confirm
1439  *
1440  * Issue a message and ask 'Are you sure (Y/N)', waiting on a valid
1441  * answer.
1442  *
1443  * Returns True if Y answer is selected
1444  *
1445  */
1446 BOOL WCMD_ask_confirm (char *message, BOOL showSureText) {
1447
1448     char  msgbuffer[MAXSTRING];
1449     char  Ybuffer[MAXSTRING];
1450     char  Nbuffer[MAXSTRING];
1451     char  answer[MAX_PATH] = "";
1452     DWORD count = 0;
1453
1454     /* Load the translated 'Are you sure', plus valid answers */
1455     LoadString (hinst, WCMD_CONFIRM, msgbuffer, sizeof(msgbuffer));
1456     LoadString (hinst, WCMD_YES, Ybuffer, sizeof(Ybuffer));
1457     LoadString (hinst, WCMD_NO, Nbuffer, sizeof(Nbuffer));
1458
1459     /* Loop waiting on a Y or N */
1460     while (answer[0] != Ybuffer[0] && answer[0] != Nbuffer[0]) {
1461       WCMD_output_asis (message);
1462       if (showSureText) {
1463         WCMD_output_asis (msgbuffer);
1464       }
1465       WCMD_output_asis (" (");
1466       WCMD_output_asis (Ybuffer);
1467       WCMD_output_asis ("/");
1468       WCMD_output_asis (Nbuffer);
1469       WCMD_output_asis (")?");
1470       ReadFile (GetStdHandle(STD_INPUT_HANDLE), answer, sizeof(answer),
1471                 &count, NULL);
1472       answer[0] = toupper(answer[0]);
1473     }
1474
1475     /* Return the answer */
1476     return (answer[0] == Ybuffer[0]);
1477 }
1478
1479 /*****************************************************************************
1480  * WCMD_assoc
1481  *
1482  *      Lists or sets file associations
1483  */
1484 void WCMD_assoc (char *command) {
1485
1486     HKEY    key;
1487     DWORD   accessOptions = KEY_READ;
1488     char   *newValue;
1489     LONG    rc = ERROR_SUCCESS;
1490     char    keyValue[MAXSTRING];
1491     DWORD   valueLen = MAXSTRING;
1492     HKEY    readKey;
1493
1494
1495     /* See if parameter includes '=' */
1496     errorlevel = 0;
1497     newValue = strchr(command, '=');
1498     if (newValue) accessOptions |= KEY_WRITE;
1499
1500     /* Open a key to HKEY_CLASSES_ROOT for enumerating */
1501     if (RegOpenKeyEx(HKEY_CLASSES_ROOT, "", 0,
1502                      accessOptions, &key) != ERROR_SUCCESS) {
1503       WINE_FIXME("Unexpected failure opening HKCR key: %d\n", GetLastError());
1504       return;
1505     }
1506
1507     /* If no parameters then list all associations */
1508     if (*command == 0x00) {
1509       int index = 0;
1510
1511       /* Enumerate all the keys */
1512       while (rc != ERROR_NO_MORE_ITEMS) {
1513         char  keyName[MAXSTRING];
1514         DWORD nameLen;
1515
1516         /* Find the next value */
1517         nameLen = MAXSTRING;
1518         rc = RegEnumKeyEx(key, index++,
1519                           keyName, &nameLen,
1520                           NULL, NULL, NULL, NULL);
1521
1522         if (rc == ERROR_SUCCESS) {
1523
1524           /* Only interested in extension ones */
1525           if (keyName[0] == '.') {
1526
1527             if (RegOpenKeyEx(key, keyName, 0,
1528                              accessOptions, &readKey) == ERROR_SUCCESS) {
1529
1530               rc = RegQueryValueEx(readKey, NULL, NULL, NULL,
1531                                    (LPBYTE)keyValue, &valueLen);
1532               WCMD_output_asis(keyName);
1533               WCMD_output_asis("=");
1534               /* If no default value found, leave line empty after '=' */
1535               if (rc == ERROR_SUCCESS) {
1536                 WCMD_output_asis(keyValue);
1537               }
1538               WCMD_output_asis("\n");
1539             }
1540           }
1541         }
1542       }
1543       RegCloseKey(readKey);
1544
1545     } else {
1546
1547       /* Parameter supplied - if no '=' on command line, its a query */
1548       if (newValue == NULL) {
1549         char *space;
1550
1551         /* Query terminates the parameter at the first space */
1552         strcpy(keyValue, command);
1553         space = strchr(keyValue, ' ');
1554         if (space) *space=0x00;
1555
1556         if (RegOpenKeyEx(key, keyValue, 0,
1557                          accessOptions, &readKey) == ERROR_SUCCESS) {
1558
1559           rc = RegQueryValueEx(readKey, NULL, NULL, NULL,
1560                                (LPBYTE)keyValue, &valueLen);
1561           WCMD_output_asis(command);
1562           WCMD_output_asis("=");
1563           /* If no default value found, leave line empty after '=' */
1564           if (rc == ERROR_SUCCESS) WCMD_output_asis(keyValue);
1565           WCMD_output_asis("\n");
1566           RegCloseKey(readKey);
1567
1568         } else {
1569           char  msgbuffer[MAXSTRING];
1570           char  outbuffer[MAXSTRING];
1571
1572           /* Load the translated 'File association not found' */
1573           LoadString (hinst, WCMD_NOASSOC, msgbuffer, sizeof(msgbuffer));
1574           sprintf(outbuffer, msgbuffer, keyValue);
1575           WCMD_output_asis(outbuffer);
1576           errorlevel = 2;
1577         }
1578
1579       /* Not a query - its a set or clear of a value */
1580       } else {
1581
1582         /* Get pointer to new value */
1583         *newValue = 0x00;
1584         newValue++;
1585
1586         /* If nothing after '=' then clear value */
1587         if (*newValue == 0x00) {
1588
1589           rc = RegDeleteKey(key, command);
1590           if (rc == ERROR_SUCCESS) {
1591             WINE_TRACE("HKCR Key '%s' deleted\n", command);
1592
1593           } else if (rc != ERROR_FILE_NOT_FOUND) {
1594             WCMD_print_error();
1595             errorlevel = 2;
1596
1597           } else {
1598             char  msgbuffer[MAXSTRING];
1599             char  outbuffer[MAXSTRING];
1600
1601             /* Load the translated 'File association not found' */
1602             LoadString (hinst, WCMD_NOASSOC, msgbuffer, sizeof(msgbuffer));
1603             sprintf(outbuffer, msgbuffer, keyValue);
1604             WCMD_output_asis(outbuffer);
1605             errorlevel = 2;
1606           }
1607
1608         /* It really is a set value = contents */
1609         } else {
1610           rc = RegCreateKeyEx(key, command, 0, NULL, REG_OPTION_NON_VOLATILE,
1611                               accessOptions, NULL, &readKey, NULL);
1612           if (rc == ERROR_SUCCESS) {
1613             rc = RegSetValueEx(readKey, NULL, 0, REG_SZ,
1614                                  (LPBYTE)newValue, strlen(newValue));
1615             RegCloseKey(readKey);
1616           }
1617
1618           if (rc != ERROR_SUCCESS) {
1619             WCMD_print_error();
1620             errorlevel = 2;
1621           } else {
1622             WCMD_output_asis(command);
1623             WCMD_output_asis("=");
1624             WCMD_output_asis(newValue);
1625             WCMD_output_asis("\n");
1626           }
1627         }
1628       }
1629     }
1630
1631     /* Clean up */
1632     RegCloseKey(key);
1633 }