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