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