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