VirtualBox

source: vbox/trunk/src/VBox/Runtime/common/misc/getoptargv.cpp

Last change on this file was 103398, checked in by vboxsync, 3 months ago

IPRT/getopt: Documented parfait false positives. bugref:3409
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 21.0 KB
Line 
1/* $Id: getoptargv.cpp 103398 2024-02-16 10:10:54Z vboxsync $ */
2/** @file
3 * IPRT - Command Line Parsing, Argument Vector.
4 */
5
6/*
7 * Copyright (C) 2010-2023 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/getopt.h>
42#include "internal/iprt.h"
43
44#include <iprt/asm.h>
45#include <iprt/assert.h>
46#include <iprt/err.h>
47#include <iprt/mem.h>
48#include <iprt/string.h>
49
50
51/*********************************************************************************************************************************
52* Header Files *
53*********************************************************************************************************************************/
54/** @todo move to cdefs.h */
55#ifdef __GNUC__
56# define DECL_VAR_ALIGNED(a_Scope, a_Type, a_Name, a_Alignment) a_Scope a_Type a_Name __attribute__((__aligned__(a_Alignment)))
57#elif defined(_MSC_VER)
58# define DECL_VAR_ALIGNED(a_Scope, a_Type, a_Name, a_Alignment) a_Scope __declspec(align(a_Alignment)) a_Type a_Name
59#else
60# define DECL_VAR_ALIGNED(a_Scope, a_Type, a_Name, a_Alignment) a_Scope a_Type a_Name
61#endif
62
63/**
64 * Array indexed by the quoting type and 7-bit ASCII character.
65 *
66 * We include some extra stuff here that the corresponding shell would normally
67 * require quoting of.
68 *
69 * @note We 16-byte align this as ASMBitSet/ASMBitTest expects aligned data, and
70 * with a uint8_t type the compiler/linker may use byte alignment.
71 */
72#ifndef IPRT_REGENERATE_QUOTE_CHARS
73DECL_VAR_ALIGNED(static, uint8_t const, g_abmQuoteChars[RTGETOPTARGV_CNV_QUOTE_MASK + 1][16], 16) =
74#else
75DECL_VAR_ALIGNED(static, uint8_t, g_abmQuoteChars[RTGETOPTARGV_CNV_QUOTE_MASK + 1][16], 16) =
76#endif
77{
78 { 0xfe, 0xff, 0xff, 0xff, 0x65, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 },
79 { 0xfe, 0xff, 0xff, 0xff, 0xd7, 0x07, 0x00, 0xd8, 0x00, 0x00, 0x00, 0x18, 0x01, 0x00, 0x00, 0x50 },
80};
81
82
83#ifdef IPRT_REGENERATE_QUOTE_CHARS /* To re-generate the bitmaps. */
84# include <stdio.h>
85int main()
86{
87 RT_ZERO(g_abmQuoteChars);
88
89# define SET_ALL(ch) \
90 do { \
91 for (size_t iType = 0; iType <= RTGETOPTARGV_CNV_QUOTE_MASK; iType++) \
92 ASMBitSet(&g_abmQuoteChars[iType], (ch)); \
93 } while (0)
94# define SET(ConstSuffix, ch) \
95 do { \
96 ASMBitSet(&g_abmQuoteChars[RTGETOPTARGV_CNV_QUOTE_##ConstSuffix], (ch)); \
97 printf(#ConstSuffix ": %#x %d %c\n", (ch), (ch), (ch)); \
98 } while (0)
99
100 /* just flag all the control chars as in need of quoting. */
101 for (char ch = 1; ch < 0x20; ch++)
102 SET_ALL(ch);
103
104 /* ... and space of course */
105 SET_ALL(' ');
106
107 /* MS CRT / CMD.EXE: */
108 SET(MS_CRT, '"');
109 SET(MS_CRT, '&');
110 SET(MS_CRT, '>');
111 SET(MS_CRT, '<');
112 SET(MS_CRT, '|');
113 SET(MS_CRT, '%');
114
115 /* Bourne shell: */
116 SET(BOURNE_SH, '!');
117 SET(BOURNE_SH, '"');
118 SET(BOURNE_SH, '$');
119 SET(BOURNE_SH, '&');
120 SET(BOURNE_SH, '(');
121 SET(BOURNE_SH, ')');
122 SET(BOURNE_SH, '*');
123 SET(BOURNE_SH, ';');
124 SET(BOURNE_SH, '<');
125 SET(BOURNE_SH, '>');
126 SET(BOURNE_SH, '?');
127 SET(BOURNE_SH, '[');
128 SET(BOURNE_SH, '\'');
129 SET(BOURNE_SH, '\\');
130 SET(BOURNE_SH, '`');
131 SET(BOURNE_SH, '|');
132 SET(BOURNE_SH, '~');
133
134 for (size_t iType = 0; iType <= RTGETOPTARGV_CNV_QUOTE_MASK; iType++)
135 {
136 printf(" {");
137 for (size_t iByte = 0; iByte < 16; iByte++)
138 printf(iByte == 0 ? " 0x%02x" : ", 0x%02x", g_abmQuoteChars[iType][iByte]);
139 printf(" },\n");
140 }
141 return 0;
142}
143
144#else /* !IPRT_REGENERATE_QUOTE_CHARS */
145
146/**
147 * Look for an unicode code point in the separator string.
148 *
149 * @returns true if it's a separator, false if it isn't.
150 * @param Cp The code point.
151 * @param pszSeparators The separators.
152 */
153static bool rtGetOptIsUniCpInString(RTUNICP Cp, const char *pszSeparators)
154{
155 /* This could be done in a more optimal fashion. Probably worth a
156 separate RTStr function at some point. */
157 for (;;)
158 {
159 RTUNICP CpSep;
160 int rc = RTStrGetCpEx(&pszSeparators, &CpSep);
161 AssertRCReturn(rc, false);
162 if (CpSep == Cp)
163 return true;
164 if (!CpSep)
165 return false;
166 }
167}
168
169
170/**
171 * Look for an 7-bit ASCII character in the separator string.
172 *
173 * @returns true if it's a separator, false if it isn't.
174 * @param ch The character.
175 * @param pszSeparators The separators.
176 * @param cchSeparators The number of separators chars.
177 */
178DECLINLINE(bool) rtGetOptIsAsciiInSet(char ch, const char *pszSeparators, size_t cchSeparators)
179{
180 switch (cchSeparators)
181 {
182 case 8: if (ch == pszSeparators[7]) return true; RT_FALL_THRU();
183 case 7: if (ch == pszSeparators[6]) return true; RT_FALL_THRU();
184 case 6: if (ch == pszSeparators[5]) return true; RT_FALL_THRU();
185 case 5: if (ch == pszSeparators[4]) return true; RT_FALL_THRU();
186 case 4: if (ch == pszSeparators[3]) return true; RT_FALL_THRU();
187 case 3: if (ch == pszSeparators[2]) return true; RT_FALL_THRU();
188 case 2: if (ch == pszSeparators[1]) return true; RT_FALL_THRU();
189 case 1: if (ch == pszSeparators[0]) return true;
190 return false;
191 default:
192 return memchr(pszSeparators, ch, cchSeparators) != NULL;
193 }
194}
195
196
197/**
198 * Checks if the character is in the set of separators
199 *
200 * @returns true if it is, false if it isn't.
201 *
202 * @param Cp The code point.
203 * @param pszSeparators The separators.
204 * @param cchSeparators The length of @a pszSeparators.
205 */
206DECL_FORCE_INLINE(bool) rtGetOptIsCpInSet(RTUNICP Cp, const char *pszSeparators, size_t cchSeparators)
207{
208 if (RT_LIKELY(Cp <= 127))
209 return rtGetOptIsAsciiInSet((char)Cp, pszSeparators, cchSeparators);
210 return rtGetOptIsUniCpInString(Cp, pszSeparators);
211}
212
213
214/**
215 * Skips any delimiters at the start of the string that is pointed to.
216 *
217 * @returns VINF_SUCCESS or RTStrGetCpEx status code.
218 * @param ppszSrc Where to get and return the string pointer.
219 * @param pszSeparators The separators.
220 * @param cchSeparators The length of @a pszSeparators.
221 */
222static int rtGetOptSkipDelimiters(const char **ppszSrc, const char *pszSeparators, size_t cchSeparators)
223{
224 const char *pszSrc = *ppszSrc;
225 const char *pszRet;
226 for (;;)
227 {
228 pszRet = pszSrc;
229 RTUNICP Cp;
230 int rc = RTStrGetCpEx(&pszSrc, &Cp);
231 if (RT_FAILURE(rc))
232 {
233 *ppszSrc = pszRet;
234 return rc;
235 }
236 if ( !Cp
237 || !rtGetOptIsCpInSet(Cp, pszSeparators, cchSeparators))
238 break;
239 }
240
241 *ppszSrc = pszRet;
242 return VINF_SUCCESS;
243}
244
245
246RTDECL(int) RTGetOptArgvFromString(char ***ppapszArgv, int *pcArgs, const char *pszCmdLine,
247 uint32_t fFlags, const char *pszSeparators)
248{
249 /*
250 * Some input validation.
251 */
252 AssertPtr(pszCmdLine);
253 AssertPtr(pcArgs);
254 AssertPtr(ppapszArgv);
255 AssertReturn( (fFlags & RTGETOPTARGV_CNV_QUOTE_MASK) == RTGETOPTARGV_CNV_QUOTE_BOURNE_SH
256 || (fFlags & RTGETOPTARGV_CNV_QUOTE_MASK) == RTGETOPTARGV_CNV_QUOTE_MS_CRT, VERR_INVALID_FLAGS);
257 AssertReturn(~(fFlags & ~RTGETOPTARGV_CNV_VALID_MASK), VERR_INVALID_FLAGS);
258
259 if (!pszSeparators)
260 pszSeparators = " \t\n\r";
261 else
262 AssertPtr(pszSeparators);
263 size_t const cchSeparators = strlen(pszSeparators);
264 AssertReturn(cchSeparators > 0, VERR_INVALID_PARAMETER);
265
266 /*
267 * Parse the command line and chop off it into argv individual argv strings.
268 */
269 const char *pszSrc = pszCmdLine;
270 char *pszDup = NULL;
271 char *pszDst;
272 if (fFlags & RTGETOPTARGV_CNV_MODIFY_INPUT)
273 pszDst = (char *)pszCmdLine;
274 else
275 {
276 pszDst = pszDup = (char *)RTMemAlloc(strlen(pszSrc) + 1);
277 if (!pszDup)
278 return VERR_NO_STR_MEMORY;
279 }
280 int rc = VINF_SUCCESS;
281 char **papszArgs = NULL;
282 unsigned iArg = 0;
283 while (*pszSrc)
284 {
285 /* Skip stuff */
286 rc = rtGetOptSkipDelimiters(&pszSrc, pszSeparators, cchSeparators);
287 if (RT_FAILURE(rc))
288 break;
289 if (!*pszSrc)
290 break;
291
292 /* Start a new entry. */
293 if ((iArg % 32) == 0)
294 {
295 void *pvNew = RTMemRealloc(papszArgs, (iArg + 33) * sizeof(char *));
296 if (!pvNew)
297 {
298 rc = VERR_NO_MEMORY;
299 break;
300 }
301 papszArgs = (char **)pvNew;
302 }
303 papszArgs[iArg++] = pszDst;
304
305 /*
306 * Parse and copy the string over.
307 */
308 RTUNICP uc;
309 if ((fFlags & RTGETOPTARGV_CNV_QUOTE_MASK) == RTGETOPTARGV_CNV_QUOTE_BOURNE_SH)
310 {
311 /*
312 * Bourne shell style.
313 */
314 RTUNICP ucQuote = 0;
315 for (;;)
316 {
317 rc = RTStrGetCpEx(&pszSrc, &uc);
318 if (RT_FAILURE(rc) || !uc)
319 break;
320 if (!ucQuote)
321 {
322 if (uc == '"' || uc == '\'')
323 ucQuote = uc;
324 else if (rtGetOptIsCpInSet(uc, pszSeparators, cchSeparators))
325 break;
326 else if (uc != '\\')
327 pszDst = RTStrPutCp(pszDst, uc);
328 else
329 {
330 /* escaped char */
331 rc = RTStrGetCpEx(&pszSrc, &uc);
332 if (RT_FAILURE(rc) || !uc)
333 break;
334 pszDst = RTStrPutCp(pszDst, uc);
335 }
336 }
337 else if (ucQuote != uc)
338 {
339 if (uc != '\\' || ucQuote == '\'')
340 pszDst = RTStrPutCp(pszDst, uc);
341 else
342 {
343 /* escaped char */
344 rc = RTStrGetCpEx(&pszSrc, &uc);
345 if (RT_FAILURE(rc) || !uc)
346 break;
347 if ( uc != '"'
348 && uc != '\\'
349 && uc != '`'
350 && uc != '$'
351 && uc != '\n')
352 pszDst = RTStrPutCp(pszDst, ucQuote);
353 pszDst = RTStrPutCp(pszDst, uc);
354 }
355 }
356 else
357 ucQuote = 0;
358 }
359 }
360 else
361 {
362 /*
363 * Microsoft CRT style.
364 */
365 Assert((fFlags & RTGETOPTARGV_CNV_QUOTE_MASK) == RTGETOPTARGV_CNV_QUOTE_MS_CRT);
366 bool fInQuote = false;
367 for (;;)
368 {
369 rc = RTStrGetCpEx(&pszSrc, &uc);
370 if (RT_FAILURE(rc) || !uc)
371 break;
372 if (uc == '"')
373 {
374 /* Two double quotes insides a quoted string in an escape
375 sequence and we output one double quote char.
376 See http://www.daviddeley.com/autohotkey/parameters/parameters.htm */
377 if (!fInQuote)
378 fInQuote = true;
379 else if (*pszSrc != '"')
380 fInQuote = false;
381 else
382 {
383 pszDst = RTStrPutCp(pszDst, '"');
384 pszSrc++;
385 }
386 }
387 else if (!fInQuote && rtGetOptIsCpInSet(uc, pszSeparators, cchSeparators))
388 break;
389 else if (uc != '\\')
390 pszDst = RTStrPutCp(pszDst, uc);
391 else
392 {
393 /* A backslash sequence is only relevant if followed by
394 a double quote, then it will work like an escape char. */
395 size_t cSlashes = 1;
396 while (*pszSrc == '\\')
397 {
398 cSlashes++;
399 pszSrc++;
400 }
401 if (*pszSrc != '"')
402 /* Not an escape sequence. */
403 while (cSlashes-- > 0)
404 pszDst = RTStrPutCp(pszDst, '\\');
405 else
406 {
407 /* Escape sequence. Output half of the slashes. If odd
408 number, output the escaped double quote . */
409 while (cSlashes >= 2)
410 {
411 pszDst = RTStrPutCp(pszDst, '\\');
412 cSlashes -= 2;
413 }
414 if (cSlashes)
415 {
416 pszDst = RTStrPutCp(pszDst, '"');
417 pszSrc++;
418 }
419 }
420 }
421 }
422 }
423
424 *pszDst++ = '\0';
425 if (RT_FAILURE(rc) || !uc)
426 break;
427 }
428
429 if (RT_FAILURE(rc))
430 {
431 RTMemFree(pszDup);
432 RTMemFree(papszArgs);
433 return rc;
434 }
435
436 /*
437 * Terminate the array.
438 * Check for empty string to make sure we've got an array.
439 */
440 if (iArg == 0)
441 {
442 RTMemFree(pszDup);
443 papszArgs = (char **)RTMemAlloc(1 * sizeof(char *));
444 if (!papszArgs)
445 return VERR_NO_MEMORY; /* (parfait is wrong about leak here (of other papszArgs alloc)) */
446 }
447 papszArgs[iArg] = NULL;
448
449 *pcArgs = iArg;
450 *ppapszArgv = papszArgs;
451 return VINF_SUCCESS; /* (parfait is wrong about any pszDup & papszArgv leaks here, they are intentional) */
452}
453
454
455RTDECL(void) RTGetOptArgvFree(char **papszArgv)
456{
457 RTGetOptArgvFreeEx(papszArgv, 0);
458}
459
460
461RTDECL(void) RTGetOptArgvFreeEx(char **papszArgv, uint32_t fFlags)
462{
463 Assert(~(fFlags & ~RTGETOPTARGV_CNV_VALID_MASK));
464 if (papszArgv)
465 {
466 /*
467 * We've really only _two_ allocations here. Check the code in
468 * RTGetOptArgvFromString for the particulars.
469 */
470 if (!(fFlags & RTGETOPTARGV_CNV_MODIFY_INPUT))
471 RTMemFree(papszArgv[0]);
472 RTMemFree(papszArgv);
473 }
474}
475
476
477/**
478 * Checks if the argument needs quoting or not.
479 *
480 * @returns true if it needs, false if it don't.
481 * @param pszArg The argument.
482 * @param fFlags Quoting style.
483 * @param pcch Where to store the argument length when quoting
484 * is not required. (optimization)
485 */
486DECLINLINE(bool) rtGetOpArgvRequiresQuoting(const char *pszArg, uint32_t fFlags, size_t *pcch)
487{
488 if ((fFlags & RTGETOPTARGV_CNV_QUOTE_MASK) != RTGETOPTARGV_CNV_UNQUOTED)
489 {
490 char const *psz = pszArg;
491 unsigned char ch;
492 while ((ch = (unsigned char)*psz))
493 {
494 if ( ch < 128
495 && ASMBitTest(&g_abmQuoteChars[fFlags & RTGETOPTARGV_CNV_QUOTE_MASK], ch))
496 return true;
497 psz++;
498 }
499
500 *pcch = psz - pszArg;
501 }
502 else
503 *pcch = strlen(pszArg);
504 return false;
505}
506
507
508/**
509 * Grows the command line string buffer.
510 *
511 * @returns VINF_SUCCESS or VERR_NO_STR_MEMORY.
512 * @param ppszCmdLine Pointer to the command line string pointer.
513 * @param pcbCmdLineAlloc Pointer to the allocation length variable.
514 * @param cchMin The minimum size to grow with, kind of.
515 */
516static int rtGetOptArgvToStringGrow(char **ppszCmdLine, size_t *pcbCmdLineAlloc, size_t cchMin)
517{
518 size_t cb = *pcbCmdLineAlloc;
519 while (cb < cchMin)
520 cb *= 2;
521 cb *= 2;
522 *pcbCmdLineAlloc = cb;
523 return RTStrRealloc(ppszCmdLine, cb);
524}
525
526/**
527 * Checks if we have a sequence of DOS slashes followed by a double quote char.
528 *
529 * @returns true / false accordingly.
530 * @param psz The string.
531 */
532DECLINLINE(bool) rtGetOptArgvMsCrtIsSlashQuote(const char *psz)
533{
534 while (*psz == '\\')
535 psz++;
536 return *psz == '"' || *psz == '\0';
537}
538
539
540RTDECL(int) RTGetOptArgvToString(char **ppszCmdLine, const char * const *papszArgv, uint32_t fFlags)
541{
542 AssertReturn((fFlags & RTGETOPTARGV_CNV_QUOTE_MASK) <= RTGETOPTARGV_CNV_UNQUOTED, VERR_INVALID_FLAGS);
543 AssertReturn(!(fFlags & (~RTGETOPTARGV_CNV_VALID_MASK | RTGETOPTARGV_CNV_MODIFY_INPUT)), VERR_INVALID_FLAGS);
544
545#define PUT_CH(ch) \
546 if (RT_UNLIKELY(off + 1 >= cbCmdLineAlloc)) { \
547 rc = rtGetOptArgvToStringGrow(&pszCmdLine, &cbCmdLineAlloc, 1); \
548 if (RT_FAILURE(rc)) \
549 break; \
550 } \
551 pszCmdLine[off++] = (ch)
552
553#define PUT_PSZ(psz, cch) \
554 if (RT_UNLIKELY(off + (cch) >= cbCmdLineAlloc)) { \
555 rc = rtGetOptArgvToStringGrow(&pszCmdLine, &cbCmdLineAlloc, (cch)); \
556 if (RT_FAILURE(rc)) \
557 break; \
558 } \
559 memcpy(&pszCmdLine[off], (psz), (cch)); \
560 off += (cch);
561#define PUT_SZ(sz) PUT_PSZ(sz, sizeof(sz) - 1)
562
563 /*
564 * Take the realloc approach, it requires less code and is probably more
565 * efficient than figuring out the size first.
566 */
567 int rc = VINF_SUCCESS;
568 size_t off = 0;
569 size_t cbCmdLineAlloc = 256;
570 char *pszCmdLine = RTStrAlloc(256);
571 if (!pszCmdLine)
572 return VERR_NO_STR_MEMORY;
573
574 for (size_t i = 0; papszArgv[i]; i++)
575 {
576 if (i > 0)
577 {
578 PUT_CH(' ');
579 }
580
581 /* does it need quoting? */
582 const char *pszArg = papszArgv[i];
583 size_t cchArg;
584 if (!rtGetOpArgvRequiresQuoting(pszArg, fFlags, &cchArg))
585 {
586 /* No quoting needed, just append the argument. */
587 PUT_PSZ(pszArg, cchArg);
588 }
589 else if ((fFlags & RTGETOPTARGV_CNV_QUOTE_MASK) == RTGETOPTARGV_CNV_QUOTE_MS_CRT)
590 {
591 /*
592 * Microsoft CRT quoting. Quote the whole argument in double
593 * quotes to make it easier to read and code.
594 */
595 PUT_CH('"');
596 char ch;
597 while ((ch = *pszArg++))
598 {
599 if ( ch == '\\'
600 && rtGetOptArgvMsCrtIsSlashQuote(pszArg))
601 {
602 PUT_SZ("\\\\");
603 }
604 else if (ch == '"')
605 {
606 PUT_SZ("\\\"");
607 }
608 else
609 {
610 PUT_CH(ch);
611 }
612 }
613 PUT_CH('"');
614 }
615 else
616 {
617 /*
618 * Bourne Shell quoting. Quote the whole thing in single quotes
619 * and use double quotes for any single quote chars.
620 */
621 PUT_CH('\'');
622 char ch;
623 while ((ch = *pszArg++))
624 {
625 if (ch == '\'')
626 {
627 PUT_SZ("'\"'\"'");
628 }
629 else
630 {
631 PUT_CH(ch);
632 }
633 }
634 PUT_CH('\'');
635 }
636 }
637
638 /* Set return value / cleanup. */
639 if (RT_SUCCESS(rc))
640 {
641 pszCmdLine[off] = '\0';
642 *ppszCmdLine = pszCmdLine;
643 }
644 else
645 RTStrFree(pszCmdLine);
646#undef PUT_SZ
647#undef PUT_PSZ
648#undef PUT_CH
649 return rc;
650}
651
652
653RTDECL(int) RTGetOptArgvToUtf16String(PRTUTF16 *ppwszCmdLine, const char * const *papszArgv, uint32_t fFlags)
654{
655 char *pszCmdLine;
656 int rc = RTGetOptArgvToString(&pszCmdLine, papszArgv, fFlags);
657 if (RT_SUCCESS(rc))
658 {
659 rc = RTStrToUtf16(pszCmdLine, ppwszCmdLine);
660 RTStrFree(pszCmdLine);
661 }
662 return rc;
663}
664
665#endif /* !IPRT_REGENERATE_QUOTE_CHARS */
666
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use