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