fuzz-config.cpp@ 99739

Last change on this file since 99739 was 99739, checked in by vboxsync, 19 months ago
*: doxygen corrections (mostly about removing @returns from functions returning void).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 21.3 KB

Line
1	/* $Id: fuzz-config.cpp 99739 2023-05-11 01:01:08Z vboxsync $ */
2	/** @file
3	* IPRT - Fuzzing framework API, config API.
4	*/
5
6	/*
7	* Copyright (C) 2020-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/fuzz.h>
42	#include "internal/iprt.h"
43
44	#include <iprt/asm.h>
45	#include <iprt/assert.h>
46	#include <iprt/file.h>
47	#include <iprt/err.h>
48	#include <iprt/mem.h>
49	#include <iprt/string.h>
50	#include <iprt/json.h>
51	#include <iprt/vfs.h>
52	#include <iprt/zip.h>
53
54
55	/*********************************************************************************************************************************
56	* Defined Constants And Macros *
57	*********************************************************************************************************************************/
58
59	/** The index filename used to get all the other content. */
60	#define RTFUZZ_CFG_INDEX_FILE_NAME "index.json"
61	/** The custom config object member name. */
62	#define RTFUZZ_CFG_JSON_CUSTOM_CFG "CustomCfg"
63	/** The input corpus array member name. */
64	#define RTFUZZ_CFG_JSON_INPUT_CORPUS "InputCorpus"
65	/** The input name. */
66	#define RTFUZZ_CFG_JSON_INPUT_NAME "Name"
67
68
69	/*********************************************************************************************************************************
70	* Structures and Typedefs *
71	*********************************************************************************************************************************/
72
73	/**
74	* Internal fuzzer config state.
75	*/
76	typedef struct RTFUZZCFGINT
77	{
78	/** Magic value identifying the struct. */
79	uint32_t u32Magic;
80	/** Reference counter. */
81	volatile uint32_t cRefs;
82	/** The VFS file handle we get the config from. */
83	RTVFSFILE hVfsFile;
84	/** The JSON root handle of the config. */
85	RTJSONVAL hJsonRoot;
86	/** The custom config file handle if existing. */
87	RTVFSFILE hVfsFileCustomCfg;
88	} RTFUZZCFGINT;
89	/** Pointer to the internal fuzzer config state. */
90	typedef RTFUZZCFGINT *PRTFUZZCFGINT;
91	/** Pointer to a const internal fuzzer config state. */
92	typedef const RTFUZZCFGINT *PCRTFUZZCFGINT;
93
94
95	/*********************************************************************************************************************************
96	* Internal Functions *
97	*********************************************************************************************************************************/
98
99
100	/**
101	* Creates a filesystem stream from the given VFS file object.
102	*
103	* @returns IPRT status code.
104	* @param phVfsFss Where to store the handle to the filesystem stream on success.
105	* @param hVFsFile The VFS file handle.
106	*/
107	static int rtFuzzCfgTarFssFromVfsFile(PRTVFSFSSTREAM phVfsFss, RTVFSFILE hVfsFile)
108	{
109	int rc = RTVfsFileSeek(hVfsFile, 0, RTFILE_SEEK_BEGIN, NULL);
110	if (RT_SUCCESS(rc))
111	{
112	RTVFSIOSTREAM hVfsFileIos = RTVfsFileToIoStream(hVfsFile);
113	if (hVfsFileIos != NIL_RTVFSIOSTREAM)
114	{
115	RTVFSIOSTREAM hGunzipIos;
116	rc = RTZipGzipDecompressIoStream(hVfsFileIos, 0 /fFlags/, &hGunzipIos);
117	if (RT_SUCCESS(rc))
118	{
119	RTVFSFSSTREAM hTarFss;
120	rc = RTZipTarFsStreamFromIoStream(hGunzipIos, 0 /fFlags/, &hTarFss);
121	if (RT_SUCCESS(rc))
122	{
123	RTVfsIoStrmRelease(hGunzipIos);
124	RTVfsIoStrmRelease(hVfsFileIos);
125	*phVfsFss = hTarFss;
126	return VINF_SUCCESS;
127	}
128
129	RTVfsIoStrmRelease(hGunzipIos);
130	}
131
132	RTVfsIoStrmRelease(hVfsFileIos);
133	}
134	else
135	rc = VERR_INVALID_STATE; /** @todo */
136	}
137
138	return rc;
139	}
140
141
142	/**
143	* Finds a given file in the filesystem stream.
144	*
145	* @returns IPRT status code.
146	* @param hVfsFss The filesystem stream handle.
147	* @param pszFilename The filename to look for.
148	* @param fValidateUtf8 Flag whether tpo validate the content as UTF-8.
149	* @param phVfsFile Where to store the VFS file handle on success (content is completely in memory).
150	*/
151	static int rtFuzzCfgFindFile(RTVFSFSSTREAM hVfsFss, const char *pszFilename, bool fValidateUtf8,
152	PRTVFSFILE phVfsFile)
153	{
154	int rc = VINF_SUCCESS;
155
156	*phVfsFile = NIL_RTVFSFILE;
157	for (;;)
158	{
159	/*
160	* Get the next stream object.
161	*/
162	char *pszName;
163	RTVFSOBJ hVfsObj;
164	RTVFSOBJTYPE enmType;
165	rc = RTVfsFsStrmNext(hVfsFss, &pszName, &enmType, &hVfsObj);
166	if (RT_FAILURE(rc))
167	{
168	if (rc == VERR_EOF)
169	rc = VERR_NOT_FOUND;
170	break;
171	}
172	const char *pszAdjName = pszName[0] == '.' && pszName[1] == '/' ? &pszName[2] : pszName;
173
174	if ( !strcmp(pszAdjName, pszFilename)
175	&& ( enmType == RTVFSOBJTYPE_FILE
176	\|\| enmType == RTVFSOBJTYPE_IO_STREAM))
177	{
178	RTStrFree(pszName);
179
180	RTVFSIOSTREAM hVfsIos = RTVfsObjToIoStream(hVfsObj);
181	rc = RTVfsMemorizeIoStreamAsFile(hVfsIos, RTFILE_O_READ, phVfsFile);
182	if ( RT_SUCCESS(rc)
183	&& fValidateUtf8)
184	rc = RTVfsIoStrmValidateUtf8Encoding(hVfsIos,
185	RTVFS_VALIDATE_UTF8_BY_RTC_3629 \| RTVFS_VALIDATE_UTF8_NO_NULL,
186	NULL);
187
188	RTVfsObjRelease(hVfsObj);
189	RTVfsIoStrmRelease(hVfsIos);
190	if ( RT_FAILURE(rc)
191	&& *phVfsFile != NIL_RTVFSFILE)
192	{
193	RTVfsFileRelease(*phVfsFile);
194	*phVfsFile = NIL_RTVFSFILE;
195	}
196	return rc;
197	}
198
199	/*
200	* Clean up.
201	*/
202	RTVfsObjRelease(hVfsObj);
203	RTStrFree(pszName);
204	}
205
206	return rc;
207	}
208
209
210	/**
211	* Returns the memorized file handle for the given name from the given tarball VFS file handle.
212	*
213	* @returns IPRT status code.
214	* @param hVfsTarball The VFS file handle of the tarball containing the object.
215	* @param pszFilename The filename to look for.
216	* @param fValidateUtf8 Flag whether tpo validate the content as UTF-8.
217	* @param phVfsFile Where to store the VFS file handle on success (content is completely in memory).
218	*/
219	static int rtFuzzCfgGrabFileFromTarball(RTVFSFILE hVfsTarball, const char *pszFilename, bool fValidateUtf8, PRTVFSFILE phVfsFile)
220	{
221	RTVFSFSSTREAM hVfsFss;
222	int rc = rtFuzzCfgTarFssFromVfsFile(&hVfsFss, hVfsTarball);
223	if (RT_SUCCESS(rc))
224	{
225	/* Search for the index file and parse it. */
226	RTVFSFILE hVfsJson;
227	rc = rtFuzzCfgFindFile(hVfsFss, pszFilename, fValidateUtf8, &hVfsJson);
228	RTVfsFsStrmRelease(hVfsFss);
229	if (RT_SUCCESS(rc))
230	*phVfsFile = hVfsJson;
231	}
232
233	return rc;
234	}
235
236
237	/**
238	* Loads the given fuzzing config.
239	*
240	* @returns IPRT status code.
241	* @param pThis The fuzzing config instance.
242	* @param pErrInfo Additional error information, optional.
243	*/
244	static int rtFuzzCfgLoad(PRTFUZZCFGINT pThis, PRTERRINFO pErrInfo)
245	{
246	/* Search for the index file and parse it. */
247	RTVFSFILE hVfsJson;
248	int rc = rtFuzzCfgGrabFileFromTarball(pThis->hVfsFile, RTFUZZ_CFG_INDEX_FILE_NAME, true /fValidateUtf8/, &hVfsJson);
249	if (RT_SUCCESS(rc))
250	{
251	rc = RTJsonParseFromVfsFile(&pThis->hJsonRoot, hVfsJson, pErrInfo);
252	if (RT_SUCCESS(rc))
253	{
254	/* Look for the custom config in the JSON and find it in the VFS file. */
255	char *pszCustomCfgFilename = NULL;
256	rc = RTJsonValueQueryStringByName(pThis->hJsonRoot, RTFUZZ_CFG_JSON_CUSTOM_CFG, &pszCustomCfgFilename);
257	if (rc == VERR_NOT_FOUND)
258	rc = VINF_SUCCESS; /* The custom config is optional. */
259	if ( RT_SUCCESS(rc)
260	&& pszCustomCfgFilename)
261	{
262	rc = rtFuzzCfgGrabFileFromTarball(pThis->hVfsFile, pszCustomCfgFilename, false /fValidateUtf8/, &pThis->hVfsFileCustomCfg);
263	RTStrFree(pszCustomCfgFilename);
264	}
265
266	if (RT_FAILURE(rc))
267	{
268	RTJsonValueRelease(pThis->hJsonRoot);
269	pThis->hJsonRoot = NIL_RTJSONVAL;
270	}
271	}
272
273	RTVfsFileRelease(hVfsJson);
274	}
275
276	return rc;
277	}
278
279
280	/**
281	* Searches for the given object name in the given JSON array, returning the object on success.
282	*
283	* @returns IPRT status code.
284	* @param hJsonValArr JSON value handle containing the input corpus objects.
285	* @param pszName The name to look for.
286	* @param phJsonVal Where to store the referenced JSON value on success.
287	*/
288	static int rtFuzzCfgQueryInputCorpusEntryFromArray(RTJSONVAL hJsonValArr, const char *pszName, PRTJSONVAL phJsonVal)
289	{
290	int rc = VERR_NOT_FOUND;
291	uint32_t cEntries = RTJsonValueGetArraySize(hJsonValArr);
292
293	for (uint32_t i = 0; i < cEntries; i++)
294	{
295	RTJSONVAL hJsonVal;
296	int rc2 = RTJsonValueQueryByIndex(hJsonValArr, i, &hJsonVal);
297	if (RT_SUCCESS(rc2))
298	{
299	char *pszObjName;
300	rc2 = RTJsonValueQueryStringByName(hJsonVal, RTFUZZ_CFG_JSON_INPUT_NAME, &pszObjName);
301	if (RT_SUCCESS(rc2))
302	{
303	if (!strcmp(pszObjName, pszName))
304	{
305	RTStrFree(pszObjName);
306	*phJsonVal = hJsonVal;
307	return VINF_SUCCESS;
308	}
309
310	RTStrFree(pszObjName);
311	}
312
313	RTJsonValueRelease(hJsonVal);
314	}
315
316	if (RT_FAILURE(rc2))
317	{
318	rc = rc2;
319	break;
320	}
321	}
322
323	return rc;
324	}
325
326
327	/**
328	* Queries a 64bit unsigned integer.
329	*
330	* @returns IPRT status code.
331	* @param hJsonInp JSON object handle to search in.
332	* @param pszName Value name to look for.
333	* @param pu64Val Where to store the value on success.
334	*/
335	static int rtFuzzCfgInputQueryU64(RTJSONVAL hJsonInp, const char pszName, uint64_t pu64Val)
336	{
337	int64_t i64Val;
338	int rc = RTJsonValueQueryIntegerByName(hJsonInp, pszName, &i64Val);
339	if (RT_SUCCESS(rc))
340	{
341	if (i64Val >= 0)
342	*pu64Val = (uint64_t)i64Val;
343	else
344	rc = VERR_OUT_OF_RANGE;
345	}
346
347	return rc;
348	}
349
350
351	/**
352	* Queries a 64bit unsigned integer, supplying a default value if the name is not found in the
353	* given JSON object.
354	*
355	* @returns IPRT status code.
356	* @param hJsonInp JSON object handle to search in.
357	* @param pszName Value name to look for.
358	* @param pu64Val Where to store the value on success.
359	* @param u64Def The value to set if the value is not found.
360	*/
361	static int rtFuzzCfgInputQueryU64Def(RTJSONVAL hJsonInp, const char pszName, uint64_t pu64Val, uint64_t u64Def)
362	{
363	int rc = rtFuzzCfgInputQueryU64(hJsonInp, pszName, pu64Val);
364	if (rc == VERR_NOT_FOUND)
365	{
366	*pu64Val = u64Def;
367	rc = VINF_SUCCESS;
368	}
369
370	return rc;
371	}
372
373
374	/**
375	* Adds the given input to the given fuzzing contexts input corpus.
376	*
377	* @returns IPRT status code.
378	* @param hFuzzCtx The fuzzing context to add the input to.
379	* @param hJsonInp The JSON input object with further parameters.
380	* @param hVfsIos The VFS I/O stream of the input data to add.
381	*/
382	static int rtFuzzCfgAddInputToCtx(RTFUZZCTX hFuzzCtx, RTJSONVAL hJsonInp, RTVFSIOSTREAM hVfsIos)
383	{
384	uint64_t offMutStart = 0;
385	int rc = rtFuzzCfgInputQueryU64Def(hJsonInp, "MutationStartOffset", &offMutStart, 0);
386	if (RT_SUCCESS(rc))
387	{
388	uint64_t cbMutRange = UINT64_MAX;
389	rc = rtFuzzCfgInputQueryU64Def(hJsonInp, "MutationRangeSize", &cbMutRange, UINT64_MAX);
390	if (RT_SUCCESS(rc))
391	rc = RTFuzzCtxCorpusInputAddFromVfsIoStrmEx(hFuzzCtx, hVfsIos, offMutStart, cbMutRange);
392	}
393
394	return rc;
395	}
396
397
398	/**
399	* Sets the global fuzzer config form the given JSON object.
400	*
401	* @returns IPRT status code.
402	* @param hJsonRoot The JSON object handle for the fuzzer config.
403	* @param hFuzzCtx The fuzzing context to configure.
404	*/
405	static int rtFuzzCfgSetFuzzCtxCfg(RTJSONVAL hJsonRoot, RTFUZZCTX hFuzzCtx)
406	{
407	uint64_t u64Tmp;
408	int rc = rtFuzzCfgInputQueryU64(hJsonRoot, "Seed", &u64Tmp);
409	if (RT_SUCCESS(rc))
410	rc = RTFuzzCtxReseed(hFuzzCtx, u64Tmp);
411	else if (rc == VERR_NOT_FOUND)
412	rc = VINF_SUCCESS;
413
414	if (RT_SUCCESS(rc))
415	{
416	rc = rtFuzzCfgInputQueryU64(hJsonRoot, "InputSizeMax", &u64Tmp);
417	if (RT_SUCCESS(rc))
418	rc = RTFuzzCtxCfgSetInputSeedMaximum(hFuzzCtx, (size_t)u64Tmp);
419	else if (rc == VERR_NOT_FOUND)
420	rc = VINF_SUCCESS;
421	}
422
423	if (RT_SUCCESS(rc))
424	{
425	uint64_t offMutateStart = 0;
426	uint64_t cbMutateRange = UINT64_MAX;
427	rc = rtFuzzCfgInputQueryU64(hJsonRoot, "MutationStartOffset", &offMutateStart);
428	if (rc == VERR_NOT_FOUND)
429	rc = VINF_SUCCESS;
430
431	if (RT_SUCCESS(rc))
432	{
433	rc = rtFuzzCfgInputQueryU64(hJsonRoot, "MutationRangeSize", &cbMutateRange);
434	if (rc == VERR_NOT_FOUND)
435	rc = VINF_SUCCESS;
436	}
437
438	if (RT_SUCCESS(rc))
439	rc = RTFuzzCtxCfgSetMutationRange(hFuzzCtx, offMutateStart, cbMutateRange);
440	}
441
442	/** @todo More here */
443	return rc;
444	}
445
446
447	/**
448	* Adds all inputs in the iven config file to the given fuzzer context.
449	*
450	* @returns IPRT status code.
451	* @param pThis The fuzzing config instance.
452	* @param hJsonValCorpusArr The JSON array handle containing the input corpus configuration.
453	* @param hFuzzCtx The fuzzing context to configure.
454	*/
455	static int rtFuzzCfgAddFuzzCtxInputs(PRTFUZZCFGINT pThis, RTJSONVAL hJsonValCorpusArr, RTFUZZCTX hFuzzCtx)
456	{
457	/*
458	* Go through the tarball sequentially and search the corresponding entries in the JSON array
459	* instead of the other way around because reopening the tarball and seeking around
460	* each time (filesystem stream) is much more expensive.
461	*/
462	RTVFSFSSTREAM hVfsFss;
463	int rc = rtFuzzCfgTarFssFromVfsFile(&hVfsFss, pThis->hVfsFile);
464	if (RT_SUCCESS(rc))
465	{
466	for (;;)
467	{
468	/*
469	* Get the next stream object.
470	*/
471	char *pszName;
472	RTVFSOBJ hVfsObj;
473	RTVFSOBJTYPE enmType;
474	rc = RTVfsFsStrmNext(hVfsFss, &pszName, &enmType, &hVfsObj);
475	if (RT_FAILURE(rc))
476	{
477	if (rc == VERR_EOF)
478	rc = VINF_SUCCESS;
479	break;
480	}
481
482	if ( enmType == RTVFSOBJTYPE_FILE
483	\|\| enmType == RTVFSOBJTYPE_IO_STREAM)
484	{
485	const char *pszAdjName = pszName[0] == '.' && pszName[1] == '/' ? &pszName[2] : pszName;
486
487	/* Skip the index.json. */
488	if (strcmp(pszAdjName, RTFUZZ_CFG_INDEX_FILE_NAME))
489	{
490	/* Look for a JSON object with the matching filename and process it. */
491	RTJSONVAL hJsonInp = NIL_RTJSONVAL;
492	rc = rtFuzzCfgQueryInputCorpusEntryFromArray(hJsonValCorpusArr, pszAdjName, &hJsonInp);
493	if (RT_SUCCESS(rc))
494	{
495	RTVFSIOSTREAM hVfsIos = RTVfsObjToIoStream(hVfsObj);
496	rc = rtFuzzCfgAddInputToCtx(hFuzzCtx, hJsonInp, hVfsIos);
497	RTVfsIoStrmRelease(hVfsIos);
498	RTJsonValueRelease(hJsonInp);
499	}
500	}
501	}
502
503	/*
504	* Clean up.
505	*/
506	RTVfsObjRelease(hVfsObj);
507	RTStrFree(pszName);
508	if (RT_FAILURE(rc))
509	break; /* Abort on error. */
510	}
511
512	RTVfsFsStrmRelease(hVfsFss);
513	}
514
515	return rc;
516	}
517
518
519	/**
520	* Destroys the given fuzzing config.
521	*
522	* @param pThis The fuzzing config instance to destroy.
523	*/
524	static void rtFuzzCfgDestroy(PRTFUZZCFGINT pThis)
525	{
526	RTJsonValueRelease(pThis->hJsonRoot);
527	RTVfsFileRelease(pThis->hVfsFile);
528	if (pThis->hVfsFileCustomCfg != NIL_RTVFSFILE)
529	RTVfsFileRelease(pThis->hVfsFileCustomCfg);
530	pThis->hVfsFile = NIL_RTVFSFILE;
531	RTMemFree(pThis);
532	}
533
534
535	RTDECL(int) RTFuzzCfgCreateFromVfsFile(PRTFUZZCFG phFuzzCfg, RTVFSFILE hVfsFile, PRTERRINFO pErrInfo)
536	{
537	AssertPtrReturn(phFuzzCfg, VERR_INVALID_POINTER);
538
539	int rc;
540	PRTFUZZCFGINT pThis = (PRTFUZZCFGINT)RTMemAllocZ(sizeof(*pThis));
541	if (RT_LIKELY(pThis))
542	{
543	pThis->u32Magic = 0; /** @todo */
544	pThis->cRefs = 1;
545	RTVfsFileRetain(hVfsFile);
546	pThis->hVfsFile = hVfsFile;
547	pThis->hVfsFileCustomCfg = NIL_RTVFSFILE;
548
549	rc = rtFuzzCfgLoad(pThis, pErrInfo);
550	if (RT_SUCCESS(rc))
551	{
552	*phFuzzCfg = pThis;
553	return VINF_SUCCESS;
554	}
555
556	RTVfsFileRelease(hVfsFile);
557	pThis->hVfsFile = NULL;
558	RTMemFree(pThis);
559	}
560	else
561	rc = VERR_NO_MEMORY;
562
563	return rc;
564	}
565
566
567	RTDECL(int) RTFuzzCfgCreateFromFile(PRTFUZZCFG phFuzzCfg, const char *pszFilename, PRTERRINFO pErrInfo)
568	{
569	AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
570
571	RTVFSFILE hVfsFile;
572	int rc = RTVfsFileOpenNormal(pszFilename, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE, &hVfsFile);
573	if (RT_SUCCESS(rc))
574	{
575	rc = RTFuzzCfgCreateFromVfsFile(phFuzzCfg, hVfsFile, pErrInfo);
576	RTVfsFileRelease(hVfsFile);
577	}
578
579	return rc;
580	}
581
582
583	RTDECL(uint32_t) RTFuzzCfgRetain(RTFUZZCFG hFuzzCfg)
584	{
585	PRTFUZZCFGINT pThis = hFuzzCfg;
586
587	AssertPtrReturn(pThis, UINT32_MAX);
588
589	uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs);
590	AssertMsg(cRefs > 1 && cRefs < _1M, ("%#x %p\n", cRefs, pThis));
591	return cRefs;
592	}
593
594
595	RTDECL(uint32_t) RTFuzzCfgRelease(RTFUZZCFG hFuzzCfg)
596	{
597	PRTFUZZCFGINT pThis = hFuzzCfg;
598	if (pThis == NIL_RTFUZZCFG)
599	return 0;
600	AssertPtrReturn(pThis, UINT32_MAX);
601
602	uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs);
603	AssertMsg(cRefs < _1M, ("%#x %p\n", cRefs, pThis));
604	if (cRefs == 0)
605	rtFuzzCfgDestroy(pThis);
606	return cRefs;
607	}
608
609
610	RTDECL(int) RTFuzzCfgImport(RTFUZZCFG hFuzzCfg, RTFUZZCTX hFuzzCtx, uint32_t fFlags)
611	{
612	AssertReturn(hFuzzCfg != NIL_RTFUZZCFG, VERR_INVALID_HANDLE);
613	AssertReturn(hFuzzCtx != NIL_RTFUZZCTX, VERR_INVALID_HANDLE);
614	AssertReturn(!(fFlags & ~RTFUZZCFG_IMPORT_F_VALID), VERR_INVALID_PARAMETER);
615
616	/* Get the input corpus array. */
617	PRTFUZZCFGINT pThis = hFuzzCfg;
618	RTJSONVAL hJsonValCorpusArr;
619	int rc = RTJsonValueQueryByName(pThis->hJsonRoot, RTFUZZ_CFG_JSON_INPUT_CORPUS, &hJsonValCorpusArr);
620	if (RT_SUCCESS(rc))
621	{
622	if (RTJsonValueGetType(hJsonValCorpusArr) == RTJSONVALTYPE_ARRAY)
623	{
624	/* If not ommitted set the global fuzzing context config now. */
625	if (!(fFlags & RTFUZZCFG_IMPORT_F_ONLY_INPUT))
626	rc = rtFuzzCfgSetFuzzCtxCfg(pThis->hJsonRoot, hFuzzCtx);
627
628	if (RT_SUCCESS(rc))
629	rc = rtFuzzCfgAddFuzzCtxInputs(pThis, hJsonValCorpusArr, hFuzzCtx);
630	}
631	else
632	rc = VERR_JSON_VALUE_INVALID_TYPE;
633	}
634
635	return rc;
636	}
637
638
639	RTDECL(int) RTFuzzCfgQueryCustomCfg(RTFUZZCFG hFuzzCfg, PRTVFSFILE phVfsFile)
640	{
641	PRTFUZZCFGINT pThis = hFuzzCfg;
642
643	if (pThis->hVfsFileCustomCfg != NIL_RTVFSFILE)
644	{
645	RTVfsFileRetain(pThis->hVfsFileCustomCfg);
646	*phVfsFile = pThis->hVfsFileCustomCfg;
647	return VINF_SUCCESS;
648	}
649
650	return VERR_NOT_FOUND;
651	}

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

source: vbox/trunk/src/VBox/Runtime/common/fuzz/fuzz-config.cpp@ 99739

Download in other formats: