VirtualBox

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

Last change on this file was 99739, checked in by vboxsync, 13 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 */
76typedef 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. */
90typedef RTFUZZCFGINT *PRTFUZZCFGINT;
91/** Pointer to a const internal fuzzer config state. */
92typedef 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 */
107static 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 */
151static 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 */
219static 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 */
244static 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 */
288static 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 */
335static 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 */
361static 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 */
382static 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 */
405static 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 */
455static 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 */
524static 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
535RTDECL(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
567RTDECL(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
583RTDECL(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
595RTDECL(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
610RTDECL(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
639RTDECL(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.

© 2023 Oracle
Contact – Privacy policy – Terms of Use