?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 6e61d6ca5bcaf95ac09a664b4ba4f88238c927be
[wine/hacks.git] / programs / cmd / builtins.c
blob15d320cf2e6104a50ed7494a48e3877fc9569184
1 /*
2 * CMD - Wine-compatible command line interface - built-in functions.
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 /*
23 * NOTES:
24 * On entry to each function, global variables quals, param1, param2 contain
25 * the qualifiers (uppercased and concatenated) and parameters entered, with
26 * environment-variable and batch parameter substitution already done.
27 */
28
29 /*
30 * FIXME:
31 * - No support for pipes, shell parameters
32 * - Lots of functionality missing from builtins
33 * - Messages etc need international support
34 */
35
36 #define WIN32_LEAN_AND_MEAN
37
38 #include "wcmd.h"
39 #include <shellapi.h>
40 #include "wine/debug.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(cmd);
43
44 static void WCMD_part_execute(CMD_LIST **commands, WCHAR *firstcmd, WCHAR *variable,
45 WCHAR *value, BOOL isIF, BOOL conditionTRUE);
46
47 struct env_stack *saved_environment;
48 struct env_stack *pushd_directories;
49
50 extern HINSTANCE hinst;
51 extern WCHAR inbuilt[][10];
52 extern int echo_mode, verify_mode, defaultColor;
53 extern WCHAR quals[MAX_PATH], param1[MAX_PATH], param2[MAX_PATH];
54 extern BATCH_CONTEXT *context;
55 extern DWORD errorlevel;
56
57 static const WCHAR dotW[] = {'.','\0'};
58 static const WCHAR dotdotW[] = {'.','.','\0'};
59 static const WCHAR slashW[] = {'\\','\0'};
60 static const WCHAR starW[] = {'*','\0'};
61 static const WCHAR equalW[] = {'=','\0'};
62 static const WCHAR fslashW[] = {'/','\0'};
63 static const WCHAR onW[] = {'O','N','\0'};
64 static const WCHAR offW[] = {'O','F','F','\0'};
65 static const WCHAR parmY[] = {'/','Y','\0'};
66 static const WCHAR parmNoY[] = {'/','-','Y','\0'};
67 static const WCHAR nullW[] = {'\0'};
68
69 /**************************************************************************
70 * WCMD_ask_confirm
71 *
72 * Issue a message and ask 'Are you sure (Y/N)', waiting on a valid
73 * answer.
74 *
75 * Returns True if Y (or A) answer is selected
76 * If optionAll contains a pointer, ALL is allowed, and if answered
77 * set to TRUE
78 *
79 */
80 static BOOL WCMD_ask_confirm (WCHAR *message, BOOL showSureText, BOOL *optionAll) {
81
82 WCHAR msgbuffer[MAXSTRING];
83 WCHAR Ybuffer[MAXSTRING];
84 WCHAR Nbuffer[MAXSTRING];
85 WCHAR Abuffer[MAXSTRING];
86 WCHAR answer[MAX_PATH] = {'\0'};
87 DWORD count = 0;
88
89 /* Load the translated 'Are you sure', plus valid answers */
90 LoadStringW(hinst, WCMD_CONFIRM, msgbuffer, sizeof(msgbuffer)/sizeof(WCHAR));
91 LoadStringW(hinst, WCMD_YES, Ybuffer, sizeof(Ybuffer)/sizeof(WCHAR));
92 LoadStringW(hinst, WCMD_NO, Nbuffer, sizeof(Nbuffer)/sizeof(WCHAR));
93 LoadStringW(hinst, WCMD_ALL, Abuffer, sizeof(Abuffer)/sizeof(WCHAR));
94
95 /* Loop waiting on a Y or N */
96 while (answer[0] != Ybuffer[0] && answer[0] != Nbuffer[0]) {
97 static const WCHAR startBkt[] = {' ','(','\0'};
98 static const WCHAR endBkt[] = {')','?','\0'};
99
100 WCMD_output_asis (message);
101 if (showSureText) {
102 WCMD_output_asis (msgbuffer);
103 }
104 WCMD_output_asis (startBkt);
105 WCMD_output_asis (Ybuffer);
106 WCMD_output_asis (fslashW);
107 WCMD_output_asis (Nbuffer);
108 if (optionAll) {
109 WCMD_output_asis (fslashW);
110 WCMD_output_asis (Abuffer);
111 }
112 WCMD_output_asis (endBkt);
113 WCMD_ReadFile (GetStdHandle(STD_INPUT_HANDLE), answer,
114 sizeof(answer)/sizeof(WCHAR), &count, NULL);
115 answer[0] = toupperW(answer[0]);
116 }
117
118 /* Return the answer */
119 return ((answer[0] == Ybuffer[0]) ||
120 (optionAll && (answer[0] == Abuffer[0])));
121 }
122
123 /****************************************************************************
124 * WCMD_clear_screen
125 *
126 * Clear the terminal screen.
127 */
128
129 void WCMD_clear_screen (void) {
130
131 /* Emulate by filling the screen from the top left to bottom right with
132 spaces, then moving the cursor to the top left afterwards */
133 CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
134 HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
135
136 if (GetConsoleScreenBufferInfo(hStdOut, &consoleInfo))
137 {
138 COORD topLeft;
139 DWORD screenSize;
140
141 screenSize = consoleInfo.dwSize.X * (consoleInfo.dwSize.Y + 1);
142
143 topLeft.X = 0;
144 topLeft.Y = 0;
145 FillConsoleOutputCharacterW(hStdOut, ' ', screenSize, topLeft, &screenSize);
146 SetConsoleCursorPosition(hStdOut, topLeft);
147 }
148 }
149
150 /****************************************************************************
151 * WCMD_change_tty
152 *
153 * Change the default i/o device (ie redirect STDin/STDout).
154 */
155
156 void WCMD_change_tty (void) {
157
158 WCMD_output (WCMD_LoadMessage(WCMD_NYI));
159
160 }
161
162 /****************************************************************************
163 * WCMD_copy
164 *
165 * Copy a file or wildcarded set.
166 * FIXME: Add support for a+b+c type syntax
167 */
168
169 void WCMD_copy (void) {
170
171 WIN32_FIND_DATAW fd;
172 HANDLE hff;
173 BOOL force, status;
174 WCHAR outpath[MAX_PATH], srcpath[MAX_PATH], copycmd[4];
175 DWORD len;
176 static const WCHAR copyCmdW[] = {'C','O','P','Y','C','M','D','\0'};
177 BOOL copyToDir = FALSE;
178 BOOL copyFromDir = FALSE;
179 WCHAR srcspec[MAX_PATH];
180 DWORD attribs;
181 WCHAR drive[10];
182 WCHAR dir[MAX_PATH];
183 WCHAR fname[MAX_PATH];
184 WCHAR ext[MAX_PATH];
185
186 if (param1[0] == 0x00) {
187 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
188 return;
189 }
190
191 /* Convert source into full spec */
192 WINE_TRACE("Copy source (supplied): '%s'\n", wine_dbgstr_w(param1));
193 GetFullPathNameW(param1, sizeof(srcpath)/sizeof(WCHAR), srcpath, NULL);
194 if (srcpath[strlenW(srcpath) - 1] == '\\')
195 srcpath[strlenW(srcpath) - 1] = '\0';
196
197 if ((strchrW(srcpath,'*') == NULL) && (strchrW(srcpath,'?') == NULL)) {
198 attribs = GetFileAttributesW(srcpath);
199 } else {
200 attribs = 0;
201 }
202 strcpyW(srcspec, srcpath);
203
204 /* If a directory, then add \* on the end when searching */
205 if (attribs & FILE_ATTRIBUTE_DIRECTORY) {
206 strcatW(srcpath, slashW);
207 copyFromDir = TRUE;
208 strcatW(srcspec, slashW);
209 strcatW(srcspec, starW);
210 } else {
211 WCMD_splitpath(srcpath, drive, dir, fname, ext);
212 strcpyW(srcpath, drive);
213 strcatW(srcpath, dir);
214 }
215
216 WINE_TRACE("Copy source (calculated): path: '%s'\n", wine_dbgstr_w(srcpath));
217
218 /* If no destination supplied, assume current directory */
219 WINE_TRACE("Copy destination (supplied): '%s'\n", wine_dbgstr_w(param2));
220 if (param2[0] == 0x00) {
221 strcpyW(param2, dotW);
222 }
223
224 GetFullPathNameW(param2, sizeof(outpath)/sizeof(WCHAR), outpath, NULL);
225 if (outpath[strlenW(outpath) - 1] == '\\')
226 outpath[strlenW(outpath) - 1] = '\0';
227 attribs = GetFileAttributesW(outpath);
228 if (attribs != INVALID_FILE_ATTRIBUTES && (attribs & FILE_ATTRIBUTE_DIRECTORY)) {
229 strcatW (outpath, slashW);
230 copyToDir = TRUE;
231 }
232 WINE_TRACE("Copy destination (calculated): '%s'(%d)\n",
233 wine_dbgstr_w(outpath), copyToDir);
234
235 /* /-Y has the highest priority, then /Y and finally the COPYCMD env. variable */
236 if (strstrW (quals, parmNoY))
237 force = FALSE;
238 else if (strstrW (quals, parmY))
239 force = TRUE;
240 else {
241 /* By default, we will force the overwrite in batch mode and ask for
242 * confirmation in interactive mode. */
243 force = !!context;
244
245 /* If COPYCMD is set, then we force the overwrite with /Y and ask for
246 * confirmation with /-Y. If COPYCMD is neither of those, then we use the
247 * default behavior. */
248 len = GetEnvironmentVariableW(copyCmdW, copycmd, sizeof(copycmd)/sizeof(WCHAR));
249 if (len && len < (sizeof(copycmd)/sizeof(WCHAR))) {
250 if (!lstrcmpiW (copycmd, parmY))
251 force = TRUE;
252 else if (!lstrcmpiW (copycmd, parmNoY))
253 force = FALSE;
254 }
255 }
256
257 /* Loop through all source files */
258 WINE_TRACE("Searching for: '%s'\n", wine_dbgstr_w(srcspec));
259 hff = FindFirstFileW(srcspec, &fd);
260 if (hff != INVALID_HANDLE_VALUE) {
261 do {
262 WCHAR outname[MAX_PATH];
263 WCHAR srcname[MAX_PATH];
264 BOOL overwrite = force;
265
266 /* Destination is either supplied filename, or source name in
267 supplied destination directory */
268 strcpyW(outname, outpath);
269 if (copyToDir) strcatW(outname, fd.cFileName);
270 strcpyW(srcname, srcpath);
271 strcatW(srcname, fd.cFileName);
272
273 WINE_TRACE("Copying from : '%s'\n", wine_dbgstr_w(srcname));
274 WINE_TRACE("Copying to : '%s'\n", wine_dbgstr_w(outname));
275
276 /* Skip . and .., and directories */
277 if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
278 overwrite = FALSE;
279 WINE_TRACE("Skipping directories\n");
280 }
281
282 /* Prompt before overwriting */
283 else if (!overwrite) {
284 attribs = GetFileAttributesW(outname);
285 if (attribs != INVALID_FILE_ATTRIBUTES) {
286 WCHAR buffer[MAXSTRING];
287 wsprintfW(buffer, WCMD_LoadMessage(WCMD_OVERWRITE), outname);
288 overwrite = WCMD_ask_confirm(buffer, FALSE, NULL);
289 }
290 else overwrite = TRUE;
291 }
292
293 /* Do the copy as appropriate */
294 if (overwrite) {
295 status = CopyFileW(srcname, outname, FALSE);
296 if (!status) WCMD_print_error ();
297 }
298
299 } while (FindNextFileW(hff, &fd) != 0);
300 FindClose (hff);
301 } else {
302 status = ERROR_FILE_NOT_FOUND;
303 WCMD_print_error ();
304 }
305 }
306
307 /****************************************************************************
308 * WCMD_create_dir
309 *
310 * Create a directory.
311 *
312 * this works recursively. so mkdir dir1\dir2\dir3 will create dir1 and dir2 if
313 * they do not already exist.
314 */
315
316 static BOOL create_full_path(WCHAR* path)
317 {
318 int len;
319 WCHAR *new_path;
320 BOOL ret = TRUE;
321
322 new_path = HeapAlloc(GetProcessHeap(),0,(strlenW(path)+1) * sizeof(WCHAR));
323 strcpyW(new_path,path);
324
325 while ((len = strlenW(new_path)) && new_path[len - 1] == '\\')
326 new_path[len - 1] = 0;
327
328 while (!CreateDirectoryW(new_path,NULL))
329 {
330 WCHAR *slash;
331 DWORD last_error = GetLastError();
332 if (last_error == ERROR_ALREADY_EXISTS)
333 break;
334
335 if (last_error != ERROR_PATH_NOT_FOUND)
336 {
337 ret = FALSE;
338 break;
339 }
340
341 if (!(slash = strrchrW(new_path,'\\')) && ! (slash = strrchrW(new_path,'/')))
342 {
343 ret = FALSE;
344 break;
345 }
346
347 len = slash - new_path;
348 new_path[len] = 0;
349 if (!create_full_path(new_path))
350 {
351 ret = FALSE;
352 break;
353 }
354 new_path[len] = '\\';
355 }
356 HeapFree(GetProcessHeap(),0,new_path);
357 return ret;
358 }
359
360 void WCMD_create_dir (void) {
361
362 if (param1[0] == 0x00) {
363 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
364 return;
365 }
366 if (!create_full_path(param1)) WCMD_print_error ();
367 }
368
369 /****************************************************************************
370 * WCMD_delete
371 *
372 * Delete a file or wildcarded set.
373 *
374 * Note on /A:
375 * - Testing shows /A is repeatable, eg. /a-r /ar matches all files
376 * - Each set is a pattern, eg /ahr /as-r means
377 * readonly+hidden OR nonreadonly system files
378 * - The '-' applies to a single field, ie /a:-hr means read only
379 * non-hidden files
380 */
381
382 BOOL WCMD_delete (WCHAR *command, BOOL expectDir) {
383
384 int argno = 0;
385 int argsProcessed = 0;
386 WCHAR *argN = command;
387 BOOL foundAny = FALSE;
388 static const WCHAR parmA[] = {'/','A','\0'};
389 static const WCHAR parmQ[] = {'/','Q','\0'};
390 static const WCHAR parmP[] = {'/','P','\0'};
391 static const WCHAR parmS[] = {'/','S','\0'};
392 static const WCHAR parmF[] = {'/','F','\0'};
393
394 /* If not recursing, clear error flag */
395 if (expectDir) errorlevel = 0;
396
397 /* Loop through all args */
398 while (argN) {
399 WCHAR *thisArg = WCMD_parameter (command, argno++, &argN);
400 WCHAR argCopy[MAX_PATH];
401
402 if (argN && argN[0] != '/') {
403
404 WIN32_FIND_DATAW fd;
405 HANDLE hff;
406 WCHAR fpath[MAX_PATH];
407 WCHAR *p;
408 BOOL handleParm = TRUE;
409 BOOL found = FALSE;
410 static const WCHAR anyExt[]= {'.','*','\0'};
411
412 strcpyW(argCopy, thisArg);
413 WINE_TRACE("del: Processing arg %s (quals:%s)\n",
414 wine_dbgstr_w(argCopy), wine_dbgstr_w(quals));
415 argsProcessed++;
416
417 /* If filename part of parameter is * or *.*, prompt unless
418 /Q supplied. */
419 if ((strstrW (quals, parmQ) == NULL) && (strstrW (quals, parmP) == NULL)) {
420
421 WCHAR drive[10];
422 WCHAR dir[MAX_PATH];
423 WCHAR fname[MAX_PATH];
424 WCHAR ext[MAX_PATH];
425
426 /* Convert path into actual directory spec */
427 GetFullPathNameW(argCopy, sizeof(fpath)/sizeof(WCHAR), fpath, NULL);
428 WCMD_splitpath(fpath, drive, dir, fname, ext);
429
430 /* Only prompt for * and *.*, not *a, a*, *.a* etc */
431 if ((strcmpW(fname, starW) == 0) &&
432 (*ext == 0x00 || (strcmpW(ext, anyExt) == 0))) {
433 BOOL ok;
434 WCHAR question[MAXSTRING];
435 static const WCHAR fmt[] = {'%','s',' ','\0'};
436
437 /* Note: Flag as found, to avoid file not found message */
438 found = TRUE;
439
440 /* Ask for confirmation */
441 wsprintfW(question, fmt, fpath);
442 ok = WCMD_ask_confirm(question, TRUE, NULL);
443
444 /* Abort if answer is 'N' */
445 if (!ok) continue;
446 }
447 }
448
449 /* First, try to delete in the current directory */
450 hff = FindFirstFileW(argCopy, &fd);
451 if (hff == INVALID_HANDLE_VALUE) {
452 handleParm = FALSE;
453 } else {
454 found = TRUE;
455 }
456
457 /* Support del <dirname> by just deleting all files dirname\* */
458 if (handleParm && (strchrW(argCopy,'*') == NULL) && (strchrW(argCopy,'?') == NULL)
459 && (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
460 WCHAR modifiedParm[MAX_PATH];
461 static const WCHAR slashStar[] = {'\\','*','\0'};
462
463 strcpyW(modifiedParm, argCopy);
464 strcatW(modifiedParm, slashStar);
465 FindClose(hff);
466 found = TRUE;
467 WCMD_delete(modifiedParm, FALSE);
468
469 } else if (handleParm) {
470
471 /* Build the filename to delete as <supplied directory>\<findfirst filename> */
472 strcpyW (fpath, argCopy);
473 do {
474 p = strrchrW (fpath, '\\');
475 if (p != NULL) {
476 *++p = '\0';
477 strcatW (fpath, fd.cFileName);
478 }
479 else strcpyW (fpath, fd.cFileName);
480 if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
481 BOOL ok = TRUE;
482 WCHAR *nextA = strstrW (quals, parmA);
483
484 /* Handle attribute matching (/A) */
485 if (nextA != NULL) {
486 ok = FALSE;
487 while (nextA != NULL && !ok) {
488
489 WCHAR *thisA = (nextA+2);
490 BOOL stillOK = TRUE;
491
492 /* Skip optional : */
493 if (*thisA == ':') thisA++;
494
495 /* Parse each of the /A[:]xxx in turn */
496 while (*thisA && *thisA != '/') {
497 BOOL negate = FALSE;
498 BOOL attribute = FALSE;
499
500 /* Match negation of attribute first */
501 if (*thisA == '-') {
502 negate=TRUE;
503 thisA++;
504 }
505
506 /* Match attribute */
507 switch (*thisA) {
508 case 'R': attribute = (fd.dwFileAttributes & FILE_ATTRIBUTE_READONLY);
509 break;
510 case 'H': attribute = (fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN);
511 break;
512 case 'S': attribute = (fd.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM);
513 break;
514 case 'A': attribute = (fd.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE);
515 break;
516 default:
517 WCMD_output (WCMD_LoadMessage(WCMD_SYNTAXERR));
518 }
519
520 /* Now check result, keeping a running boolean about whether it
521 matches all parsed attributes so far */
522 if (attribute && !negate) {
523 stillOK = stillOK;
524 } else if (!attribute && negate) {
525 stillOK = stillOK;
526 } else {
527 stillOK = FALSE;
528 }
529 thisA++;
530 }
531
532 /* Save the running total as the final result */
533 ok = stillOK;
534
535 /* Step on to next /A set */
536 nextA = strstrW (nextA+1, parmA);
537 }
538 }
539
540 /* /P means prompt for each file */
541 if (ok && strstrW (quals, parmP) != NULL) {
542 WCHAR question[MAXSTRING];
543
544 /* Ask for confirmation */
545 wsprintfW(question, WCMD_LoadMessage(WCMD_DELPROMPT), fpath);
546 ok = WCMD_ask_confirm(question, FALSE, NULL);
547 }
548
549 /* Only proceed if ok to */
550 if (ok) {
551
552 /* If file is read only, and /F supplied, delete it */
553 if (fd.dwFileAttributes & FILE_ATTRIBUTE_READONLY &&
554 strstrW (quals, parmF) != NULL) {
555 SetFileAttributesW(fpath, fd.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY);
556 }
557
558 /* Now do the delete */
559 if (!DeleteFileW(fpath)) WCMD_print_error ();
560 }
561
562 }
563 } while (FindNextFileW(hff, &fd) != 0);
564 FindClose (hff);
565 }
566
567 /* Now recurse into all subdirectories handling the parameter in the same way */
568 if (strstrW (quals, parmS) != NULL) {
569
570 WCHAR thisDir[MAX_PATH];
571 int cPos;
572
573 WCHAR drive[10];
574 WCHAR dir[MAX_PATH];
575 WCHAR fname[MAX_PATH];
576 WCHAR ext[MAX_PATH];
577
578 /* Convert path into actual directory spec */
579 GetFullPathNameW(argCopy, sizeof(thisDir)/sizeof(WCHAR), thisDir, NULL);
580 WCMD_splitpath(thisDir, drive, dir, fname, ext);
581
582 strcpyW(thisDir, drive);
583 strcatW(thisDir, dir);
584 cPos = strlenW(thisDir);
585
586 WINE_TRACE("Searching recursively in '%s'\n", wine_dbgstr_w(thisDir));
587
588 /* Append '*' to the directory */
589 thisDir[cPos] = '*';
590 thisDir[cPos+1] = 0x00;
591
592 hff = FindFirstFileW(thisDir, &fd);
593
594 /* Remove residual '*' */
595 thisDir[cPos] = 0x00;
596
597 if (hff != INVALID_HANDLE_VALUE) {
598 DIRECTORY_STACK *allDirs = NULL;
599 DIRECTORY_STACK *lastEntry = NULL;
600
601 do {
602 if ((fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
603 (strcmpW(fd.cFileName, dotdotW) != 0) &&
604 (strcmpW(fd.cFileName, dotW) != 0)) {
605
606 DIRECTORY_STACK *nextDir;
607 WCHAR subParm[MAX_PATH];
608
609 /* Work out search parameter in sub dir */
610 strcpyW (subParm, thisDir);
611 strcatW (subParm, fd.cFileName);
612 strcatW (subParm, slashW);
613 strcatW (subParm, fname);
614 strcatW (subParm, ext);
615 WINE_TRACE("Recursive, Adding to search list '%s'\n", wine_dbgstr_w(subParm));
616
617 /* Allocate memory, add to list */
618 nextDir = HeapAlloc(GetProcessHeap(),0,sizeof(DIRECTORY_STACK));
619 if (allDirs == NULL) allDirs = nextDir;
620 if (lastEntry != NULL) lastEntry->next = nextDir;
621 lastEntry = nextDir;
622 nextDir->next = NULL;
623 nextDir->dirName = HeapAlloc(GetProcessHeap(),0,
624 (strlenW(subParm)+1) * sizeof(WCHAR));
625 strcpyW(nextDir->dirName, subParm);
626 }
627 } while (FindNextFileW(hff, &fd) != 0);
628 FindClose (hff);
629
630 /* Go through each subdir doing the delete */
631 while (allDirs != NULL) {
632 DIRECTORY_STACK *tempDir;
633
634 tempDir = allDirs->next;
635 found |= WCMD_delete (allDirs->dirName, FALSE);
636
637 HeapFree(GetProcessHeap(),0,allDirs->dirName);
638 HeapFree(GetProcessHeap(),0,allDirs);
639 allDirs = tempDir;
640 }
641 }
642 }
643 /* Keep running total to see if any found, and if not recursing
644 issue error message */
645 if (expectDir) {
646 if (!found) {
647 errorlevel = 1;
648 WCMD_output (WCMD_LoadMessage(WCMD_FILENOTFOUND), argCopy);
649 }
650 }
651 foundAny |= found;
652 }
653 }
654
655 /* Handle no valid args */
656 if (argsProcessed == 0) {
657 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
658 }
659
660 return foundAny;
661 }
662
663 /****************************************************************************
664 * WCMD_echo
665 *
666 * Echo input to the screen (or not). We don't try to emulate the bugs
667 * in DOS (try typing "ECHO ON AGAIN" for an example).
668 */
669
670 void WCMD_echo (const WCHAR *command) {
671
672 int count;
673
674 if ((command[0] == '.') && (command[1] == 0)) {
675 WCMD_output (newline);
676 return;
677 }
678 if (command[0]==' ')
679 command++;
680 count = strlenW(command);
681 if (count == 0) {
682 if (echo_mode) WCMD_output (WCMD_LoadMessage(WCMD_ECHOPROMPT), onW);
683 else WCMD_output (WCMD_LoadMessage(WCMD_ECHOPROMPT), offW);
684 return;
685 }
686 if (lstrcmpiW(command, onW) == 0) {
687 echo_mode = 1;
688 return;
689 }
690 if (lstrcmpiW(command, offW) == 0) {
691 echo_mode = 0;
692 return;
693 }
694 WCMD_output_asis (command);
695 WCMD_output (newline);
696
697 }
698
699 /**************************************************************************
700 * WCMD_for
701 *
702 * Batch file loop processing.
703 *
704 * On entry: cmdList contains the syntax up to the set
705 * next cmdList and all in that bracket contain the set data
706 * next cmdlist contains the DO cmd
707 * following that is either brackets or && entries (as per if)
708 *
709 */
710
711 void WCMD_for (WCHAR *p, CMD_LIST **cmdList) {
712
713 WIN32_FIND_DATAW fd;
714 HANDLE hff;
715 int i;
716 const WCHAR inW[] = {'i', 'n', ' ', '\0'};
717 const WCHAR doW[] = {'d', 'o', ' ', '\0'};
718 CMD_LIST *setStart, *thisSet, *cmdStart, *cmdEnd;
719 WCHAR variable[4];
720 WCHAR *firstCmd;
721 int thisDepth;
722
723 WCHAR *curPos = p;
724 BOOL expandDirs = FALSE;
725 BOOL useNumbers = FALSE;
726 BOOL doRecursive = FALSE;
727 BOOL doFileset = FALSE;
728 LONG numbers[3] = {0,0,0}; /* Defaults to 0 in native */
729 int itemNum;
730 CMD_LIST *thisCmdStart;
731
732
733 /* Handle optional qualifiers (multiple are allowed) */
734 while (*curPos && *curPos == '/') {
735 WINE_TRACE("Processing qualifier at %s\n", wine_dbgstr_w(curPos));
736 curPos++;
737 switch (toupperW(*curPos)) {
738 case 'D': curPos++; expandDirs = TRUE; break;
739 case 'L': curPos++; useNumbers = TRUE; break;
740
741 /* Recursive is special case - /R can have an optional path following it */
742 /* filenamesets are another special case - /F can have an optional options following it */
743 case 'R':
744 case 'F':
745 {
746 BOOL isRecursive = (*curPos == 'R');
747
748 if (isRecursive) doRecursive = TRUE;
749 else doFileset = TRUE;
750
751 /* Skip whitespace */
752 curPos++;
753 while (*curPos && *curPos==' ') curPos++;
754
755 /* Next parm is either qualifier, path/options or variable -
756 only care about it if it is the path/options */
757 if (*curPos && *curPos != '/' && *curPos != '%') {
758 if (isRecursive) WINE_FIXME("/R needs to handle supplied root\n");
759 else WINE_FIXME("/F needs to handle options\n");
760 }
761 break;
762 }
763 default:
764 WINE_FIXME("for qualifier '%c' unhandled\n", *curPos);
765 curPos++;
766 }
767
768 /* Skip whitespace between qualifiers */
769 while (*curPos && *curPos==' ') curPos++;
770 }
771
772 /* Skip whitespace before variable */
773 while (*curPos && *curPos==' ') curPos++;
774
775 /* Ensure line continues with variable */
776 if (!*curPos || *curPos != '%') {
777 WCMD_output (WCMD_LoadMessage(WCMD_SYNTAXERR));
778 return;
779 }
780
781 /* Variable should follow */
782 i = 0;
783 while (curPos[i] && curPos[i]!=' ') i++;
784 memcpy(&variable[0], curPos, i*sizeof(WCHAR));
785 variable[i] = 0x00;
786 WINE_TRACE("Variable identified as %s\n", wine_dbgstr_w(variable));
787 curPos = &curPos[i];
788
789 /* Skip whitespace before IN */
790 while (*curPos && *curPos==' ') curPos++;
791
792 /* Ensure line continues with IN */
793 if (!*curPos || lstrcmpiW (curPos, inW)) {
794 WCMD_output (WCMD_LoadMessage(WCMD_SYNTAXERR));
795 return;
796 }
797
798 /* Save away where the set of data starts and the variable */
799 thisDepth = (*cmdList)->bracketDepth;
800 *cmdList = (*cmdList)->nextcommand;
801 setStart = (*cmdList);
802
803 /* Skip until the close bracket */
804 WINE_TRACE("Searching %p as the set\n", *cmdList);
805 while (*cmdList &&
806 (*cmdList)->command != NULL &&
807 (*cmdList)->bracketDepth > thisDepth) {
808 WINE_TRACE("Skipping %p which is part of the set\n", *cmdList);
809 *cmdList = (*cmdList)->nextcommand;
810 }
811
812 /* Skip the close bracket, if there is one */
813 if (*cmdList) *cmdList = (*cmdList)->nextcommand;
814
815 /* Syntax error if missing close bracket, or nothing following it
816 and once we have the complete set, we expect a DO */
817 WINE_TRACE("Looking for 'do' in %p\n", *cmdList);
818 if ((*cmdList == NULL) ||
819 (CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
820 (*cmdList)->command, 3, doW, -1) != 2)) {
821 WCMD_output (WCMD_LoadMessage(WCMD_SYNTAXERR));
822 return;
823 }
824
825 /* Save away the starting position for the commands (and offset for the
826 first one */
827 cmdStart = *cmdList;
828 cmdEnd = *cmdList;
829 firstCmd = (*cmdList)->command + 3; /* Skip 'do ' */
830 itemNum = 0;
831
832 thisSet = setStart;
833 /* Loop through all set entries */
834 while (thisSet &&
835 thisSet->command != NULL &&
836 thisSet->bracketDepth >= thisDepth) {
837
838 /* Loop through all entries on the same line */
839 WCHAR *item;
840 WCHAR *itemStart;
841
842 WINE_TRACE("Processing for set %p\n", thisSet);
843 i = 0;
844 while (*(item = WCMD_parameter (thisSet->command, i, &itemStart))) {
845
846 /*
847 * If the parameter within the set has a wildcard then search for matching files
848 * otherwise do a literal substitution.
849 */
850 static const WCHAR wildcards[] = {'*','?','\0'};
851 thisCmdStart = cmdStart;
852
853 itemNum++;
854 WINE_TRACE("Processing for item %d '%s'\n", itemNum, wine_dbgstr_w(item));
855
856 if (!useNumbers && !doFileset) {
857 if (strpbrkW (item, wildcards)) {
858 hff = FindFirstFileW(item, &fd);
859 if (hff != INVALID_HANDLE_VALUE) {
860 do {
861 BOOL isDirectory = FALSE;
862
863 if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) isDirectory = TRUE;
864
865 /* Handle as files or dirs appropriately, but ignore . and .. */
866 if (isDirectory == expandDirs &&
867 (strcmpW(fd.cFileName, dotdotW) != 0) &&
868 (strcmpW(fd.cFileName, dotW) != 0))
869 {
870 thisCmdStart = cmdStart;
871 WINE_TRACE("Processing FOR filename %s\n", wine_dbgstr_w(fd.cFileName));
872 WCMD_part_execute (&thisCmdStart, firstCmd, variable,
873 fd.cFileName, FALSE, TRUE);
874 }
875
876 } while (FindNextFileW(hff, &fd) != 0);
877 FindClose (hff);
878 }
879 } else {
880 WCMD_part_execute(&thisCmdStart, firstCmd, variable, item, FALSE, TRUE);
881 }
882
883 } else if (useNumbers) {
884 /* Convert the first 3 numbers to signed longs and save */
885 if (itemNum <=3) numbers[itemNum-1] = atolW(item);
886 /* else ignore them! */
887
888 /* Filesets - either a list of files, or a command to run and parse the output */
889 } else if (doFileset && *itemStart != '"') {
890
891 HANDLE input;
892 WCHAR temp_file[MAX_PATH];
893
894 WINE_TRACE("Processing for filespec from item %d '%s'\n", itemNum,
895 wine_dbgstr_w(item));
896
897 /* If backquote or single quote, we need to launch that command
898 and parse the results - use a temporary file */
899 if (*itemStart == '`' || *itemStart == '\'') {
900
901 WCHAR temp_path[MAX_PATH], temp_cmd[MAXSTRING];
902 static const WCHAR redirOut[] = {'>','%','s','\0'};
903 static const WCHAR cmdW[] = {'C','M','D','\0'};
904
905 /* Remove trailing character */
906 itemStart[strlenW(itemStart)-1] = 0x00;
907
908 /* Get temp filename */
909 GetTempPathW(sizeof(temp_path)/sizeof(WCHAR), temp_path);
910 GetTempFileNameW(temp_path, cmdW, 0, temp_file);
911
912 /* Execute program and redirect output */
913 wsprintfW(temp_cmd, redirOut, (itemStart+1), temp_file);
914 WCMD_execute (itemStart, temp_cmd, NULL, NULL, NULL);
915
916 /* Open the file, read line by line and process */
917 input = CreateFileW(temp_file, GENERIC_READ, FILE_SHARE_READ,
918 NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
919 } else {
920
921 /* Open the file, read line by line and process */
922 input = CreateFileW(item, GENERIC_READ, FILE_SHARE_READ,
923 NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
924 }
925
926 /* Process the input file */
927 if (input == INVALID_HANDLE_VALUE) {
928 WCMD_print_error ();
929 WCMD_output (WCMD_LoadMessage(WCMD_READFAIL), item);
930 errorlevel = 1;
931 return; /* FOR loop aborts at first failure here */
932
933 } else {
934
935 WCHAR buffer[MAXSTRING] = {'\0'};
936 WCHAR *where, *parm;
937
938 while (WCMD_fgets (buffer, sizeof(buffer)/sizeof(WCHAR), input)) {
939
940 /* Skip blank lines*/
941 parm = WCMD_parameter (buffer, 0, &where);
942 WINE_TRACE("Parsed parameter: %s from %s\n", wine_dbgstr_w(parm),
943 wine_dbgstr_w(buffer));
944
945 if (where) {
946 /* FIXME: The following should be moved into its own routine and
947 reused for the string literal parsing below */
948 thisCmdStart = cmdStart;
949 WCMD_part_execute(&thisCmdStart, firstCmd, variable, parm, FALSE, TRUE);
950 cmdEnd = thisCmdStart;
951 }
952
953 buffer[0] = 0x00;
954
955 }
956 CloseHandle (input);
957 }
958
959 /* Delete the temporary file */
960 if (*itemStart == '`' || *itemStart == '\'') {
961 DeleteFileW(temp_file);
962 }
963
964 /* Filesets - A string literal */
965 } else if (doFileset && *itemStart == '"') {
966 WCHAR buffer[MAXSTRING] = {'\0'};
967 WCHAR *where, *parm;
968
969 /* Skip blank lines, and re-extract parameter now string has quotes removed */
970 strcpyW(buffer, item);
971 parm = WCMD_parameter (buffer, 0, &where);
972 WINE_TRACE("Parsed parameter: %s from %s\n", wine_dbgstr_w(parm),
973 wine_dbgstr_w(buffer));
974
975 if (where) {
976 /* FIXME: The following should be moved into its own routine and
977 reused for the string literal parsing below */
978 thisCmdStart = cmdStart;
979 WCMD_part_execute(&thisCmdStart, firstCmd, variable, parm, FALSE, TRUE);
980 cmdEnd = thisCmdStart;
981 }
982 }
983
984 WINE_TRACE("Post-command, cmdEnd = %p\n", cmdEnd);
985 cmdEnd = thisCmdStart;
986 i++;
987 }
988
989 /* Move onto the next set line */
990 thisSet = thisSet->nextcommand;
991 }
992
993 /* If /L is provided, now run the for loop */
994 if (useNumbers) {
995 WCHAR thisNum[20];
996 static const WCHAR fmt[] = {'%','d','\0'};
997
998 WINE_TRACE("FOR /L provided range from %d to %d step %d\n",
999 numbers[0], numbers[2], numbers[1]);
1000 for (i=numbers[0];
1001 (numbers[1]<0)? i>numbers[2] : i<numbers[2];
1002 i=i + numbers[1]) {
1003
1004 sprintfW(thisNum, fmt, i);
1005 WINE_TRACE("Processing FOR number %s\n", wine_dbgstr_w(thisNum));
1006
1007 thisCmdStart = cmdStart;
1008 WCMD_part_execute(&thisCmdStart, firstCmd, variable, thisNum, FALSE, TRUE);
1009 cmdEnd = thisCmdStart;
1010 }
1011 }
1012
1013 /* When the loop ends, either something like a GOTO or EXIT /b has terminated
1014 all processing, OR it should be pointing to the end of && processing OR
1015 it should be pointing at the NULL end of bracket for the DO. The return
1016 value needs to be the NEXT command to execute, which it either is, or
1017 we need to step over the closing bracket */
1018 *cmdList = cmdEnd;
1019 if (cmdEnd && cmdEnd->command == NULL) *cmdList = cmdEnd->nextcommand;
1020 }
1021
1022
1023 /*****************************************************************************
1024 * WCMD_part_execute
1025 *
1026 * Execute a command, and any && or bracketed follow on to the command. The
1027 * first command to be executed may not be at the front of the
1028 * commands->thiscommand string (eg. it may point after a DO or ELSE)
1029 */
1030 void WCMD_part_execute(CMD_LIST **cmdList, WCHAR *firstcmd, WCHAR *variable,
1031 WCHAR *value, BOOL isIF, BOOL conditionTRUE) {
1032
1033 CMD_LIST *curPosition = *cmdList;
1034 int myDepth = (*cmdList)->bracketDepth;
1035
1036 WINE_TRACE("cmdList(%p), firstCmd(%p), with '%s'='%s', doIt(%d)\n",
1037 cmdList, wine_dbgstr_w(firstcmd),
1038 wine_dbgstr_w(variable), wine_dbgstr_w(value),
1039 conditionTRUE);
1040
1041 /* Skip leading whitespace between condition and the command */
1042 while (firstcmd && *firstcmd && (*firstcmd==' ' || *firstcmd=='\t')) firstcmd++;
1043
1044 /* Process the first command, if there is one */
1045 if (conditionTRUE && firstcmd && *firstcmd) {
1046 WCHAR *command = WCMD_strdupW(firstcmd);
1047 WCMD_execute (firstcmd, (*cmdList)->redirects, variable, value, cmdList);
1048 HeapFree(GetProcessHeap(), 0, command);
1049 }
1050
1051
1052 /* If it didn't move the position, step to next command */
1053 if (curPosition == *cmdList) *cmdList = (*cmdList)->nextcommand;
1054
1055 /* Process any other parts of the command */
1056 if (*cmdList) {
1057 BOOL processThese = TRUE;
1058
1059 if (isIF) processThese = conditionTRUE;
1060
1061 while (*cmdList) {
1062 const WCHAR ifElse[] = {'e','l','s','e',' ','\0'};
1063
1064 /* execute all appropriate commands */
1065 curPosition = *cmdList;
1066
1067 WINE_TRACE("Processing cmdList(%p) - delim(%d) bd(%d / %d)\n",
1068 *cmdList,
1069 (*cmdList)->prevDelim,
1070 (*cmdList)->bracketDepth, myDepth);
1071
1072 /* Execute any statements appended to the line */
1073 /* FIXME: Only if previous call worked for && or failed for || */
1074 if ((*cmdList)->prevDelim == CMD_ONFAILURE ||
1075 (*cmdList)->prevDelim == CMD_ONSUCCESS) {
1076 if (processThese && (*cmdList)->command) {
1077 WCMD_execute ((*cmdList)->command, (*cmdList)->redirects, variable,
1078 value, cmdList);
1079 }
1080 if (curPosition == *cmdList) *cmdList = (*cmdList)->nextcommand;
1081
1082 /* Execute any appended to the statement with (...) */
1083 } else if ((*cmdList)->bracketDepth > myDepth) {
1084 if (processThese) {
1085 *cmdList = WCMD_process_commands(*cmdList, TRUE, variable, value);
1086 WINE_TRACE("Back from processing commands, (next = %p)\n", *cmdList);
1087 }
1088 if (curPosition == *cmdList) *cmdList = (*cmdList)->nextcommand;
1089
1090 /* End of the command - does 'ELSE ' follow as the next command? */
1091 } else {
1092 if (isIF && CompareStringW(LOCALE_USER_DEFAULT,
1093 NORM_IGNORECASE | SORT_STRINGSORT,
1094 (*cmdList)->command, 5, ifElse, -1) == 2) {
1095
1096 /* Swap between if and else processing */
1097 processThese = !processThese;
1098
1099 /* Process the ELSE part */
1100 if (processThese) {
1101 WCHAR *cmd = ((*cmdList)->command) + strlenW(ifElse);
1102
1103 /* Skip leading whitespace between condition and the command */
1104 while (*cmd && (*cmd==' ' || *cmd=='\t')) cmd++;
1105 if (*cmd) {
1106 WCMD_execute (cmd, (*cmdList)->redirects, variable, value, cmdList);
1107 }
1108 }
1109 if (curPosition == *cmdList) *cmdList = (*cmdList)->nextcommand;
1110 } else {
1111 WINE_TRACE("Found end of this IF statement (next = %p)\n", *cmdList);
1112 break;
1113 }
1114 }
1115 }
1116 }
1117 return;
1118 }
1119
1120 /**************************************************************************
1121 * WCMD_give_help
1122 *
1123 * Simple on-line help. Help text is stored in the resource file.
1124 */
1125
1126 void WCMD_give_help (WCHAR *command) {
1127
1128 int i;
1129
1130 command = WCMD_strtrim_leading_spaces(command);
1131 if (strlenW(command) == 0) {
1132 WCMD_output_asis (WCMD_LoadMessage(WCMD_ALLHELP));
1133 }
1134 else {
1135 for (i=0; i<=WCMD_EXIT; i++) {
1136 if (CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
1137 command, -1, inbuilt[i], -1) == 2) {
1138 WCMD_output_asis (WCMD_LoadMessage(i));
1139 return;
1140 }
1141 }
1142 WCMD_output (WCMD_LoadMessage(WCMD_NOCMDHELP), command);
1143 }
1144 return;
1145 }
1146
1147 /****************************************************************************
1148 * WCMD_go_to
1149 *
1150 * Batch file jump instruction. Not the most efficient algorithm ;-)
1151 * Prints error message if the specified label cannot be found - the file pointer is
1152 * then at EOF, effectively stopping the batch file.
1153 * FIXME: DOS is supposed to allow labels with spaces - we don't.
1154 */
1155
1156 void WCMD_goto (CMD_LIST **cmdList) {
1157
1158 WCHAR string[MAX_PATH];
1159
1160 /* Do not process any more parts of a processed multipart or multilines command */
1161 if (cmdList) *cmdList = NULL;
1162
1163 if (param1[0] == 0x00) {
1164 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
1165 return;
1166 }
1167 if (context != NULL) {
1168 WCHAR *paramStart = param1;
1169 static const WCHAR eofW[] = {':','e','o','f','\0'};
1170
1171 /* Handle special :EOF label */
1172 if (lstrcmpiW (eofW, param1) == 0) {
1173 context -> skip_rest = TRUE;
1174 return;
1175 }
1176
1177 /* Support goto :label as well as goto label */
1178 if (*paramStart == ':') paramStart++;
1179
1180 SetFilePointer (context -> h, 0, NULL, FILE_BEGIN);
1181 while (WCMD_fgets (string, sizeof(string)/sizeof(WCHAR), context -> h)) {
1182 if ((string[0] == ':') && (lstrcmpiW (&string[1], paramStart) == 0)) return;
1183 }
1184 WCMD_output (WCMD_LoadMessage(WCMD_NOTARGET));
1185 }
1186 return;
1187 }
1188
1189 /*****************************************************************************
1190 * WCMD_pushd
1191 *
1192 * Push a directory onto the stack
1193 */
1194
1195 void WCMD_pushd (WCHAR *command) {
1196 struct env_stack *curdir;
1197 WCHAR *thisdir;
1198 static const WCHAR parmD[] = {'/','D','\0'};
1199
1200 if (strchrW(command, '/') != NULL) {
1201 SetLastError(ERROR_INVALID_PARAMETER);
1202 WCMD_print_error();
1203 return;
1204 }
1205
1206 curdir = LocalAlloc (LMEM_FIXED, sizeof (struct env_stack));
1207 thisdir = LocalAlloc (LMEM_FIXED, 1024 * sizeof(WCHAR));
1208 if( !curdir || !thisdir ) {
1209 LocalFree(curdir);
1210 LocalFree(thisdir);
1211 WINE_ERR ("out of memory\n");
1212 return;
1213 }
1214
1215 /* Change directory using CD code with /D parameter */
1216 strcpyW(quals, parmD);
1217 GetCurrentDirectoryW (1024, thisdir);
1218 errorlevel = 0;
1219 WCMD_setshow_default(command);
1220 if (errorlevel) {
1221 LocalFree(curdir);
1222 LocalFree(thisdir);
1223 return;
1224 } else {
1225 curdir -> next = pushd_directories;
1226 curdir -> strings = thisdir;
1227 if (pushd_directories == NULL) {
1228 curdir -> u.stackdepth = 1;
1229 } else {
1230 curdir -> u.stackdepth = pushd_directories -> u.stackdepth + 1;
1231 }
1232 pushd_directories = curdir;
1233 }
1234 }
1235
1236
1237 /*****************************************************************************
1238 * WCMD_popd
1239 *
1240 * Pop a directory from the stack
1241 */
1242
1243 void WCMD_popd (void) {
1244 struct env_stack *temp = pushd_directories;
1245
1246 if (!pushd_directories)
1247 return;
1248
1249 /* pop the old environment from the stack, and make it the current dir */
1250 pushd_directories = temp->next;
1251 SetCurrentDirectoryW(temp->strings);
1252 LocalFree (temp->strings);
1253 LocalFree (temp);
1254 }
1255
1256 /****************************************************************************
1257 * WCMD_if
1258 *
1259 * Batch file conditional.
1260 *
1261 * On entry, cmdlist will point to command containing the IF, and optionally
1262 * the first command to execute (if brackets not found)
1263 * If &&'s were found, this may be followed by a record flagged as isAmpersand
1264 * If ('s were found, execute all within that bracket
1265 * Command may optionally be followed by an ELSE - need to skip instructions
1266 * in the else using the same logic
1267 *
1268 * FIXME: Much more syntax checking needed!
1269 */
1270
1271 void WCMD_if (WCHAR *p, CMD_LIST **cmdList) {
1272
1273 int negate = 0, test = 0;
1274 WCHAR condition[MAX_PATH], *command, *s;
1275 static const WCHAR notW[] = {'n','o','t','\0'};
1276 static const WCHAR errlvlW[] = {'e','r','r','o','r','l','e','v','e','l','\0'};
1277 static const WCHAR existW[] = {'e','x','i','s','t','\0'};
1278 static const WCHAR defdW[] = {'d','e','f','i','n','e','d','\0'};
1279 static const WCHAR eqeqW[] = {'=','=','\0'};
1280 static const WCHAR parmI[] = {'/','I','\0'};
1281
1282 if (!lstrcmpiW (param1, notW)) {
1283 negate = 1;
1284 strcpyW (condition, param2);
1285 }
1286 else {
1287 strcpyW (condition, param1);
1288 }
1289 WINE_TRACE("Condition: %s\n", wine_dbgstr_w(condition));
1290
1291 if (!lstrcmpiW (condition, errlvlW)) {
1292 if (errorlevel >= atoiW(WCMD_parameter (p, 1+negate, NULL))) test = 1;
1293 WCMD_parameter (p, 2+negate, &command);
1294 }
1295 else if (!lstrcmpiW (condition, existW)) {
1296 if (GetFileAttributesW(WCMD_parameter (p, 1+negate, NULL)) != INVALID_FILE_ATTRIBUTES) {
1297 test = 1;
1298 }
1299 WCMD_parameter (p, 2+negate, &command);
1300 }
1301 else if (!lstrcmpiW (condition, defdW)) {
1302 if (GetEnvironmentVariableW(WCMD_parameter (p, 1+negate, NULL), NULL, 0) > 0) {
1303 test = 1;
1304 }
1305 WCMD_parameter (p, 2+negate, &command);
1306 }
1307 else if ((s = strstrW (p, eqeqW))) {
1308 s += 2;
1309 if (strstrW (quals, parmI) == NULL) {
1310 if (!lstrcmpW (condition, WCMD_parameter (s, 0, NULL))) test = 1;
1311 }
1312 else {
1313 if (!lstrcmpiW (condition, WCMD_parameter (s, 0, NULL))) test = 1;
1314 }
1315 WCMD_parameter (s, 1, &command);
1316 }
1317 else {
1318 WCMD_output (WCMD_LoadMessage(WCMD_SYNTAXERR));
1319 return;
1320 }
1321
1322 /* Process rest of IF statement which is on the same line
1323 Note: This may process all or some of the cmdList (eg a GOTO) */
1324 WCMD_part_execute(cmdList, command, NULL, NULL, TRUE, (test != negate));
1325 }
1326
1327 /****************************************************************************
1328 * WCMD_move
1329 *
1330 * Move a file, directory tree or wildcarded set of files.
1331 */
1332
1333 void WCMD_move (void) {
1334
1335 int status;
1336 WIN32_FIND_DATAW fd;
1337 HANDLE hff;
1338 WCHAR input[MAX_PATH];
1339 WCHAR output[MAX_PATH];
1340 WCHAR drive[10];
1341 WCHAR dir[MAX_PATH];
1342 WCHAR fname[MAX_PATH];
1343 WCHAR ext[MAX_PATH];
1344
1345 if (param1[0] == 0x00) {
1346 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
1347 return;
1348 }
1349
1350 /* If no destination supplied, assume current directory */
1351 if (param2[0] == 0x00) {
1352 strcpyW(param2, dotW);
1353 }
1354
1355 /* If 2nd parm is directory, then use original filename */
1356 /* Convert partial path to full path */
1357 GetFullPathNameW(param1, sizeof(input)/sizeof(WCHAR), input, NULL);
1358 GetFullPathNameW(param2, sizeof(output)/sizeof(WCHAR), output, NULL);
1359 WINE_TRACE("Move from '%s'('%s') to '%s'\n", wine_dbgstr_w(input),
1360 wine_dbgstr_w(param1), wine_dbgstr_w(output));
1361
1362 /* Split into components */
1363 WCMD_splitpath(input, drive, dir, fname, ext);
1364
1365 hff = FindFirstFileW(input, &fd);
1366 while (hff != INVALID_HANDLE_VALUE) {
1367 WCHAR dest[MAX_PATH];
1368 WCHAR src[MAX_PATH];
1369 DWORD attribs;
1370
1371 WINE_TRACE("Processing file '%s'\n", wine_dbgstr_w(fd.cFileName));
1372
1373 /* Build src & dest name */
1374 strcpyW(src, drive);
1375 strcatW(src, dir);
1376
1377 /* See if dest is an existing directory */
1378 attribs = GetFileAttributesW(output);
1379 if (attribs != INVALID_FILE_ATTRIBUTES &&
1380 (attribs & FILE_ATTRIBUTE_DIRECTORY)) {
1381 strcpyW(dest, output);
1382 strcatW(dest, slashW);
1383 strcatW(dest, fd.cFileName);
1384 } else {
1385 strcpyW(dest, output);
1386 }
1387
1388 strcatW(src, fd.cFileName);
1389
1390 WINE_TRACE("Source '%s'\n", wine_dbgstr_w(src));
1391 WINE_TRACE("Dest '%s'\n", wine_dbgstr_w(dest));
1392
1393 /* Check if file is read only, otherwise move it */
1394 attribs = GetFileAttributesW(src);
1395 if ((attribs != INVALID_FILE_ATTRIBUTES) &&
1396 (attribs & FILE_ATTRIBUTE_READONLY)) {
1397 SetLastError(ERROR_ACCESS_DENIED);
1398 status = 0;
1399 } else {
1400 BOOL ok = TRUE;
1401
1402 /* If destination exists, prompt unless /Y supplied */
1403 if (GetFileAttributesW(dest) != INVALID_FILE_ATTRIBUTES) {
1404 BOOL force = FALSE;
1405 WCHAR copycmd[MAXSTRING];
1406 int len;
1407
1408 /* /-Y has the highest priority, then /Y and finally the COPYCMD env. variable */
1409 if (strstrW (quals, parmNoY))
1410 force = FALSE;
1411 else if (strstrW (quals, parmY))
1412 force = TRUE;
1413 else {
1414 const WCHAR copyCmdW[] = {'C','O','P','Y','C','M','D','\0'};
1415 len = GetEnvironmentVariableW(copyCmdW, copycmd, sizeof(copycmd)/sizeof(WCHAR));
1416 force = (len && len < (sizeof(copycmd)/sizeof(WCHAR))
1417 && ! lstrcmpiW (copycmd, parmY));
1418 }
1419
1420 /* Prompt if overwriting */
1421 if (!force) {
1422 WCHAR question[MAXSTRING];
1423 WCHAR yesChar[10];
1424
1425 strcpyW(yesChar, WCMD_LoadMessage(WCMD_YES));
1426
1427 /* Ask for confirmation */
1428 wsprintfW(question, WCMD_LoadMessage(WCMD_OVERWRITE), dest);
1429 ok = WCMD_ask_confirm(question, FALSE, NULL);
1430
1431 /* So delete the destination prior to the move */
1432 if (ok) {
1433 if (!DeleteFileW(dest)) {
1434 WCMD_print_error ();
1435 errorlevel = 1;
1436 ok = FALSE;
1437 }
1438 }
1439 }
1440 }
1441
1442 if (ok) {
1443 status = MoveFileW(src, dest);
1444 } else {
1445 status = 1; /* Anything other than 0 to prevent error msg below */
1446 }
1447 }
1448
1449 if (!status) {
1450 WCMD_print_error ();
1451 errorlevel = 1;
1452 }
1453
1454 /* Step on to next match */
1455 if (FindNextFileW(hff, &fd) == 0) {
1456 FindClose(hff);
1457 hff = INVALID_HANDLE_VALUE;
1458 break;
1459 }
1460 }
1461 }
1462
1463 /****************************************************************************
1464 * WCMD_pause
1465 *
1466 * Wait for keyboard input.
1467 */
1468
1469 void WCMD_pause (void) {
1470
1471 DWORD count;
1472 WCHAR string[32];
1473
1474 WCMD_output (anykey);
1475 WCMD_ReadFile (GetStdHandle(STD_INPUT_HANDLE), string,
1476 sizeof(string)/sizeof(WCHAR), &count, NULL);
1477 }
1478
1479 /****************************************************************************
1480 * WCMD_remove_dir
1481 *
1482 * Delete a directory.
1483 */
1484
1485 void WCMD_remove_dir (WCHAR *command) {
1486
1487 int argno = 0;
1488 int argsProcessed = 0;
1489 WCHAR *argN = command;
1490 static const WCHAR parmS[] = {'/','S','\0'};
1491 static const WCHAR parmQ[] = {'/','Q','\0'};
1492
1493 /* Loop through all args */
1494 while (argN) {
1495 WCHAR *thisArg = WCMD_parameter (command, argno++, &argN);
1496 if (argN && argN[0] != '/') {
1497 WINE_TRACE("rd: Processing arg %s (quals:%s)\n", wine_dbgstr_w(thisArg),
1498 wine_dbgstr_w(quals));
1499 argsProcessed++;
1500
1501 /* If subdirectory search not supplied, just try to remove
1502 and report error if it fails (eg if it contains a file) */
1503 if (strstrW (quals, parmS) == NULL) {
1504 if (!RemoveDirectoryW(thisArg)) WCMD_print_error ();
1505
1506 /* Otherwise use ShFileOp to recursively remove a directory */
1507 } else {
1508
1509 SHFILEOPSTRUCTW lpDir;
1510
1511 /* Ask first */
1512 if (strstrW (quals, parmQ) == NULL) {
1513 BOOL ok;
1514 WCHAR question[MAXSTRING];
1515 static const WCHAR fmt[] = {'%','s',' ','\0'};
1516
1517 /* Ask for confirmation */
1518 wsprintfW(question, fmt, thisArg);
1519 ok = WCMD_ask_confirm(question, TRUE, NULL);
1520
1521 /* Abort if answer is 'N' */
1522 if (!ok) return;
1523 }
1524
1525 /* Do the delete */
1526 lpDir.hwnd = NULL;
1527 lpDir.pTo = NULL;
1528 lpDir.pFrom = thisArg;
1529 lpDir.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI;
1530 lpDir.wFunc = FO_DELETE;
1531 if (SHFileOperationW(&lpDir)) WCMD_print_error ();
1532 }
1533 }
1534 }
1535
1536 /* Handle no valid args */
1537 if (argsProcessed == 0) {
1538 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
1539 return;
1540 }
1541
1542 }
1543
1544 /****************************************************************************
1545 * WCMD_rename
1546 *
1547 * Rename a file.
1548 */
1549
1550 void WCMD_rename (void) {
1551
1552 int status;
1553 HANDLE hff;
1554 WIN32_FIND_DATAW fd;
1555 WCHAR input[MAX_PATH];
1556 WCHAR *dotDst = NULL;
1557 WCHAR drive[10];
1558 WCHAR dir[MAX_PATH];
1559 WCHAR fname[MAX_PATH];
1560 WCHAR ext[MAX_PATH];
1561 DWORD attribs;
1562
1563 errorlevel = 0;
1564
1565 /* Must be at least two args */
1566 if (param1[0] == 0x00 || param2[0] == 0x00) {
1567 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
1568 errorlevel = 1;
1569 return;
1570 }
1571
1572 /* Destination cannot contain a drive letter or directory separator */
1573 if ((strchrW(param1,':') != NULL) || (strchrW(param1,'\\') != NULL)) {
1574 SetLastError(ERROR_INVALID_PARAMETER);
1575 WCMD_print_error();
1576 errorlevel = 1;
1577 return;
1578 }
1579
1580 /* Convert partial path to full path */
1581 GetFullPathNameW(param1, sizeof(input)/sizeof(WCHAR), input, NULL);
1582 WINE_TRACE("Rename from '%s'('%s') to '%s'\n", wine_dbgstr_w(input),
1583 wine_dbgstr_w(param1), wine_dbgstr_w(param2));
1584 dotDst = strchrW(param2, '.');
1585
1586 /* Split into components */
1587 WCMD_splitpath(input, drive, dir, fname, ext);
1588
1589 hff = FindFirstFileW(input, &fd);
1590 while (hff != INVALID_HANDLE_VALUE) {
1591 WCHAR dest[MAX_PATH];
1592 WCHAR src[MAX_PATH];
1593 WCHAR *dotSrc = NULL;
1594 int dirLen;
1595
1596 WINE_TRACE("Processing file '%s'\n", wine_dbgstr_w(fd.cFileName));
1597
1598 /* FIXME: If dest name or extension is *, replace with filename/ext
1599 part otherwise use supplied name. This supports:
1600 ren *.fred *.jim
1601 ren jim.* fred.* etc
1602 However, windows has a more complex algorithm supporting eg
1603 ?'s and *'s mid name */
1604 dotSrc = strchrW(fd.cFileName, '.');
1605
1606 /* Build src & dest name */
1607 strcpyW(src, drive);
1608 strcatW(src, dir);
1609 strcpyW(dest, src);
1610 dirLen = strlenW(src);
1611 strcatW(src, fd.cFileName);
1612
1613 /* Build name */
1614 if (param2[0] == '*') {
1615 strcatW(dest, fd.cFileName);
1616 if (dotSrc) dest[dirLen + (dotSrc - fd.cFileName)] = 0x00;
1617 } else {
1618 strcatW(dest, param2);
1619 if (dotDst) dest[dirLen + (dotDst - param2)] = 0x00;
1620 }
1621
1622 /* Build Extension */
1623 if (dotDst && (*(dotDst+1)=='*')) {
1624 if (dotSrc) strcatW(dest, dotSrc);
1625 } else if (dotDst) {
1626 if (dotDst) strcatW(dest, dotDst);
1627 }
1628
1629 WINE_TRACE("Source '%s'\n", wine_dbgstr_w(src));
1630 WINE_TRACE("Dest '%s'\n", wine_dbgstr_w(dest));
1631
1632 /* Check if file is read only, otherwise move it */
1633 attribs = GetFileAttributesW(src);
1634 if ((attribs != INVALID_FILE_ATTRIBUTES) &&
1635 (attribs & FILE_ATTRIBUTE_READONLY)) {
1636 SetLastError(ERROR_ACCESS_DENIED);
1637 status = 0;
1638 } else {
1639 status = MoveFileW(src, dest);
1640 }
1641
1642 if (!status) {
1643 WCMD_print_error ();
1644 errorlevel = 1;
1645 }
1646
1647 /* Step on to next match */
1648 if (FindNextFileW(hff, &fd) == 0) {
1649 FindClose(hff);
1650 hff = INVALID_HANDLE_VALUE;
1651 break;
1652 }
1653 }
1654 }
1655
1656 /*****************************************************************************
1657 * WCMD_dupenv
1658 *
1659 * Make a copy of the environment.
1660 */
1661 static WCHAR *WCMD_dupenv( const WCHAR *env )
1662 {
1663 WCHAR *env_copy;
1664 int len;
1665
1666 if( !env )
1667 return NULL;
1668
1669 len = 0;
1670 while ( env[len] )
1671 len += (strlenW(&env[len]) + 1);
1672
1673 env_copy = LocalAlloc (LMEM_FIXED, (len+1) * sizeof (WCHAR) );
1674 if (!env_copy)
1675 {
1676 WINE_ERR("out of memory\n");
1677 return env_copy;
1678 }
1679 memcpy (env_copy, env, len*sizeof (WCHAR));
1680 env_copy[len] = 0;
1681
1682 return env_copy;
1683 }
1684
1685 /*****************************************************************************
1686 * WCMD_setlocal
1687 *
1688 * setlocal pushes the environment onto a stack
1689 * Save the environment as unicode so we don't screw anything up.
1690 */
1691 void WCMD_setlocal (const WCHAR *s) {
1692 WCHAR *env;
1693 struct env_stack *env_copy;
1694 WCHAR cwd[MAX_PATH];
1695
1696 /* DISABLEEXTENSIONS ignored */
1697
1698 env_copy = LocalAlloc (LMEM_FIXED, sizeof (struct env_stack));
1699 if( !env_copy )
1700 {
1701 WINE_ERR ("out of memory\n");
1702 return;
1703 }
1704
1705 env = GetEnvironmentStringsW ();
1706
1707 env_copy->strings = WCMD_dupenv (env);
1708 if (env_copy->strings)
1709 {
1710 env_copy->next = saved_environment;
1711 saved_environment = env_copy;
1712
1713 /* Save the current drive letter */
1714 GetCurrentDirectoryW(MAX_PATH, cwd);
1715 env_copy->u.cwd = cwd[0];
1716 }
1717 else
1718 LocalFree (env_copy);
1719
1720 FreeEnvironmentStringsW (env);
1721
1722 }
1723
1724 /*****************************************************************************
1725 * WCMD_endlocal
1726 *
1727 * endlocal pops the environment off a stack
1728 * Note: When searching for '=', search from WCHAR position 1, to handle
1729 * special internal environment variables =C:, =D: etc
1730 */
1731 void WCMD_endlocal (void) {
1732 WCHAR *env, *old, *p;
1733 struct env_stack *temp;
1734 int len, n;
1735
1736 if (!saved_environment)
1737 return;
1738
1739 /* pop the old environment from the stack */
1740 temp = saved_environment;
1741 saved_environment = temp->next;
1742
1743 /* delete the current environment, totally */
1744 env = GetEnvironmentStringsW ();
1745 old = WCMD_dupenv (GetEnvironmentStringsW ());
1746 len = 0;
1747 while (old[len]) {
1748 n = strlenW(&old[len]) + 1;
1749 p = strchrW(&old[len] + 1, '=');
1750 if (p)
1751 {
1752 *p++ = 0;
1753 SetEnvironmentVariableW (&old[len], NULL);
1754 }
1755 len += n;
1756 }
1757 LocalFree (old);
1758 FreeEnvironmentStringsW (env);
1759
1760 /* restore old environment */
1761 env = temp->strings;
1762 len = 0;
1763 while (env[len]) {
1764 n = strlenW(&env[len]) + 1;
1765 p = strchrW(&env[len] + 1, '=');
1766 if (p)
1767 {
1768 *p++ = 0;
1769 SetEnvironmentVariableW (&env[len], p);
1770 }
1771 len += n;
1772 }
1773
1774 /* Restore current drive letter */
1775 if (IsCharAlphaW(temp->u.cwd)) {
1776 WCHAR envvar[4];
1777 WCHAR cwd[MAX_PATH];
1778 static const WCHAR fmt[] = {'=','%','c',':','\0'};
1779
1780 wsprintfW(envvar, fmt, temp->u.cwd);
1781 if (GetEnvironmentVariableW(envvar, cwd, MAX_PATH)) {
1782 WINE_TRACE("Resetting cwd to %s\n", wine_dbgstr_w(cwd));
1783 SetCurrentDirectoryW(cwd);
1784 }
1785 }
1786
1787 LocalFree (env);
1788 LocalFree (temp);
1789 }
1790
1791 /*****************************************************************************
1792 * WCMD_setshow_attrib
1793 *
1794 * Display and optionally sets DOS attributes on a file or directory
1795 *
1796 */
1797
1798 void WCMD_setshow_attrib (void) {
1799
1800 DWORD count;
1801 HANDLE hff;
1802 WIN32_FIND_DATAW fd;
1803 WCHAR flags[9] = {' ',' ',' ',' ',' ',' ',' ',' ','\0'};
1804 WCHAR *name = param1;
1805 DWORD attrib_set=0;
1806 DWORD attrib_clear=0;
1807
1808 if (param1[0] == '+' || param1[0] == '-') {
1809 DWORD attrib = 0;
1810 /* FIXME: the real cmd can handle many more than two args; this should be in a loop */
1811 switch (param1[1]) {
1812 case 'H': case 'h': attrib |= FILE_ATTRIBUTE_HIDDEN; break;
1813 case 'S': case 's': attrib |= FILE_ATTRIBUTE_SYSTEM; break;
1814 case 'R': case 'r': attrib |= FILE_ATTRIBUTE_READONLY; break;
1815 case 'A': case 'a': attrib |= FILE_ATTRIBUTE_ARCHIVE; break;
1816 default:
1817 WCMD_output (WCMD_LoadMessage(WCMD_NYI));
1818 return;
1819 }
1820 switch (param1[0]) {
1821 case '+': attrib_set = attrib; break;
1822 case '-': attrib_clear = attrib; break;
1823 }
1824 name = param2;
1825 }
1826
1827 if (strlenW(name) == 0) {
1828 static const WCHAR slashStarW[] = {'\\','*','\0'};
1829
1830 GetCurrentDirectoryW(sizeof(param2)/sizeof(WCHAR), name);
1831 strcatW (name, slashStarW);
1832 }
1833
1834 hff = FindFirstFileW(name, &fd);
1835 if (hff == INVALID_HANDLE_VALUE) {
1836 WCMD_output (WCMD_LoadMessage(WCMD_FILENOTFOUND), name);
1837 }
1838 else {
1839 do {
1840 if (attrib_set || attrib_clear) {
1841 fd.dwFileAttributes &= ~attrib_clear;
1842 fd.dwFileAttributes |= attrib_set;
1843 if (!fd.dwFileAttributes)
1844 fd.dwFileAttributes |= FILE_ATTRIBUTE_NORMAL;
1845 SetFileAttributesW(name, fd.dwFileAttributes);
1846 } else {
1847 static const WCHAR fmt[] = {'%','s',' ',' ',' ','%','s','\n','\0'};
1848 if (fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) {
1849 flags[0] = 'H';
1850 }
1851 if (fd.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) {
1852 flags[1] = 'S';
1853 }
1854 if (fd.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE) {
1855 flags[2] = 'A';
1856 }
1857 if (fd.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
1858 flags[3] = 'R';
1859 }
1860 if (fd.dwFileAttributes & FILE_ATTRIBUTE_TEMPORARY) {
1861 flags[4] = 'T';
1862 }
1863 if (fd.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED) {
1864 flags[5] = 'C';
1865 }
1866 WCMD_output (fmt, flags, fd.cFileName);
1867 for (count=0; count < 8; count++) flags[count] = ' ';
1868 }
1869 } while (FindNextFileW(hff, &fd) != 0);
1870 }
1871 FindClose (hff);
1872 }
1873
1874 /*****************************************************************************
1875 * WCMD_setshow_default
1876 *
1877 * Set/Show the current default directory
1878 */
1879
1880 void WCMD_setshow_default (WCHAR *command) {
1881
1882 BOOL status;
1883 WCHAR string[1024];
1884 WCHAR cwd[1024];
1885 WCHAR *pos;
1886 WIN32_FIND_DATAW fd;
1887 HANDLE hff;
1888 static const WCHAR parmD[] = {'/','D','\0'};
1889
1890 WINE_TRACE("Request change to directory '%s'\n", wine_dbgstr_w(command));
1891
1892 /* Skip /D and trailing whitespace if on the front of the command line */
1893 if (CompareStringW(LOCALE_USER_DEFAULT,
1894 NORM_IGNORECASE | SORT_STRINGSORT,
1895 command, 2, parmD, -1) == 2) {
1896 command += 2;
1897 while (*command && *command==' ') command++;
1898 }
1899
1900 GetCurrentDirectoryW(sizeof(cwd)/sizeof(WCHAR), cwd);
1901 if (strlenW(command) == 0) {
1902 strcatW (cwd, newline);
1903 WCMD_output (cwd);
1904 }
1905 else {
1906 /* Remove any double quotes, which may be in the
1907 middle, eg. cd "C:\Program Files"\Microsoft is ok */
1908 pos = string;
1909 while (*command) {
1910 if (*command != '"') *pos++ = *command;
1911 command++;
1912 }
1913 *pos = 0x00;
1914
1915 /* Search for appropriate directory */
1916 WINE_TRACE("Looking for directory '%s'\n", wine_dbgstr_w(string));
1917 hff = FindFirstFileW(string, &fd);
1918 while (hff != INVALID_HANDLE_VALUE) {
1919 if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
1920 WCHAR fpath[MAX_PATH];
1921 WCHAR drive[10];
1922 WCHAR dir[MAX_PATH];
1923 WCHAR fname[MAX_PATH];
1924 WCHAR ext[MAX_PATH];
1925 static const WCHAR fmt[] = {'%','s','%','s','%','s','\0'};
1926
1927 /* Convert path into actual directory spec */
1928 GetFullPathNameW(string, sizeof(fpath)/sizeof(WCHAR), fpath, NULL);
1929 WCMD_splitpath(fpath, drive, dir, fname, ext);
1930
1931 /* Rebuild path */
1932 wsprintfW(string, fmt, drive, dir, fd.cFileName);
1933
1934 FindClose(hff);
1935 hff = INVALID_HANDLE_VALUE;
1936 break;
1937 }
1938
1939 /* Step on to next match */
1940 if (FindNextFileW(hff, &fd) == 0) {
1941 FindClose(hff);
1942 hff = INVALID_HANDLE_VALUE;
1943 break;
1944 }
1945 }
1946
1947 /* Change to that directory */
1948 WINE_TRACE("Really changing to directory '%s'\n", wine_dbgstr_w(string));
1949
1950 status = SetCurrentDirectoryW(string);
1951 if (!status) {
1952 errorlevel = 1;
1953 WCMD_print_error ();
1954 return;
1955 } else {
1956
1957 /* Save away the actual new directory, to store as current location */
1958 GetCurrentDirectoryW (sizeof(string)/sizeof(WCHAR), string);
1959
1960 /* Restore old directory if drive letter would change, and
1961 CD x:\directory /D (or pushd c:\directory) not supplied */
1962 if ((strstrW(quals, parmD) == NULL) &&
1963 (param1[1] == ':') && (toupper(param1[0]) != toupper(cwd[0]))) {
1964 SetCurrentDirectoryW(cwd);
1965 }
1966 }
1967
1968 /* Set special =C: type environment variable, for drive letter of
1969 change of directory, even if path was restored due to missing
1970 /D (allows changing drive letter when not resident on that
1971 drive */
1972 if ((string[1] == ':') && IsCharAlphaW(string[0])) {
1973 WCHAR env[4];
1974 strcpyW(env, equalW);
1975 memcpy(env+1, string, 2 * sizeof(WCHAR));
1976 env[3] = 0x00;
1977 WINE_TRACE("Setting '%s' to '%s'\n", wine_dbgstr_w(env), wine_dbgstr_w(string));
1978 SetEnvironmentVariableW(env, string);
1979 }
1980
1981 }
1982 return;
1983 }
1984
1985 /****************************************************************************
1986 * WCMD_setshow_date
1987 *
1988 * Set/Show the system date
1989 * FIXME: Can't change date yet
1990 */
1991
1992 void WCMD_setshow_date (void) {
1993
1994 WCHAR curdate[64], buffer[64];
1995 DWORD count;
1996 static const WCHAR parmT[] = {'/','T','\0'};
1997
1998 if (strlenW(param1) == 0) {
1999 if (GetDateFormatW(LOCALE_USER_DEFAULT, 0, NULL, NULL,
2000 curdate, sizeof(curdate)/sizeof(WCHAR))) {
2001 WCMD_output (WCMD_LoadMessage(WCMD_CURRENTDATE), curdate);
2002 if (strstrW (quals, parmT) == NULL) {
2003 WCMD_output (WCMD_LoadMessage(WCMD_NEWDATE));
2004 WCMD_ReadFile (GetStdHandle(STD_INPUT_HANDLE),
2005 buffer, sizeof(buffer)/sizeof(WCHAR), &count, NULL);
2006 if (count > 2) {
2007 WCMD_output (WCMD_LoadMessage(WCMD_NYI));
2008 }
2009 }
2010 }
2011 else WCMD_print_error ();
2012 }
2013 else {
2014 WCMD_output (WCMD_LoadMessage(WCMD_NYI));
2015 }
2016 }
2017
2018 /****************************************************************************
2019 * WCMD_compare
2020 */
2021 static int WCMD_compare( const void *a, const void *b )
2022 {
2023 int r;
2024 const WCHAR * const *str_a = a, * const *str_b = b;
2025 r = CompareStringW( LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
2026 *str_a, -1, *str_b, -1 );
2027 if( r == CSTR_LESS_THAN ) return -1;
2028 if( r == CSTR_GREATER_THAN ) return 1;
2029 return 0;
2030 }
2031
2032 /****************************************************************************
2033 * WCMD_setshow_sortenv
2034 *
2035 * sort variables into order for display
2036 * Optionally only display those who start with a stub
2037 * returns the count displayed
2038 */
2039 static int WCMD_setshow_sortenv(const WCHAR *s, const WCHAR *stub)
2040 {
2041 UINT count=0, len=0, i, displayedcount=0, stublen=0;
2042 const WCHAR **str;
2043
2044 if (stub) stublen = strlenW(stub);
2045
2046 /* count the number of strings, and the total length */
2047 while ( s[len] ) {
2048 len += (strlenW(&s[len]) + 1);
2049 count++;
2050 }
2051
2052 /* add the strings to an array */
2053 str = LocalAlloc (LMEM_FIXED | LMEM_ZEROINIT, count * sizeof (WCHAR*) );
2054 if( !str )
2055 return 0;
2056 str[0] = s;
2057 for( i=1; i<count; i++ )
2058 str[i] = str[i-1] + strlenW(str[i-1]) + 1;
2059
2060 /* sort the array */
2061 qsort( str, count, sizeof (WCHAR*), WCMD_compare );
2062
2063 /* print it */
2064 for( i=0; i<count; i++ ) {
2065 if (!stub || CompareStringW(LOCALE_USER_DEFAULT,
2066 NORM_IGNORECASE | SORT_STRINGSORT,
2067 str[i], stublen, stub, -1) == 2) {
2068 /* Don't display special internal variables */
2069 if (str[i][0] != '=') {
2070 WCMD_output_asis(str[i]);
2071 WCMD_output_asis(newline);
2072 displayedcount++;
2073 }
2074 }
2075 }
2076
2077 LocalFree( str );
2078 return displayedcount;
2079 }
2080
2081 /****************************************************************************
2082 * WCMD_setshow_env
2083 *
2084 * Set/Show the environment variables
2085 */
2086
2087 void WCMD_setshow_env (WCHAR *s) {
2088
2089 LPVOID env;
2090 WCHAR *p;
2091 int status;
2092 static const WCHAR parmP[] = {'/','P','\0'};
2093
2094 errorlevel = 0;
2095 if (param1[0] == 0x00 && quals[0] == 0x00) {
2096 env = GetEnvironmentStringsW();
2097 WCMD_setshow_sortenv( env, NULL );
2098 return;
2099 }
2100
2101 /* See if /P supplied, and if so echo the prompt, and read in a reply */
2102 if (CompareStringW(LOCALE_USER_DEFAULT,
2103 NORM_IGNORECASE | SORT_STRINGSORT,
2104 s, 2, parmP, -1) == 2) {
2105 WCHAR string[MAXSTRING];
2106 DWORD count;
2107
2108 s += 2;
2109 while (*s && *s==' ') s++;
2110 if (*s=='\"')
2111 WCMD_opt_s_strip_quotes(s);
2112
2113 /* If no parameter, or no '=' sign, return an error */
2114 if (!(*s) || ((p = strchrW (s, '=')) == NULL )) {
2115 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
2116 return;
2117 }
2118
2119 /* Output the prompt */
2120 *p++ = '\0';
2121 if (strlenW(p) != 0) WCMD_output(p);
2122
2123 /* Read the reply */
2124 WCMD_ReadFile (GetStdHandle(STD_INPUT_HANDLE), string,
2125 sizeof(string)/sizeof(WCHAR), &count, NULL);
2126 if (count > 1) {
2127 string[count-1] = '\0'; /* ReadFile output is not null-terminated! */
2128 if (string[count-2] == '\r') string[count-2] = '\0'; /* Under Windoze we get CRLF! */
2129 WINE_TRACE("set /p: Setting var '%s' to '%s'\n", wine_dbgstr_w(s),
2130 wine_dbgstr_w(string));
2131 status = SetEnvironmentVariableW(s, string);
2132 }
2133
2134 } else {
2135 DWORD gle;
2136
2137 if (*s=='\"')
2138 WCMD_opt_s_strip_quotes(s);
2139 p = strchrW (s, '=');
2140 if (p == NULL) {
2141 env = GetEnvironmentStringsW();
2142 if (WCMD_setshow_sortenv( env, s ) == 0) {
2143 WCMD_output (WCMD_LoadMessage(WCMD_MISSINGENV), s);
2144 errorlevel = 1;
2145 }
2146 return;
2147 }
2148 *p++ = '\0';
2149
2150 if (strlenW(p) == 0) p = NULL;
2151 status = SetEnvironmentVariableW(s, p);
2152 gle = GetLastError();
2153 if ((!status) & (gle == ERROR_ENVVAR_NOT_FOUND)) {
2154 errorlevel = 1;
2155 } else if ((!status)) WCMD_print_error();
2156 }
2157 }
2158
2159 /****************************************************************************
2160 * WCMD_setshow_path
2161 *
2162 * Set/Show the path environment variable
2163 */
2164
2165 void WCMD_setshow_path (WCHAR *command) {
2166
2167 WCHAR string[1024];
2168 DWORD status;
2169 static const WCHAR pathW[] = {'P','A','T','H','\0'};
2170 static const WCHAR pathEqW[] = {'P','A','T','H','=','\0'};
2171
2172 if (strlenW(param1) == 0) {
2173 status = GetEnvironmentVariableW(pathW, string, sizeof(string)/sizeof(WCHAR));
2174 if (status != 0) {
2175 WCMD_output_asis ( pathEqW);
2176 WCMD_output_asis ( string);
2177 WCMD_output_asis ( newline);
2178 }
2179 else {
2180 WCMD_output (WCMD_LoadMessage(WCMD_NOPATH));
2181 }
2182 }
2183 else {
2184 if (*command == '=') command++; /* Skip leading '=' */
2185 status = SetEnvironmentVariableW(pathW, command);
2186 if (!status) WCMD_print_error();
2187 }
2188 }
2189
2190 /****************************************************************************
2191 * WCMD_setshow_prompt
2192 *
2193 * Set or show the command prompt.
2194 */
2195
2196 void WCMD_setshow_prompt (void) {
2197
2198 WCHAR *s;
2199 static const WCHAR promptW[] = {'P','R','O','M','P','T','\0'};
2200
2201 if (strlenW(param1) == 0) {
2202 SetEnvironmentVariableW(promptW, NULL);
2203 }
2204 else {
2205 s = param1;
2206 while ((*s == '=') || (*s == ' ')) s++;
2207 if (strlenW(s) == 0) {
2208 SetEnvironmentVariableW(promptW, NULL);
2209 }
2210 else SetEnvironmentVariableW(promptW, s);
2211 }
2212 }
2213
2214 /****************************************************************************
2215 * WCMD_setshow_time
2216 *
2217 * Set/Show the system time
2218 * FIXME: Can't change time yet
2219 */
2220
2221 void WCMD_setshow_time (void) {
2222
2223 WCHAR curtime[64], buffer[64];
2224 DWORD count;
2225 SYSTEMTIME st;
2226 static const WCHAR parmT[] = {'/','T','\0'};
2227
2228 if (strlenW(param1) == 0) {
2229 GetLocalTime(&st);
2230 if (GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL,
2231 curtime, sizeof(curtime)/sizeof(WCHAR))) {
2232 WCMD_output (WCMD_LoadMessage(WCMD_CURRENTTIME), curtime);
2233 if (strstrW (quals, parmT) == NULL) {
2234 WCMD_output (WCMD_LoadMessage(WCMD_NEWTIME));
2235 WCMD_ReadFile (GetStdHandle(STD_INPUT_HANDLE), buffer,
2236 sizeof(buffer)/sizeof(WCHAR), &count, NULL);
2237 if (count > 2) {
2238 WCMD_output (WCMD_LoadMessage(WCMD_NYI));
2239 }
2240 }
2241 }
2242 else WCMD_print_error ();
2243 }
2244 else {
2245 WCMD_output (WCMD_LoadMessage(WCMD_NYI));
2246 }
2247 }
2248
2249 /****************************************************************************
2250 * WCMD_shift
2251 *
2252 * Shift batch parameters.
2253 * Optional /n says where to start shifting (n=0-8)
2254 */
2255
2256 void WCMD_shift (WCHAR *command) {
2257 int start;
2258
2259 if (context != NULL) {
2260 WCHAR *pos = strchrW(command, '/');
2261 int i;
2262
2263 if (pos == NULL) {
2264 start = 0;
2265 } else if (*(pos+1)>='0' && *(pos+1)<='8') {
2266 start = (*(pos+1) - '0');
2267 } else {
2268 SetLastError(ERROR_INVALID_PARAMETER);
2269 WCMD_print_error();
2270 return;
2271 }
2272
2273 WINE_TRACE("Shifting variables, starting at %d\n", start);
2274 for (i=start;i<=8;i++) {
2275 context -> shift_count[i] = context -> shift_count[i+1] + 1;
2276 }
2277 context -> shift_count[9] = context -> shift_count[9] + 1;
2278 }
2279
2280 }
2281
2282 /****************************************************************************
2283 * WCMD_title
2284 *
2285 * Set the console title
2286 */
2287 void WCMD_title (WCHAR *command) {
2288 SetConsoleTitleW(command);
2289 }
2290
2291 /****************************************************************************
2292 * WCMD_type
2293 *
2294 * Copy a file to standard output.
2295 */
2296
2297 void WCMD_type (WCHAR *command) {
2298
2299 int argno = 0;
2300 WCHAR *argN = command;
2301 BOOL writeHeaders = FALSE;
2302
2303 if (param1[0] == 0x00) {
2304 WCMD_output (WCMD_LoadMessage(WCMD_NOARG));
2305 return;
2306 }
2307
2308 if (param2[0] != 0x00) writeHeaders = TRUE;
2309
2310 /* Loop through all args */
2311 errorlevel = 0;
2312 while (argN) {
2313 WCHAR *thisArg = WCMD_parameter (command, argno++, &argN);
2314
2315 HANDLE h;
2316 WCHAR buffer[512];
2317 DWORD count;
2318
2319 if (!argN) break;
2320
2321 WINE_TRACE("type: Processing arg '%s'\n", wine_dbgstr_w(thisArg));
2322 h = CreateFileW(thisArg, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
2323 FILE_ATTRIBUTE_NORMAL, NULL);
2324 if (h == INVALID_HANDLE_VALUE) {
2325 WCMD_print_error ();
2326 WCMD_output (WCMD_LoadMessage(WCMD_READFAIL), thisArg);
2327 errorlevel = 1;
2328 } else {
2329 if (writeHeaders) {
2330 static const WCHAR fmt[] = {'\n','%','s','\n','\n','\0'};
2331 WCMD_output(fmt, thisArg);
2332 }
2333 while (WCMD_ReadFile (h, buffer, sizeof(buffer)/sizeof(WCHAR) - 1, &count, NULL)) {
2334 if (count == 0) break; /* ReadFile reports success on EOF! */
2335 buffer[count] = 0;
2336 WCMD_output_asis (buffer);
2337 }
2338 CloseHandle (h);
2339 if (!writeHeaders)
2340 WCMD_output_asis (newline);
2341 }
2342 }
2343 }
2344
2345 /****************************************************************************
2346 * WCMD_more
2347 *
2348 * Output either a file or stdin to screen in pages
2349 */
2350
2351 void WCMD_more (WCHAR *command) {
2352
2353 int argno = 0;
2354 WCHAR *argN = command;
2355 BOOL useinput = FALSE;
2356 WCHAR moreStr[100];
2357 WCHAR moreStrPage[100];
2358 WCHAR buffer[512];
2359 DWORD count;
2360 static const WCHAR moreStart[] = {'-','-',' ','\0'};
2361 static const WCHAR moreFmt[] = {'%','s',' ','-','-','\n','\0'};
2362 static const WCHAR moreFmt2[] = {'%','s',' ','(','%','2','.','2','d','%','%',
2363 ')',' ','-','-','\n','\0'};
2364 static const WCHAR conInW[] = {'C','O','N','I','N','$','\0'};
2365
2366 /* Prefix the NLS more with '-- ', then load the text */
2367 errorlevel = 0;
2368 strcpyW(moreStr, moreStart);
2369 LoadStringW(hinst, WCMD_MORESTR, &moreStr[3],
2370 (sizeof(moreStr)/sizeof(WCHAR))-3);
2371
2372 if (param1[0] == 0x00) {
2373
2374 /* Wine implements pipes via temporary files, and hence stdin is
2375 effectively reading from the file. This means the prompts for
2376 more are satisfied by the next line from the input (file). To
2377 avoid this, ensure stdin is to the console */
2378 HANDLE hstdin = GetStdHandle(STD_INPUT_HANDLE);
2379 HANDLE hConIn = CreateFileW(conInW, GENERIC_READ | GENERIC_WRITE,
2380 FILE_SHARE_READ, NULL, OPEN_EXISTING,
2381 FILE_ATTRIBUTE_NORMAL, 0);
2382 WINE_TRACE("No parms - working probably in pipe mode\n");
2383 SetStdHandle(STD_INPUT_HANDLE, hConIn);
2384
2385 /* Warning: No easy way of ending the stream (ctrl+z on windows) so
2386 once you get in this bit unless due to a pipe, its going to end badly... */
2387 useinput = TRUE;
2388 wsprintfW(moreStrPage, moreFmt, moreStr);
2389
2390 WCMD_enter_paged_mode(moreStrPage);
2391 while (WCMD_ReadFile (hstdin, buffer, (sizeof(buffer)/sizeof(WCHAR))-1, &count, NULL)) {
2392 if (count == 0) break; /* ReadFile reports success on EOF! */
2393 buffer[count] = 0;
2394 WCMD_output_asis (buffer);
2395 }
2396 WCMD_leave_paged_mode();
2397
2398 /* Restore stdin to what it was */
2399 SetStdHandle(STD_INPUT_HANDLE, hstdin);
2400 CloseHandle(hConIn);
2401
2402 return;
2403 } else {
2404 BOOL needsPause = FALSE;
2405
2406 /* Loop through all args */
2407 WINE_TRACE("Parms supplied - working through each file\n");
2408 WCMD_enter_paged_mode(moreStrPage);
2409
2410 while (argN) {
2411 WCHAR *thisArg = WCMD_parameter (command, argno++, &argN);
2412 HANDLE h;
2413
2414 if (!argN) break;
2415
2416 if (needsPause) {
2417
2418 /* Wait */
2419 wsprintfW(moreStrPage, moreFmt2, moreStr, 100);
2420 WCMD_leave_paged_mode();
2421 WCMD_output_asis(moreStrPage);
2422 WCMD_ReadFile (GetStdHandle(STD_INPUT_HANDLE), buffer,
2423 sizeof(buffer)/sizeof(WCHAR), &count, NULL);
2424 WCMD_enter_paged_mode(moreStrPage);
2425 }
2426
2427
2428 WINE_TRACE("more: Processing arg '%s'\n", wine_dbgstr_w(thisArg));
2429 h = CreateFileW(thisArg, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
2430 FILE_ATTRIBUTE_NORMAL, NULL);
2431 if (h == INVALID_HANDLE_VALUE) {
2432 WCMD_print_error ();
2433 WCMD_output (WCMD_LoadMessage(WCMD_READFAIL), thisArg);
2434 errorlevel = 1;
2435 } else {
2436 ULONG64 curPos = 0;
2437 ULONG64 fileLen = 0;
2438 WIN32_FILE_ATTRIBUTE_DATA fileInfo;
2439
2440 /* Get the file size */
2441 GetFileAttributesExW(thisArg, GetFileExInfoStandard, (void*)&fileInfo);
2442 fileLen = (((ULONG64)fileInfo.nFileSizeHigh) << 32) + fileInfo.nFileSizeLow;
2443
2444 needsPause = TRUE;
2445 while (WCMD_ReadFile (h, buffer, (sizeof(buffer)/sizeof(WCHAR))-1, &count, NULL)) {
2446 if (count == 0) break; /* ReadFile reports success on EOF! */
2447 buffer[count] = 0;
2448 curPos += count;
2449
2450 /* Update % count (would be used in WCMD_output_asis as prompt) */
2451 wsprintfW(moreStrPage, moreFmt2, moreStr, (int) min(99, (curPos * 100)/fileLen));
2452
2453 WCMD_output_asis (buffer);
2454 }
2455 CloseHandle (h);
2456 }
2457 }
2458
2459 WCMD_leave_paged_mode();
2460 }
2461 }
2462
2463 /****************************************************************************
2464 * WCMD_verify
2465 *
2466 * Display verify flag.
2467 * FIXME: We don't actually do anything with the verify flag other than toggle
2468 * it...
2469 */
2470
2471 void WCMD_verify (WCHAR *command) {
2472
2473 int count;
2474
2475 count = strlenW(command);
2476 if (count == 0) {
2477 if (verify_mode) WCMD_output (WCMD_LoadMessage(WCMD_VERIFYPROMPT), onW);
2478 else WCMD_output (WCMD_LoadMessage(WCMD_VERIFYPROMPT), offW);
2479 return;
2480 }
2481 if (lstrcmpiW(command, onW) == 0) {
2482 verify_mode = 1;
2483 return;
2484 }
2485 else if (lstrcmpiW(command, offW) == 0) {
2486 verify_mode = 0;
2487 return;
2488 }
2489 else WCMD_output (WCMD_LoadMessage(WCMD_VERIFYERR));
2490 }
2491
2492 /****************************************************************************
2493 * WCMD_version
2494 *
2495 * Display version info.
2496 */
2497
2498 void WCMD_version (void) {
2499
2500 WCMD_output (version_string);
2501
2502 }
2503
2504 /****************************************************************************
2505 * WCMD_volume
2506 *
2507 * Display volume info and/or set volume label. Returns 0 if error.
2508 */
2509
2510 int WCMD_volume (int mode, WCHAR *path) {
2511
2512 DWORD count, serial;
2513 WCHAR string[MAX_PATH], label[MAX_PATH], curdir[MAX_PATH];
2514 BOOL status;
2515
2516 if (strlenW(path) == 0) {
2517 status = GetCurrentDirectoryW(sizeof(curdir)/sizeof(WCHAR), curdir);
2518 if (!status) {
2519 WCMD_print_error ();
2520 return 0;
2521 }
2522 status = GetVolumeInformationW(NULL, label, sizeof(label)/sizeof(WCHAR),
2523 &serial, NULL, NULL, NULL, 0);
2524 }
2525 else {
2526 static const WCHAR fmt[] = {'%','s','\\','\0'};
2527 if ((path[1] != ':') || (strlenW(path) != 2)) {
2528 WCMD_output (WCMD_LoadMessage(WCMD_SYNTAXERR));
2529 return 0;
2530 }
2531 wsprintfW (curdir, fmt, path);
2532 status = GetVolumeInformationW(curdir, label, sizeof(label)/sizeof(WCHAR),
2533 &serial, NULL,
2534 NULL, NULL, 0);
2535 }
2536 if (!status) {
2537 WCMD_print_error ();
2538 return 0;
2539 }
2540 WCMD_output (WCMD_LoadMessage(WCMD_VOLUMEDETAIL),
2541 curdir[0], label, HIWORD(serial), LOWORD(serial));
2542 if (mode) {
2543 WCMD_output (WCMD_LoadMessage(WCMD_VOLUMEPROMPT));
2544 WCMD_ReadFile (GetStdHandle(STD_INPUT_HANDLE), string,
2545 sizeof(string)/sizeof(WCHAR), &count, NULL);
2546 if (count > 1) {
2547 string[count-1] = '\0'; /* ReadFile output is not null-terminated! */
2548 if (string[count-2] == '\r') string[count-2] = '\0'; /* Under Windoze we get CRLF! */
2549 }
2550 if (strlenW(path) != 0) {
2551 if (!SetVolumeLabelW(curdir, string)) WCMD_print_error ();
2552 }
2553 else {
2554 if (!SetVolumeLabelW(NULL, string)) WCMD_print_error ();
2555 }
2556 }
2557 return 1;
2558 }
2559
2560 /**************************************************************************
2561 * WCMD_exit
2562 *
2563 * Exit either the process, or just this batch program
2564 *
2565 */
2566
2567 void WCMD_exit (CMD_LIST **cmdList) {
2568
2569 static const WCHAR parmB[] = {'/','B','\0'};
2570 int rc = atoiW(param1); /* Note: atoi of empty parameter is 0 */
2571
2572 if (context && lstrcmpiW(quals, parmB) == 0) {
2573 errorlevel = rc;
2574 context -> skip_rest = TRUE;
2575 *cmdList = NULL;
2576 } else {
2577 ExitProcess(rc);
2578 }
2579 }
2580
2581
2582 /*****************************************************************************
2583 * WCMD_assoc
2584 *
2585 * Lists or sets file associations (assoc = TRUE)
2586 * Lists or sets file types (assoc = FALSE)
2587 */
2588 void WCMD_assoc (WCHAR *command, BOOL assoc) {
2589
2590 HKEY key;
2591 DWORD accessOptions = KEY_READ;
2592 WCHAR *newValue;
2593 LONG rc = ERROR_SUCCESS;
2594 WCHAR keyValue[MAXSTRING];
2595 DWORD valueLen = MAXSTRING;
2596 HKEY readKey;
2597 static const WCHAR shOpCmdW[] = {'\\','S','h','e','l','l','\\',
2598 'O','p','e','n','\\','C','o','m','m','a','n','d','\0'};
2599
2600 /* See if parameter includes '=' */
2601 errorlevel = 0;
2602 newValue = strchrW(command, '=');
2603 if (newValue) accessOptions |= KEY_WRITE;
2604
2605 /* Open a key to HKEY_CLASSES_ROOT for enumerating */
2606 if (RegOpenKeyExW(HKEY_CLASSES_ROOT, nullW, 0,
2607 accessOptions, &key) != ERROR_SUCCESS) {
2608 WINE_FIXME("Unexpected failure opening HKCR key: %d\n", GetLastError());
2609 return;
2610 }
2611
2612 /* If no parameters then list all associations */
2613 if (*command == 0x00) {
2614 int index = 0;
2615
2616 /* Enumerate all the keys */
2617 while (rc != ERROR_NO_MORE_ITEMS) {
2618 WCHAR keyName[MAXSTRING];
2619 DWORD nameLen;
2620
2621 /* Find the next value */
2622 nameLen = MAXSTRING;
2623 rc = RegEnumKeyExW(key, index++, keyName, &nameLen, NULL, NULL, NULL, NULL);
2624
2625 if (rc == ERROR_SUCCESS) {
2626
2627 /* Only interested in extension ones if assoc, or others
2628 if not assoc */
2629 if ((keyName[0] == '.' && assoc) ||
2630 (!(keyName[0] == '.') && (!assoc)))
2631 {
2632 WCHAR subkey[MAXSTRING];
2633 strcpyW(subkey, keyName);
2634 if (!assoc) strcatW(subkey, shOpCmdW);
2635
2636 if (RegOpenKeyExW(key, subkey, 0, accessOptions, &readKey) == ERROR_SUCCESS) {
2637
2638 valueLen = sizeof(keyValue)/sizeof(WCHAR);
2639 rc = RegQueryValueExW(readKey, NULL, NULL, NULL, (LPBYTE)keyValue, &valueLen);
2640 WCMD_output_asis(keyName);
2641 WCMD_output_asis(equalW);
2642 /* If no default value found, leave line empty after '=' */
2643 if (rc == ERROR_SUCCESS) {
2644 WCMD_output_asis(keyValue);
2645 }
2646 WCMD_output_asis(newline);
2647 RegCloseKey(readKey);
2648 }
2649 }
2650 }
2651 }
2652
2653 } else {
2654
2655 /* Parameter supplied - if no '=' on command line, its a query */
2656 if (newValue == NULL) {
2657 WCHAR *space;
2658 WCHAR subkey[MAXSTRING];
2659
2660 /* Query terminates the parameter at the first space */
2661 strcpyW(keyValue, command);
2662 space = strchrW(keyValue, ' ');
2663 if (space) *space=0x00;
2664
2665 /* Set up key name */
2666 strcpyW(subkey, keyValue);
2667 if (!assoc) strcatW(subkey, shOpCmdW);
2668
2669 if (RegOpenKeyExW(key, subkey, 0, accessOptions, &readKey) == ERROR_SUCCESS) {
2670
2671 rc = RegQueryValueExW(readKey, NULL, NULL, NULL, (LPBYTE)keyValue, &valueLen);
2672 WCMD_output_asis(command);
2673 WCMD_output_asis(equalW);
2674 /* If no default value found, leave line empty after '=' */
2675 if (rc == ERROR_SUCCESS) WCMD_output_asis(keyValue);
2676 WCMD_output_asis(newline);
2677 RegCloseKey(readKey);
2678
2679 } else {
2680 WCHAR msgbuffer[MAXSTRING];
2681 WCHAR outbuffer[MAXSTRING];
2682
2683 /* Load the translated 'File association not found' */
2684 if (assoc) {
2685 LoadStringW(hinst, WCMD_NOASSOC, msgbuffer, sizeof(msgbuffer)/sizeof(WCHAR));
2686 } else {
2687 LoadStringW(hinst, WCMD_NOFTYPE, msgbuffer, sizeof(msgbuffer)/sizeof(WCHAR));
2688 }
2689 wsprintfW(outbuffer, msgbuffer, keyValue);
2690 WCMD_output_asis(outbuffer);
2691 errorlevel = 2;
2692 }
2693
2694 /* Not a query - its a set or clear of a value */
2695 } else {
2696
2697 WCHAR subkey[MAXSTRING];
2698
2699 /* Get pointer to new value */
2700 *newValue = 0x00;
2701 newValue++;
2702
2703 /* Set up key name */
2704 strcpyW(subkey, command);
2705 if (!assoc) strcatW(subkey, shOpCmdW);
2706
2707 /* If nothing after '=' then clear value - only valid for ASSOC */
2708 if (*newValue == 0x00) {
2709
2710 if (assoc) rc = RegDeleteKeyW(key, command);
2711 if (assoc && rc == ERROR_SUCCESS) {
2712 WINE_TRACE("HKCR Key '%s' deleted\n", wine_dbgstr_w(command));
2713
2714 } else if (assoc && rc != ERROR_FILE_NOT_FOUND) {
2715 WCMD_print_error();
2716 errorlevel = 2;
2717
2718 } else {
2719 WCHAR msgbuffer[MAXSTRING];
2720 WCHAR outbuffer[MAXSTRING];
2721
2722 /* Load the translated 'File association not found' */
2723 if (assoc) {
2724 LoadStringW(hinst, WCMD_NOASSOC, msgbuffer,
2725 sizeof(msgbuffer)/sizeof(WCHAR));
2726 } else {
2727 LoadStringW(hinst, WCMD_NOFTYPE, msgbuffer,
2728 sizeof(msgbuffer)/sizeof(WCHAR));
2729 }
2730 wsprintfW(outbuffer, msgbuffer, keyValue);
2731 WCMD_output_asis(outbuffer);
2732 errorlevel = 2;
2733 }
2734
2735 /* It really is a set value = contents */
2736 } else {
2737 rc = RegCreateKeyExW(key, subkey, 0, NULL, REG_OPTION_NON_VOLATILE,
2738 accessOptions, NULL, &readKey, NULL);
2739 if (rc == ERROR_SUCCESS) {
2740 rc = RegSetValueExW(readKey, NULL, 0, REG_SZ,
2741 (LPBYTE)newValue, strlenW(newValue));
2742 RegCloseKey(readKey);
2743 }
2744
2745 if (rc != ERROR_SUCCESS) {
2746 WCMD_print_error();
2747 errorlevel = 2;
2748 } else {
2749 WCMD_output_asis(command);
2750 WCMD_output_asis(equalW);
2751 WCMD_output_asis(newValue);
2752 WCMD_output_asis(newline);
2753 }
2754 }
2755 }
2756 }
2757
2758 /* Clean up */
2759 RegCloseKey(key);
2760 }
2761
2762 /****************************************************************************
2763 * WCMD_color
2764 *
2765 * Clear the terminal screen.
2766 */
2767
2768 void WCMD_color (void) {
2769
2770 /* Emulate by filling the screen from the top left to bottom right with
2771 spaces, then moving the cursor to the top left afterwards */
2772 CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
2773 HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
2774
2775 if (param1[0] != 0x00 && strlenW(param1) > 2) {
2776 WCMD_output (WCMD_LoadMessage(WCMD_ARGERR));
2777 return;
2778 }
2779
2780 if (GetConsoleScreenBufferInfo(hStdOut, &consoleInfo))
2781 {
2782 COORD topLeft;
2783 DWORD screenSize;
2784 DWORD color = 0;
2785
2786 screenSize = consoleInfo.dwSize.X * (consoleInfo.dwSize.Y + 1);
2787
2788 topLeft.X = 0;
2789 topLeft.Y = 0;
2790
2791 /* Convert the color hex digits */
2792 if (param1[0] == 0x00) {
2793 color = defaultColor;
2794 } else {
2795 color = strtoulW(param1, NULL, 16);
2796 }
2797
2798 /* Fail if fg == bg color */
2799 if (((color & 0xF0) >> 4) == (color & 0x0F)) {
2800 errorlevel = 1;
2801 return;
2802 }
2803
2804 /* Set the current screen contents and ensure all future writes
2805 remain this color */
2806 FillConsoleOutputAttribute(hStdOut, color, screenSize, topLeft, &screenSize);
2807 SetConsoleTextAttribute(hStdOut, color);
2808 }
2809 }
useful hacks and other patches not (yet) suitable for mainline