Changed setting default port number from HTTP_Connect to
[wine] / programs / wcmd / builtins.c
1 /*
2  * WCMD - Wine-compatible command line interface - built-in functions.
3  *
4  * Copyright (C) 1999 D A Pickles
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 /*
22  * NOTES:
23  * On entry to each function, global variables quals, param1, param2 contain
24  * the qualifiers (uppercased and concatenated) and parameters entered, with
25  * environment-variable and batch parameter substitution already done.
26  */
27
28 /*
29  * FIXME:
30  * - No support for pipes, shell parameters
31  * - Lots of functionality missing from builtins
32  * - Messages etc need international support
33  */
34
35 #include "wcmd.h"
36
37 void WCMD_execute (char *orig_command, char *parameter, char *substitution);
38
39 struct env_stack
40 {
41   struct env_stack *next;
42   WCHAR *strings;
43 };
44
45 struct env_stack *saved_environment;
46
47 extern HINSTANCE hinst;
48 extern char *inbuilt[];
49 extern int echo_mode, verify_mode;
50 extern char quals[MAX_PATH], param1[MAX_PATH], param2[MAX_PATH];
51 extern BATCH_CONTEXT *context;
52 extern DWORD errorlevel;
53
54
55
56 /****************************************************************************
57  * WCMD_clear_screen
58  *
59  * Clear the terminal screen.
60  */
61
62 void WCMD_clear_screen (void) {
63
64   /* Emulate by filling the screen from the top left to bottom right with
65         spaces, then moving the cursor to the top left afterwards */
66   CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
67   HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
68
69   if (GetConsoleScreenBufferInfo(hStdOut, &consoleInfo))
70   {
71       COORD topLeft;
72       long screenSize;
73       
74       screenSize = consoleInfo.dwSize.X * (consoleInfo.dwSize.Y + 1);
75
76       topLeft.X = 0;
77       topLeft.Y = 0;
78       FillConsoleOutputCharacter(hStdOut, ' ', screenSize, topLeft, &screenSize);
79       SetConsoleCursorPosition(hStdOut, topLeft);
80   }
81 }
82
83 /****************************************************************************
84  * WCMD_change_tty
85  *
86  * Change the default i/o device (ie redirect STDin/STDout).
87  */
88
89 void WCMD_change_tty (void) {
90
91   WCMD_output (nyi);
92
93 }
94
95 /****************************************************************************
96  * WCMD_copy
97  *
98  * Copy a file or wildcarded set.
99  * FIXME: No wildcard support
100  */
101
102 void WCMD_copy (void) {
103
104 DWORD count;
105 WIN32_FIND_DATA fd;
106 HANDLE hff;
107 BOOL force, status;
108 static const char *overwrite = "Overwrite file (Y/N)?";
109 char string[8], outpath[MAX_PATH], inpath[MAX_PATH], *infile;
110
111   if ((strchr(param1,'*') != NULL) && (strchr(param1,'%') != NULL)) {
112     WCMD_output ("Wildcards not yet supported\n");
113     return;
114   }
115
116   /* If no destination supplied, assume current directory */
117   if (param2[0] == 0x00) {
118       strcpy(param2, ".");
119   }
120
121   GetFullPathName (param2, sizeof(outpath), outpath, NULL);
122   hff = FindFirstFile (outpath, &fd);
123   if (hff != INVALID_HANDLE_VALUE) {
124     if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
125       GetFullPathName (param1, sizeof(inpath), inpath, &infile);
126       strcat (outpath, "\\");
127       strcat (outpath, infile);
128     }
129     FindClose (hff);
130   }
131
132   force = (strstr (quals, "/Y") != NULL);
133   if (!force) {
134     hff = FindFirstFile (outpath, &fd);
135     if (hff != INVALID_HANDLE_VALUE) {
136       FindClose (hff);
137       WCMD_output (overwrite);
138       ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
139       if (toupper(string[0]) == 'Y') force = TRUE;
140     }
141     else force = TRUE;
142   }
143   if (force) {
144     status = CopyFile (param1, outpath, FALSE);
145     if (!status) WCMD_print_error ();
146   }
147 }
148
149 /****************************************************************************
150  * WCMD_create_dir
151  *
152  * Create a directory.
153  */
154
155 void WCMD_create_dir (void) {
156
157   if (!CreateDirectory (param1, NULL)) WCMD_print_error ();
158 }
159
160 /****************************************************************************
161  * WCMD_delete
162  *
163  * Delete a file or wildcarded set.
164  *
165  */
166
167 void WCMD_delete (int recurse) {
168
169 WIN32_FIND_DATA fd;
170 HANDLE hff;
171 char fpath[MAX_PATH];
172 char *p;
173
174   hff = FindFirstFile (param1, &fd);
175   if (hff == INVALID_HANDLE_VALUE) {
176     WCMD_output ("%s :File Not Found\n",param1);
177     return;
178   }
179   if ((strchr(param1,'*') == NULL) && (strchr(param1,'?') == NULL)
180         && (!recurse) && (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
181     strcat (param1, "\\*");
182     FindClose(hff);
183     WCMD_delete (1);
184     return;
185   }
186   if ((strchr(param1,'*') != NULL) || (strchr(param1,'?') != NULL)) {
187     strcpy (fpath, param1);
188     do {
189       p = strrchr (fpath, '\\');
190       if (p != NULL) {
191         *++p = '\0';
192         strcat (fpath, fd.cFileName);
193       }
194       else strcpy (fpath, fd.cFileName);
195       if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
196         if (!DeleteFile (fpath)) WCMD_print_error ();
197       }
198     } while (FindNextFile(hff, &fd) != 0);
199     FindClose (hff);
200   }
201   else {
202     if (!DeleteFile (param1)) WCMD_print_error ();
203     FindClose (hff);
204   }
205 }
206
207 /****************************************************************************
208  * WCMD_echo
209  *
210  * Echo input to the screen (or not). We don't try to emulate the bugs
211  * in DOS (try typing "ECHO ON AGAIN" for an example).
212  */
213
214 void WCMD_echo (const char *command) {
215
216 static const char *eon = "Echo is ON\n", *eoff = "Echo is OFF\n";
217 int count;
218
219   if ((command[0] == '.') && (command[1] == 0)) {
220     WCMD_output (newline);
221     return;
222   }
223   if (command[0]==' ')
224     command++;
225   count = strlen(command);
226   if (count == 0) {
227     if (echo_mode) WCMD_output (eon);
228     else WCMD_output (eoff);
229     return;
230   }
231   if (lstrcmpi(command, "ON") == 0) {
232     echo_mode = 1;
233     return;
234   }
235   if (lstrcmpi(command, "OFF") == 0) {
236     echo_mode = 0;
237     return;
238   }
239   WCMD_output_asis (command);
240   WCMD_output (newline);
241
242 }
243
244 /**************************************************************************
245  * WCMD_for
246  *
247  * Batch file loop processing.
248  * FIXME: We don't exhaustively check syntax. Any command which works in MessDOS
249  * will probably work here, but the reverse is not necessarily the case...
250  */
251
252 void WCMD_for (char *p) {
253
254 WIN32_FIND_DATA fd;
255 HANDLE hff;
256 char *cmd, *item;
257 char set[MAX_PATH], param[MAX_PATH];
258 int i;
259
260   if (lstrcmpi (WCMD_parameter (p, 1, NULL), "in")
261         || lstrcmpi (WCMD_parameter (p, 3, NULL), "do")
262         || (param1[0] != '%')) {
263     WCMD_output ("Syntax error\n");
264     return;
265   }
266   lstrcpyn (set, WCMD_parameter (p, 2, NULL), sizeof(set));
267   WCMD_parameter (p, 4, &cmd);
268   lstrcpy (param, param1);
269
270 /*
271  *      If the parameter within the set has a wildcard then search for matching files
272  *      otherwise do a literal substitution.
273  */
274
275   i = 0;
276   while (*(item = WCMD_parameter (set, i, NULL))) {
277     if (strpbrk (item, "*?")) {
278       hff = FindFirstFile (item, &fd);
279       if (hff == INVALID_HANDLE_VALUE) {
280         return;
281       }
282       do {
283         WCMD_execute (cmd, param, fd.cFileName);
284       } while (FindNextFile(hff, &fd) != 0);
285       FindClose (hff);
286 }
287     else {
288       WCMD_execute (cmd, param, item);
289     }
290     i++;
291   }
292 }
293
294 /*****************************************************************************
295  * WCMD_Execute
296  *
297  *      Execute a command after substituting variable text for the supplied parameter
298  */
299
300 void WCMD_execute (char *orig_cmd, char *param, char *subst) {
301
302 char *new_cmd, *p, *s, *dup;
303 int size;
304
305   size = lstrlen (orig_cmd);
306   new_cmd = (char *) LocalAlloc (LMEM_FIXED | LMEM_ZEROINIT, size);
307   dup = s = strdup (orig_cmd);
308
309   while ((p = strstr (s, param))) {
310     *p = '\0';
311     size += lstrlen (subst);
312     new_cmd = (char *) LocalReAlloc ((HANDLE)new_cmd, size, 0);
313     strcat (new_cmd, s);
314     strcat (new_cmd, subst);
315     s = p + lstrlen (param);
316   }
317   strcat (new_cmd, s);
318   WCMD_process_command (new_cmd);
319   free (dup);
320   LocalFree ((HANDLE)new_cmd);
321 }
322
323
324 /**************************************************************************
325  * WCMD_give_help
326  *
327  *      Simple on-line help. Help text is stored in the resource file.
328  */
329
330 void WCMD_give_help (char *command) {
331
332 int i;
333 char buffer[2048];
334
335   command = WCMD_strtrim_leading_spaces(command);
336   if (lstrlen(command) == 0) {
337     LoadString (hinst, 1000, buffer, sizeof(buffer));
338     WCMD_output_asis (buffer);
339   }
340   else {
341     for (i=0; i<=WCMD_EXIT; i++) {
342       if (CompareString (LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
343           param1, -1, inbuilt[i], -1) == 2) {
344         LoadString (hinst, i, buffer, sizeof(buffer));
345         WCMD_output_asis (buffer);
346         return;
347       }
348     }
349     WCMD_output ("No help available for %s\n", param1);
350   }
351   return;
352 }
353
354 /****************************************************************************
355  * WCMD_go_to
356  *
357  * Batch file jump instruction. Not the most efficient algorithm ;-)
358  * Prints error message if the specified label cannot be found - the file pointer is
359  * then at EOF, effectively stopping the batch file.
360  * FIXME: DOS is supposed to allow labels with spaces - we don't.
361  */
362
363 void WCMD_goto (void) {
364
365 char string[MAX_PATH];
366
367   if (context != NULL) {
368     SetFilePointer (context -> h, 0, NULL, FILE_BEGIN);
369     while (WCMD_fgets (string, sizeof(string), context -> h)) {
370       if ((string[0] == ':') && (strcmp (&string[1], param1) == 0)) return;
371     }
372     WCMD_output ("Target to GOTO not found\n");
373   }
374   return;
375 }
376
377
378 /****************************************************************************
379  * WCMD_if
380  *
381  * Batch file conditional.
382  * FIXME: Much more syntax checking needed!
383  */
384
385 void WCMD_if (char *p) {
386
387 int negate = 0, test = 0;
388 char condition[MAX_PATH], *command, *s;
389
390   if (!lstrcmpi (param1, "not")) {
391     negate = 1;
392     lstrcpy (condition, param2);
393 }
394   else {
395     lstrcpy (condition, param1);
396   }
397   if (!lstrcmpi (condition, "errorlevel")) {
398     if (errorlevel >= atoi(WCMD_parameter (p, 1+negate, NULL))) test = 1;
399     return;
400     WCMD_parameter (p, 2+negate, &command);
401   }
402   else if (!lstrcmpi (condition, "exist")) {
403     if (GetFileAttributesA(WCMD_parameter (p, 1+negate, NULL)) != INVALID_FILE_ATTRIBUTES) {
404         test = 1;
405     }
406     WCMD_parameter (p, 2+negate, &command);
407   }
408   else if ((s = strstr (p, "=="))) {
409     s += 2;
410     if (!lstrcmpi (condition, WCMD_parameter (s, 0, NULL))) test = 1;
411     WCMD_parameter (s, 1, &command);
412   }
413   else {
414     WCMD_output ("Syntax error\n");
415     return;
416   }
417   if (test != negate) {
418     command = strdup (command);
419     WCMD_process_command (command);
420     free (command);
421   }
422 }
423
424 /****************************************************************************
425  * WCMD_move
426  *
427  * Move a file, directory tree or wildcarded set of files.
428  * FIXME: Needs input and output files to be fully specified.
429  */
430
431 void WCMD_move (void) {
432
433 int status;
434 char outpath[MAX_PATH], inpath[MAX_PATH], *infile;
435 WIN32_FIND_DATA fd;
436 HANDLE hff;
437
438   if ((strchr(param1,'*') != NULL) || (strchr(param1,'%') != NULL)) {
439     WCMD_output ("Wildcards not yet supported\n");
440     return;
441   }
442
443   /* If no destination supplied, assume current directory */
444   if (param2[0] == 0x00) {
445       strcpy(param2, ".");
446   }
447
448   /* If 2nd parm is directory, then use original filename */
449   GetFullPathName (param2, sizeof(outpath), outpath, NULL);
450   hff = FindFirstFile (outpath, &fd);
451   if (hff != INVALID_HANDLE_VALUE) {
452     if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
453       GetFullPathName (param1, sizeof(inpath), inpath, &infile);
454       strcat (outpath, "\\");
455       strcat (outpath, infile);
456     }
457     FindClose (hff);
458   }
459
460   status = MoveFile (param1, outpath);
461   if (!status) WCMD_print_error ();
462 }
463
464 /****************************************************************************
465  * WCMD_pause
466  *
467  * Wait for keyboard input.
468  */
469
470 void WCMD_pause (void) {
471
472 DWORD count;
473 char string[32];
474
475   WCMD_output (anykey);
476   ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
477 }
478
479 /****************************************************************************
480  * WCMD_remove_dir
481  *
482  * Delete a directory.
483  */
484
485 void WCMD_remove_dir (void) {
486
487   if (!RemoveDirectory (param1)) WCMD_print_error ();
488 }
489
490 /****************************************************************************
491  * WCMD_rename
492  *
493  * Rename a file.
494  * FIXME: Needs input and output files to be fully specified.
495  */
496
497 void WCMD_rename (void) {
498
499 int status;
500
501   if ((strchr(param1,'*') != NULL) || (strchr(param1,'%') != NULL)) {
502     WCMD_output ("Wildcards not yet supported\n");
503     return;
504   }
505   status = MoveFile (param1, param2);
506   if (!status) WCMD_print_error ();
507 }
508
509 /*****************************************************************************
510  * WCMD_dupenv
511  *
512  * Make a copy of the environment.
513  */
514 static WCHAR *WCMD_dupenv( const WCHAR *env )
515 {
516   WCHAR *env_copy;
517   int len;
518
519   if( !env )
520     return NULL;
521
522   len = 0;
523   while ( env[len] )
524     len += (lstrlenW(&env[len]) + 1);
525
526   env_copy = LocalAlloc (LMEM_FIXED, (len+1) * sizeof (WCHAR) );
527   if (!env_copy)
528   {
529     WCMD_output ("out of memory\n");
530     return env_copy;
531   }
532   memcpy (env_copy, env, len*sizeof (WCHAR));
533   env_copy[len] = 0;
534
535   return env_copy;
536 }
537
538 /*****************************************************************************
539  * WCMD_setlocal
540  *
541  *  setlocal pushes the environment onto a stack
542  *  Save the environment as unicode so we don't screw anything up.
543  */
544 void WCMD_setlocal (const char *s) {
545   WCHAR *env;
546   struct env_stack *env_copy;
547
548   /* DISABLEEXTENSIONS ignored */
549
550   env_copy = LocalAlloc (LMEM_FIXED, sizeof (struct env_stack));
551   if( !env_copy )
552   {
553     WCMD_output ("out of memory\n");
554     return;
555   }
556
557   env = GetEnvironmentStringsW ();
558
559   env_copy->strings = WCMD_dupenv (env);
560   if (env_copy->strings)
561   {
562     env_copy->next = saved_environment;
563     saved_environment = env_copy;
564   }
565   else
566     LocalFree (env_copy);
567
568   FreeEnvironmentStringsW (env);
569 }
570
571 /*****************************************************************************
572  * WCMD_strchrW
573  */
574 static inline WCHAR *WCMD_strchrW(WCHAR *str, WCHAR ch)
575 {
576    while(*str)
577    {
578      if(*str == ch)
579        return str;
580      str++;
581    }
582    return NULL;
583 }
584
585 /*****************************************************************************
586  * WCMD_endlocal
587  *
588  *  endlocal pops the environment off a stack
589  */
590 void WCMD_endlocal (void) {
591   WCHAR *env, *old, *p;
592   struct env_stack *temp;
593   int len, n;
594
595   if (!saved_environment)
596     return;
597
598   /* pop the old environment from the stack */
599   temp = saved_environment;
600   saved_environment = temp->next;
601
602   /* delete the current environment, totally */
603   env = GetEnvironmentStringsW ();
604   old = WCMD_dupenv (GetEnvironmentStringsW ());
605   len = 0;
606   while (old[len]) {
607     n = lstrlenW(&old[len]) + 1;
608     p = WCMD_strchrW(&old[len], '=');
609     if (p)
610     {
611       *p++ = 0;
612       SetEnvironmentVariableW (&old[len], NULL);
613     }
614     len += n;
615   }
616   LocalFree (old);
617   FreeEnvironmentStringsW (env);
618   
619   /* restore old environment */
620   env = temp->strings;
621   len = 0;
622   while (env[len]) {
623     n = lstrlenW(&env[len]) + 1;
624     p = WCMD_strchrW(&env[len], '=');
625     if (p)
626     {
627       *p++ = 0;
628       SetEnvironmentVariableW (&env[len], p);
629     }
630     len += n;
631   }
632   LocalFree (env);
633   LocalFree (temp);
634 }
635
636 /*****************************************************************************
637  * WCMD_setshow_attrib
638  *
639  * Display and optionally sets DOS attributes on a file or directory
640  *
641  * FIXME: Wine currently uses the Unix stat() function to get file attributes.
642  * As a result only the Readonly flag is correctly reported, the Archive bit
643  * is always set and the rest are not implemented. We do the Right Thing anyway.
644  *
645  * FIXME: No SET functionality.
646  *
647  */
648
649 void WCMD_setshow_attrib (void) {
650
651 DWORD count;
652 HANDLE hff;
653 WIN32_FIND_DATA fd;
654 char flags[9] = {"        "};
655
656   if (param1[0] == '-') {
657     WCMD_output (nyi);
658     return;
659   }
660
661   if (lstrlen(param1) == 0) {
662     GetCurrentDirectory (sizeof(param1), param1);
663     strcat (param1, "\\*");
664   }
665
666   hff = FindFirstFile (param1, &fd);
667   if (hff == INVALID_HANDLE_VALUE) {
668     WCMD_output ("%s: File Not Found\n",param1);
669   }
670   else {
671     do {
672       if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
673         if (fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) {
674           flags[0] = 'H';
675         }
676         if (fd.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) {
677           flags[1] = 'S';
678         }
679         if (fd.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE) {
680           flags[2] = 'A';
681         }
682         if (fd.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
683           flags[3] = 'R';
684         }
685         if (fd.dwFileAttributes & FILE_ATTRIBUTE_TEMPORARY) {
686           flags[4] = 'T';
687         }
688         if (fd.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED) {
689           flags[5] = 'C';
690         }
691         WCMD_output ("%s   %s\n", flags, fd.cFileName);
692         for (count=0; count < 8; count++) flags[count] = ' ';
693       }
694     } while (FindNextFile(hff, &fd) != 0);
695   }
696   FindClose (hff);
697 }
698
699 /*****************************************************************************
700  * WCMD_setshow_default
701  *
702  *      Set/Show the current default directory
703  */
704
705 void WCMD_setshow_default (void) {
706
707 BOOL status;
708 char string[1024];
709
710   if (strlen(param1) == 0) {
711     GetCurrentDirectory (sizeof(string), string);
712     strcat (string, "\n");
713     WCMD_output (string);
714   }
715   else {
716     status = SetCurrentDirectory (param1);
717     if (!status) {
718       WCMD_print_error ();
719       return;
720     }
721    }
722   return;
723 }
724
725 /****************************************************************************
726  * WCMD_setshow_date
727  *
728  * Set/Show the system date
729  * FIXME: Can't change date yet
730  */
731
732 void WCMD_setshow_date (void) {
733
734 char curdate[64], buffer[64];
735 DWORD count;
736
737   if (lstrlen(param1) == 0) {
738     if (GetDateFormat (LOCALE_USER_DEFAULT, 0, NULL, NULL,
739                 curdate, sizeof(curdate))) {
740       WCMD_output ("Current Date is %s\nEnter new date: ", curdate);
741       ReadFile (GetStdHandle(STD_INPUT_HANDLE), buffer, sizeof(buffer), &count, NULL);
742       if (count > 2) {
743         WCMD_output (nyi);
744       }
745     }
746     else WCMD_print_error ();
747   }
748   else {
749     WCMD_output (nyi);
750   }
751 }
752
753 /****************************************************************************
754  * WCMD_compare
755  */
756 static int WCMD_compare( const void *a, const void *b )
757 {
758     int r;
759     const char * const *str_a = a, * const *str_b = b;
760     r = CompareString( LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
761           *str_a, -1, *str_b, -1 );
762     if( r == CSTR_LESS_THAN ) return -1;
763     if( r == CSTR_GREATER_THAN ) return 1;
764     return 0;
765 }
766
767 /****************************************************************************
768  * WCMD_setshow_sortenv
769  *
770  * sort variables into order for display
771  */
772 static void WCMD_setshow_sortenv(const char *s)
773 {
774   UINT count=0, len=0, i;
775   const char **str;
776
777   /* count the number of strings, and the total length */
778   while ( s[len] ) {
779     len += (lstrlen(&s[len]) + 1);
780     count++;
781   }
782
783   /* add the strings to an array */
784   str = LocalAlloc (LMEM_FIXED | LMEM_ZEROINIT, count * sizeof (char*) );
785   if( !str )
786     return;
787   str[0] = s;
788   for( i=1; i<count; i++ )
789     str[i] = str[i-1] + lstrlen(str[i-1]) + 1;
790
791   /* sort the array */
792   qsort( str, count, sizeof (char*), WCMD_compare );
793
794   /* print it */
795   for( i=0; i<count; i++ )
796     WCMD_output("%s\n", str[i] );
797
798   LocalFree( str );
799 }
800
801 /****************************************************************************
802  * WCMD_setshow_env
803  *
804  * Set/Show the environment variables
805  */
806
807 void WCMD_setshow_env (char *s) {
808
809 LPVOID env;
810 char *p;
811 int status;
812 char buffer[1048];
813
814   if (strlen(param1) == 0) {
815     env = GetEnvironmentStrings ();
816     WCMD_setshow_sortenv( env );
817   }
818   else {
819     p = strchr (s, '=');
820     if (p == NULL) {
821
822       /* FIXME: Emulate Win98 for now, ie "SET C" looks ONLY for an
823          environment variable C, whereas on NT it shows ALL variables
824          starting with C.
825        */
826       status = GetEnvironmentVariable(s, buffer, sizeof(buffer));
827       if (status) {
828         WCMD_output("%s=%s\n", s, buffer);
829       } else {
830         WCMD_output ("Environment variable %s not defined\n", s);
831       }
832       return;
833     }
834     *p++ = '\0';
835
836     if (strlen(p) == 0) p = 0x00;
837     status = SetEnvironmentVariable (s, p);
838     if (!status) WCMD_print_error();
839   }
840   /* WCMD_output (newline);   @JED*/
841 }
842
843 /****************************************************************************
844  * WCMD_setshow_path
845  *
846  * Set/Show the path environment variable
847  */
848
849 void WCMD_setshow_path (char *command) {
850
851 char string[1024];
852 DWORD status;
853
854   if (strlen(param1) == 0) {
855     status = GetEnvironmentVariable ("PATH", string, sizeof(string));
856     if (status != 0) {
857       WCMD_output ("PATH=%s\n", string);
858     }
859     else {
860       WCMD_output ("PATH not found\n");
861     }
862   }
863   else {
864     status = SetEnvironmentVariable ("PATH", command);
865     if (!status) WCMD_print_error();
866   }
867 }
868
869 /****************************************************************************
870  * WCMD_setshow_prompt
871  *
872  * Set or show the command prompt.
873  */
874
875 void WCMD_setshow_prompt (void) {
876
877 char *s;
878
879   if (strlen(param1) == 0) {
880     SetEnvironmentVariable ("PROMPT", NULL);
881   }
882   else {
883     s = param1;
884     while ((*s == '=') || (*s == ' ')) s++;
885     if (strlen(s) == 0) {
886       SetEnvironmentVariable ("PROMPT", NULL);
887     }
888     else SetEnvironmentVariable ("PROMPT", s);
889   }
890 }
891
892 /****************************************************************************
893  * WCMD_setshow_time
894  *
895  * Set/Show the system time
896  * FIXME: Can't change time yet
897  */
898
899 void WCMD_setshow_time (void) {
900
901 char curtime[64], buffer[64];
902 DWORD count;
903 SYSTEMTIME st;
904
905   if (strlen(param1) == 0) {
906     GetLocalTime(&st);
907     if (GetTimeFormat (LOCALE_USER_DEFAULT, 0, &st, NULL,
908                 curtime, sizeof(curtime))) {
909       WCMD_output ("Current Time is %s\nEnter new time: ", curtime);
910       ReadFile (GetStdHandle(STD_INPUT_HANDLE), buffer, sizeof(buffer), &count, NULL);
911       if (count > 2) {
912         WCMD_output (nyi);
913       }
914     }
915     else WCMD_print_error ();
916   }
917   else {
918     WCMD_output (nyi);
919   }
920 }
921
922 /****************************************************************************
923  * WCMD_shift
924  *
925  * Shift batch parameters.
926  */
927
928 void WCMD_shift (void) {
929
930   if (context != NULL) context -> shift_count++;
931
932 }
933
934 /****************************************************************************
935  * WCMD_title
936  *
937  * Set the console title
938  */
939 void WCMD_title (char *command) {
940   SetConsoleTitle(command);
941 }
942
943 /****************************************************************************
944  * WCMD_type
945  *
946  * Copy a file to standard output.
947  */
948
949 void WCMD_type (void) {
950
951 HANDLE h;
952 char buffer[512];
953 DWORD count;
954
955   h = CreateFile (param1, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
956                 FILE_ATTRIBUTE_NORMAL, NULL);
957   if (h == INVALID_HANDLE_VALUE) {
958     WCMD_print_error ();
959     return;
960   }
961   while (ReadFile (h, buffer, sizeof(buffer), &count, NULL)) {
962     if (count == 0) break;      /* ReadFile reports success on EOF! */
963     buffer[count] = 0;
964     WCMD_output_asis (buffer);
965   }
966   CloseHandle (h);
967 }
968
969 /****************************************************************************
970  * WCMD_verify
971  *
972  * Display verify flag.
973  * FIXME: We don't actually do anything with the verify flag other than toggle
974  * it...
975  */
976
977 void WCMD_verify (char *command) {
978
979 static const char *von = "Verify is ON\n", *voff = "Verify is OFF\n";
980 int count;
981
982   count = strlen(command);
983   if (count == 0) {
984     if (verify_mode) WCMD_output (von);
985     else WCMD_output (voff);
986     return;
987   }
988   if (lstrcmpi(command, "ON") == 0) {
989     verify_mode = 1;
990     return;
991   }
992   else if (lstrcmpi(command, "OFF") == 0) {
993     verify_mode = 0;
994     return;
995   }
996   else WCMD_output ("Verify must be ON or OFF\n");
997 }
998
999 /****************************************************************************
1000  * WCMD_version
1001  *
1002  * Display version info.
1003  */
1004
1005 void WCMD_version (void) {
1006
1007   WCMD_output (version_string);
1008
1009 }
1010
1011 /****************************************************************************
1012  * WCMD_volume
1013  *
1014  * Display volume info and/or set volume label. Returns 0 if error.
1015  */
1016
1017 int WCMD_volume (int mode, char *path) {
1018
1019 DWORD count, serial;
1020 char string[MAX_PATH], label[MAX_PATH], curdir[MAX_PATH];
1021 BOOL status;
1022
1023   if (lstrlen(path) == 0) {
1024     status = GetCurrentDirectory (sizeof(curdir), curdir);
1025     if (!status) {
1026       WCMD_print_error ();
1027       return 0;
1028     }
1029     status = GetVolumeInformation (NULL, label, sizeof(label), &serial, NULL,
1030         NULL, NULL, 0);
1031   }
1032   else {
1033     if ((path[1] != ':') || (lstrlen(path) != 2)) {
1034       WCMD_output_asis("Syntax Error\n\n");
1035       return 0;
1036     }
1037     wsprintf (curdir, "%s\\", path);
1038     status = GetVolumeInformation (curdir, label, sizeof(label), &serial, NULL,
1039         NULL, NULL, 0);
1040   }
1041   if (!status) {
1042     WCMD_print_error ();
1043     return 0;
1044   }
1045   WCMD_output ("Volume in drive %c is %s\nVolume Serial Number is %04x-%04x\n\n",
1046         curdir[0], label, HIWORD(serial), LOWORD(serial));
1047   if (mode) {
1048     WCMD_output ("Volume label (11 characters, ENTER for none)?");
1049     ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
1050     if (count > 1) {
1051       string[count-1] = '\0';           /* ReadFile output is not null-terminated! */
1052       if (string[count-2] == '\r') string[count-2] = '\0'; /* Under Windoze we get CRLF! */
1053     }
1054     if (lstrlen(path) != 0) {
1055       if (!SetVolumeLabel (curdir, string)) WCMD_print_error ();
1056     }
1057     else {
1058       if (!SetVolumeLabel (NULL, string)) WCMD_print_error ();
1059     }
1060   }
1061   return 1;
1062 }