RTFsCmdLs.cpp@ 96407

Last change on this file since 96407 was 96407, checked in by vboxsync, 2 years ago
scm copyright and license note update
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 70.8 KB

Line
1	/* $Id: RTFsCmdLs.cpp 96407 2022-08-22 17:43:14Z vboxsync $ */
2	/** @file
3	* IPRT - /bin/ls like utility for testing the VFS code.
4	*/
5
6	/*
7	* Copyright (C) 2017-2022 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#include <iprt/vfs.h>
42
43	#include <iprt/buildconfig.h>
44	#include <iprt/err.h>
45	#include <iprt/file.h>
46	#include <iprt/getopt.h>
47	#include <iprt/initterm.h>
48	#include <iprt/mem.h>
49	#include <iprt/message.h>
50	#include <iprt/param.h>
51	#include <iprt/path.h>
52	#include <iprt/sort.h>
53	#include <iprt/stream.h>
54	#include <iprt/string.h>
55
56
57	/*********************************************************************************************************************************
58	* Structures and Typedefs *
59	*********************************************************************************************************************************/
60	/**
61	* Display entry.
62	*/
63	typedef struct RTCMDLSENTRY
64	{
65	/** The information about the entry. */
66	RTFSOBJINFO Info;
67	/** Symbolic link target (allocated after the name). */
68	const char *pszTarget;
69	/** Owner if applicable(allocated after the name). */
70	const char *pszOwner;
71	/** Group if applicable (allocated after the name). */
72	const char *pszGroup;
73	/** The length of szName. */
74	size_t cchName;
75	/** The entry name. */
76	RT_FLEXIBLE_ARRAY_EXTENSION
77	char szName[RT_FLEXIBLE_ARRAY];
78	} RTCMDLSENTRY;
79	/** Pointer to a ls display entry. */
80	typedef RTCMDLSENTRY *PRTCMDLSENTRY;
81	/** Pointer to a ls display entry pointer. */
82	typedef PRTCMDLSENTRY *PPRTCMDLSENTRY;
83
84
85	/**
86	* Collection of display entries.
87	*/
88	typedef struct RTCMDLSCOLLECTION
89	{
90	/** Current size of papEntries. */
91	size_t cEntries;
92	/** Memory allocated for papEntries. */
93	size_t cEntriesAllocated;
94	/** Current entries pending sorting and display. */
95	PPRTCMDLSENTRY papEntries;
96
97	/** Total number of bytes allocated for the above entries. */
98	uint64_t cbTotalAllocated;
99	/** Total number of file content bytes. */
100	uint64_t cbTotalFiles;
101
102	/** The collection name (path). */
103	RT_FLEXIBLE_ARRAY_EXTENSION
104	char szName[RT_FLEXIBLE_ARRAY];
105	} RTCMDLSCOLLECTION;
106	/** Pointer to a display entry collection. */
107	typedef RTCMDLSCOLLECTION *PRTCMDLSCOLLECTION;
108	/** Pointer to a display entry collection pointer. */
109	typedef PRTCMDLSCOLLECTION *PPRTCMDLSCOLLECTION;
110
111
112	/** Sorting. */
113	typedef enum RTCMDLSSORT
114	{
115	RTCMDLSSORT_INVALID = 0,
116	RTCMDLSSORT_NONE,
117	RTCMDLSSORT_NAME,
118	RTCMDLSSORT_EXTENSION,
119	RTCMDLSSORT_SIZE,
120	RTCMDLSSORT_TIME,
121	RTCMDLSSORT_VERSION
122	} RTCMDLSSORT;
123
124	/** Time selection. */
125	typedef enum RTCMDLSTIME
126	{
127	RTCMDLSTIME_INVALID = 0,
128	RTCMDLSTIME_BTIME,
129	RTCMDLSTIME_CTIME,
130	RTCMDLSTIME_MTIME,
131	RTCMDLSTIME_ATIME
132	} RTCMDLSTIME;
133
134	/** Time display style. */
135	typedef enum RTCMDLSTIMESTYLE
136	{
137	RTCMDLSTIMESTYLE_INVALID = 0,
138	RTCMDLSTIMESTYLE_FULL_ISO,
139	RTCMDLSTIMESTYLE_LONG_ISO,
140	RTCMDLSTIMESTYLE_ISO,
141	RTCMDLSTIMESTYLE_LOCALE,
142	RTCMDLSTIMESTYLE_CUSTOM
143	} RTCMDLSTIMESTYLE;
144
145	/** Coloring selection. */
146	typedef enum RTCMDLSCOLOR
147	{
148	RTCMDLSCOLOR_INVALID = 0,
149	RTCMDLSCOLOR_NONE
150	} RTCMDLSCOLOR;
151
152	/** Formatting. */
153	typedef enum RTCMDLSFORMAT
154	{
155	RTCMDLSFORMAT_INVALID = 0,
156	RTCMDLSFORMAT_COLS_VERTICAL, /*< -C/default /
157	RTCMDLSFORMAT_COLS_HORIZONTAL, /*< -x /
158	RTCMDLSFORMAT_COMMAS, /*< -m /
159	RTCMDLSFORMAT_SINGLE, /*< -1 /
160	RTCMDLSFORMAT_LONG, /*< -l /
161	RTCMDLSFORMAT_MACHINE_READABLE /*< --machine-readable /
162	} RTCMDLSFORMAT;
163
164
165	/**
166	* LS command options and state.
167	*/
168	typedef struct RTCMDLSOPTS
169	{
170	/** @name Traversal.
171	* @{ */
172	bool fFollowSymlinksInDirs; /*< -L /
173	bool fFollowSymlinkToAnyArgs;
174	bool fFollowSymlinkToDirArgs;
175	bool fFollowDirectoryArgs; /*< Inverse -d/--directory. /
176	bool fRecursive; /*< -R /
177	/** @} */
178
179
180	/** @name Filtering.
181	* @{ */
182	bool fShowHidden; /*< -a/--all or -A/--almost-all /
183	bool fShowDotAndDotDot; /*< -a vs -A /
184	bool fShowBackups; /*< Inverse -B/--ignore-backups (~). */
185	/** @} */
186
187	/** @name Sorting
188	* @{ */
189	RTCMDLSSORT enmSort; /*< --sort /
190	bool fReverseSort; /*< -r /
191	bool fGroupDirectoriesFirst; /*< fGroupDirectoriesFirst /
192	/** @} */
193
194	/** @name Formatting
195	* @{ */
196	RTCMDLSFORMAT enmFormat; /*< --format /
197
198	bool fEscapeNonGraphicChars; /*< -b, --escape /
199	bool fEscapeControlChars;
200	bool fHideControlChars; /*< -q/--hide-control-chars, --show-control-chars /
201
202	bool fHumanReadableSizes; /*< -h /
203	bool fSiUnits; /*< --si /
204	uint32_t cbBlock; /*< --block-size=N, -k /
205
206	bool fShowOwner;
207	bool fShowGroup;
208	bool fNumericalIds; /*< -n /
209	bool fShowINode;
210	bool fShowAllocatedSize; /*< -s /
211	uint8_t cchTab; /*< -T /
212	uint32_t cchWidth; /*< -w /
213
214	RTCMDLSCOLOR enmColor; /*< --color /
215
216	RTCMDLSTIME enmTime; /*< --time /
217	RTCMDLSTIMESTYLE enmTimeStyle; /*< --time-style, --full-time /
218	const char pszTimeCustom; /< --time-style=+xxx /
219	/** @} */
220
221	/** @name State
222	* @{ */
223	/** Current size of papCollections. */
224	size_t cCollections;
225	/** Memory allocated for papCollections. */
226	size_t cCollectionsAllocated;
227	/** Current entry collection pending display, the last may also be pending
228	* sorting. */
229	PPRTCMDLSCOLLECTION papCollections;
230	/** @} */
231	} RTCMDLSOPTS;
232	/** Pointer to ls options and state. */
233	typedef RTCMDLSOPTS *PRTCMDLSOPTS;
234
235
236
237
238	/** @callback_method_impl{FNRTSORTCMP, Dirs first + Unsorted} */
239	static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstUnsorted(void const pvElement1, void const pvElement2, void *pvUser)
240	{
241	RT_NOREF(pvUser);
242	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
243	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
244	return !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode);
245	}
246
247
248	/** @callback_method_impl{FNRTSORTCMP, Name} */
249	static DECLCALLBACK(int) rtCmdLsEntryCmpName(void const pvElement1, void const pvElement2, void *pvUser)
250	{
251	RT_NOREF(pvUser);
252	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
253	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
254	return RTStrCmp(pEntry1->szName, pEntry2->szName);
255	}
256
257
258	/** @callback_method_impl{FNRTSORTCMP, Dirs first + Name} */
259	static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstName(void const pvElement1, void const pvElement2, void *pvUser)
260	{
261	RT_NOREF(pvUser);
262	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
263	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
264	int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode);
265	if (!iDiff)
266	iDiff = rtCmdLsEntryCmpName(pEntry1, pEntry2, pvUser);
267	return iDiff;
268	}
269
270
271	/** @callback_method_impl{FNRTSORTCMP, extension} */
272	static DECLCALLBACK(int) rtCmdLsEntryCmpExtension(void const pvElement1, void const pvElement2, void *pvUser)
273	{
274	RT_NOREF(pvUser);
275	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
276	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
277	int iDiff = RTStrCmp(RTPathSuffix(pEntry1->szName), RTPathSuffix(pEntry2->szName));
278	if (!iDiff)
279	iDiff = RTStrCmp(pEntry1->szName, pEntry2->szName);
280	return iDiff;
281	}
282
283
284	/** @callback_method_impl{FNRTSORTCMP, Dirs first + Ext + Name} */
285	static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstExtension(void const pvElement1, void const pvElement2, void *pvUser)
286	{
287	RT_NOREF(pvUser);
288	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
289	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
290	int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode);
291	if (!iDiff)
292	iDiff = rtCmdLsEntryCmpExtension(pEntry1, pEntry2, pvUser);
293	return iDiff;
294	}
295
296
297	/** @callback_method_impl{FNRTSORTCMP, Allocated size + Name} */
298	static DECLCALLBACK(int) rtCmdLsEntryCmpAllocated(void const pvElement1, void const pvElement2, void *pvUser)
299	{
300	RT_NOREF(pvUser);
301	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
302	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
303	if (pEntry1->Info.cbAllocated == pEntry2->Info.cbAllocated)
304	return rtCmdLsEntryCmpName(pEntry1, pEntry2, pvUser);
305	return pEntry1->Info.cbAllocated < pEntry2->Info.cbAllocated ? -1 : 1;
306	}
307
308
309	/** @callback_method_impl{FNRTSORTCMP, Dirs first + Allocated size + Name} */
310	static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstAllocated(void const pvElement1, void const pvElement2, void *pvUser)
311	{
312	RT_NOREF(pvUser);
313	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
314	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
315	int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode);
316	if (!iDiff)
317	iDiff = rtCmdLsEntryCmpAllocated(pEntry1, pEntry2, pvUser);
318	return iDiff;
319	}
320
321
322	/** @callback_method_impl{FNRTSORTCMP, Content size + Name} */
323	static DECLCALLBACK(int) rtCmdLsEntryCmpSize(void const pvElement1, void const pvElement2, void *pvUser)
324	{
325	RT_NOREF(pvUser);
326	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
327	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
328	if (pEntry1->Info.cbObject == pEntry2->Info.cbObject)
329	return rtCmdLsEntryCmpName(pEntry1, pEntry2, pvUser);
330	return pEntry1->Info.cbObject < pEntry2->Info.cbObject ? -1 : 1;
331	}
332
333
334	/** @callback_method_impl{FNRTSORTCMP, Dirs first + Content size + Name} */
335	static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstSize(void const pvElement1, void const pvElement2, void *pvUser)
336	{
337	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
338	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
339	int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode);
340	if (!iDiff)
341	iDiff = rtCmdLsEntryCmpSize(pEntry1, pEntry2, pvUser);
342	return iDiff;
343	}
344
345
346	/** @callback_method_impl{FNRTSORTCMP, Modification time + name} */
347	static DECLCALLBACK(int) rtCmdLsEntryCmpMTime(void const pvElement1, void const pvElement2, void *pvUser)
348	{
349	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
350	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
351	int iDiff = RTTimeSpecCompare(&pEntry1->Info.ModificationTime, &pEntry2->Info.ModificationTime);
352	if (!iDiff)
353	iDiff = rtCmdLsEntryCmpName(pEntry1, pEntry2, pvUser);
354	return iDiff;
355	}
356
357
358	/** @callback_method_impl{FNRTSORTCMP, Dirs first + Modification time + Name} */
359	static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstMTime(void const pvElement1, void const pvElement2, void *pvUser)
360	{
361	RT_NOREF(pvUser);
362	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
363	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
364	int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode);
365	if (!iDiff)
366	iDiff = rtCmdLsEntryCmpMTime(pEntry1, pEntry2, pvUser);
367	return iDiff;
368	}
369
370
371	/** @callback_method_impl{FNRTSORTCMP, Birth time + name} */
372	static DECLCALLBACK(int) rtCmdLsEntryCmpBTime(void const pvElement1, void const pvElement2, void *pvUser)
373	{
374	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
375	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
376	int iDiff = RTTimeSpecCompare(&pEntry1->Info.BirthTime, &pEntry2->Info.BirthTime);
377	if (!iDiff)
378	iDiff = rtCmdLsEntryCmpName(pEntry1, pEntry2, pvUser);
379	return iDiff;
380	}
381
382
383	/** @callback_method_impl{FNRTSORTCMP, Dirs first + Birth time + Name} */
384	static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstBTime(void const pvElement1, void const pvElement2, void *pvUser)
385	{
386	RT_NOREF(pvUser);
387	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
388	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
389	int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode);
390	if (!iDiff)
391	iDiff = rtCmdLsEntryCmpBTime(pEntry1, pEntry2, pvUser);
392	return iDiff;
393	}
394
395
396	/** @callback_method_impl{FNRTSORTCMP, Change time + name} */
397	static DECLCALLBACK(int) rtCmdLsEntryCmpCTime(void const pvElement1, void const pvElement2, void *pvUser)
398	{
399	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
400	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
401	int iDiff = RTTimeSpecCompare(&pEntry1->Info.ChangeTime, &pEntry2->Info.ChangeTime);
402	if (!iDiff)
403	iDiff = rtCmdLsEntryCmpName(pEntry1, pEntry2, pvUser);
404	return iDiff;
405	}
406
407
408	/** @callback_method_impl{FNRTSORTCMP, Dirs first + Change time + Name} */
409	static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstCTime(void const pvElement1, void const pvElement2, void *pvUser)
410	{
411	RT_NOREF(pvUser);
412	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
413	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
414	int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode);
415	if (!iDiff)
416	iDiff = rtCmdLsEntryCmpCTime(pEntry1, pEntry2, pvUser);
417	return iDiff;
418	}
419
420
421	/** @callback_method_impl{FNRTSORTCMP, Accessed time + name} */
422	static DECLCALLBACK(int) rtCmdLsEntryCmpATime(void const pvElement1, void const pvElement2, void *pvUser)
423	{
424	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
425	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
426	int iDiff = RTTimeSpecCompare(&pEntry1->Info.AccessTime, &pEntry2->Info.AccessTime);
427	if (!iDiff)
428	iDiff = rtCmdLsEntryCmpName(pEntry1, pEntry2, pvUser);
429	return iDiff;
430	}
431
432
433	/** @callback_method_impl{FNRTSORTCMP, Dirs first + Accessed time + Name} */
434	static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstATime(void const pvElement1, void const pvElement2, void *pvUser)
435	{
436	RT_NOREF(pvUser);
437	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
438	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
439	int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode);
440	if (!iDiff)
441	iDiff = rtCmdLsEntryCmpATime(pEntry1, pEntry2, pvUser);
442	return iDiff;
443	}
444
445
446	/** @callback_method_impl{FNRTSORTCMP, Name as version} */
447	static DECLCALLBACK(int) rtCmdLsEntryCmpVersion(void const pvElement1, void const pvElement2, void *pvUser)
448	{
449	RT_NOREF(pvUser);
450	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
451	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
452	return RTStrVersionCompare(pEntry1->szName, pEntry2->szName);
453	}
454
455
456	/** @callback_method_impl{FNRTSORTCMP, Dirs first + Name as version} */
457	static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstVersion(void const pvElement1, void const pvElement2, void *pvUser)
458	{
459	RT_NOREF(pvUser);
460	PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1;
461	PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2;
462	int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode);
463	if (!iDiff)
464	iDiff = rtCmdLsEntryCmpVersion(pEntry1, pEntry2, pvUser);
465	return iDiff;
466	}
467
468
469	/**
470	* Sorts the entries in the collections according the sorting options.
471	*
472	* @param pOpts The options and state.
473	*/
474	static void rtCmdLsSortCollections(PRTCMDLSOPTS pOpts)
475	{
476	/*
477	* Sort the entries in each collection.
478	*/
479	PFNRTSORTCMP pfnCmp;
480	switch (pOpts->enmSort)
481	{
482	case RTCMDLSSORT_NONE:
483	pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstUnsorted : NULL;
484	break;
485	default: AssertFailed(); RT_FALL_THRU();
486	case RTCMDLSSORT_NAME:
487	pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstName : rtCmdLsEntryCmpName;
488	break;
489	case RTCMDLSSORT_EXTENSION:
490	pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstExtension : rtCmdLsEntryCmpExtension;
491	break;
492	case RTCMDLSSORT_SIZE:
493	if (pOpts->fShowAllocatedSize)
494	pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstAllocated : rtCmdLsEntryCmpAllocated;
495	else
496	pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstSize : rtCmdLsEntryCmpSize;
497	break;
498	case RTCMDLSSORT_TIME:
499	switch (pOpts->enmTime)
500	{
501	default: AssertFailed(); RT_FALL_THRU();
502	case RTCMDLSTIME_MTIME: pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstMTime : rtCmdLsEntryCmpMTime; break;
503	case RTCMDLSTIME_BTIME: pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstBTime : rtCmdLsEntryCmpBTime; break;
504	case RTCMDLSTIME_CTIME: pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstCTime : rtCmdLsEntryCmpCTime; break;
505	case RTCMDLSTIME_ATIME: pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstATime : rtCmdLsEntryCmpATime; break;
506	}
507	break;
508	case RTCMDLSSORT_VERSION:
509	pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstVersion : rtCmdLsEntryCmpVersion;
510	break;
511	}
512	if (pfnCmp)
513	{
514	/*
515	* Walk thru the collections and sort their entries.
516	*/
517	size_t i = pOpts->cCollections;
518	while (i-- > 0)
519	{
520	PRTCMDLSCOLLECTION pCollection = pOpts->papCollections[i];
521	RTSortApvShell((void **)pCollection->papEntries, pCollection->cEntries, pfnCmp, NULL);
522
523	if (pOpts->fReverseSort)
524	{
525	PPRTCMDLSENTRY papEntries = pCollection->papEntries;
526	size_t iHead = 0;
527	size_t iTail = pCollection->cEntries;
528	while (iHead < iTail)
529	{
530	PRTCMDLSENTRY pTmp = papEntries[iHead];
531	papEntries[iHead] = papEntries[iTail];
532	papEntries[iTail] = pTmp;
533	iHead++;
534	iTail--;
535	}
536	}
537	}
538	}
539
540	/** @todo sort the collections too, except for the first one. */
541	}
542
543
544	/**
545	* Format human readable size.
546	*/
547	static const char rtCmdLsFormatSizeHumanReadable(PRTCMDLSOPTS pOpts, uint64_t cb, char pszDst, size_t cbDst)
548	{
549	if (pOpts->fHumanReadableSizes)
550	{
551	if (!pOpts->fSiUnits)
552	{
553	size_t cch = RTStrPrintf(pszDst, cbDst, "%Rhub", cb);
554	if (pszDst[cch - 1] == 'i')
555	pszDst[cch - 1] = '\0'; /* drop the trailing 'i' */
556	}
557	else
558	RTStrPrintf(pszDst, cbDst, "%Rhui", cb);
559	}
560	else if (pOpts->cbBlock)
561	RTStrFormatU64(pszDst, cbDst, (cb + pOpts->cbBlock - 1) / pOpts->cbBlock, 10, 0, 0, 0);
562	else
563	RTStrFormatU64(pszDst, cbDst, cb, 10, 0, 0, 0);
564	return pszDst;
565	}
566
567
568	/**
569	* Format block count.
570	*/
571	static const char rtCmdLsFormatBlocks(PRTCMDLSOPTS pOpts, uint64_t cb, char pszDst, size_t cbDst)
572	{
573	if (pOpts->fHumanReadableSizes)
574	return rtCmdLsFormatSizeHumanReadable(pOpts, cb, pszDst, cbDst);
575
576	uint32_t cbBlock = pOpts->cbBlock;
577	if (cbBlock == 0)
578	cbBlock = _1K;
579	RTStrFormatU64(pszDst, cbDst, (cb + cbBlock / 2 - 1) / cbBlock, 10, 0, 0, 0);
580	return pszDst;
581	}
582
583
584	/**
585	* Format file size.
586	*/
587	static const char rtCmdLsFormatSize(PRTCMDLSOPTS pOpts, uint64_t cb, char pszDst, size_t cbDst)
588	{
589	if (pOpts->fHumanReadableSizes)
590	return rtCmdLsFormatSizeHumanReadable(pOpts, cb, pszDst, cbDst);
591	if (pOpts->cbBlock > 0)
592	return rtCmdLsFormatBlocks(pOpts, cb, pszDst, cbDst);
593	RTStrFormatU64(pszDst, cbDst, cb, 10, 0, 0, 0);
594	return pszDst;
595	}
596
597
598	/**
599	* Format name, i.e. escape, hide, quote stuff.
600	*/
601	static const char rtCmdLsFormatName(PRTCMDLSOPTS pOpts, const char pszName, char *pszDst, size_t cbDst)
602	{
603	if ( !pOpts->fEscapeNonGraphicChars
604	&& !pOpts->fEscapeControlChars
605	&& !pOpts->fHideControlChars)
606	return pszName;
607	/** @todo implement name formatting. */
608	RT_NOREF(pszDst, cbDst);
609	return pszName;
610	}
611
612
613	/**
614	* Figures out the length for a 32-bit number when formatted as decimal.
615	* @returns Number of digits.
616	* @param uValue The number.
617	*/
618	DECLINLINE(size_t) rtCmdLsDecimalFormatLengthU32(uint32_t uValue)
619	{
620	if (uValue < 10)
621	return 1;
622	if (uValue < 100)
623	return 2;
624	if (uValue < 1000)
625	return 3;
626	if (uValue < 10000)
627	return 4;
628	if (uValue < 100000)
629	return 5;
630	if (uValue < 1000000)
631	return 6;
632	if (uValue < 10000000)
633	return 7;
634	if (uValue < 100000000)
635	return 8;
636	if (uValue < 1000000000)
637	return 9;
638	return 10;
639	}
640
641
642	/**
643	* Formats the given group ID according to the specified options.
644	*
645	* @returns pszDst
646	* @param pOpts The options and state.
647	* @param gid The GID to format.
648	* @param pszOwner The owner returned by the FS.
649	* @param pszDst The output buffer.
650	* @param cbDst The output buffer size.
651	*/
652	static const char rtCmdLsDecimalFormatGroup(PRTCMDLSOPTS pOpts, RTGID gid, const char pszGroup, char *pszDst, size_t cbDst)
653	{
654	if (!pOpts->fNumericalIds)
655	{
656	if (pszGroup)
657	{
658	RTStrCopy(pszDst, cbDst, pszGroup);
659	return pszDst;
660	}
661	if (gid == NIL_RTGID)
662	return "<Nil>";
663	}
664	RTStrFormatU64(pszDst, cbDst, gid, 10, 0, 0, 0);
665	return pszDst;
666	}
667
668
669	/**
670	* Formats the given user ID according to the specified options.
671	*
672	* @returns pszDst
673	* @param pOpts The options and state.
674	* @param uid The UID to format.
675	* @param pszOwner The owner returned by the FS.
676	* @param pszDst The output buffer.
677	* @param cbDst The output buffer size.
678	*/
679	static const char rtCmdLsDecimalFormatOwner(PRTCMDLSOPTS pOpts, RTUID uid, const char pszOwner, char *pszDst, size_t cbDst)
680	{
681	if (!pOpts->fNumericalIds)
682	{
683	if (pszOwner)
684	{
685	RTStrCopy(pszDst, cbDst, pszOwner);
686	return pszDst;
687	}
688	if (uid == NIL_RTUID)
689	return "<Nil>";
690	}
691	RTStrFormatU64(pszDst, cbDst, uid, 10, 0, 0, 0);
692	return pszDst;
693	}
694
695
696	/**
697	* Formats the given timestamp according to the desired --time-style.
698	*
699	* @returns pszDst
700	* @param pOpts The options and state.
701	* @param pTimestamp The timestamp.
702	* @param pszDst The output buffer.
703	* @param cbDst The output buffer size.
704	*/
705	static const char rtCmdLsFormatTimestamp(PRTCMDLSOPTS pOpts, PCRTTIMESPEC pTimestamp, char pszDst, size_t cbDst)
706	{
707	/** @todo timestamp formatting according to the given style. */
708	RT_NOREF(pOpts);
709	return RTTimeSpecToString(pTimestamp, pszDst, cbDst);
710	}
711
712
713
714	/**
715	* RTCMDLSFORMAT_MACHINE_READABLE: --machine-readable
716	*/
717	static RTEXITCODE rtCmdLsDisplayCollectionInMachineReadableFormat(PRTCMDLSOPTS pOpts, PRTCMDLSCOLLECTION pCollection,
718	char *pszTmp, size_t cbTmp)
719	{
720	RT_NOREF(pOpts, pCollection, pszTmp, cbTmp);
721	RTMsgError("Machine readable format not implemented\n");
722	return RTEXITCODE_FAILURE;
723	}
724
725
726	/**
727	* RTCMDLSFORMAT_COMMAS: -m
728	*/
729	static RTEXITCODE rtCmdLsDisplayCollectionInCvsFormat(PRTCMDLSOPTS pOpts, PRTCMDLSCOLLECTION pCollection,
730	char *pszTmp, size_t cbTmp)
731	{
732	RT_NOREF(pOpts, pCollection, pszTmp, cbTmp);
733	RTMsgError("Table output formats not implemented\n");
734	return RTEXITCODE_FAILURE;
735	}
736
737
738	/**
739	* RTCMDLSFORMAT_LONG: -l
740	*/
741	static RTEXITCODE rtCmdLsDisplayCollectionInLongFormat(PRTCMDLSOPTS pOpts, PRTCMDLSCOLLECTION pCollection,
742	char *pszTmp, size_t cbTmp, size_t cchAllocatedCol)
743	{
744	/*
745	* Figure the width of the size, the link count, the uid, the gid, and the inode columns.
746	*/
747	size_t cchSizeCol = 1;
748	size_t cchLinkCol = 1;
749	size_t cchUidCol = pOpts->fShowOwner ? 1 : 0;
750	size_t cchGidCol = pOpts->fShowGroup ? 1 : 0;
751	size_t cchINodeCol = pOpts->fShowINode ? 1 : 0;
752
753	size_t i = pCollection->cEntries;
754	while (i-- > 0)
755	{
756	PRTCMDLSENTRY pEntry = pCollection->papEntries[i];
757
758	rtCmdLsFormatSize(pOpts, pEntry->Info.cbObject, pszTmp, cbTmp);
759	size_t cchTmp = strlen(pszTmp);
760	if (cchTmp > cchSizeCol)
761	cchSizeCol = cchTmp;
762
763	cchTmp = rtCmdLsDecimalFormatLengthU32(pEntry->Info.Attr.u.Unix.cHardlinks) + 1;
764	if (cchTmp > cchLinkCol)
765	cchLinkCol = cchTmp;
766
767	if (pOpts->fShowOwner)
768	{
769	rtCmdLsDecimalFormatOwner(pOpts, pEntry->Info.Attr.u.Unix.uid, pEntry->pszOwner, pszTmp, cbTmp);
770	cchTmp = strlen(pszTmp);
771	if (cchTmp > cchUidCol)
772	cchUidCol = cchTmp;
773	}
774
775	if (pOpts->fShowGroup)
776	{
777	rtCmdLsDecimalFormatGroup(pOpts, pEntry->Info.Attr.u.Unix.gid, pEntry->pszGroup, pszTmp, cbTmp);
778	cchTmp = strlen(pszTmp);
779	if (cchTmp > cchGidCol)
780	cchGidCol = cchTmp;
781	}
782
783	if (pOpts->fShowINode)
784	{
785	cchTmp = RTStrFormatU64(pszTmp, cchTmp, pEntry->Info.Attr.u.Unix.INodeId, 10, 0, 0, 0);
786	if (cchTmp > cchINodeCol)
787	cchINodeCol = cchTmp;
788	}
789	}
790
791	/*
792	* Determin time member offset.
793	*/
794	size_t offTime;
795	switch (pOpts->enmTime)
796	{
797	default: AssertFailed(); RT_FALL_THRU();
798	case RTCMDLSTIME_MTIME: offTime = RT_UOFFSETOF(RTCMDLSENTRY, Info.ModificationTime); break;
799	case RTCMDLSTIME_BTIME: offTime = RT_UOFFSETOF(RTCMDLSENTRY, Info.BirthTime); break;
800	case RTCMDLSTIME_CTIME: offTime = RT_UOFFSETOF(RTCMDLSENTRY, Info.ChangeTime); break;
801	case RTCMDLSTIME_ATIME: offTime = RT_UOFFSETOF(RTCMDLSENTRY, Info.AccessTime); break;
802	}
803
804	/*
805	* Display the entries.
806	*/
807	for (i = 0; i < pCollection->cEntries; i++)
808	{
809	PRTCMDLSENTRY pEntry = pCollection->papEntries[i];
810
811	if (cchINodeCol)
812	RTPrintf("%*RU64 ", cchINodeCol, pEntry->Info.Attr.u.Unix.INodeId);
813	if (cchAllocatedCol)
814	RTPrintf("%*s ", cchAllocatedCol, rtCmdLsFormatBlocks(pOpts, pEntry->Info.cbAllocated, pszTmp, cbTmp));
815
816	RTFMODE fMode = pEntry->Info.Attr.fMode;
817	switch (fMode & RTFS_TYPE_MASK)
818	{
819	case RTFS_TYPE_FIFO: RTPrintf("f"); break;
820	case RTFS_TYPE_DEV_CHAR: RTPrintf("c"); break;
821	case RTFS_TYPE_DIRECTORY: RTPrintf("d"); break;
822	case RTFS_TYPE_DEV_BLOCK: RTPrintf("b"); break;
823	case RTFS_TYPE_FILE: RTPrintf("-"); break;
824	case RTFS_TYPE_SYMLINK: RTPrintf("l"); break;
825	case RTFS_TYPE_SOCKET: RTPrintf("s"); break;
826	case RTFS_TYPE_WHITEOUT: RTPrintf("w"); break;
827	default: RTPrintf("?"); AssertFailed(); break;
828	}
829	/** @todo sticy bits++ */
830	RTPrintf("%c%c%c",
831	fMode & RTFS_UNIX_IRUSR ? 'r' : '-',
832	fMode & RTFS_UNIX_IWUSR ? 'w' : '-',
833	fMode & RTFS_UNIX_IXUSR ? 'x' : '-');
834	RTPrintf("%c%c%c",
835	fMode & RTFS_UNIX_IRGRP ? 'r' : '-',
836	fMode & RTFS_UNIX_IWGRP ? 'w' : '-',
837	fMode & RTFS_UNIX_IXGRP ? 'x' : '-');
838	RTPrintf("%c%c%c",
839	fMode & RTFS_UNIX_IROTH ? 'r' : '-',
840	fMode & RTFS_UNIX_IWOTH ? 'w' : '-',
841	fMode & RTFS_UNIX_IXOTH ? 'x' : '-');
842	if (1)
843	{
844	RTPrintf(" %c%c%c%c%c%c%c%c%c%c%c%c%c%c",
845	fMode & RTFS_DOS_READONLY ? 'R' : '-',
846	fMode & RTFS_DOS_HIDDEN ? 'H' : '-',
847	fMode & RTFS_DOS_SYSTEM ? 'S' : '-',
848	fMode & RTFS_DOS_DIRECTORY ? 'D' : '-',
849	fMode & RTFS_DOS_ARCHIVED ? 'A' : '-',
850	fMode & RTFS_DOS_NT_DEVICE ? 'd' : '-',
851	fMode & RTFS_DOS_NT_NORMAL ? 'N' : '-',
852	fMode & RTFS_DOS_NT_TEMPORARY ? 'T' : '-',
853	fMode & RTFS_DOS_NT_SPARSE_FILE ? 'P' : '-',
854	fMode & RTFS_DOS_NT_REPARSE_POINT ? 'J' : '-',
855	fMode & RTFS_DOS_NT_COMPRESSED ? 'C' : '-',
856	fMode & RTFS_DOS_NT_OFFLINE ? 'O' : '-',
857	fMode & RTFS_DOS_NT_NOT_CONTENT_INDEXED ? 'I' : '-',
858	fMode & RTFS_DOS_NT_ENCRYPTED ? 'E' : '-');
859	}
860	RTPrintf(" %*u", cchLinkCol, pEntry->Info.Attr.u.Unix.cHardlinks);
861	if (cchUidCol)
862	RTPrintf(" %*s", cchUidCol,
863	rtCmdLsDecimalFormatOwner(pOpts, pEntry->Info.Attr.u.Unix.uid, pEntry->pszOwner, pszTmp, cbTmp));
864	if (cchGidCol)
865	RTPrintf(" %*s", cchGidCol,
866	rtCmdLsDecimalFormatGroup(pOpts, pEntry->Info.Attr.u.Unix.gid, pEntry->pszGroup, pszTmp, cbTmp));
867	RTPrintf(" %*s", cchSizeCol, rtCmdLsFormatSize(pOpts, pEntry->Info.cbObject, pszTmp, cbTmp));
868
869	PCRTTIMESPEC pTime = (PCRTTIMESPEC)((uintptr_t)pEntry + offTime);
870	RTPrintf(" %s", rtCmdLsFormatTimestamp(pOpts, pTime, pszTmp, cbTmp));
871
872	RTPrintf(" %s\n", rtCmdLsFormatName(pOpts, pEntry->szName, pszTmp, cbTmp));
873	}
874
875	return RTEXITCODE_SUCCESS;
876	}
877
878
879	/**
880	* RTCMDLSFORMAT_SINGLE: -1
881	*/
882	static RTEXITCODE rtCmdLsDisplayCollectionInSingleFormat(PRTCMDLSOPTS pOpts, PRTCMDLSCOLLECTION pCollection,
883	char *pszTmp, size_t cbTmp, size_t cchAllocatedCol)
884	{
885	if (cchAllocatedCol > 0)
886	for (size_t i = 0; i < pCollection->cEntries; i++)
887	{
888	PRTCMDLSENTRY pEntry = pCollection->papEntries[i];
889	RTPrintf("%*s %s\n",
890	cchAllocatedCol, rtCmdLsFormatBlocks(pOpts, pEntry->Info.cbAllocated, pszTmp, cbTmp / 4),
891	rtCmdLsFormatName(pOpts, pEntry->szName, &pszTmp[cbTmp / 4], cbTmp / 4 * 3));
892	}
893	else
894	for (size_t i = 0; i < pCollection->cEntries; i++)
895	{
896	PRTCMDLSENTRY pEntry = pCollection->papEntries[i];
897	RTPrintf("%s\n", rtCmdLsFormatName(pOpts, pEntry->szName, pszTmp, cbTmp));
898	}
899
900	return RTEXITCODE_SUCCESS;
901	}
902
903
904	/**
905	* RTCMDLSFORMAT_COLS_VERTICAL: default, -C; RTCMDLSFORMAT_COLS_HORIZONTAL: -x
906	*/
907	static RTEXITCODE rtCmdLsDisplayCollectionInTableFormat(PRTCMDLSOPTS pOpts, PRTCMDLSCOLLECTION pCollection,
908	char *pszTmp, size_t cbTmp, size_t cchAllocatedCol)
909	{
910	RT_NOREF(pOpts, pCollection, pszTmp, cbTmp, cchAllocatedCol);
911	RTMsgError("Table output formats not implemented\n");
912	return RTEXITCODE_FAILURE;
913	}
914
915
916	/**
917	* Does the actual displaying of the entry collections.
918	*
919	* @returns Program exit code.
920	* @param pOpts The options and state.
921	*/
922	static RTEXITCODE rtCmdLsDisplayCollections(PRTCMDLSOPTS pOpts)
923	{
924	rtCmdLsSortCollections(pOpts);
925
926	bool const fNeedCollectionName = pOpts->cCollections > 2
927	\|\| ( pOpts->cCollections == 2
928	&& pOpts->papCollections[0]->cEntries > 0);
929	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
930	for (size_t iCollection = 0; iCollection < pOpts->cCollections; iCollection++)
931	{
932	PRTCMDLSCOLLECTION pCollection = pOpts->papCollections[iCollection];
933	char szTmp[RTPATH_MAX*2];
934
935	/* The header. */
936	if (iCollection != 0)
937	{
938	if ( iCollection > 1
939	\|\| pOpts->papCollections[0]->cEntries > 0)
940	RTPrintf("\n");
941	if (fNeedCollectionName)
942	RTPrintf("%s:\n", rtCmdLsFormatName(pOpts, pCollection->szName, szTmp, sizeof(szTmp)));
943	RTPrintf("total %s\n", rtCmdLsFormatBlocks(pOpts, pCollection->cbTotalAllocated, szTmp, sizeof(szTmp)));
944	}
945
946	/* Format the entries. */
947	RTEXITCODE rcExit2;
948	if (pOpts->enmFormat == RTCMDLSFORMAT_MACHINE_READABLE)
949	rcExit2 = rtCmdLsDisplayCollectionInMachineReadableFormat(pOpts, pCollection, szTmp, sizeof(szTmp));
950	else if (pOpts->enmFormat == RTCMDLSFORMAT_COMMAS)
951	rcExit2 = rtCmdLsDisplayCollectionInCvsFormat(pOpts, pCollection, szTmp, sizeof(szTmp));
952	else
953	{
954	/* If the allocated size is requested, calculate the column width. */
955	size_t cchAllocatedCol = 0;
956	if (pOpts->fShowAllocatedSize)
957	{
958	size_t i = pCollection->cEntries;
959	while (i-- > 0)
960	{
961	rtCmdLsFormatBlocks(pOpts, pCollection->papEntries[i]->Info.cbAllocated, szTmp, sizeof(szTmp));
962	size_t cchTmp = strlen(szTmp);
963	if (cchTmp > cchAllocatedCol)
964	cchAllocatedCol = cchTmp;
965	}
966	}
967
968	/* Do the individual formatting. */
969	if (pOpts->enmFormat == RTCMDLSFORMAT_LONG)
970	rcExit2 = rtCmdLsDisplayCollectionInLongFormat(pOpts, pCollection, szTmp, sizeof(szTmp), cchAllocatedCol);
971	else if (pOpts->enmFormat == RTCMDLSFORMAT_SINGLE)
972	rcExit2 = rtCmdLsDisplayCollectionInSingleFormat(pOpts, pCollection, szTmp, sizeof(szTmp), cchAllocatedCol);
973	else
974	rcExit2 = rtCmdLsDisplayCollectionInTableFormat(pOpts, pCollection, szTmp, sizeof(szTmp), cchAllocatedCol);
975	}
976	if (rcExit2 != RTEXITCODE_SUCCESS)
977	rcExit = rcExit2;
978	}
979	return rcExit;
980	}
981
982
983	/**
984	* Frees all collections and their entries.
985	* @param pOpts The options and state.
986	*/
987	static void rtCmdLsFreeCollections(PRTCMDLSOPTS pOpts)
988	{
989	size_t i = pOpts->cCollections;
990	while (i-- > 0)
991	{
992	PRTCMDLSCOLLECTION pCollection = pOpts->papCollections[i];
993	PPRTCMDLSENTRY papEntries = pCollection->papEntries;
994	size_t j = pCollection->cEntries;
995	while (j-- > 0)
996	{
997	RTMemFree(papEntries[j]);
998	papEntries[j] = NULL;
999	}
1000	RTMemFree(papEntries);
1001	pCollection->papEntries = NULL;
1002	pCollection->cEntries = 0;
1003	pCollection->cEntriesAllocated = 0;
1004	RTMemFree(pCollection);
1005	pOpts->papCollections[i] = NULL;
1006	}
1007
1008	RTMemFree(pOpts->papCollections);
1009	pOpts->papCollections = NULL;
1010	pOpts->cCollections = 0;
1011	pOpts->cCollectionsAllocated = 0;
1012	}
1013
1014
1015	/**
1016	* Allocates a new collection.
1017	*
1018	* @returns Pointer to the collection.
1019	* @param pOpts The options and state.
1020	* @param pszName The collection name. Empty for special first
1021	* collection.
1022	*/
1023	static PRTCMDLSCOLLECTION rtCmdLsNewCollection(PRTCMDLSOPTS pOpts, const char *pszName)
1024	{
1025	/* Grow the pointer table? */
1026	if (pOpts->cCollections >= pOpts->cCollectionsAllocated)
1027	{
1028	size_t cNew = pOpts->cCollectionsAllocated ? pOpts->cCollectionsAllocated * 2 : 16;
1029	void pvNew = RTMemRealloc(pOpts->papCollections, cNew sizeof(pOpts->papCollections[0]));
1030	if (!pvNew)
1031	{
1032	RTMsgError("Out of memory! (resize collections)");
1033	return NULL;
1034	}
1035	pOpts->cCollectionsAllocated = cNew;
1036	pOpts->papCollections = (PPRTCMDLSCOLLECTION)pvNew;
1037
1038	/* If this is the first time and pszName isn't empty, add the zero'th
1039	entry for the command line stuff (hardcoded first collection). */
1040	if ( pOpts->cCollections == 0
1041	&& *pszName)
1042	{
1043	PRTCMDLSCOLLECTION pCollection = (PRTCMDLSCOLLECTION)RTMemAllocZ(RT_UOFFSETOF(RTCMDLSCOLLECTION, szName[1]));
1044	if (!pCollection)
1045	{
1046	RTMsgError("Out of memory! (collection)");
1047	return NULL;
1048	}
1049	pOpts->papCollections[0] = pCollection;
1050	pOpts->cCollections = 1;
1051	}
1052	}
1053
1054	/* Add new collection. */
1055	size_t cbName = strlen(pszName) + 1;
1056	PRTCMDLSCOLLECTION pCollection = (PRTCMDLSCOLLECTION)RTMemAllocZ(RT_UOFFSETOF_DYN(RTCMDLSCOLLECTION, szName[cbName]));
1057	if (pCollection)
1058	{
1059	memcpy(pCollection->szName, pszName, cbName);
1060	pOpts->papCollections[pOpts->cCollections++] = pCollection;
1061	}
1062	else
1063	RTMsgError("Out of memory! (collection)");
1064	return pCollection;
1065	}
1066
1067
1068	/**
1069	* Adds one entry to a collection.
1070	* @returns Program exit code
1071	* @param pCollection The collection.
1072	* @param pszEntry The entry name.
1073	* @param pInfo The entry info.
1074	* @param pszOwner The owner name if available, otherwise NULL.
1075	* @param pszGroup The group anme if available, otherwise NULL.
1076	* @param pszTarget The symbolic link target if applicable and
1077	* available, otherwise NULL.
1078	*/
1079	static RTEXITCODE rtCmdLsAddOne(PRTCMDLSCOLLECTION pCollection, const char *pszEntry, PRTFSOBJINFO pInfo,
1080	const char pszOwner, const char pszGroup, const char *pszTarget)
1081	{
1082
1083	/* Make sure there is space in the collection for the new entry. */
1084	if (pCollection->cEntries >= pCollection->cEntriesAllocated)
1085	{
1086	size_t cNew = pCollection->cEntriesAllocated ? pCollection->cEntriesAllocated * 2 : 16;
1087	void pvNew = RTMemRealloc(pCollection->papEntries, cNew sizeof(pCollection->papEntries[0]));
1088	if (!pvNew)
1089	return RTMsgErrorExitFailure("Out of memory! (resize entries)");
1090	pCollection->papEntries = (PPRTCMDLSENTRY)pvNew;
1091	pCollection->cEntriesAllocated = cNew;
1092	}
1093
1094	/* Create and insert a new entry. */
1095	size_t const cchEntry = strlen(pszEntry);
1096	size_t const cbOwner = pszOwner ? strlen(pszOwner) + 1 : 0;
1097	size_t const cbGroup = pszGroup ? strlen(pszGroup) + 1 : 0;
1098	size_t const cbTarget = pszTarget ? strlen(pszTarget) + 1 : 0;
1099	size_t const cbEntry = RT_UOFFSETOF_DYN(RTCMDLSENTRY, szName[cchEntry + 1 + cbOwner + cbGroup + cbTarget]);
1100	PRTCMDLSENTRY pEntry = (PRTCMDLSENTRY)RTMemAlloc(cbEntry);
1101	if (pEntry)
1102	{
1103	pEntry->Info = *pInfo;
1104	pEntry->pszTarget = NULL; /** @todo symbolic links. */
1105	pEntry->pszOwner = NULL;
1106	pEntry->pszGroup = NULL;
1107	pEntry->cchName = cchEntry;
1108	memcpy(pEntry->szName, pszEntry, cchEntry);
1109	pEntry->szName[cchEntry] = '\0';
1110
1111	char *psz = &pEntry->szName[cchEntry + 1];
1112	if (pszTarget)
1113	{
1114	pEntry->pszTarget = psz;
1115	memcpy(psz, pszTarget, cbTarget);
1116	psz += cbTarget;
1117	}
1118	if (pszOwner)
1119	{
1120	pEntry->pszOwner = psz;
1121	memcpy(psz, pszOwner, cbOwner);
1122	psz += cbOwner;
1123	}
1124	if (pszGroup)
1125	{
1126	pEntry->pszGroup = psz;
1127	memcpy(psz, pszGroup, cbGroup);
1128	}
1129
1130	pCollection->papEntries[pCollection->cEntries++] = pEntry;
1131	pCollection->cbTotalAllocated += pEntry->Info.cbAllocated;
1132	pCollection->cbTotalFiles += pEntry->Info.cbObject;
1133	return RTEXITCODE_SUCCESS;
1134	}
1135	return RTMsgErrorExitFailure("Out of memory! (entry)");
1136	}
1137
1138
1139	/**
1140	* Checks if the entry is to be filtered out.
1141	*
1142	* @returns true if filtered out, false if included.
1143	* @param pOpts The options and state.
1144	* @param pszEntry The entry name.
1145	* @param pInfo The entry info.
1146	*/
1147	static bool rtCmdLsIsFilteredOut(PRTCMDLSOPTS pOpts, const char *pszEntry, PCRTFSOBJINFO pInfo)
1148	{
1149	/*
1150	* Should we filter out this entry?
1151	*/
1152	if ( !pOpts->fShowHidden
1153	&& (pInfo->Attr.fMode & RTFS_DOS_HIDDEN))
1154	return true;
1155
1156	size_t const cchEntry = strlen(pszEntry);
1157	if ( !pOpts->fShowDotAndDotDot
1158	&& cchEntry <= 2
1159	&& pszEntry[0] == '.'
1160	&& ( cchEntry == 1
1161	\|\| pszEntry[1] == '.' ))
1162	return true;
1163
1164	if ( !pOpts->fShowBackups
1165	&& pszEntry[cchEntry - 1] == '~')
1166	return true;
1167	return false;
1168	}
1169
1170
1171	/**
1172	* Processes a directory, recursing into subdirectories if desired.
1173	*
1174	* @returns Program exit code.
1175	* @param pOpts The options.
1176	* @param hVfsDir The directory.
1177	* @param pszPath Path buffer, RTPATH_MAX in size.
1178	* @param cchPath The length of the current path.
1179	* @param pInfo The parent information.
1180	*/
1181	static RTEXITCODE rtCmdLsProcessDirectory(PRTCMDLSOPTS pOpts, RTVFSDIR hVfsDir, char *pszPath, size_t cchPath, PCRTFSOBJINFO pInfo)
1182	{
1183	/*
1184	* Create a new collection for this directory.
1185	*/
1186	RT_NOREF(pInfo);
1187	PRTCMDLSCOLLECTION pCollection = rtCmdLsNewCollection(pOpts, pszPath);
1188	if (!pCollection)
1189	return RTEXITCODE_FAILURE;
1190
1191	/*
1192	* Process the directory entries.
1193	*/
1194	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
1195	size_t cbDirEntryAlloced = sizeof(RTDIRENTRYEX);
1196	PRTDIRENTRYEX pDirEntry = (PRTDIRENTRYEX)RTMemTmpAlloc(cbDirEntryAlloced);
1197	if (!pDirEntry)
1198	return RTMsgErrorExitFailure("Out of memory! (direntry buffer)");
1199
1200	for (;;)
1201	{
1202	/*
1203	* Read the next entry.
1204	*/
1205	size_t cbDirEntry = cbDirEntryAlloced;
1206	int rc = RTVfsDirReadEx(hVfsDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_UNIX);
1207	if (RT_FAILURE(rc))
1208	{
1209	if (rc == VERR_BUFFER_OVERFLOW)
1210	{
1211	RTMemTmpFree(pDirEntry);
1212	cbDirEntryAlloced = RT_ALIGN_Z(RT_MIN(cbDirEntry, cbDirEntryAlloced) + 64, 64);
1213	pDirEntry = (PRTDIRENTRYEX)RTMemTmpAlloc(cbDirEntryAlloced);
1214	if (pDirEntry)
1215	continue;
1216	rcExit = RTMsgErrorExitFailure("Out of memory (direntry buffer)");
1217	}
1218	else if (rc != VERR_NO_MORE_FILES)
1219	rcExit = RTMsgErrorExitFailure("RTVfsDirReadEx failed: %Rrc\n", rc);
1220	break;
1221	}
1222
1223	/*
1224	* Process the entry.
1225	*/
1226	if (rtCmdLsIsFilteredOut(pOpts, pDirEntry->szName, &pDirEntry->Info))
1227	continue;
1228
1229
1230	const char *pszOwner = NULL;
1231	RTFSOBJINFO OwnerInfo;
1232	if (pDirEntry->Info.Attr.u.Unix.uid != NIL_RTUID && pOpts->fShowOwner)
1233	{
1234	rc = RTVfsDirQueryPathInfo(hVfsDir, pDirEntry->szName, &OwnerInfo, RTFSOBJATTRADD_UNIX_OWNER, RTPATH_F_ON_LINK);
1235	if (RT_SUCCESS(rc) && OwnerInfo.Attr.u.UnixOwner.szName[0])
1236	pszOwner = &OwnerInfo.Attr.u.UnixOwner.szName[0];
1237	}
1238
1239	const char *pszGroup = NULL;
1240	RTFSOBJINFO GroupInfo;
1241	if (pDirEntry->Info.Attr.u.Unix.gid != NIL_RTGID && pOpts->fShowGroup)
1242	{
1243	rc = RTVfsDirQueryPathInfo(hVfsDir, pDirEntry->szName, &GroupInfo, RTFSOBJATTRADD_UNIX_GROUP, RTPATH_F_ON_LINK);
1244	if (RT_SUCCESS(rc) && GroupInfo.Attr.u.UnixGroup.szName[0])
1245	pszGroup = &GroupInfo.Attr.u.UnixGroup.szName[0];
1246	}
1247
1248	RTEXITCODE rcExit2 = rtCmdLsAddOne(pCollection, pDirEntry->szName, &pDirEntry->Info, pszOwner, pszGroup, NULL);
1249	if (rcExit2 != RTEXITCODE_SUCCESS)
1250	rcExit = rcExit2;
1251	}
1252
1253	RTMemTmpFree(pDirEntry);
1254
1255	/*
1256	* Recurse into subdirectories if requested.
1257	*/
1258	if (pOpts->fRecursive)
1259	{
1260	for (uint32_t i = 0; i < pCollection->cEntries; i++)
1261	{
1262	PRTCMDLSENTRY pEntry = pCollection->papEntries[i];
1263	if (RTFS_IS_SYMLINK(pEntry->Info.Attr.fMode))
1264	{
1265	if (!pOpts->fFollowSymlinksInDirs)
1266	continue;
1267	/** @todo implement following symbolic links in the tree. */
1268	continue;
1269	}
1270	else if ( !RTFS_IS_DIRECTORY(pEntry->Info.Attr.fMode)
1271	\|\| ( pEntry->szName[0] == '.'
1272	&& ( pEntry->szName[1] == '\0'
1273	\|\| ( pEntry->szName[1] == '.'
1274	&& pEntry->szName[2] == '\0'))) )
1275	continue;
1276
1277	/* Open subdirectory and process it. */
1278	RTVFSDIR hSubDir;
1279	int rc = RTVfsDirOpenDir(hVfsDir, pEntry->szName, 0 /fFlags/, &hSubDir);
1280	if (RT_SUCCESS(rc))
1281	{
1282	if (cchPath + 1 + pEntry->cchName + 1 < RTPATH_MAX)
1283	{
1284	pszPath[cchPath] = RTPATH_SLASH;
1285	memcpy(&pszPath[cchPath + 1], pEntry->szName, pEntry->cchName + 1);
1286	RTEXITCODE rcExit2 = rtCmdLsProcessDirectory(pOpts, hSubDir, pszPath,
1287	cchPath + 1 + pEntry->cchName, &pEntry->Info);
1288	if (rcExit2 != RTEXITCODE_SUCCESS)
1289	rcExit = rcExit2;
1290	pszPath[cchPath] = '\0';
1291	}
1292	else
1293	rcExit = RTMsgErrorExitFailure("Too deep recursion: %s%c%s", pszPath, RTPATH_SLASH, pEntry->szName);
1294	RTVfsDirRelease(hSubDir);
1295	}
1296	else
1297	rcExit = RTMsgErrorExitFailure("RTVfsDirOpenDir failed on %s in %s: %Rrc\n", pEntry->szName, pszPath, rc);
1298	}
1299	}
1300	return rcExit;
1301	}
1302
1303
1304	/**
1305	* Processes one argument.
1306	*
1307	* @returns Program exit code.
1308	* @param pOpts The options.
1309	* @param pszArg The argument.
1310	*/
1311	static RTEXITCODE rtCmdLsProcessArgument(PRTCMDLSOPTS pOpts, const char *pszArg)
1312	{
1313	/*
1314	* Query info about the object 'pszArg' indicates.
1315	*/
1316	RTERRINFOSTATIC ErrInfo;
1317	uint32_t offError;
1318	RTFSOBJINFO Info;
1319	uint32_t fPath = pOpts->fFollowSymlinkToAnyArgs ? RTPATH_F_FOLLOW_LINK : RTPATH_F_ON_LINK;
1320	int rc = RTVfsChainQueryInfo(pszArg, &Info, RTFSOBJATTRADD_UNIX, fPath, &offError, RTErrInfoInitStatic(&ErrInfo));
1321	if (RT_FAILURE(rc))
1322	return RTVfsChainMsgErrorExitFailure("RTVfsChainQueryInfo", pszArg, rc, offError, &ErrInfo.Core);
1323
1324	/* Symbolic links requires special handling of course. */
1325	if (RTFS_IS_SYMLINK(Info.Attr.fMode))
1326	{
1327	if (pOpts->fFollowSymlinkToDirArgs)
1328	{
1329	RTFSOBJINFO Info2;
1330	rc = RTVfsChainQueryInfo(pszArg, &Info2, RTFSOBJATTRADD_UNIX, RTPATH_F_FOLLOW_LINK,
1331	&offError, RTErrInfoInitStatic(&ErrInfo));
1332	if (RT_SUCCESS(rc) && !RTFS_IS_DIRECTORY(Info.Attr.fMode))
1333	Info = Info2;
1334	}
1335	}
1336
1337	/*
1338	* If it's not a directory or we've been told to process directories
1339	* without going into them, just add it to the default collection.
1340	*/
1341	if ( !pOpts->fFollowDirectoryArgs
1342	\|\| !RTFS_IS_DIRECTORY(Info.Attr.fMode))
1343	{
1344	if ( pOpts->cCollections > 0
1345	\|\| rtCmdLsNewCollection(pOpts, "") != NULL)
1346	{
1347	const char *pszOwner = NULL;
1348	RTFSOBJINFO OwnerInfo;
1349	if (Info.Attr.u.Unix.uid != NIL_RTUID && pOpts->fShowOwner)
1350	{
1351	rc = RTVfsChainQueryInfo(pszArg, &OwnerInfo, RTFSOBJATTRADD_UNIX_OWNER, fPath, NULL, NULL);
1352	if (RT_SUCCESS(rc) && OwnerInfo.Attr.u.UnixOwner.szName[0])
1353	pszOwner = &OwnerInfo.Attr.u.UnixOwner.szName[0];
1354	}
1355
1356	const char *pszGroup = NULL;
1357	RTFSOBJINFO GroupInfo;
1358	if (Info.Attr.u.Unix.gid != NIL_RTGID && pOpts->fShowGroup)
1359	{
1360	rc = RTVfsChainQueryInfo(pszArg, &GroupInfo, RTFSOBJATTRADD_UNIX_GROUP, fPath, NULL, NULL);
1361	if (RT_SUCCESS(rc) && GroupInfo.Attr.u.UnixGroup.szName[0])
1362	pszGroup = &GroupInfo.Attr.u.UnixGroup.szName[0];
1363	}
1364
1365	return rtCmdLsAddOne(pOpts->papCollections[0], pszArg, &Info, pszOwner, pszGroup, NULL);
1366	}
1367	return RTEXITCODE_FAILURE;
1368	}
1369
1370	/*
1371	* Open the directory.
1372	*/
1373	RTVFSDIR hVfsDir;
1374	rc = RTVfsChainOpenDir(pszArg, 0 /fFlags/, &hVfsDir, &offError, RTErrInfoInitStatic(&ErrInfo));
1375	if (RT_FAILURE(rc))
1376	return RTVfsChainMsgErrorExitFailure("RTVfsChainOpenDir", pszArg, rc, offError, &ErrInfo.Core);
1377
1378	RTEXITCODE rcExit;
1379	char szPath[RTPATH_MAX];
1380	size_t cchPath = strlen(pszArg);
1381	if (cchPath < sizeof(szPath))
1382	{
1383	memcpy(szPath, pszArg, cchPath + 1);
1384	rcExit = rtCmdLsProcessDirectory(pOpts, hVfsDir, szPath, cchPath, &Info);
1385	}
1386	else
1387	rcExit = RTMsgErrorExitFailure("Too long argument: %s", pszArg);
1388	RTVfsDirRelease(hVfsDir);
1389	return rcExit;
1390	}
1391
1392
1393	/**
1394	* A /bin/ls clone.
1395	*
1396	* @returns Program exit code.
1397	*
1398	* @param cArgs The number of arguments.
1399	* @param papszArgs The argument vector. (Note that this may be
1400	* reordered, so the memory must be writable.)
1401	*/
1402	RTR3DECL(RTEXITCODE) RTFsCmdLs(unsigned cArgs, char **papszArgs)
1403	{
1404	/*
1405	* Parse the command line.
1406	*/
1407	#define OPT_AUTHOR 1000
1408	#define OPT_BLOCK_SIZE 1001
1409	#define OPT_COLOR 1002
1410	#define OPT_FILE_TYPE 1003
1411	#define OPT_FORMAT 1004
1412	#define OPT_FULL_TIME 1005
1413	#define OPT_GROUP_DIRECTORIES_FIRST 1006
1414	#define OPT_SI 1007
1415	#define OPT_DEREFERENCE_COMMAND_LINE_SYMLINK_TO_DIR 1008
1416	#define OPT_HIDE 1009
1417	#define OPT_INDICATOR_STYLE 1010
1418	#define OPT_MACHINE_READABLE 1011
1419	#define OPT_SHOW_CONTROL_CHARS 1012
1420	#define OPT_QUOTING_STYLE 1013
1421	#define OPT_SORT 1014
1422	#define OPT_TIME 1015
1423	#define OPT_TIME_STYLE 1016
1424	static const RTGETOPTDEF s_aOptions[] =
1425	{
1426	{ "--all", 'a', RTGETOPT_REQ_NOTHING },
1427	{ "--almost-all", 'A', RTGETOPT_REQ_NOTHING },
1428	//{ "--author", OPT_AUTHOR, RTGETOPT_REQ_NOTHING },
1429	{ "--escape", 'b', RTGETOPT_REQ_NOTHING },
1430	{ "--block-size", OPT_BLOCK_SIZE, RTGETOPT_REQ_UINT32 },
1431	{ "--ctime", 'c', RTGETOPT_REQ_NOTHING },
1432	//{ "--columns", 'C', RTGETOPT_REQ_NOTHING },
1433	//{ "--color", OPT_COLOR, RTGETOPT_OPT_STRING },
1434	{ "--directory", 'd', RTGETOPT_REQ_NOTHING },
1435	//{ "--dired", 'D', RTGETOPT_REQ_NOTHING },
1436	{ "--dash-f", 'f', RTGETOPT_REQ_NOTHING },
1437	//{ "--classify", 'F', RTGETOPT_REQ_NOTHING },
1438	//{ "--file-type", OPT_FILE_TYPE, RTGETOPT_REQ_NOTHING },
1439	{ "--format", OPT_FORMAT, RTGETOPT_REQ_STRING },
1440	{ "--full-time", OPT_FULL_TIME, RTGETOPT_REQ_NOTHING },
1441	{ "--dash-g", 'g', RTGETOPT_REQ_NOTHING },
1442	{ "--group-directories-first", OPT_GROUP_DIRECTORIES_FIRST, RTGETOPT_REQ_NOTHING },
1443	{ "--no-group", 'G', RTGETOPT_REQ_NOTHING },
1444	{ "--human-readable", 'h', RTGETOPT_REQ_NOTHING },
1445	{ "--si", OPT_SI, RTGETOPT_REQ_NOTHING },
1446	{ "--dereference-command-line", 'H', RTGETOPT_REQ_NOTHING },
1447	{ "--dereference-command-line-symlink-to-dir", OPT_DEREFERENCE_COMMAND_LINE_SYMLINK_TO_DIR, RTGETOPT_REQ_NOTHING },
1448	//{ "--hide" OPT_HIDE, RTGETOPT_REQ_STRING },
1449	//{ "--indicator-style" OPT_INDICATOR_STYLE, RTGETOPT_REQ_STRING },
1450	{ "--inode", 'i', RTGETOPT_REQ_NOTHING },
1451	{ "--block-size-1kib", 'k', RTGETOPT_REQ_NOTHING },
1452	{ "--long", 'l', RTGETOPT_REQ_NOTHING },
1453	{ "--dereference", 'L', RTGETOPT_REQ_NOTHING },
1454	{ "--format-commas", 'm', RTGETOPT_REQ_NOTHING },
1455	{ "--machinereadable", OPT_MACHINE_READABLE, RTGETOPT_REQ_NOTHING },
1456	{ "--machine-readable", OPT_MACHINE_READABLE, RTGETOPT_REQ_NOTHING },
1457	{ "--numeric-uid-gid", 'n', RTGETOPT_REQ_NOTHING },
1458	{ "--literal", 'N', RTGETOPT_REQ_NOTHING },
1459	{ "--long-without-group-info", 'o', RTGETOPT_REQ_NOTHING },
1460	//{ "--indicator-style", 'p', RTGETOPT_REQ_STRING },
1461	{ "--hide-control-chars", 'q', RTGETOPT_REQ_NOTHING },
1462	{ "--show-control-chars", OPT_SHOW_CONTROL_CHARS, RTGETOPT_REQ_NOTHING },
1463	//{ "--quote-name", 'Q', RTGETOPT_REQ_NOTHING },
1464	//{ "--quoting-style", OPT_QUOTING_STYLE, RTGETOPT_REQ_STRING },
1465	{ "--reverse", 'r', RTGETOPT_REQ_NOTHING },
1466	{ "--recursive", 'R', RTGETOPT_REQ_NOTHING },
1467	{ "--size", 's', RTGETOPT_REQ_NOTHING },
1468	{ "--sort-by-size", 'S', RTGETOPT_REQ_NOTHING },
1469	{ "--sort", OPT_SORT, RTGETOPT_REQ_STRING },
1470	{ "--time", OPT_TIME, RTGETOPT_REQ_STRING },
1471	{ "--time-style", OPT_TIME_STYLE, RTGETOPT_REQ_STRING },
1472	{ "--sort-by-time", 't', RTGETOPT_REQ_NOTHING },
1473	{ "--tabsize", 'T', RTGETOPT_REQ_UINT8 },
1474	{ "--atime", 'u', RTGETOPT_REQ_NOTHING },
1475	{ "--unsorted", 'U', RTGETOPT_REQ_NOTHING },
1476	{ "--version-sort", 'v', RTGETOPT_REQ_NOTHING },
1477	{ "--width", 'w', RTGETOPT_REQ_UINT32 },
1478	{ "--list-by-line", 'x', RTGETOPT_REQ_NOTHING },
1479	{ "--sort-by-extension", 'X', RTGETOPT_REQ_NOTHING },
1480	{ "--one-file-per-line", '1', RTGETOPT_REQ_NOTHING },
1481	{ "--help", '?', RTGETOPT_REQ_NOTHING },
1482	};
1483
1484	RTCMDLSOPTS Opts;
1485	Opts.fFollowSymlinksInDirs = false;
1486	Opts.fFollowSymlinkToAnyArgs = false;
1487	Opts.fFollowSymlinkToDirArgs = false;
1488	Opts.fFollowDirectoryArgs = true;
1489	Opts.fRecursive = false;
1490	Opts.fShowHidden = false;
1491	Opts.fShowDotAndDotDot = false;
1492	Opts.fShowBackups = true;
1493	Opts.enmSort = RTCMDLSSORT_NAME;
1494	Opts.fReverseSort = false;
1495	Opts.fGroupDirectoriesFirst = false;
1496	Opts.enmFormat = RTCMDLSFORMAT_COLS_VERTICAL;
1497	Opts.fEscapeNonGraphicChars = false;
1498	Opts.fEscapeControlChars = true;
1499	Opts.fHideControlChars = false;
1500	Opts.fHumanReadableSizes = false; /*< -h /
1501	Opts.fSiUnits = false;
1502	Opts.cbBlock = 0;
1503	Opts.fShowOwner = true;
1504	Opts.fShowGroup = true;
1505	Opts.fNumericalIds = false;
1506	Opts.fShowINode = false;
1507	Opts.fShowAllocatedSize = false;
1508	Opts.cchTab = 8;
1509	Opts.cchWidth = 80;
1510	Opts.enmColor = RTCMDLSCOLOR_NONE;
1511	Opts.enmTime = RTCMDLSTIME_MTIME;
1512	Opts.enmTimeStyle = RTCMDLSTIMESTYLE_LOCALE;
1513	Opts.pszTimeCustom = NULL;
1514
1515	Opts.cCollections = 0;
1516	Opts.cCollectionsAllocated = 0;
1517	Opts.papCollections = NULL;
1518
1519
1520	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
1521	unsigned cProcessed = 0;
1522	RTGETOPTSTATE GetState;
1523	int rc = RTGetOptInit(&GetState, cArgs, papszArgs, s_aOptions, RT_ELEMENTS(s_aOptions), 1,
1524	RTGETOPTINIT_FLAGS_OPTS_FIRST);
1525	if (RT_FAILURE(rc))
1526	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "RTGetOptInit: %Rrc", rc);
1527
1528	for (;;)
1529	{
1530	RTGETOPTUNION ValueUnion;
1531	int chOpt = RTGetOpt(&GetState, &ValueUnion);
1532	switch (chOpt)
1533	{
1534	case 0:
1535	/* When reaching the end of arguments without having processed any
1536	files/dirs/whatever yet, we do the current directory. */
1537	if (cProcessed > 0)
1538	{
1539	RTEXITCODE rcExit2 = rtCmdLsDisplayCollections(&Opts);
1540	if (rcExit2 != RTEXITCODE_SUCCESS)
1541	rcExit = rcExit2;
1542	rtCmdLsFreeCollections(&Opts);
1543	return rcExit;
1544	}
1545	ValueUnion.psz = ".";
1546	RT_FALL_THRU();
1547	case VINF_GETOPT_NOT_OPTION:
1548	{
1549	RTEXITCODE rcExit2 = rtCmdLsProcessArgument(&Opts, ValueUnion.psz);
1550	if (rcExit2 != RTEXITCODE_SUCCESS)
1551	rcExit = rcExit2;
1552	cProcessed++;
1553	break;
1554	}
1555
1556	case 'a':
1557	Opts.fShowHidden = true;
1558	Opts.fShowDotAndDotDot = true;
1559	break;
1560
1561	case 'A':
1562	Opts.fShowHidden = true;
1563	Opts.fShowDotAndDotDot = false;
1564	break;
1565
1566	case 'b':
1567	Opts.fEscapeNonGraphicChars = true;
1568	break;
1569
1570	case OPT_BLOCK_SIZE:
1571	if (!ValueUnion.u32)
1572	{
1573	Assert(!Opts.papCollections);
1574	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Invalid block size: %u", ValueUnion.u32);
1575	}
1576	Opts.cbBlock = ValueUnion.u32;
1577	Opts.fHumanReadableSizes = false;
1578	Opts.fSiUnits = false;
1579	break;
1580
1581	case 'c':
1582	Opts.enmTime = RTCMDLSTIME_CTIME;
1583	break;
1584
1585	case 'C':
1586	Opts.enmFormat = RTCMDLSFORMAT_COLS_VERTICAL;
1587	break;
1588
1589	case 'd':
1590	Opts.fFollowDirectoryArgs = false;
1591	Opts.fFollowSymlinkToAnyArgs = false;
1592	Opts.fFollowSymlinkToDirArgs = false;
1593	Opts.fRecursive = false;
1594	break;
1595
1596	case 'f':
1597	Opts.fShowHidden = true;
1598	Opts.fShowDotAndDotDot = true;
1599	if (Opts.enmFormat == RTCMDLSFORMAT_LONG)
1600	Opts.enmFormat = RTCMDLSFORMAT_COLS_VERTICAL;
1601	Opts.enmColor = RTCMDLSCOLOR_NONE;
1602	Opts.enmSort = RTCMDLSSORT_NONE;
1603	break;
1604
1605	case OPT_FORMAT:
1606	if ( strcmp(ValueUnion.psz, "across") == 0
1607	\|\| strcmp(ValueUnion.psz, "horizontal") == 0)
1608	Opts.enmFormat = RTCMDLSFORMAT_COLS_HORIZONTAL;
1609	else if (strcmp(ValueUnion.psz, "commas") == 0)
1610	Opts.enmFormat = RTCMDLSFORMAT_COMMAS;
1611	else if ( strcmp(ValueUnion.psz, "long") == 0
1612	\|\| strcmp(ValueUnion.psz, "verbose") == 0)
1613	Opts.enmFormat = RTCMDLSFORMAT_LONG;
1614	else if (strcmp(ValueUnion.psz, "single-column") == 0)
1615	Opts.enmFormat = RTCMDLSFORMAT_SINGLE;
1616	else if (strcmp(ValueUnion.psz, "vertical") == 0)
1617	Opts.enmFormat = RTCMDLSFORMAT_COLS_VERTICAL;
1618	else if (strcmp(ValueUnion.psz, "machine-readable") == 0)
1619	Opts.enmFormat = RTCMDLSFORMAT_MACHINE_READABLE;
1620	else
1621	{
1622	Assert(!Opts.papCollections);
1623	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown format: %s", ValueUnion.psz);
1624	}
1625	break;
1626
1627	case OPT_FULL_TIME:
1628	Opts.enmFormat = RTCMDLSFORMAT_LONG;
1629	Opts.enmTimeStyle = RTCMDLSTIMESTYLE_FULL_ISO;
1630	break;
1631
1632	case 'g':
1633	Opts.enmFormat = RTCMDLSFORMAT_LONG;
1634	Opts.fShowOwner = false;
1635	break;
1636
1637	case OPT_GROUP_DIRECTORIES_FIRST:
1638	Opts.fGroupDirectoriesFirst = true;
1639	break;
1640
1641	case 'G':
1642	Opts.fShowGroup = false;
1643	break;
1644
1645	case 'h':
1646	Opts.fHumanReadableSizes = true;
1647	Opts.fSiUnits = false;
1648	break;
1649
1650	case OPT_SI:
1651	Opts.fHumanReadableSizes = true;
1652	Opts.fSiUnits = true;
1653	break;
1654
1655	case 'H':
1656	Opts.fFollowSymlinkToAnyArgs = true;
1657	Opts.fFollowSymlinkToDirArgs = true;
1658	break;
1659
1660	case OPT_DEREFERENCE_COMMAND_LINE_SYMLINK_TO_DIR:
1661	Opts.fFollowSymlinkToAnyArgs = false;
1662	Opts.fFollowSymlinkToDirArgs = true;
1663	break;
1664
1665	case 'i':
1666	Opts.fShowINode = true;
1667	break;
1668
1669	case 'k':
1670	Opts.cbBlock = _1K;
1671	Opts.fHumanReadableSizes = false;
1672	Opts.fSiUnits = false;
1673	break;
1674
1675	case 'l':
1676	Opts.enmFormat = RTCMDLSFORMAT_LONG;
1677	break;
1678
1679	case 'L':
1680	Opts.fFollowSymlinksInDirs = true;
1681	Opts.fFollowSymlinkToAnyArgs = true;
1682	Opts.fFollowSymlinkToDirArgs = true;
1683	break;
1684
1685	case 'm':
1686	Opts.enmFormat = RTCMDLSFORMAT_COMMAS;
1687	break;
1688
1689	case OPT_MACHINE_READABLE:
1690	Opts.enmFormat = RTCMDLSFORMAT_MACHINE_READABLE;
1691	break;
1692
1693	case 'n':
1694	Opts.fNumericalIds = true;
1695	break;
1696
1697	case 'N':
1698	Opts.fEscapeNonGraphicChars = false;
1699	Opts.fEscapeControlChars = false;
1700	Opts.fHideControlChars = false;
1701	break;
1702
1703	case 'o':
1704	Opts.enmFormat = RTCMDLSFORMAT_LONG;
1705	Opts.fShowGroup = false;
1706	break;
1707
1708	case 'q':
1709	Opts.fHideControlChars = true;
1710	break;
1711
1712	case OPT_SHOW_CONTROL_CHARS:
1713	Opts.fHideControlChars = true;
1714	break;
1715
1716	case 'r':
1717	Opts.fReverseSort = true;
1718	break;
1719
1720	case 'R':
1721	Opts.fRecursive = true;
1722	break;
1723
1724	case 's':
1725	Opts.fShowAllocatedSize = true;
1726	break;
1727
1728	case 'S':
1729	Opts.enmSort = RTCMDLSSORT_SIZE;
1730	break;
1731
1732	case OPT_SORT:
1733	if (strcmp(ValueUnion.psz, "none") == 0)
1734	Opts.enmSort = RTCMDLSSORT_NONE;
1735	else if (strcmp(ValueUnion.psz, "extension") == 0)
1736	Opts.enmSort = RTCMDLSSORT_EXTENSION;
1737	else if (strcmp(ValueUnion.psz, "size") == 0)
1738	Opts.enmSort = RTCMDLSSORT_SIZE;
1739	else if (strcmp(ValueUnion.psz, "time") == 0)
1740	Opts.enmSort = RTCMDLSSORT_TIME;
1741	else if (strcmp(ValueUnion.psz, "version") == 0)
1742	Opts.enmSort = RTCMDLSSORT_VERSION;
1743	else
1744	{
1745	Assert(!Opts.papCollections);
1746	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown sort by: %s", ValueUnion.psz);
1747	}
1748	break;
1749
1750	case OPT_TIME:
1751	if ( strcmp(ValueUnion.psz, "btime") == 0
1752	\|\| strcmp(ValueUnion.psz, "birth") == 0)
1753	Opts.enmTime = RTCMDLSTIME_BTIME;
1754	else if ( strcmp(ValueUnion.psz, "ctime") == 0
1755	\|\| strcmp(ValueUnion.psz, "status") == 0)
1756	Opts.enmTime = RTCMDLSTIME_CTIME;
1757	else if ( strcmp(ValueUnion.psz, "mtime") == 0
1758	\|\| strcmp(ValueUnion.psz, "write") == 0
1759	\|\| strcmp(ValueUnion.psz, "modify") == 0)
1760	Opts.enmTime = RTCMDLSTIME_MTIME;
1761	else if ( strcmp(ValueUnion.psz, "atime") == 0
1762	\|\| strcmp(ValueUnion.psz, "access") == 0
1763	\|\| strcmp(ValueUnion.psz, "use") == 0)
1764	Opts.enmTime = RTCMDLSTIME_ATIME;
1765	else
1766	{
1767	Assert(!Opts.papCollections);
1768	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown time attribute: %s", ValueUnion.psz);
1769	}
1770	break;
1771
1772	case OPT_TIME_STYLE:
1773	if (strcmp(ValueUnion.psz, "full-iso") == 0)
1774	Opts.enmTimeStyle = RTCMDLSTIMESTYLE_FULL_ISO;
1775	else if (strcmp(ValueUnion.psz, "long-iso") == 0)
1776	Opts.enmTimeStyle = RTCMDLSTIMESTYLE_LONG_ISO;
1777	else if (strcmp(ValueUnion.psz, "iso") == 0)
1778	Opts.enmTimeStyle = RTCMDLSTIMESTYLE_ISO;
1779	else if (strcmp(ValueUnion.psz, "locale") == 0)
1780	Opts.enmTimeStyle = RTCMDLSTIMESTYLE_LOCALE;
1781	else if (*ValueUnion.psz == '+')
1782	{
1783	Opts.enmTimeStyle = RTCMDLSTIMESTYLE_CUSTOM;
1784	Opts.pszTimeCustom = ValueUnion.psz;
1785	}
1786	else
1787	{
1788	Assert(!Opts.papCollections);
1789	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown sort by: %s", ValueUnion.psz);
1790	}
1791	break;
1792
1793	case 't':
1794	Opts.enmSort = RTCMDLSSORT_TIME;
1795	break;
1796
1797	case 'T':
1798	Opts.cchTab = ValueUnion.u8;
1799	break;
1800
1801	case 'u':
1802	Opts.enmTime = RTCMDLSTIME_ATIME;
1803	break;
1804
1805	case 'U':
1806	Opts.enmSort = RTCMDLSSORT_NONE;
1807	break;
1808
1809	case 'v':
1810	Opts.enmSort = RTCMDLSSORT_VERSION;
1811	break;
1812
1813	case 'w':
1814	Opts.cchWidth = ValueUnion.u32;
1815	break;
1816
1817	case 'x':
1818	Opts.enmFormat = RTCMDLSFORMAT_COLS_HORIZONTAL;
1819	break;
1820
1821	case 'X':
1822	Opts.enmSort = RTCMDLSSORT_EXTENSION;
1823	break;
1824
1825	case '1':
1826	Opts.enmFormat = RTCMDLSFORMAT_SINGLE;
1827	break;
1828
1829	case '?':
1830	{
1831	RTPrintf("Usage: to be written\n"
1832	"Options dump:\n");
1833	for (unsigned i = 0; i < RT_ELEMENTS(s_aOptions); i++)
1834	if (s_aOptions[i].iShort < 127 && s_aOptions[i].iShort >= 0x20)
1835	RTPrintf(" -%c,%s\n", s_aOptions[i].iShort, s_aOptions[i].pszLong);
1836	else
1837	RTPrintf(" %s\n", s_aOptions[i].pszLong);
1838	#ifdef RT_OS_WINDOWS
1839	const char *pszProgNm = RTPathFilename(papszArgs[0]);
1840	RTPrintf("\n"
1841	"The path prefix '\\\\:iprtnt:\\' can be used to access the NT namespace.\n"
1842	"To list devices: %s -la \\\\:iprtnt:\\Device\n"
1843	"To list win32 devices: %s -la \\\\:iprtnt:\\GLOBAL??\n"
1844	"To list the root (hack/bug): %s -la \\\\:iprtnt:\\\n",
1845	pszProgNm, pszProgNm, pszProgNm);
1846	#endif
1847	Assert(!Opts.papCollections);
1848	return RTEXITCODE_SUCCESS;
1849	}
1850
1851	case 'V':
1852	RTPrintf("%sr%d\n", RTBldCfgVersion(), RTBldCfgRevision());
1853	Assert(!Opts.papCollections);
1854	return RTEXITCODE_SUCCESS;
1855
1856	default:
1857	Assert(!Opts.papCollections);
1858	return RTGetOptPrintError(chOpt, &ValueUnion);
1859	}
1860	}
1861	}
1862

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/common/fs/RTFsCmdLs.cpp@ 96407

Download in other formats: