ntdll: Set a valid process title for the initial process.
[wine] / programs / cmd / directory.c
1 /*
2  * CMD - Wine-compatible command line interface - Directory 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, 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 #define WIN32_LEAN_AND_MEAN
30
31 #include "wcmd.h"
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(cmd);
35
36
37 extern int echo_mode;
38 extern WCHAR quals[MAX_PATH], param1[MAX_PATH], param2[MAX_PATH];
39 extern DWORD errorlevel;
40
41 typedef enum _DISPLAYTIME
42 {
43     Creation = 0,
44     Access,
45     Written
46 } DISPLAYTIME;
47
48 typedef enum _DISPLAYORDER
49 {
50     Name = 0,
51     Extension,
52     Size,
53     Date
54 } DISPLAYORDER;
55
56 static int file_total, dir_total, recurse, wide, bare, max_width, lower;
57 static int shortname, usernames;
58 static ULONGLONG byte_total;
59 static DISPLAYTIME dirTime;
60 static DISPLAYORDER dirOrder;
61 static BOOL orderReverse, orderGroupDirs, orderGroupDirsReverse, orderByCol;
62 static BOOL separator;
63 static ULONG showattrs, attrsbits;
64
65 static const WCHAR dotW[]    = {'.','\0'};
66 static const WCHAR dotdotW[] = {'.','.','\0'};
67 static const WCHAR starW[]   = {'*','\0'};
68 static const WCHAR slashW[]  = {'\\','\0'};
69 static const WCHAR emptyW[]  = {'\0'};
70 static const WCHAR spaceW[]  = {' ','\0'};
71
72 /*****************************************************************************
73  * WCMD_strrev
74  *
75  * Reverse a WCHARacter string in-place (strrev() is not available under unixen :-( ).
76  */
77 static WCHAR * WCMD_strrev (WCHAR *buff) {
78
79   int r, i;
80   WCHAR b;
81
82   r = strlenW (buff);
83   for (i=0; i<r/2; i++) {
84     b = buff[i];
85     buff[i] = buff[r-i-1];
86     buff[r-i-1] = b;
87   }
88   return (buff);
89 }
90
91 /*****************************************************************************
92  * WCMD_filesize64
93  *
94  * Convert a 64-bit number into a WCHARacter string, with commas every three digits.
95  * Result is returned in a static string overwritten with each call.
96  * FIXME: There must be a better algorithm!
97  */
98 static WCHAR * WCMD_filesize64 (ULONGLONG n) {
99
100   ULONGLONG q;
101   unsigned int r, i;
102   WCHAR *p;
103   static WCHAR buff[32];
104
105   p = buff;
106   i = -3;
107   do {
108     if (separator && ((++i)%3 == 1)) *p++ = ',';
109     q = n / 10;
110     r = n - (q * 10);
111     *p++ = r + '0';
112     *p = '\0';
113     n = q;
114   } while (n != 0);
115   WCMD_strrev (buff);
116   return buff;
117 }
118
119 /*****************************************************************************
120  * WCMD_dir_sort
121  *
122  * Sort based on the /O options supplied on the command line
123  */
124 static int WCMD_dir_sort (const void *a, const void *b)
125 {
126   const WIN32_FIND_DATAW *filea = (const WIN32_FIND_DATAW *)a;
127   const WIN32_FIND_DATAW *fileb = (const WIN32_FIND_DATAW *)b;
128   int result = 0;
129
130   /* If /OG or /O-G supplied, dirs go at the top or bottom, ignoring the
131      requested sort order for the directory components                   */
132   if (orderGroupDirs &&
133       ((filea->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
134        (fileb->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)))
135   {
136     BOOL aDir = filea->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
137     if (aDir) result = -1;
138     else result = 1;
139     if (orderGroupDirsReverse) result = -result;
140     return result;
141
142   /* Order by Name: */
143   } else if (dirOrder == Name) {
144     result = lstrcmpiW(filea->cFileName, fileb->cFileName);
145
146   /* Order by Size: */
147   } else if (dirOrder == Size) {
148     ULONG64 sizea = (((ULONG64)filea->nFileSizeHigh) << 32) + filea->nFileSizeLow;
149     ULONG64 sizeb = (((ULONG64)fileb->nFileSizeHigh) << 32) + fileb->nFileSizeLow;
150     if( sizea < sizeb ) result = -1;
151     else if( sizea == sizeb ) result = 0;
152     else result = 1;
153
154   /* Order by Date: (Takes into account which date (/T option) */
155   } else if (dirOrder == Date) {
156
157     const FILETIME *ft;
158     ULONG64 timea, timeb;
159
160     if (dirTime == Written) {
161       ft = &filea->ftLastWriteTime;
162       timea = (((ULONG64)ft->dwHighDateTime) << 32) + ft->dwLowDateTime;
163       ft = &fileb->ftLastWriteTime;
164       timeb = (((ULONG64)ft->dwHighDateTime) << 32) + ft->dwLowDateTime;
165     } else if (dirTime == Access) {
166       ft = &filea->ftLastAccessTime;
167       timea = (((ULONG64)ft->dwHighDateTime) << 32) + ft->dwLowDateTime;
168       ft = &fileb->ftLastAccessTime;
169       timeb = (((ULONG64)ft->dwHighDateTime) << 32) + ft->dwLowDateTime;
170     } else {
171       ft = &filea->ftCreationTime;
172       timea = (((ULONG64)ft->dwHighDateTime) << 32) + ft->dwLowDateTime;
173       ft = &fileb->ftCreationTime;
174       timeb = (((ULONG64)ft->dwHighDateTime) << 32) + ft->dwLowDateTime;
175     }
176     if( timea < timeb ) result = -1;
177     else if( timea == timeb ) result = 0;
178     else result = 1;
179
180   /* Order by Extension: (Takes into account which date (/T option) */
181   } else if (dirOrder == Extension) {
182       WCHAR drive[10];
183       WCHAR dir[MAX_PATH];
184       WCHAR fname[MAX_PATH];
185       WCHAR extA[MAX_PATH];
186       WCHAR extB[MAX_PATH];
187
188       /* Split into components */
189       WCMD_splitpath(filea->cFileName, drive, dir, fname, extA);
190       WCMD_splitpath(fileb->cFileName, drive, dir, fname, extB);
191       result = lstrcmpiW(extA, extB);
192   }
193
194   if (orderReverse) result = -result;
195   return result;
196 }
197
198 /*****************************************************************************
199  * WCMD_getfileowner
200  *
201  * Reverse a WCHARacter string in-place (strrev() is not available under unixen :-( ).
202  */
203 static void WCMD_getfileowner(WCHAR *filename, WCHAR *owner, int ownerlen) {
204
205     ULONG sizeNeeded = 0;
206     DWORD rc;
207     WCHAR name[MAXSTRING];
208     WCHAR domain[MAXSTRING];
209
210     /* In case of error, return empty string */
211     *owner = 0x00;
212
213     /* Find out how much space we need for the owner security descriptor */
214     GetFileSecurityW(filename, OWNER_SECURITY_INFORMATION, 0, 0, &sizeNeeded);
215     rc = GetLastError();
216
217     if(rc == ERROR_INSUFFICIENT_BUFFER && sizeNeeded > 0) {
218
219         LPBYTE secBuffer;
220         PSID pSID = NULL;
221         BOOL defaulted = FALSE;
222         ULONG nameLen = MAXSTRING;
223         ULONG domainLen = MAXSTRING;
224         SID_NAME_USE nameuse;
225
226         secBuffer = HeapAlloc(GetProcessHeap(),0,sizeNeeded * sizeof(BYTE));
227         if(!secBuffer) return;
228
229         /* Get the owners security descriptor */
230         if(!GetFileSecurityW(filename, OWNER_SECURITY_INFORMATION, secBuffer,
231                             sizeNeeded, &sizeNeeded)) {
232             HeapFree(GetProcessHeap(),0,secBuffer);
233             return;
234         }
235
236         /* Get the SID from the SD */
237         if(!GetSecurityDescriptorOwner(secBuffer, &pSID, &defaulted)) {
238             HeapFree(GetProcessHeap(),0,secBuffer);
239             return;
240         }
241
242         /* Convert to a username */
243         if (LookupAccountSidW(NULL, pSID, name, &nameLen, domain, &domainLen, &nameuse)) {
244             static const WCHAR fmt[]  = {'%','s','%','c','%','s','\0'};
245             snprintfW(owner, ownerlen, fmt, domain, '\\', name);
246         }
247         HeapFree(GetProcessHeap(),0,secBuffer);
248     }
249     return;
250 }
251
252 /*****************************************************************************
253  * WCMD_list_directory
254  *
255  * List a single file directory. This function (and those below it) can be called
256  * recursively when the /S switch is used.
257  *
258  * FIXME: Assumes 24-line display for the /P qualifier.
259  */
260
261 static DIRECTORY_STACK *WCMD_list_directory (DIRECTORY_STACK *inputparms, int level) {
262
263   WCHAR string[1024], datestring[32], timestring[32];
264   WCHAR real_path[MAX_PATH];
265   WIN32_FIND_DATAW *fd;
266   FILETIME ft;
267   SYSTEMTIME st;
268   HANDLE hff;
269   int dir_count, file_count, entry_count, i, widest, cur_width, tmp_width;
270   int numCols, numRows;
271   int rows, cols;
272   ULARGE_INTEGER byte_count, file_size;
273   DIRECTORY_STACK *parms;
274   int concurrentDirs = 0;
275   BOOL done_header = FALSE;
276
277   static const WCHAR fmtDir[]  = {'%','1','0','s',' ',' ','%','8','s',' ',' ',
278                                   '<','D','I','R','>',' ',' ',' ',' ',' ',' ',' ',' ',' ','\0'};
279   static const WCHAR fmtFile[] = {'%','1','0','s',' ',' ','%','8','s',' ',' ',
280                                   ' ',' ','%','1','0','s',' ',' ','\0'};
281   static const WCHAR fmt2[]  = {'%','-','1','3','s','\0'};
282   static const WCHAR fmt3[]  = {'%','-','2','3','s','\0'};
283   static const WCHAR fmt4[]  = {'%','s','\0'};
284   static const WCHAR fmt5[]  = {'%','s','%','s','\0'};
285
286   dir_count = 0;
287   file_count = 0;
288   entry_count = 0;
289   byte_count.QuadPart = 0;
290   widest = 0;
291   cur_width = 0;
292
293   /* Loop merging all the files from consecutive parms which relate to the
294      same directory. Note issuing a directory header with no contents
295      mirrors what windows does                                            */
296   parms = inputparms;
297   fd = HeapAlloc(GetProcessHeap(),0,sizeof(WIN32_FIND_DATAW));
298   while (parms && strcmpW(inputparms->dirName, parms->dirName) == 0) {
299     concurrentDirs++;
300
301     /* Work out the full path + filename */
302     strcpyW(real_path, parms->dirName);
303     strcatW(real_path, parms->fileName);
304
305     /* Load all files into an in memory structure */
306     WINE_TRACE("Looking for matches to '%s'\n", wine_dbgstr_w(real_path));
307     hff = FindFirstFileW(real_path, (fd+entry_count));
308     if (hff != INVALID_HANDLE_VALUE) {
309       do {
310         /* Skip any which are filtered out by attribute */
311         if (((fd+entry_count)->dwFileAttributes & attrsbits) != showattrs) continue;
312
313         entry_count++;
314
315         /* Keep running track of longest filename for wide output */
316         if (wide || orderByCol) {
317            int tmpLen = strlenW((fd+(entry_count-1))->cFileName) + 3;
318            if ((fd+(entry_count-1))->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) tmpLen = tmpLen + 2;
319            if (tmpLen > widest) widest = tmpLen;
320         }
321
322         fd = HeapReAlloc(GetProcessHeap(),0,fd,(entry_count+1)*sizeof(WIN32_FIND_DATAW));
323         if (fd == NULL) {
324           FindClose (hff);
325           WINE_ERR("Out of memory\n");
326           errorlevel = 1;
327           return parms->next;
328         }
329       } while (FindNextFileW(hff, (fd+entry_count)) != 0);
330       FindClose (hff);
331     }
332
333     /* Work out the actual current directory name without a trailing \ */
334     strcpyW(real_path, parms->dirName);
335     real_path[strlenW(parms->dirName)-1] = 0x00;
336
337     /* Output the results */
338     if (!bare) {
339        if (level != 0 && (entry_count > 0)) WCMD_output (newline);
340        if (!recurse || ((entry_count > 0) && done_header==FALSE)) {
341            static const WCHAR headerW[] = {'D','i','r','e','c','t','o','r','y',' ','o','f',
342                                            ' ','%','s','\n','\n','\0'};
343            WCMD_output (headerW, real_path);
344            done_header = TRUE;
345        }
346     }
347
348     /* Move to next parm */
349     parms = parms->next;
350   }
351
352   /* Handle case where everything is filtered out */
353   if (entry_count > 0) {
354
355     /* Sort the list of files */
356     qsort (fd, entry_count, sizeof(WIN32_FIND_DATAW), WCMD_dir_sort);
357
358     /* Work out the number of columns */
359     WINE_TRACE("%d entries, maxwidth=%d, widest=%d\n", entry_count, max_width, widest);
360     if (wide || orderByCol) {
361       numCols = max(1, (int)max_width / widest);
362       numRows = entry_count / numCols;
363       if (entry_count % numCols) numRows++;
364     } else {
365       numCols = 1;
366       numRows = entry_count;
367     }
368     WINE_TRACE("cols=%d, rows=%d\n", numCols, numRows);
369
370     for (rows=0; rows<numRows; rows++) {
371      BOOL addNewLine = TRUE;
372      for (cols=0; cols<numCols; cols++) {
373       WCHAR username[24];
374
375       /* Work out the index of the entry being pointed to */
376       if (orderByCol) {
377         i = (cols * numRows) + rows;
378         if (i >= entry_count) continue;
379       } else {
380         i = (rows * numCols) + cols;
381         if (i >= entry_count) continue;
382       }
383
384       /* /L convers all names to lower case */
385       if (lower) {
386           WCHAR *p = (fd+i)->cFileName;
387           while ( (*p = tolower(*p)) ) ++p;
388       }
389
390       /* /Q gets file ownership information */
391       if (usernames) {
392           strcpyW (string, inputparms->dirName);
393           strcatW (string, (fd+i)->cFileName);
394           WCMD_getfileowner(string, username, sizeof(username)/sizeof(WCHAR));
395       }
396
397       if (dirTime == Written) {
398         FileTimeToLocalFileTime (&(fd+i)->ftLastWriteTime, &ft);
399       } else if (dirTime == Access) {
400         FileTimeToLocalFileTime (&(fd+i)->ftLastAccessTime, &ft);
401       } else {
402         FileTimeToLocalFileTime (&(fd+i)->ftCreationTime, &ft);
403       }
404       FileTimeToSystemTime (&ft, &st);
405       GetDateFormatW(0, DATE_SHORTDATE, &st, NULL, datestring,
406                         sizeof(datestring)/sizeof(WCHAR));
407       GetTimeFormatW(0, TIME_NOSECONDS, &st,
408                         NULL, timestring, sizeof(timestring)/sizeof(WCHAR));
409
410       if (wide) {
411
412         tmp_width = cur_width;
413         if ((fd+i)->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
414             static const WCHAR fmt[] = {'[','%','s',']','\0'};
415             WCMD_output (fmt, (fd+i)->cFileName);
416             dir_count++;
417             tmp_width = tmp_width + strlenW((fd+i)->cFileName) + 2;
418         } else {
419             static const WCHAR fmt[] = {'%','s','\0'};
420             WCMD_output (fmt, (fd+i)->cFileName);
421             tmp_width = tmp_width + strlenW((fd+i)->cFileName) ;
422             file_count++;
423             file_size.u.LowPart = (fd+i)->nFileSizeLow;
424             file_size.u.HighPart = (fd+i)->nFileSizeHigh;
425         byte_count.QuadPart += file_size.QuadPart;
426         }
427         cur_width = cur_width + widest;
428
429         if ((cur_width + widest) > max_width) {
430             cur_width = 0;
431         } else {
432             int padding = cur_width - tmp_width;
433             int toWrite = 0;
434             WCHAR temp[101];
435
436             /* Note: WCMD_output uses wvsprintf which does not allow %*
437                  so manually pad with spaces to appropriate width       */
438             strcpyW(temp, emptyW);
439             while (padding > 0) {
440                 strcatW(&temp[toWrite], spaceW);
441                 toWrite++;
442                 if (toWrite > 99) {
443                     WCMD_output(temp);
444                     toWrite = 0;
445                     strcpyW(temp, emptyW);
446                 }
447                 padding--;
448             }
449             WCMD_output(temp);
450         }
451
452       } else if ((fd+i)->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
453         dir_count++;
454
455         if (!bare) {
456            WCMD_output (fmtDir, datestring, timestring);
457            if (shortname) WCMD_output (fmt2, (fd+i)->cAlternateFileName);
458            if (usernames) WCMD_output (fmt3, username);
459            WCMD_output(fmt4,(fd+i)->cFileName);
460         } else {
461            if (!((strcmpW((fd+i)->cFileName, dotW) == 0) ||
462                  (strcmpW((fd+i)->cFileName, dotdotW) == 0))) {
463               WCMD_output (fmt5, recurse?inputparms->dirName:emptyW, (fd+i)->cFileName);
464            } else {
465               addNewLine = FALSE;
466            }
467         }
468       }
469       else {
470         file_count++;
471         file_size.u.LowPart = (fd+i)->nFileSizeLow;
472         file_size.u.HighPart = (fd+i)->nFileSizeHigh;
473         byte_count.QuadPart += file_size.QuadPart;
474         if (!bare) {
475            WCMD_output (fmtFile, datestring, timestring,
476                         WCMD_filesize64(file_size.QuadPart));
477            if (shortname) WCMD_output (fmt2, (fd+i)->cAlternateFileName);
478            if (usernames) WCMD_output (fmt3, username);
479            WCMD_output(fmt4,(fd+i)->cFileName);
480         } else {
481            WCMD_output (fmt5, recurse?inputparms->dirName:emptyW, (fd+i)->cFileName);
482         }
483       }
484      }
485      if (addNewLine) WCMD_output (newline);
486      cur_width = 0;
487     }
488
489     if (!bare) {
490        if (file_count == 1) {
491          static const WCHAR fmt[] = {' ',' ',' ',' ',' ',' ',' ','1',' ','f','i','l','e',' ',
492                                      '%','2','5','s',' ','b','y','t','e','s','\n','\0'};
493          WCMD_output (fmt, WCMD_filesize64 (byte_count.QuadPart));
494        }
495        else {
496          static const WCHAR fmt[] = {'%','8','d',' ','f','i','l','e','s',' ','%','2','4','s',
497                                      ' ','b','y','t','e','s','\n','\0'};
498          WCMD_output (fmt, file_count, WCMD_filesize64 (byte_count.QuadPart));
499        }
500     }
501     byte_total = byte_total + byte_count.QuadPart;
502     file_total = file_total + file_count;
503     dir_total = dir_total + dir_count;
504
505     if (!bare && !recurse) {
506        if (dir_count == 1) {
507            static const WCHAR fmt[] = {'%','8','d',' ','d','i','r','e','c','t','o','r','y',
508                                        ' ',' ',' ',' ',' ',' ',' ',' ',' ','\0'};
509            WCMD_output (fmt, 1);
510        } else {
511            static const WCHAR fmt[] = {'%','8','d',' ','d','i','r','e','c','t','o','r','i',
512                                        'e','s','\0'};
513            WCMD_output (fmt, dir_count);
514        }
515     }
516   }
517   HeapFree(GetProcessHeap(),0,fd);
518
519   /* When recursing, look in all subdirectories for matches */
520   if (recurse) {
521     DIRECTORY_STACK *dirStack = NULL;
522     DIRECTORY_STACK *lastEntry = NULL;
523     WIN32_FIND_DATAW finddata;
524
525     /* Build path to search */
526     strcpyW(string, inputparms->dirName);
527     strcatW(string, starW);
528
529     WINE_TRACE("Recursive, looking for '%s'\n", wine_dbgstr_w(string));
530     hff = FindFirstFileW(string, &finddata);
531     if (hff != INVALID_HANDLE_VALUE) {
532       do {
533         if ((finddata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
534             (strcmpW(finddata.cFileName, dotdotW) != 0) &&
535             (strcmpW(finddata.cFileName, dotW) != 0)) {
536
537           DIRECTORY_STACK *thisDir;
538           int              dirsToCopy = concurrentDirs;
539
540           /* Loop creating list of subdirs for all concurrent entries */
541           parms = inputparms;
542           while (dirsToCopy > 0) {
543             dirsToCopy--;
544
545             /* Work out search parameter in sub dir */
546             strcpyW (string, inputparms->dirName);
547             strcatW (string, finddata.cFileName);
548             strcatW (string, slashW);
549             WINE_TRACE("Recursive, Adding to search list '%s'\n", wine_dbgstr_w(string));
550
551             /* Allocate memory, add to list */
552             thisDir = HeapAlloc(GetProcessHeap(),0,sizeof(DIRECTORY_STACK));
553             if (dirStack == NULL) dirStack = thisDir;
554             if (lastEntry != NULL) lastEntry->next = thisDir;
555             lastEntry = thisDir;
556             thisDir->next = NULL;
557             thisDir->dirName = HeapAlloc(GetProcessHeap(),0,
558                                          sizeof(WCHAR) * (strlenW(string)+1));
559             strcpyW(thisDir->dirName, string);
560             thisDir->fileName = HeapAlloc(GetProcessHeap(),0,
561                                           sizeof(WCHAR) * (strlenW(parms->fileName)+1));
562             strcpyW(thisDir->fileName, parms->fileName);
563             parms = parms->next;
564           }
565         }
566       } while (FindNextFileW(hff, &finddata) != 0);
567       FindClose (hff);
568
569       while (dirStack != NULL) {
570         DIRECTORY_STACK *thisDir = dirStack;
571         dirStack = WCMD_list_directory (thisDir, 1);
572         while (thisDir != dirStack) {
573           DIRECTORY_STACK *tempDir = thisDir->next;
574           HeapFree(GetProcessHeap(),0,thisDir->dirName);
575           HeapFree(GetProcessHeap(),0,thisDir->fileName);
576           HeapFree(GetProcessHeap(),0,thisDir);
577           thisDir = tempDir;
578         }
579       }
580     }
581   }
582
583   /* Handle case where everything is filtered out */
584   if ((file_total + dir_total == 0) && (level == 0)) {
585     SetLastError (ERROR_FILE_NOT_FOUND);
586     WCMD_print_error ();
587     errorlevel = 1;
588   }
589
590   return parms;
591 }
592
593 /*****************************************************************************
594  * WCMD_dir_trailer
595  *
596  * Print out the trailer for the supplied drive letter
597  */
598 static void WCMD_dir_trailer(WCHAR drive) {
599     ULARGE_INTEGER avail, total, freebytes;
600     DWORD status;
601     WCHAR driveName[4] = {'c',':','\\','\0'};
602
603     driveName[0] = drive;
604     status = GetDiskFreeSpaceExW(driveName, &avail, &total, &freebytes);
605     WINE_TRACE("Writing trailer for '%s' gave %d(%d)\n", wine_dbgstr_w(driveName),
606                status, GetLastError());
607
608     if (errorlevel==0 && !bare) {
609       if (recurse) {
610         static const WCHAR fmt1[] = {'\n',' ',' ',' ',' ',' ','T','o','t','a','l',' ','f','i','l','e','s',
611                                      ' ','l','i','s','t','e','d',':','\n','%','8','d',' ','f','i','l','e',
612                                      's','%','2','5','s',' ','b','y','t','e','s','\n','\0'};
613         static const WCHAR fmt2[] = {'%','8','d',' ','d','i','r','e','c','t','o','r','i','e','s',' ','%',
614                                      '1','8','s',' ','b','y','t','e','s',' ','f','r','e','e','\n','\n',
615                                      '\0'};
616         WCMD_output (fmt1, file_total, WCMD_filesize64 (byte_total));
617         WCMD_output (fmt2, dir_total, WCMD_filesize64 (freebytes.QuadPart));
618       } else {
619         static const WCHAR fmt[] = {' ','%','1','8','s',' ','b','y','t','e','s',' ','f','r','e','e',
620                                     '\n','\n','\0'};
621         WCMD_output (fmt, WCMD_filesize64 (freebytes.QuadPart));
622       }
623     }
624 }
625
626 /*****************************************************************************
627  * WCMD_directory
628  *
629  * List a file directory.
630  *
631  */
632
633 void WCMD_directory (WCHAR *cmd) {
634
635   WCHAR path[MAX_PATH], cwd[MAX_PATH];
636   int status, paged_mode;
637   CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
638   WCHAR *p;
639   WCHAR string[MAXSTRING];
640   int   argno         = 0;
641   WCHAR *argN          = cmd;
642   WCHAR  lastDrive;
643   BOOL  trailerReqd = FALSE;
644   DIRECTORY_STACK *fullParms = NULL;
645   DIRECTORY_STACK *prevEntry = NULL;
646   DIRECTORY_STACK *thisEntry = NULL;
647   WCHAR drive[10];
648   WCHAR dir[MAX_PATH];
649   WCHAR fname[MAX_PATH];
650   WCHAR ext[MAX_PATH];
651   static const WCHAR dircmdW[] = {'D','I','R','C','M','D','\0'};
652
653   errorlevel = 0;
654
655   /* Prefill quals with (uppercased) DIRCMD env var */
656   if (GetEnvironmentVariableW(dircmdW, string, sizeof(string)/sizeof(WCHAR))) {
657     p = string;
658     while ( (*p = toupper(*p)) ) ++p;
659     strcatW(string,quals);
660     strcpyW(quals, string);
661   }
662
663   byte_total = 0;
664   file_total = dir_total = 0;
665
666   /* Initialize all flags to their defaults as if no DIRCMD or quals */
667   paged_mode = FALSE;
668   recurse    = FALSE;
669   wide       = FALSE;
670   bare       = FALSE;
671   lower      = FALSE;
672   shortname  = FALSE;
673   usernames  = FALSE;
674   orderByCol = FALSE;
675   separator  = TRUE;
676   dirTime = Written;
677   dirOrder = Name;
678   orderReverse = FALSE;
679   orderGroupDirs = FALSE;
680   orderGroupDirsReverse = FALSE;
681   showattrs  = 0;
682   attrsbits  = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
683
684   /* Handle args - Loop through so right most is the effective one */
685   /* Note: /- appears to be a negate rather than an off, eg. dir
686            /-W is wide, or dir /w /-w /-w is also wide             */
687   p = quals;
688   while (*p && (*p=='/' || *p==' ')) {
689     BOOL negate = FALSE;
690     if (*p++==' ') continue;  /* Skip / and blanks introduced through DIRCMD */
691
692     if (*p=='-') {
693       negate = TRUE;
694       p++;
695     }
696
697     WINE_TRACE("Processing arg '%c' (in %s)\n", *p, wine_dbgstr_w(quals));
698     switch (*p) {
699     case 'P': if (negate) paged_mode = !paged_mode;
700               else paged_mode = TRUE;
701               break;
702     case 'S': if (negate) recurse = !recurse;
703               else recurse = TRUE;
704               break;
705     case 'W': if (negate) wide = !wide;
706               else wide = TRUE;
707               break;
708     case 'B': if (negate) bare = !bare;
709               else bare = TRUE;
710               break;
711     case 'L': if (negate) lower = !lower;
712               else lower = TRUE;
713               break;
714     case 'X': if (negate) shortname = !shortname;
715               else shortname = TRUE;
716               break;
717     case 'Q': if (negate) usernames = !usernames;
718               else usernames = TRUE;
719               break;
720     case 'D': if (negate) orderByCol = !orderByCol;
721               else orderByCol = TRUE;
722               break;
723     case 'C': if (negate) separator = !separator;
724               else separator = TRUE;
725               break;
726     case 'T': p = p + 1;
727               if (*p==':') p++;  /* Skip optional : */
728
729               if (*p == 'A') dirTime = Access;
730               else if (*p == 'C') dirTime = Creation;
731               else if (*p == 'W') dirTime = Written;
732
733               /* Support /T and /T: with no parms, default to written */
734               else if (*p == 0x00 || *p == '/') {
735                 dirTime = Written;
736                 p = p - 1; /* So when step on, move to '/' */
737               } else {
738                 SetLastError(ERROR_INVALID_PARAMETER);
739                 WCMD_print_error();
740                 errorlevel = 1;
741                 return;
742               }
743               break;
744     case 'O': p = p + 1;
745               if (*p==':') p++;  /* Skip optional : */
746               while (*p && *p != '/') {
747                 WINE_TRACE("Processing subparm '%c' (in %s)\n", *p, wine_dbgstr_w(quals));
748                 switch (*p) {
749                 case 'N': dirOrder = Name;       break;
750                 case 'E': dirOrder = Extension;  break;
751                 case 'S': dirOrder = Size;       break;
752                 case 'D': dirOrder = Date;       break;
753                 case '-': if (*(p+1)=='G') orderGroupDirsReverse=TRUE;
754                           else orderReverse = TRUE;
755                           break;
756                 case 'G': orderGroupDirs = TRUE; break;
757                 default:
758                     SetLastError(ERROR_INVALID_PARAMETER);
759                     WCMD_print_error();
760                     errorlevel = 1;
761                     return;
762                 }
763                 p++;
764               }
765               p = p - 1; /* So when step on, move to '/' */
766               break;
767     case 'A': p = p + 1;
768               showattrs = 0;
769               attrsbits = 0;
770               if (*p==':') p++;  /* Skip optional : */
771               while (*p && *p != '/') {
772                 BOOL anegate = FALSE;
773                 ULONG mask;
774
775                 /* Note /A: - options are 'offs' not toggles */
776                 if (*p=='-') {
777                   anegate = TRUE;
778                   p++;
779                 }
780
781                 WINE_TRACE("Processing subparm '%c' (in %s)\n", *p, wine_dbgstr_w(quals));
782                 switch (*p) {
783                 case 'D': mask = FILE_ATTRIBUTE_DIRECTORY; break;
784                 case 'H': mask = FILE_ATTRIBUTE_HIDDEN;    break;
785                 case 'S': mask = FILE_ATTRIBUTE_SYSTEM;    break;
786                 case 'R': mask = FILE_ATTRIBUTE_READONLY;  break;
787                 case 'A': mask = FILE_ATTRIBUTE_ARCHIVE;   break;
788                 default:
789                     SetLastError(ERROR_INVALID_PARAMETER);
790                     WCMD_print_error();
791                     errorlevel = 1;
792                     return;
793                 }
794
795                 /* Keep running list of bits we care about */
796                 attrsbits |= mask;
797
798                 /* Mask shows what MUST be in the bits we care about */
799                 if (anegate) showattrs = showattrs & ~mask;
800                 else showattrs |= mask;
801
802                 p++;
803               }
804               p = p - 1; /* So when step on, move to '/' */
805               WINE_TRACE("Result: showattrs %x, bits %x\n", showattrs, attrsbits);
806               break;
807     default:
808               SetLastError(ERROR_INVALID_PARAMETER);
809               WCMD_print_error();
810               errorlevel = 1;
811               return;
812     }
813     p = p + 1;
814   }
815
816   /* Handle conflicting args and initialization */
817   if (bare || shortname) wide = FALSE;
818   if (bare) shortname = FALSE;
819   if (wide) usernames = FALSE;
820   if (orderByCol) wide = TRUE;
821
822   if (wide) {
823       if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &consoleInfo))
824           max_width = consoleInfo.dwSize.X;
825       else
826           max_width = 80;
827   }
828   if (paged_mode) {
829      WCMD_enter_paged_mode(NULL);
830   }
831
832   argno         = 0;
833   argN          = cmd;
834   GetCurrentDirectoryW(MAX_PATH, cwd);
835   strcatW(cwd, slashW);
836
837   /* Loop through all args, calculating full effective directory */
838   fullParms = NULL;
839   prevEntry = NULL;
840   while (argN) {
841     WCHAR fullname[MAXSTRING];
842     WCHAR *thisArg = WCMD_parameter (cmd, argno++, &argN);
843     if (argN && argN[0] != '/') {
844
845       WINE_TRACE("Found parm '%s'\n", wine_dbgstr_w(thisArg));
846       if (thisArg[1] == ':' && thisArg[2] == '\\') {
847         strcpyW(fullname, thisArg);
848       } else if (thisArg[1] == ':' && thisArg[2] != '\\') {
849         WCHAR envvar[4];
850         static const WCHAR envFmt[] = {'=','%','c',':','\0'};
851         wsprintfW(envvar, envFmt, thisArg[0]);
852         if (!GetEnvironmentVariableW(envvar, fullname, MAX_PATH)) {
853           static const WCHAR noEnvFmt[] = {'%','c',':','\0'};
854           wsprintfW(fullname, noEnvFmt, thisArg[0]);
855         }
856         strcatW(fullname, slashW);
857         strcatW(fullname, &thisArg[2]);
858       } else if (thisArg[0] == '\\') {
859         memcpy(fullname, cwd, 2 * sizeof(WCHAR));
860         strcpyW(fullname+2, thisArg);
861       } else {
862         strcpyW(fullname, cwd);
863         strcatW(fullname, thisArg);
864       }
865       WINE_TRACE("Using location '%s'\n", wine_dbgstr_w(fullname));
866
867       status = GetFullPathNameW(fullname, sizeof(path)/sizeof(WCHAR), path, NULL);
868
869       /*
870        *  If the path supplied does not include a wildcard, and the endpoint of the
871        *  path references a directory, we need to list the *contents* of that
872        *  directory not the directory file itself.
873        */
874       if ((strchrW(path, '*') == NULL) && (strchrW(path, '%') == NULL)) {
875         status = GetFileAttributesW(path);
876         if ((status != INVALID_FILE_ATTRIBUTES) && (status & FILE_ATTRIBUTE_DIRECTORY)) {
877           if (path[strlenW(path)-1] == '\\') {
878             strcatW (path, starW);
879           }
880           else {
881             const WCHAR slashStarW[]  = {'\\','*','\0'};
882             strcatW (path, slashStarW);
883           }
884         }
885       } else {
886         /* Special case wildcard search with no extension (ie parameters ending in '.') as
887            GetFullPathName strips off the additional '.'                                  */
888         if (fullname[strlenW(fullname)-1] == '.') strcatW(path, dotW);
889       }
890
891       WINE_TRACE("Using path '%s'\n", wine_dbgstr_w(path));
892       thisEntry = HeapAlloc(GetProcessHeap(),0,sizeof(DIRECTORY_STACK));
893       if (fullParms == NULL) fullParms = thisEntry;
894       if (prevEntry != NULL) prevEntry->next = thisEntry;
895       prevEntry = thisEntry;
896       thisEntry->next = NULL;
897
898       /* Split into components */
899       WCMD_splitpath(path, drive, dir, fname, ext);
900       WINE_TRACE("Path Parts: drive: '%s' dir: '%s' name: '%s' ext:'%s'\n",
901                  wine_dbgstr_w(drive), wine_dbgstr_w(dir),
902                  wine_dbgstr_w(fname), wine_dbgstr_w(ext));
903
904       thisEntry->dirName = HeapAlloc(GetProcessHeap(),0,
905                                      sizeof(WCHAR) * (strlenW(drive)+strlenW(dir)+1));
906       strcpyW(thisEntry->dirName, drive);
907       strcatW(thisEntry->dirName, dir);
908
909       thisEntry->fileName = HeapAlloc(GetProcessHeap(),0,
910                                      sizeof(WCHAR) * (strlenW(fname)+strlenW(ext)+1));
911       strcpyW(thisEntry->fileName, fname);
912       strcatW(thisEntry->fileName, ext);
913
914     }
915   }
916
917   /* If just 'dir' entered, a '*' parameter is assumed */
918   if (fullParms == NULL) {
919     WINE_TRACE("Inserting default '*'\n");
920     fullParms = HeapAlloc(GetProcessHeap(),0, sizeof(DIRECTORY_STACK));
921     fullParms->next = NULL;
922     fullParms->dirName = HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR) * (strlenW(cwd)+1));
923     strcpyW(fullParms->dirName, cwd);
924     fullParms->fileName = HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR) * 2);
925     strcpyW(fullParms->fileName, starW);
926   }
927
928   lastDrive = '?';
929   prevEntry = NULL;
930   thisEntry = fullParms;
931   trailerReqd = FALSE;
932
933   while (thisEntry != NULL) {
934
935     /* Output disk free (trailer) and volume information (header) if the drive
936        letter changes */
937     if (lastDrive != toupper(thisEntry->dirName[0])) {
938
939       /* Trailer Information */
940       if (lastDrive != '?') {
941         trailerReqd = FALSE;
942         WCMD_dir_trailer(prevEntry->dirName[0]);
943       }
944
945       lastDrive = toupper(thisEntry->dirName[0]);
946
947       if (!bare) {
948          WCHAR drive[3];
949
950          WINE_TRACE("Writing volume for '%c:'\n", thisEntry->dirName[0]);
951          memcpy(drive, thisEntry->dirName, 2 * sizeof(WCHAR));
952          drive[2] = 0x00;
953          status = WCMD_volume (0, drive);
954          trailerReqd = TRUE;
955          if (!status) {
956            errorlevel = 1;
957            goto exit;
958          }
959       }
960     } else {
961       static const WCHAR newLine2[] = {'\n','\n','\0'};
962       if (!bare) WCMD_output (newLine2);
963     }
964
965     /* Clear any errors from previous invocations, and process it */
966     errorlevel = 0;
967     prevEntry = thisEntry;
968     thisEntry = WCMD_list_directory (thisEntry, 0);
969   }
970
971   /* Trailer Information */
972   if (trailerReqd) {
973     WCMD_dir_trailer(prevEntry->dirName[0]);
974   }
975
976 exit:
977   if (paged_mode) WCMD_leave_paged_mode();
978
979   /* Free storage allocated for parms */
980   while (fullParms != NULL) {
981     prevEntry = fullParms;
982     fullParms = prevEntry->next;
983     HeapFree(GetProcessHeap(),0,prevEntry->dirName);
984     HeapFree(GetProcessHeap(),0,prevEntry->fileName);
985     HeapFree(GetProcessHeap(),0,prevEntry);
986   }
987 }