Add files using upload-large-folder tool

local-test-tika-full-01-vuln_6/fuzz-tooling/docs/assets/css/just-the-docs-wider.scss

@@ -0,0 +1,3 @@
+---
+---
+{% include css/just-the-docs.scss.liquid color_scheme="wider" %}

local-test-tika-full-01-vuln_6/fuzz-tooling/docs/getting-started/new-project-guide/bazel.md

@@ -0,0 +1,97 @@
+---
+layout: default
+title: Integrating a Bazel project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 5
+permalink: /getting-started/new-project-guide/bazel/
+---
+
+# Integrating a Bazel project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+## Bazel projects
+
+The process of integrating a project using the [Bazel](https://bazel.build/)
+build system with OSS-Fuzz is very similar to the general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a Bazel project are outlined below.
+
+## Fuzzing support in Bazel
+
+For Bazel-based projects, we recommend using the
+[`rules_fuzzing`](https://github.com/bazelbuild/rules_fuzzing) extension library
+for defining fuzz tests. `rules_fuzzing` provides support for building and running
+fuzz tests under
+[multiple sanitizer and fuzzing engine configurations][rules-fuzzing-usage].
+It also supports specifying corpora and dictionaries as part of the fuzz test
+definition.
+
+The fuzzing rules provide out-of-the-box support for building and packaging fuzz
+test artifacts in the OSS-Fuzz format. Each `//path/to:fuzz_test` fuzz test
+target automatically has a `//path/to:fuzz_test_oss_fuzz` packaging target that
+(a) builds the fuzz test using the instrumentation and engine library specified
+in the OSS-Fuzz environment variables, and (b) generates an archive containing
+the binary and its associated artifacts (corpus, dictionary, etc.). Moreover,
+OSS-Fuzz provides a standard tool to automatically process these targets,
+substantially simplifying the `build.sh` script (see below).
+
+[rules-fuzzing-usage]: https://github.com/bazelbuild/rules_fuzzing#using-the-rules-in-your-project
+
+## Project files
+
+This section explains how to integrate the fuzz tests written using the
+`rules_fuzzing` library with OSS-Fuzz. You can also see a complete example in the
+[`bazel-rules-fuzzing-test`](https://github.com/google/oss-fuzz/tree/master/projects/bazel-rules-fuzzing-test)
+project.
+
+The structure of the project directory in the OSS-Fuzz repository does not
+differ for Bazel-based projects. The project files have the following specific
+aspects.
+
+### project.yaml
+
+Only C++ projects are currently supported.
+
+Since the OSS-Fuzz target builds the fuzz test using the instrumentation and
+engine specified in the OSS-Fuzz environment variables, all the engine and
+sanitizer configurations supported in the `project.yaml` file are automatically
+supported by the fuzzing rules.
+
+### Dockerfile
+
+There is no need to install Bazel in your Docker image. The OSS-Fuzz builder
+image provides the `bazel` executable through the
+[Bazelisk](https://github.com/bazelbuild/bazelisk) launcher, which will fetch
+and use the latest Bazel release. If your project requires a particular Bazel
+version, create a
+[`.bazelversion`](https://docs.bazel.build/versions/master/updating-bazel.html)
+file in your repository root with the desired version string.
+
+### build.sh
+
+Your `build.sh` script essentially needs to perform three steps: (1) selecting
+which fuzz tests to build, (2) building their OSS-Fuzz package targets in the
+right configuration, and (3) copying the build artifacts to the `${OUT}/`
+destination.
+
+OSS-Fuzz provides a
+[`bazel_build_fuzz_tests`](https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/bazel_build_fuzz_tests)
+tool that implements these steps in a standard way, so in most cases your
+build script only needs to invoke this command with no arguments.
+
+If necessary, the behavior of the tool can be customized through a set of
+environment variables. The most common are:
+
+* `BAZEL_EXTRA_BUILD_FLAGS` are extra build flags passed on the Bazel command
+   line.
+* `BAZEL_FUZZ_TEST_TAG` and `BAZEL_FUZZ_TEST_EXCLUDE_TAG` can be overridden to
+  specify which target tags to use when determining what fuzz tests to include.
+  By default, the tool selects all the fuzz tests except for those tagged as
+  `"no-oss-fuzz"`.
+* `BAZEL_FUZZ_TEST_QUERY` overrides the Bazel query the tool uses to identify
+  the fuzz tests to build, if the tag-based approach is not sufficient.

local-test-tika-full-01-vuln_6/fuzz-tooling/docs/getting-started/new-project-guide/go_lang.md

@@ -0,0 +1,125 @@
+---
+layout: default
+title: Integrating a Go project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 1
+permalink: /getting-started/new-project-guide/go-lang/
+---
+
+# Integrating a Go project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in Go with OSS-Fuzz is very similar
+to the general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a Go project are outlined below.
+
+## Go-fuzz support
+
+OSS-Fuzz supports **go-fuzz** in the
+[libFuzzer compatible mode](https://github.com/mdempsky/go114-fuzz-build)
+only. In that mode, fuzz targets for Go use the libFuzzer engine with native Go
+coverage instrumentation. Binaries compiled in this mode provide the same
+libFuzzer command line interface as non-Go fuzz targets.
+
+## Native Go Fuzzing support
+
+OSS-fuzz supports [fuzzers written for the native Go 1.18 engine](https://go.dev/doc/fuzz/). These fuzzers are built as libFuzzer binaries in a similar fashion as fuzzers written for the go-fuzz engine. Because of that, dictionaries and seed corpora should be handled in accordance with [the OSS-fuzz documentation](https://google.github.io/oss-fuzz/getting-started/new-project-guide/#seed-corpus).
+Unlike libFuzzer/go-fuzz targets which must accept one data buffer, fuzz targets written for the Native Go engine can accept any number of arguments of any type. Here is an example of a valid fuzzer with multiple arguments:
+
+```go
+package demofuzzing
+
+import (
+    "fmt"
+    "testing"
+)
+
+func FuzzDemo(f *testing.F) {
+    f.Fuzz(func(t *testing.T, data1 string, data2 uint32, data3 float64) {
+        fmt.Println(data1)
+        fmt.Println(data2)
+        fmt.Println(data3)
+    })
+}
+```
+
+Some requirements for native Go 1.18 fuzzers are:
+* The only `testing.F` method supported is currently `F.Fuzz()`.
+* `F.Add()` will not add seeds when fuzzing. To provide OSS-fuzz with a seed corpus, follow the documentation [here](https://google.github.io/oss-fuzz/getting-started/new-project-guide/#seed-corpus).
+
+## Project files
+
+First, you need to write a Go fuzz target. This fuzz target should reside in your project
+repository
+([example](https://github.com/golang/go/blob/4ad13555184eb0697c2e92c64c1b0bdb287ccc10/src/html/fuzz.go#L13)).
+
+The structure of the project directory in OSS-Fuzz repository doesn't differ for
+projects written in Go. The project files have the following Go specific
+aspects.
+
+### project.yaml
+
+The `language` attribute must be specified.
+
+```yaml
+language: go
+```
+
+The only supported fuzzing engine and sanitizer are `libfuzzer` and `address`,
+respectively.
+[Example](https://github.com/google/oss-fuzz/blob/356f2b947670b7eb33a1f535c71bc5c87a60b0d1/projects/syzkaller/project.yaml#L7):
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - address
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-go`
+
+The OSS-Fuzz builder image has the latest stable release of Golang installed. In
+order to install dependencies of your project, add `RUN git clone ...` command to
+your Dockerfile.
+[Example](https://github.com/google/oss-fuzz/blob/356f2b947670b7eb33a1f535c71bc5c87a60b0d1/projects/syzkaller/Dockerfile#L23):
+
+```dockerfile
+# Dependency for one of the fuzz targets.
+RUN git clone --depth 1 https://github.com/ianlancetaylor/demangle
+```
+
+go-fuzz will then automatically download the dependencies based on the go.mod file
+
+### build.sh
+
+In order to build a Go fuzz target, you need to call `go-fuzz`
+command first, and then link the resulting `.a` file against
+`$LIB_FUZZING_ENGINE` using the `$CXX $CXXFLAGS ...` command.
+
+For go-fuzz fuzzers, the best way to do this is by using the [`compile_go_fuzzer` script](https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/compile_go_fuzzer), and for native Go 1.18 fuzzers it is recommended to use the [`compile_native_go_fuzzer` script](https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/compile_native_go_fuzzer). Both of these also support coverage builds.
+
+`compile_native_go_fuzzer` requires two dependencies which can be installed with:
+```bash
+go install github.com/AdamKorcz/go-118-fuzz-build@latest
+go get github.com/AdamKorcz/go-118-fuzz-build/testing
+```
+
+A usage example from go-dns project is
+
+```sh
+compile_go_fuzzer github.com/miekg/dns FuzzNewRR fuzz_newrr fuzz
+```
+
+Arguments are :
+* path of the package with the fuzz target
+* name of the fuzz function
+* name of the fuzzer to be built
+* optional tag to be used by `go build` and such

local-test-tika-full-01-vuln_6/fuzz-tooling/docs/getting-started/new-project-guide/javascript_lang.md

@@ -0,0 +1,140 @@
+---
+layout: default
+title: Integrating a JavaScript project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 4
+permalink: /getting-started/new-project-guide/javascript-lang/
+---
+
+# Integrating a JavaScript project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in JavaScript for Node.js 
+with OSS-Fuzz is very similar to the general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a JavaScript project are outlined below.
+
+## Jazzer.js
+
+JavaScript fuzzing in OSS-Fuzz is powered by
+[Jazzer.js](https://github.com/CodeIntelligenceTesting/jazzer.js), which is
+installed during the build step. As Jazzer.js operates directly on the JavaScript
+source code level, it can be applied to any project written in a language that 
+can be transpiled into JavaScript such as TypeScript. More information on how Jazzer.js
+fuzz targets look like can be found in its
+[README's Usage section](https://github.com/CodeIntelligenceTesting/jazzer.js#usage).
+
+## Project files
+
+### Example project
+
+We recommend viewing
+[javascript-example](https://github.com/google/oss-fuzz/tree/master/projects/javascript-example)
+as an example of a simple JavaScript fuzzing project. We also recommend having a look at
+[typescript-example](https://github.com/google/oss-fuzz/tree/master/projects/typescript-example)
+as an example of how to fuzz TypeScript projects. This example also demonstrates how to use 
+Jazzer.js fuzzed data provider.
+
+### project.yaml
+
+The `language` attribute must be specified as follows:
+
+```yaml
+language: javascript
+```
+
+The only supported fuzzing engine is libFuzzer (`libfuzzer`). So far, native sanitizers such as 
+AddressSanitizer (`address`) and UndefinedBehaviorSanitizer (`undefined`) are not supported. 
+They would only be needed for projects that have native addons, which is a rather infrequent
+use case for JavaScript projects. If you have a project where you need ASan or UBSan, please 
+create open an issue on [Jazzer.js GitHub repo](https://github.com/CodeIntelligenceTesting/jazzer.js). None (`none`) is the default sanitizer for 
+JavaScript projects, so setting it up in `project.yaml` is optional.
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - none
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-javascript`
+
+The OSS-Fuzz base Docker images already come with Node.js 19 and `npm` pre-installed.
+Apart from that, you should usually not need to do more than to clone the
+project, set a `WORKDIR`, and copy any necessary files, or install any
+project-specific dependencies here as you normally would.
+
+### Fuzzers
+
+In the simplest case, every fuzzer consists of a single JavaScript file that exports
+a function named `fuzz` taking a single argument of type [Buffer](https://nodejs.org/api/buffer.html). 
+An example fuzz target could thus be a file `fuzz_string_compare.js` with contents:
+
+```javascript
+/**
+ * @param { Buffer } data
+ */
+module.exports.fuzz = function (data) {
+    const s = data.toString();
+    if (s.length !== 16) {
+        return;
+    }
+    if (
+        s.slice(0, 8) === "Awesome " &&
+        s.slice(8, 15) === "Fuzzing" &&
+        s[15] === "!"
+    ) {
+        throw Error("Welcome to Awesome Fuzzing!");
+    }
+};
+```
+
+### build.sh
+
+The OSS-Fuzz base docker image for JavaScript comes with the [`compile_javascript_fuzzer` script](https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/compile_javascript_fuzzer) preinstalled. In `build.sh`, you should install dependencies for your project, and if necessary compile the code into JavaScript. Then, you can use the script to build the fuzzers. The script ensures that [@Jazzer.js/core](https://www.npmjs.com/package/@jazzer.js/core) is installed so that its CLI can be used to execute your fuzz tests. It also generates a wrapper script that can be used as a drop-in replacement for libFuzzer. This means that the generated script accepts the same command line flags for libFuzzer. Under the hood these flags are simply forwarded to the libFuzzer native addon used by Jazzer.js.
+
+A usage example from the javascript-example project is
+
+```shell
+compile_javascript_fuzzer example fuzz_string_compare.js --sync
+```
+
+Arguments are:
+* relative path of the project in the $SRC directory
+* relative path to the fuzz test inside the project
+* remaining arguments are forwarded to the [Jazzer.js CLI](https://github.com/CodeIntelligenceTesting/jazzer.js/blob/main/docs/fuzz-targets.md#running-the-fuzz-target)
+
+The [javascript-example](https://github.com/google/oss-fuzz/blob/master/projects/javascript-example/build.sh)
+project contains an example of a `build.sh` for JavaScript projects.
+
+## FuzzedDataProvider
+
+Jazzer.js provides a `FuzzedDataProvider` that can simplify the task of creating a
+fuzz target by translating the raw input bytes received from the fuzzer into
+useful primitive JavaScript types. Its functionality is similar to
+`FuzzedDataProviders` available in other languages, such as
+[Java](https://codeintelligencetesting.github.io/jazzer-docs/jazzer-api/com/code_intelligence/jazzer/api/FuzzedDataProvider.html) and
+[C++](https://github.com/google/fuzzing/blob/master/docs/split-inputs.md).
+
+A fuzz target using the `FuzzedDataProvider` would look as follows:
+
+```javascript
+const { FuzzedDataProvider } = require("@jazzer.js/core");
+
+/**
+ * @param { Buffer } fuzzerInputData
+ */
+module.exports.fuzz = function (fuzzerInputData) {
+    const data = new FuzzedDataProvider(fuzzerInputData);
+    const i = data.consumeIntegral(4);
+    const s = data.consumeRemainingAsString();
+    exploreMe(i, s);
+};
+```

local-test-tika-full-01-vuln_6/fuzz-tooling/docs/getting-started/new-project-guide/jvm_lang.md

@@ -0,0 +1,185 @@
+---
+layout: default
+title: Integrating a Java/JVM project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 4
+permalink: /getting-started/new-project-guide/jvm-lang/
+---
+
+# Integrating a Java/JVM project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in Java or any other language
+running on the Java Virtual Machine (JVM) with OSS-Fuzz is very similar to the
+general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a JVM project are outlined below.
+
+## Jazzer
+
+Java fuzzing in OSS-Fuzz depends on
+[Jazzer](https://github.com/CodeIntelligenceTesting/jazzer), which is
+pre-installed on the OSS-Fuzz base docker images. As Jazzer operates directly
+on the bytecode level, it can be applied to any project written in a JVM-based
+language. More information on how Jazzer fuzz targets look like can be found in
+its
+[README's Usage section](https://github.com/CodeIntelligenceTesting/jazzer#usage).
+
+## Project files
+
+### Example project
+
+We recommend viewing
+[json-sanitizer](https://github.com/google/oss-fuzz/tree/master/projects/json-sanitizer)
+as an example of a simple Java-only fuzzing project. Additional examples,
+including one for a Java project with native dependencies, are part of the
+[java-example](https://github.com/google/oss-fuzz/tree/master/projects/java-example)
+project.
+
+### project.yaml
+
+The `language` attribute must be specified as follows:
+
+```yaml
+language: jvm
+```
+
+The only supported fuzzing engine is libFuzzer (`libfuzzer`). So far the only
+supported sanitizers are AddressSanitizer (`address`) and
+UndefinedBehaviorSanitizer (`undefined`). For pure Java projects, specify
+just `address`:
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - address
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-jvm`
+
+The OSS-Fuzz base Docker images already come with OpenJDK 15 pre-installed. If
+you need Maven to build your project, you can install it by adding the following
+line to your Dockerfile:
+
+```docker
+RUN apt-get update && apt-get install -y maven
+```
+
+Apart from this, you should usually not need to do more than to clone the
+project, set a `WORKDIR`, and copy any necessary files, or install any
+project-specific dependencies here as you normally would.
+
+### Fuzzers
+
+In the simplest case, every fuzzer consists of a single Java file with a
+filename matching `*Fuzzer.java` and no `package` directive. An example fuzz
+target could thus be a file `ExampleFuzzer.java` with contents:
+
+```java
+public class ExampleFuzzer {
+    public static void fuzzerTestOneInput(byte[] input) {
+        ...
+        // Call a function of the project under test with arguments derived from
+        // input and throw an exception if something unwanted happens.
+        ...
+    }
+}
+```
+
+### build.sh
+
+For JVM projects, `build.sh` does need some more significant modifications
+over C/C++ projects. Below is an annotated example build script for a
+Java-only project with single-file fuzz targets as described above:
+
+```sh
+# Step 1: Build the project
+
+# Build the project .jar as usual, e.g. using Maven.
+mvn package
+# In this example, the project is built with Maven, which typically includes the
+# project version into the name of the packaged .jar file. The version can be
+# obtained as follows:
+CURRENT_VERSION=$(mvn org.apache.maven.plugins:maven-help-plugin:3.2.0:evaluate \
+-Dexpression=project.version -q -DforceStdout)
+# Copy the project .jar into $OUT under a fixed name.
+cp "target/sample-project-$CURRENT_VERSION.jar" $OUT/sample-project.jar
+
+# Specify the projects .jar file(s), separated by spaces if there are multiple.
+PROJECT_JARS="sample-project.jar"
+
+# Step 2: Build the fuzzers (should not require any changes)
+
+# The classpath at build-time includes the project jars in $OUT as well as the
+# Jazzer API.
+BUILD_CLASSPATH=$(echo $PROJECT_JARS | xargs printf -- "$OUT/%s:"):$JAZZER_API_PATH
+
+# All .jar and .class files lie in the same directory as the fuzzer at runtime.
+RUNTIME_CLASSPATH=$(echo $PROJECT_JARS | xargs printf -- "\$this_dir/%s:"):\$this_dir
+
+for fuzzer in $(find $SRC -name '*Fuzzer.java'); do
+  fuzzer_basename=$(basename -s .java $fuzzer)
+  javac -cp $BUILD_CLASSPATH $fuzzer
+  cp $SRC/$fuzzer_basename.class $OUT/
+
+  # Create an execution wrapper that executes Jazzer with the correct arguments.
+  echo "#!/bin/bash
+# LLVMFuzzerTestOneInput for fuzzer detection.
+this_dir=\$(dirname \"\$0\")
+if [[ \"\$@\" =~ (^| )-runs=[0-9]+($| ) ]]; then
+  mem_settings='-Xmx1900m:-Xss900k'
+else
+  mem_settings='-Xmx2048m:-Xss1024k'
+fi
+LD_LIBRARY_PATH=\"$JVM_LD_LIBRARY_PATH\":\$this_dir \
+\$this_dir/jazzer_driver --agent_path=\$this_dir/jazzer_agent_deploy.jar \
+--cp=$RUNTIME_CLASSPATH \
+--target_class=$fuzzer_basename \
+--jvm_args=\"\$mem_settings:-Djava.awt.headless=true\" \
+\$@" > $OUT/$fuzzer_basename
+  chmod +x $OUT/$fuzzer_basename
+done
+```
+
+The [java-example](https://github.com/google/oss-fuzz/blob/master/projects/java-example/build.sh)
+project contains an example of a `build.sh` for Java projects with native
+libraries.
+
+## FuzzedDataProvider
+
+Jazzer provides a `FuzzedDataProvider` that can simplify the task of creating a
+fuzz target by translating the raw input bytes received from the fuzzer into
+useful primitive Java types. Its functionality is similar to
+`FuzzedDataProviders` available in other languages, such as
+[Python](https://github.com/google/atheris#fuzzeddataprovider) and
+[C++](https://github.com/google/fuzzing/blob/master/docs/split-inputs.md).
+
+On OSS-Fuzz, the required library is available in the base docker images under
+the path `$JAZZER_API_PATH`, which is added to the classpath by the example
+build script shown above. Locally, the library can be obtained from
+[Maven Central](https://search.maven.org/search?q=g:com.code-intelligence%20a:jazzer-api).
+
+A fuzz target using the `FuzzedDataProvider` would look as follows:
+
+```java
+import com.code_intelligence.jazzer.api.FuzzedDataProvider;
+
+public class ExampleFuzzer {
+    public static void fuzzerTestOneInput(FuzzedDataProvider data) {
+        int number = data.consumeInt();
+        String string = data.consumeRemainingAsString();
+        // ...
+    }
+}
+```
+
+For a list of convenience methods offered by `FuzzedDataProvider`, consult its
+[javadocs](https://codeintelligencetesting.github.io/jazzer-docs/jazzer-api/com/code_intelligence/jazzer/api/FuzzedDataProvider.html).

local-test-tika-full-01-vuln_6/fuzz-tooling/docs/getting-started/new-project-guide/python_lang.md

@@ -0,0 +1,137 @@
+---
+layout: default
+title: Integrating a Python project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 3
+permalink: /getting-started/new-project-guide/python-lang/
+---
+
+# Integrating a Python project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+
+The process of integrating a project written in Python with OSS-Fuzz is very
+similar to the general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a Python project are outlined below.
+
+## Atheris
+
+Python fuzzing in OSS-Fuzz depends on
+[Atheris](https://github.com/google/atheris). Fuzzers will depend on the
+`atheris` package, and dependencies are pre-installed on the OSS-Fuzz base
+docker images.
+
+## Project files
+
+### Example project
+
+We recommend viewing [ujson](https://github.com/google/oss-fuzz/tree/master/projects/ujson) as an
+example of a simple Python fuzzing project, with both plain-Atheris and
+Atheris + Hypothesis harnesses.
+
+### project.yaml
+
+The `language` attribute must be specified.
+
+```yaml
+language: python
+```
+
+The only supported fuzzing engine is libFuzzer (`libfuzzer`). The supported
+sanitizers are AddressSanitizer (`address`) and
+UndefinedBehaviorSanitizer (`undefined`). These must be explicitly specified.
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - address
+  - undefined
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-python`
+
+Because most dependencies are already pre-installed on the images, no
+significant changes are needed in the Dockerfile for Python fuzzing projects.
+You should simply clone the project, set a `WORKDIR`, and copy any necessary
+files, or install any project-specific dependencies here as you normally would.
+
+### build.sh
+
+For Python projects, `build.sh` does need some more significant modifications
+over normal projects. The following is an annotated example build script,
+explaining why each step is necessary and when they can be omitted.
+
+```sh
+# Build and install project (using current CFLAGS, CXXFLAGS). This is required
+# for projects with C extensions so that they're built with the proper flags.
+pip3 install .
+
+# Build fuzzers into $OUT. These could be detected in other ways.
+for fuzzer in $(find $SRC -name '*_fuzzer.py'); do
+  fuzzer_basename=$(basename -s .py $fuzzer)
+  fuzzer_package=${fuzzer_basename}.pkg
+
+  # To avoid issues with Python version conflicts, or changes in environment
+  # over time on the OSS-Fuzz bots, we use pyinstaller to create a standalone
+  # package. Though not necessarily required for reproducing issues, this is
+  # required to keep fuzzers working properly in OSS-Fuzz.
+  pyinstaller --distpath $OUT --onefile --name $fuzzer_package $fuzzer
+
+  # Create execution wrapper. Atheris requires that certain libraries are
+  # preloaded, so this is also done here to ensure compatibility and simplify
+  # test case reproduction. Since this helper script is what OSS-Fuzz will
+  # actually execute, it is also always required.
+  # NOTE: If you are fuzzing python-only code and do not have native C/C++
+  # extensions, then remove the LD_PRELOAD line below as preloading sanitizer
+  # library is not required and can lead to unexpected startup crashes.
+  echo "#!/bin/sh
+# LLVMFuzzerTestOneInput for fuzzer detection.
+this_dir=\$(dirname \"\$0\")
+LD_PRELOAD=\$this_dir/sanitizer_with_fuzzer.so \
+ASAN_OPTIONS=\$ASAN_OPTIONS:symbolize=1:external_symbolizer_path=\$this_dir/llvm-symbolizer:detect_leaks=0 \
+\$this_dir/$fuzzer_package \$@" > $OUT/$fuzzer_basename
+  chmod +x $OUT/$fuzzer_basename
+done
+```
+
+## Hypothesis
+
+Using [Hypothesis](https://hypothesis.readthedocs.io/), the Python library for
+[property-based testing](https://hypothesis.works/articles/what-is-property-based-testing/),
+makes it really easy to generate complex inputs - whether in traditional test suites
+or [by using test functions as fuzz harnesses](https://hypothesis.readthedocs.io/en/latest/details.html#use-with-external-fuzzers).
+
+> Property based testing is the construction of tests such that, when these tests are fuzzed,
+  failures in the test reveal problems with the system under test that could not have been
+  revealed by direct fuzzing of that system.
+
+We recommend using the [`hypothesis write`](https://hypothesis.readthedocs.io/en/latest/ghostwriter.html)
+command to generate a starter fuzz harness.  This "ghostwritten" code may be usable as-is,
+or provide a useful template for writing more specific tests.
+
+See [here for the core "strategies"](https://hypothesis.readthedocs.io/en/latest/data.html),
+for arbitrary data, [here for Numpy + Pandas support](https://hypothesis.readthedocs.io/en/latest/numpy.html),
+or [here for a variety of third-party extensions](https://hypothesis.readthedocs.io/en/latest/strategies.html)
+supporting everything from protobufs, to jsonschemas, to networkx graphs or geojson
+or valid Python source code.
+Hypothesis' integrated test-case reduction also makes it trivial to report a canonical minimal
+example for each distinct failure discovered while fuzzing - just run the test function!
+
+To use Hypothesis in OSS-Fuzz, install it in your Dockerfile with
+
+```shell
+RUN pip3 install hypothesis
+```
+
+See [the `ujson` structured fuzzer](https://github.com/google/oss-fuzz/blob/master/projects/ujson/hypothesis_structured_fuzzer.py)
+for an example "polyglot" which can either be run with `pytest` as a standard test function,
+or run with OSS-Fuzz as a fuzz harness.

local-test-tika-full-01-vuln_6/fuzz-tooling/docs/getting-started/new-project-guide/rust_lang.md

@@ -0,0 +1,148 @@
+---
+layout: default
+title: Integrating a Rust project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 2
+permalink: /getting-started/new-project-guide/rust-lang/
+---
+
+# Integrating a Rust project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in Rust with OSS-Fuzz is very
+similar to the general [Setting up a new project]({{ site.baseurl
+}}/getting-started/new-project-guide/) process. The key specifics of integrating
+a Rust project are outlined below.
+
+## cargo-fuzz support
+
+Rust integration with OSS-Fuzz is expected to use [`cargo
+fuzz`](https://github.com/rust-fuzz/cargo-fuzz) to build fuzzers. The `cargo
+fuzz` tool will build code with required compiler flags as well as link to the
+correct libFuzzer on OSS-Fuzz itself. Note that using `cargo fuzz` also makes it
+quite easy to run the fuzzers locally yourself if you get a failing test case!
+
+## Project files
+
+First you'll want to follow the [setup instructions for `cargo fuzz`
+itself](https://rust-fuzz.github.io/book/). Afterwards your project should have:
+
+* A top-level `fuzz` directory.
+* A `fuzz/Cargo.toml` manifest which pulls in necessary dependencies to fuzz.
+* Some `fuzz/fuzz_targets/*.rs` files which are the fuzz targets that will be
+  compiled and run on OSS-Fuzz.
+
+Note that you can customize this layout as well, but you'll need to edit some
+the scripts below to integrate into OSS-Fuzz.
+
+### project.yaml
+
+The `language` attribute must be specified.
+
+```yaml
+language: rust
+```
+
+The only supported fuzzing engine and sanitizer are `libfuzzer` and `address`,
+respectively.
+[Example](https://github.com/google/oss-fuzz/blob/12ef3654b3e9adfd20b5a6afdde54819ba71493d/projects/serde_json/project.yaml#L3-L6)
+
+```yaml
+sanitizers:
+  - address
+fuzzing_engines:
+  - libfuzzer
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-rust`
+
+The OSS-Fuzz builder image has the latest nightly release of Rust as well as
+`cargo fuzz` pre-installed and in `PATH`. In the `Dockerfile` for your project
+all you'll need to do is fetch the latest copy of your code and install any
+system dependencies necessary to build your project.
+[Example](https://github.com/google/oss-fuzz/blob/12ef3654b3e9adfd20b5a6afdde54819ba71493d/projects/serde_json/Dockerfile#L18-L20)
+
+```dockerfile
+RUN git clone --depth 1 https://github.com/serde-rs/json json
+```
+
+### build.sh
+
+Here it's expected that you'll build the fuzz targets for your project and then
+copy the final binaries into the output directory.
+[Example](https://github.com/google/oss-fuzz/blob/12ef3654b3e9adfd20b5a6afdde54819ba71493d/projects/serde_json/build.sh#L20):
+
+```sh
+cd $SRC/json
+cargo fuzz build -O
+cp fuzz/target/x86_64-unknown-linux-gnu/release/from_slice $OUT/
+```
+
+Note that you likely want to pass the `-O` flag to `cargo fuzz build` which
+builds fuzzers in release mode. You may also want to pass the
+`--debug-assertions` flag to enable more checks while fuzzing. In this example
+the `from_slice` binary is the fuzz target.
+
+With some bash-fu you can also automatically copy over all fuzz targets into
+the output directory so when you add a fuzz target to your project it's
+automatically integrated into OSS-Fuzz:
+
+```sh
+FUZZ_TARGET_OUTPUT_DIR=target/x86_64-unknown-linux-gnu/release
+for f in fuzz/fuzz_targets/*.rs
+do
+    FUZZ_TARGET_NAME=$(basename ${f%.*})
+    cp $FUZZ_TARGET_OUTPUT_DIR/$FUZZ_TARGET_NAME $OUT/
+done
+```
+
+## Writing fuzzers using a test-style strategy
+
+In Rust you will often have tests written in a way so they are only 
+compiled into the final binary when build in test-mode. This is, achieved by
+wrapping your test code in `cfg(test)`, e.g.
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+    
+    ...
+```
+
+Cargo-fuzz automatically enables the `fuzzing` feature, which means you can
+follow a similar strategy to writing fuzzers as you do when writing tests.
+Specifically, you can create modules wrapped in the `fuzzing` feature:
+```rust
+#[cfg(fuzzing)]
+pub mod fuzz_logic {
+    use super::*;
+
+    ...
+```
+and then call the logic within `fuzz_logic` from your fuzzer. 
+
+Furthermore, within your `.toml` files, you can then specify fuzzing-specific
+dependencies by wrapping them as follows:
+```
+[target.'cfg(fuzzing)'.dependencies]
+```
+similar to how you wrap test-dependencies as follows:
+```
+[dev-dependencies]
+```
+
+Finally, you can also combine the testing logic you have and the fuzz logic. This
+can be achieved simply by using 
+```rust
+#[cfg(any(test, fuzzing))]
+```
+
+A project that follows this structure is Linkerd2-proxy and the project files can be
+seen [here](https://github.com/google/oss-fuzz/tree/master/projects/linkerd2-proxy).

local-test-tika-full-01-vuln_6/fuzz-tooling/docs/getting-started/new-project-guide/swift_lang.md

@@ -0,0 +1,78 @@
+---
+layout: default
+title: Integrating a Swift project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 1
+permalink: /getting-started/new-project-guide/swift-lang/
+---
+
+# Integrating a Swift project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in Swift with OSS-Fuzz is very similar
+to the general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a Swift project are outlined below.
+
+## Project files
+
+First, you need to write a Swift fuzz target that accepts a stream of bytes and
+calls the program API with that. This fuzz target should reside in your project
+repository.
+
+The structure of the project directory in OSS-Fuzz repository doesn't differ for
+projects written in Swift. The project files have the following Swift specific
+aspects.
+
+### project.yaml
+
+The `language` attribute must be specified.
+
+```yaml
+language: swift
+```
+
+The only supported fuzzing engine is `libfuzzer`
+
+The supported sanitizers are and `address`, `thread`
+
+[Example](https://github.com/google/oss-fuzz/blob/2a15c3c88b21f4f1be2a7ff115f72bd7a08e34ac/projects/swift-nio/project.yaml#L9):
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - address
+  - thread
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-swift`
+instead of using the simple base-builder
+
+### build.sh
+
+A `precompile_swift` generates an environment variable `SWIFTFLAGS`
+This can then be used in the building command such as `swift build -c release $SWIFTFLAGS`
+
+
+A usage example from swift-protobuf project is
+
+```sh
+. precompile_swift
+# build project
+cd FuzzTesting
+swift build -c debug $SWIFTFLAGS
+
+(
+cd .build/debug/
+find . -maxdepth 1 -type f -name "*Fuzzer" -executable | while read i; do cp $i $OUT/"$i"-debug; done
+)
+
+```

local-test-tika-full-01-vuln_6/fuzz-tooling/docs/reference/reference.md

@@ -0,0 +1,9 @@
+---
+layout: default
+title: Reference
+has_children: true
+nav_order: 6
+permalink: /reference/
+---
+
+# Reference

local-test-tika-full-01-vuln_6/fuzz-tooling/tools/vscode-extension/.editorconfig

@@ -0,0 +1,8 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+insert_final_newline = true

local-test-tika-full-01-vuln_6/fuzz-tooling/tools/vscode-extension/.eslintignore

@@ -0,0 +1 @@
+build/

local-test-tika-full-01-vuln_6/fuzz-tooling/tools/vscode-extension/.gitignore

@@ -0,0 +1,6 @@
+out
+build
+dist
+node_modules
+.vscode-test/
+*.vsix

local-test-tika-full-01-vuln_6/fuzz-tooling/tools/vscode-extension/.prettierrc.js

@@ -0,0 +1,18 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+module.exports = {
+  ...require('gts/.prettierrc.json')
+}

local-test-tika-full-01-vuln_6/fuzz-tooling/tools/vscode-extension/README.md

@@ -0,0 +1,17 @@
+# OSS-Fuzz VSCode extension
+
+[OSS-Fuzz](https://github.com/google/oss-fuzz) is a fuzzing toolkit and service for fuzzing open source projects. This VSCode extension provides features and capabilities for interacting with the OSS-Fuzz toolkit and also to compare local changes to the OSS-Fuzz cloud database by way of [Open source fuzz introspection](https://introspector.oss-fuzz.com).
+
+## Features
+
+The VSCode extension is largely driven by commands at this point. The featues of these commands includes:
+
+- Easily setting up OSS-Fuzz
+- Templates for easily setting up a new OSS-Fuzz project
+- Building arbitrary projects from OSS-Fuzz
+- Modify a project from VSCode and test changes in OSS-Fuzz
+- Easily extract code coverage of fuzzers, including local-only fuzzers
+- Compare local code coverage to what is currently achieved by OSS-Fuzz
+- Auto-generation of fuzzer templates
+
+For a full list of commands and their features, please check the commands page.

local-test-tika-full-01-vuln_6/fuzz-tooling/tools/vscode-extension/src/config.ts

@@ -0,0 +1,37 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import {println} from './logger';
+
+export class ExtensionConfig {
+  /** Path to the repository that will be used. */
+  ossFuzzPepositoryWorkPath: string = '/tmp/oss-fuzz';
+
+  /** The directory where crash info is stored. */
+  crashesDirectory = process.env.HOME + '/oss-fuzz-crashes';
+
+  /** Number of seconds used for running quick test fuzzers */
+  numberOfSecondsForTestRuns = 20;
+
+  async printConfig() {
+    println('Config:');
+    println('- OSS-Fuzz repository path: ' + this.ossFuzzPepositoryWorkPath);
+    println('- Crashes directory: ' + this.crashesDirectory);
+    println('- numberOfSecondsForTestRuns: ' + this.numberOfSecondsForTestRuns);
+  }
+}
+
+export const extensionConfig = new ExtensionConfig();

local-test-tika-full-01-vuln_6/fuzz-tooling/tools/vscode-extension/src/coverageHelper.ts

@@ -0,0 +1,300 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+import {Uri} from 'vscode';
+import {println} from './logger';
+import {
+  getOSSFuzzCloudURL,
+  getLocalOutBuildDir,
+  downloadRemoteURL,
+} from './utils';
+
+const path = require('path');
+let isCodeCoverageEnabled = false;
+
+// create a decorator type that we use to decorate small numbers
+const codeCoveredLineDecorationType =
+  vscode.window.createTextEditorDecorationType({
+    backgroundColor: '#184916',
+    overviewRulerColor: 'blue',
+    overviewRulerLane: vscode.OverviewRulerLane.Right,
+    light: {
+      // this color will be used in light color themes
+      borderColor: 'darkblue',
+    },
+    dark: {
+      // this color will be used in dark color themes
+      borderColor: 'lightblue',
+    },
+  });
+
+const missingLineDecorationType = vscode.window.createTextEditorDecorationType({
+  backgroundColor: '#6C2B34',
+  overviewRulerColor: 'blue',
+  overviewRulerLane: vscode.OverviewRulerLane.Right,
+  light: {
+    // this color will be used in light color themes
+    borderColor: 'darkblue',
+  },
+  dark: {
+    // this color will be used in dark color themes
+    borderColor: 'lightblue',
+  },
+});
+
+export async function loadSummaryJsonCoverage(
+  context: vscode.ExtensionContext,
+  codeCoverageFile: Uri
+) {
+  const coverageSummaryRawJson = await vscode.workspace.openTextDocument(
+    codeCoverageFile
+  );
+  const jsonCodeCoverage = JSON.parse(coverageSummaryRawJson.getText());
+  return jsonCodeCoverage;
+}
+
+export async function compareLocalToRemoteCoverage(
+  context: vscode.ExtensionContext,
+  projectName: string
+) {
+  println('Checking the file matching');
+  /* Get the coverage from the remote server */
+  const urlString =
+    (await getOSSFuzzCloudURL(projectName)) + '/linux/summary.json';
+
+  println('URL: ' + urlString);
+  const codeCoverageFile: false | vscode.Uri = await downloadRemoteURL(
+    urlString,
+    'summary.json',
+    context
+  );
+  if (!codeCoverageFile) {
+    println('Could not get the coverage summary file');
+    return;
+  }
+  const remoteCoverage = await loadSummaryJsonCoverage(
+    context,
+    codeCoverageFile
+  );
+
+  /* Get the local coverage report */
+  // Compare the local coverage to the upstream coverage
+  const localSummaryCovPath =
+    (await getLocalOutBuildDir(projectName)) + '/report/linux/summary.json';
+  const localCodeCoverage = await loadSummaryJsonCoverage(
+    context,
+    vscode.Uri.file(localSummaryCovPath)
+  );
+
+  for (let i = 0; i < localCodeCoverage.data[0].files.length; i++) {
+    for (let j = 0; j < remoteCoverage.data[0].files.length; j++) {
+      // Get the file dictionary
+      const localFileData = localCodeCoverage.data[0].files[i];
+      const remoteFileData = remoteCoverage.data[0].files[j];
+
+      // If the filepaths are the same, then we match coverage data
+      if (localFileData.filename === remoteFileData.filename) {
+        const remoteFuncCount = remoteFileData.summary.functions.count;
+        const localFuncCount = localFileData.summary.functions.count;
+
+        if (localFuncCount > remoteFuncCount) {
+          println(
+            'Coverage improved in :' +
+              localFileData.filename +
+              ' [' +
+              localFuncCount +
+              ' : ' +
+              remoteFuncCount +
+              ']'
+          );
+        }
+      }
+    }
+  }
+}
+
+/**
+ *
+ * @param context Adds visualisation to the editor based on reading a code coverage file.
+ * @param codeCoverageFile
+ */
+export async function loadCoverageIntoWorkspace(
+  context: vscode.ExtensionContext,
+  codeCoverageFile: Uri
+) {
+  isCodeCoverageEnabled = true;
+
+  const doc3 = await vscode.workspace.openTextDocument(codeCoverageFile);
+  const jsonCodeCoverageObj3 = JSON.parse(doc3.getText());
+
+  const codeCoverageMappingWithCoverage = new Map();
+  const codeCoverageMapMissingCoverage = new Map();
+
+  Object.entries(jsonCodeCoverageObj3['files']).forEach(entry => {
+    const [key, value] = entry;
+    println(key);
+    const filename = path.parse(key).base;
+    println('Filename base: ' + filename);
+    const objectDictionary: any = value as any;
+    const linesWithCodeCoverage: unknown[] = [];
+    println(objectDictionary['executed_lines']);
+    Object.entries(objectDictionary['executed_lines']).forEach(entryInner => {
+      const lineNumber = entryInner[1];
+      //println("executed line: " + lineNumber);
+      linesWithCodeCoverage.push(lineNumber);
+    });
+    codeCoverageMappingWithCoverage.set(filename, linesWithCodeCoverage);
+
+    const linesMissingCodeCoverage: unknown[] = [];
+    Object.entries(objectDictionary['missing_lines']).forEach(entryInner => {
+      const lineNumber = entryInner[1];
+      //println("executed line: " + line_numb);
+      linesMissingCodeCoverage.push(lineNumber);
+    });
+    codeCoverageMapMissingCoverage.set(filename, linesMissingCodeCoverage);
+  });
+  println('=========>');
+
+  println('Enabling code coverage decorator');
+  println('decorator sample is activated');
+
+  let timeout: NodeJS.Timer | undefined = undefined;
+
+  // create a decorator type that we use to decorate large numbers
+
+  let activeEditor = vscode.window.activeTextEditor;
+
+  function updateDecorations(
+    linesWithCodeCoverage: any,
+    linesWithoNoCodeCoverage: any
+  ) {
+    if (!isCodeCoverageEnabled) {
+      return;
+    }
+    if (!activeEditor) {
+      return;
+    }
+    println('Filename');
+    println(activeEditor.document.fileName);
+
+    // Current file opened in the editor.
+    const nameOfCurrentFile = path.parse(activeEditor.document.fileName).base;
+
+    println('Base filename: ' + nameOfCurrentFile);
+    println('Done filename');
+    const lineNumbersWithCoverage: vscode.DecorationOptions[] = [];
+    const missingLineNumbers: vscode.DecorationOptions[] = [];
+
+    if (linesWithCodeCoverage.has(nameOfCurrentFile)) {
+      println('Has this file');
+      const elemWithCov = linesWithCodeCoverage.get(nameOfCurrentFile);
+      for (let idx = 0; idx < elemWithCov.length; idx++) {
+        const lineNo = elemWithCov[idx];
+        println('Setting up: ' + lineNo);
+        lineNumbersWithCoverage.push({
+          range: new vscode.Range(lineNo - 1, 0, lineNo, 0),
+        });
+      }
+
+      const elemNoCov = linesWithoNoCodeCoverage.get(nameOfCurrentFile);
+      for (let idx = 0; idx < elemNoCov.length; idx++) {
+        const lineNo = elemNoCov[idx];
+        println('Setting up: ' + lineNo);
+        missingLineNumbers.push({
+          range: new vscode.Range(lineNo - 1, 0, lineNo, 0),
+        });
+      }
+    } else {
+      println('Does not have this file');
+    }
+
+    activeEditor.setDecorations(
+      codeCoveredLineDecorationType,
+      lineNumbersWithCoverage
+    );
+    activeEditor.setDecorations(missingLineDecorationType, missingLineNumbers);
+    //activeEditor.setDecorations(largeNumberDecorationType, largeNumbers);
+  }
+
+  function triggerUpdateDecorations(
+    throttle = false,
+    covMap: any,
+    covMisMap: any
+  ) {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = undefined;
+    }
+    if (throttle) {
+      //timeout = setTimeout(updateDecorations, 500);
+      updateDecorations(covMap, covMisMap);
+    } else {
+      updateDecorations(covMap, covMisMap);
+    }
+  }
+
+  if (activeEditor) {
+    triggerUpdateDecorations(
+      false,
+      codeCoverageMappingWithCoverage,
+      codeCoverageMapMissingCoverage
+    );
+  }
+
+  vscode.window.onDidChangeActiveTextEditor(
+    editor => {
+      activeEditor = editor;
+      if (editor) {
+        triggerUpdateDecorations(
+          false,
+          codeCoverageMappingWithCoverage,
+          codeCoverageMapMissingCoverage
+        );
+      }
+    },
+    null,
+    context.subscriptions
+  );
+
+  vscode.workspace.onDidChangeTextDocument(
+    event => {
+      if (activeEditor && event.document === activeEditor.document) {
+        triggerUpdateDecorations(
+          true,
+          codeCoverageMappingWithCoverage,
+          codeCoverageMapMissingCoverage
+        );
+      }
+    },
+    null,
+    context.subscriptions
+  );
+}
+
+/**
+ * Removes the values from the mappings used to track code coverage. As a
+ * result, the visualisation disappears.
+ */
+export async function clearCoverage() {
+  // Set global indicator.
+  const activeEditor = vscode.window.activeTextEditor;
+  isCodeCoverageEnabled = false;
+  if (activeEditor) {
+    activeEditor.setDecorations(codeCoveredLineDecorationType, []);
+    activeEditor.setDecorations(missingLineDecorationType, []);
+  }
+}

local-test-tika-full-01-vuln_6/fuzz-tooling/tools/vscode-extension/src/logger.ts

@@ -0,0 +1,31 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+export const vscodeOutputChannel =
+  vscode.window.createOutputChannel('oss-fuzz');
+
+export function println(line: string) {
+  vscodeOutputChannel.appendLine(line);
+}
+
+export function printRaw(line: string) {
+  vscodeOutputChannel.append(line);
+}
+
+export function debugPrintln(line: string) {
+  console.log(line);
+}

local-test-tika-full-01-vuln_6/fuzz-tooling/tools/vscode-extension/src/ossfuzzWrappers.ts

@@ -0,0 +1,385 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+const fs = require('fs');
+import * as vscode from 'vscode';
+import {
+  hasOssFuzzInWorkspace,
+  getOssFuzzWorkspaceProjectName,
+  listFuzzersForProject,
+  systemSyncLogIfFailure,
+} from './utils';
+import {println} from './logger';
+import {extensionConfig} from './config';
+
+export async function buildFuzzersFromWorkspaceClusterfuzzLite() {
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    println('No workspace folder, exiting');
+    return false;
+  }
+
+  // Build the fuzzers using OSS-Fuzz infrastructure.
+  const cmdToExec = 'python3';
+  const args = [
+    extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+    'build_fuzzers',
+  ];
+
+  args.push('--external');
+  args.push(workspaceFolder[0].uri.path);
+  println('Building fuzzers');
+  if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+    println('Failed to build fuzzers');
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Builds the fuzzers for a given workspace.
+ *
+ * There are two options:
+ *  1) The fuzzers are build using the OSS-Fuzz set up in the folder
+ *  2) The fuzzers are build using the workspace and then copies that over.
+ */
+export async function buildFuzzersFromWorkspace(
+  projectNameArg: string,
+  sanitizer: string,
+  toClean: boolean
+) {
+  // println('Building fuzzers locally');
+
+  // Check if there is an OSS-Fuzz set up, and exit if not.
+  if (
+    (await isPathValidOssFuzzPath(
+      extensionConfig.ossFuzzPepositoryWorkPath
+    )) === false
+  ) {
+    println('No valid oss-fuzz path');
+    return false;
+  }
+
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    println('No workspace folder, exiting');
+    return false;
+  }
+
+  let ossFuzzProjectName = '';
+  if (await hasOssFuzzInWorkspace()) {
+    /**
+     * The fuzzers are in the workspace, as opposed to e.g. the oss-fuzz dirctory.
+     */
+    ossFuzzProjectName = await getOssFuzzWorkspaceProjectName();
+
+    /**
+     * The workspace has an OSS-Fuzz directory. We use this for the build.
+     * This is done by copying over the relevant files to the oss-fuzz repository
+     * folder. Notice that we will do a forceful copy overwriting the existing
+     * project foler if it exists.
+     */
+    println('Found project folder: ' + ossFuzzProjectName);
+
+    // Copy over the workspace oss-fuzz set up to the oss-fuzz folder.
+    let cmdToExec = 'cp';
+    let args: Array<string> = [
+      '-rfT',
+      workspaceFolder[0].uri.path + '/OSS-Fuzz/' + ossFuzzProjectName,
+      extensionConfig.ossFuzzPepositoryWorkPath +
+        '/projects/' +
+        ossFuzzProjectName +
+        '/',
+    ];
+
+    if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+      println('Failed to copy project');
+      return false;
+    }
+
+    // Build the fuzzers using OSS-Fuzz infrastructure.
+    cmdToExec = 'python3';
+    args = [
+      extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+      'build_fuzzers',
+    ];
+    println('DECIDING ABOUT SANITIZER');
+    if (sanitizer !== '') {
+      println('ADDING CODE COVERAGE SANITIZER');
+      args.push('--sanitizer=' + sanitizer);
+    }
+
+    if (toClean) {
+      args.push('--clean');
+    }
+
+    args.push(ossFuzzProjectName);
+    println('Building fuzzers');
+    if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+      println('Failed to build fuzzers');
+      return false;
+    }
+  } else {
+    ossFuzzProjectName = projectNameArg;
+
+    const targetOssFuzzProject = vscode.Uri.file(
+      extensionConfig.ossFuzzPepositoryWorkPath +
+        '/projects/' +
+        ossFuzzProjectName
+    );
+    // Check if the folder exists.
+    let projectHasOssFuzzFolder = false;
+    try {
+      await vscode.workspace.fs.readDirectory(targetOssFuzzProject);
+      projectHasOssFuzzFolder = true;
+    } catch {
+      projectHasOssFuzzFolder = false;
+    }
+
+    /**
+     * The workspace does not have a OSS-Fuzz specific folder but has
+     * a folder in the OSS-Fuzz/projects/* directory. As such, we build
+     * the project using that build.sh set up, but, instead of cloning
+     * the repository we mount the workspace root onto what would normally
+     * be cloned.
+     */
+    if (projectHasOssFuzzFolder) {
+      // println('Found a target directory');
+
+      // Build the fuzzers using OSS-Fuzz infrastructure.
+      // First, Set up a temporary workpath that will be cleanup after
+      const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+      const cmdToExec2 = 'cp';
+      const temporaryProjectPath =
+        extensionConfig.ossFuzzPepositoryWorkPath +
+        '/projects/' +
+        ossFuzzProjectName +
+        '/temporary-project';
+
+      const args2: Array<string> = [
+        '-rfT',
+        wsPath.toString(),
+        temporaryProjectPath,
+      ];
+
+      if (!(await systemSyncLogIfFailure(cmdToExec2, args2))) {
+        println('Failed to build fuzzers');
+        return false;
+      }
+
+      //const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+      const temporaryDockerPath =
+        extensionConfig.ossFuzzPepositoryWorkPath +
+        '/projects/' +
+        ossFuzzProjectName +
+        '/Dockerfile';
+      const temporaryDockerPath2 =
+        extensionConfig.ossFuzzPepositoryWorkPath +
+        '/projects/' +
+        ossFuzzProjectName +
+        '/Dockerfile2';
+
+      const args3: Array<string> = [temporaryDockerPath, temporaryDockerPath2];
+      if (!(await systemSyncLogIfFailure('cp', args3))) {
+        println('Failed to copy Dockerfile');
+        return false;
+      }
+
+      // Append COPY command to Dockerfile
+      fs.appendFileSync(
+        temporaryDockerPath,
+        'COPY temporary-project /src/' + ossFuzzProjectName
+      );
+
+      // Second, build the actual fuzzers using the temporarily created project path for mount.
+      const cmdToExec = 'python3';
+      const args = [
+        extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+        'build_fuzzers', // command
+      ];
+
+      // Add sanitizer if needed.
+      if (sanitizer !== '') {
+        args.push('--sanitizer=' + sanitizer);
+      }
+
+      // Add clean flag if needed.
+      if (toClean) {
+        args.push('--clean');
+      }
+
+      args.push(ossFuzzProjectName);
+      /*
+      Previously we used OSS-Fuzz logic that supports mounting paths for getting
+      the workspace into the Dockerfile.
+      This approach, however, has limitations in that most builds will modify
+      the contents of the folder they're working in. This can cause issues and also
+      make it not possible to build several versions of the project with changing
+      sanitizers in a sequence. As such, we disbanded.
+      */
+      println('Building fuzzers');
+      if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+        println('Failed to copy Dockerfile');
+        // Move back the modified Dockerfile
+        const args5: Array<string> = [
+          temporaryDockerPath2,
+          temporaryDockerPath,
+        ];
+        if (!(await systemSyncLogIfFailure('mv', args5))) {
+          println('Failed to copy back Dockerfile');
+          return false;
+        }
+        return false;
+      }
+
+      // Move back the modified Dockerfile
+      const args5: Array<string> = [temporaryDockerPath2, temporaryDockerPath];
+      if (!(await systemSyncLogIfFailure('mv', args5))) {
+        println('Failed to copy back Dockerfile');
+        return false;
+      }
+    } else {
+      println('OSS-Fuzz does not have the relevant project folder');
+      return false;
+    }
+  }
+
+  // If we go to here we successfully build the project. Give information.
+  vscode.window.showInformationMessage('Successfully build project');
+
+  // List the fuzzers build
+  await listFuzzersForProject(
+    ossFuzzProjectName,
+    extensionConfig.ossFuzzPepositoryWorkPath
+  );
+  return true;
+}
+
+/**
+ * Runs the fuzzer for a given CFLite project
+ */
+export async function runFuzzerHandlerCFLite(
+  projectNameArg: string,
+  fuzzerNameArg: string,
+  secondsToRunArg: string
+) {
+  // The fuzzer is run by way of OSS-Fuzz's helper.py so we use python3 to launch
+  // this script.
+  const cmdToExec = 'python3';
+
+  // Set the arguments correctly. The ordering here is important for compatibility
+  // with the underlying argparse used by OSS-Fuzz helper.py.
+  const args: Array<string> = [
+    extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+    'run_fuzzer',
+  ];
+
+  args.push('--external');
+  args.push(projectNameArg);
+  args.push(fuzzerNameArg);
+  args.push('--');
+  args.push('-max_total_time=' + secondsToRunArg);
+
+  println(
+    'Running fuzzer' +
+      fuzzerNameArg +
+      ' from project ' +
+      projectNameArg +
+      ' for ' +
+      secondsToRunArg +
+      ' seconds.'
+  );
+
+  // Run the actual command
+  if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+    println('Failed to run fuzzer');
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Runs the fuzzer for a given project.
+ */
+export async function runFuzzerHandler(
+  projectNameArg: string,
+  fuzzerNameArg: string,
+  secondsToRunArg: string,
+  fuzzerCorpusPath: string
+) {
+  // Check there is a valid OSS-Fuzz path. If not, bail out.
+  if (
+    (await isPathValidOssFuzzPath(
+      extensionConfig.ossFuzzPepositoryWorkPath
+    )) === false
+  ) {
+    println('Missing valid OSS-Fuzz path.');
+    return;
+  }
+  // The fuzzer is run by way of OSS-Fuzz's helper.py so we use python3 to launch
+  // this script.
+  const cmdToExec = 'python3';
+
+  // Set the arguments correctly. The ordering here is important for compatibility
+  // with the underlying argparse used by OSS-Fuzz helper.py.
+  const args: Array<string> = [
+    extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+    'run_fuzzer',
+  ];
+  if (fuzzerCorpusPath !== '') {
+    args.push('--corpus-dir');
+    args.push(fuzzerCorpusPath);
+  }
+  args.push(projectNameArg);
+  args.push(fuzzerNameArg);
+  args.push('--');
+  args.push('-max_total_time=' + secondsToRunArg);
+
+  println(
+    'Running fuzzer' +
+      fuzzerNameArg +
+      ' from project ' +
+      projectNameArg +
+      ' for ' +
+      secondsToRunArg +
+      ' seconds.'
+  );
+
+  // Run the actual command
+  if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+    println('Failed to run fuzzer');
+    return false;
+  }
+  return true;
+}
+
+// Validates if a directory is a valid oss-fuzz path.
+export async function isPathValidOssFuzzPath(path: string) {
+  try {
+    if (await vscode.workspace.fs.readDirectory(vscode.Uri.file(path))) {
+      // println('Is a directory');
+      // const helperPath = vscode.Uri.file(path + '/infra/helper.py');
+      const helperPath = path + '/infra/helper.py';
+      //console.log('Checking ' + helperPath.toString());
+      if (fs.existsSync(helperPath.toString())) {
+        return true;
+      }
+    }
+  } catch {
+    /* empty */
+  }
+  return false;
+}

local-test-tika-full-01-vuln_6/fuzz-tooling/tools/vscode-extension/src/projectIntegrationHelper.ts

@@ -0,0 +1,761 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+const fs = require('fs');
+import path = require('path');
+import {println} from './logger';
+import * as fuzzTemplate from './commands/cmdTemplate';
+
+export async function setupProjectInitialFiles(isClusterfuzzLite: boolean) {
+  const wsedit = new vscode.WorkspaceEdit();
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  let projectGithubRepository = '';
+
+  const isOssFuzz = isClusterfuzzLite === false;
+
+  // Get the repository if this is not ClusterfuzzLite
+  if (isOssFuzz) {
+    const tmpProjectGithubRepository = await vscode.window.showInputBox({
+      value: '',
+      placeHolder: 'Github repository for the project.',
+    });
+    if (!tmpProjectGithubRepository) {
+      return false;
+    }
+    projectGithubRepository = tmpProjectGithubRepository;
+  }
+
+  const projectNameFromRepo = path
+    .parse(projectGithubRepository)
+    .base.toLocaleLowerCase();
+
+  let pathOfLocal = '';
+  if (workspaceFolder) {
+    pathOfLocal = path
+      .parse(workspaceFolder[0].uri.fsPath)
+      .base.toLocaleLowerCase();
+    println('path of local: ' + pathOfLocal);
+  }
+  if (isOssFuzz) {
+    println('Derived project name: ' + projectNameFromRepo);
+  }
+
+  const pythonFiles = await vscode.workspace.findFiles('**/*.py');
+  const cppFiles = await vscode.workspace.findFiles('**/*.c++');
+  const cppFiles2 = await vscode.workspace.findFiles('**/*.cpp');
+  const cppFiles3 = await vscode.workspace.findFiles('**/*.cc');
+  const cfiles = await vscode.workspace.findFiles('**/*.c');
+  const hfiles = await vscode.workspace.findFiles('**/*.h');
+  const rustFiles = await vscode.workspace.findFiles('**/*.rust');
+  const golangFiles = await vscode.workspace.findFiles('**/*.go');
+  const javaFiles = await vscode.workspace.findFiles('**/*.java');
+
+  println('Number of python files: ' + pythonFiles.length);
+  println('Number of C++ files: ' + cppFiles.length + cppFiles2.length);
+  println('Number of C files: ' + cfiles.length);
+  println('Number of rustFiles files: ' + rustFiles.length);
+  println('Number of golangFiles files: ' + golangFiles.length);
+  println('Number of H files: ' + hfiles.length);
+
+  const cppFilesCount = cppFiles.length + cppFiles2.length + cppFiles3.length;
+
+  const maxCount = Math.max(
+    pythonFiles.length,
+    cppFilesCount,
+    cfiles.length,
+    rustFiles.length,
+    golangFiles.length,
+    javaFiles.length
+  );
+  let target = '';
+  if (maxCount > 0) {
+    if (maxCount === pythonFiles.length) {
+      target = 'python';
+    } else if (maxCount === cppFilesCount) {
+      target = 'cpp';
+    } else if (maxCount === cfiles.length) {
+      target = 'c';
+    } else if (maxCount === javaFiles.length) {
+      target = 'java';
+    } else {
+      println('Target is not implemented');
+      return true;
+    }
+  } else {
+    if (hfiles.length > 0) {
+      target = 'cpp';
+    } else {
+      return true;
+    }
+  }
+
+  println('Target language: ' + target);
+
+  let baseFolder = '.clusterfuzzlite';
+  if (isOssFuzz) {
+    baseFolder = 'OSS-Fuzz';
+  }
+
+  if (workspaceFolder) {
+    const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+
+    // Create workflow file for ClusterFuzzLite
+    if (isOssFuzz === false) {
+      println('Creating the workflow file');
+      const clusterfuzzWorkflowFile = vscode.Uri.file(
+        wsPath + '/' + '.github' + '/' + 'workflows/cflite_pr.yml'
+      );
+
+      let tmp_target = target;
+      if (tmp_target === 'cpp') {
+        tmp_target = 'c++';
+      }
+
+      //println('Workflow pth: ' + clusterfuzzWorkflowFile);
+
+      const cflite_workflow_yaml = `name: ClusterFuzzLite PR fuzzing
+on:
+  workflow_dispatch:
+  pull_request:
+    branches: [ main ]
+permissions: read-all
+jobs:
+  PR:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        sanitizer: [address]
+    steps:
+    - name: Build Fuzzers (\${{ matrix.sanitizer }})
+      id: build
+      uses: google/clusterfuzzlite/actions/build_fuzzers@v1
+      with:
+        sanitizer: \${{ matrix.sanitizer }}
+        language: ${tmp_target}
+        bad-build-check: false
+    - name: Run Fuzzers (\${{ matrix.sanitizer }})
+      id: run
+      uses: google/clusterfuzzlite/actions/run_fuzzers@v1
+      with:
+        github-token: \${{ secrets.GITHUB_TOKEN }}
+        fuzz-seconds: 100
+        mode: 'code-change'
+        report-unreproducible-crashes: false
+        sanitizer: \${{ matrix.sanitizer }}
+`;
+
+      // Create the file and add the contents
+      if (fs.existsSync(clusterfuzzWorkflowFile.path) === false) {
+        wsedit.createFile(clusterfuzzWorkflowFile, {ignoreIfExists: true});
+        wsedit.insert(
+          clusterfuzzWorkflowFile,
+          new vscode.Position(0, 0),
+          cflite_workflow_yaml
+        );
+      }
+    }
+
+    const ossfuzzDockerFilepath = vscode.Uri.file(
+      wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/Dockerfile'
+    );
+
+    vscode.window.showInformationMessage(ossfuzzDockerFilepath.toString());
+    //wsedit.createFile(ossfuzzDockerFilepath, {ignoreIfExists: true});
+
+    if (target === 'python') {
+      await setupPythonProjectInitialFiles(
+        projectGithubRepository,
+        projectNameFromRepo,
+        ossfuzzDockerFilepath,
+        wsedit,
+        wsPath,
+        baseFolder,
+        pathOfLocal,
+        isOssFuzz
+      );
+    }
+    if (target === 'cpp') {
+      await setupCPPProjectInitialFiles(
+        projectGithubRepository,
+        projectNameFromRepo,
+        ossfuzzDockerFilepath,
+        wsedit,
+        wsPath,
+        baseFolder,
+        pathOfLocal,
+        isOssFuzz
+      );
+    }
+    if (target === 'c') {
+      await setupCProjectInitialFiles(
+        projectGithubRepository,
+        projectNameFromRepo,
+        ossfuzzDockerFilepath,
+        wsedit,
+        wsPath,
+        baseFolder,
+        pathOfLocal,
+        isOssFuzz
+      );
+    }
+    if (target === 'java') {
+      await setupJavaProjectInitialFiles(
+        projectGithubRepository,
+        projectNameFromRepo,
+        ossfuzzDockerFilepath,
+        wsedit,
+        wsPath,
+        baseFolder,
+        isOssFuzz
+      );
+    }
+    vscode.workspace.applyEdit(wsedit);
+    vscode.window.showInformationMessage('Created a new file: hello/world.md');
+  }
+  return true;
+}
+
+function createProjectYamlContent(
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  isOssFuzz: boolean,
+  projectGithubRepository: string,
+  projectNameFromRepo: string,
+  language: string
+) {
+  const projectYamlFilepath = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/project.yaml'
+  );
+  if (fs.existsSync(projectYamlFilepath.path) === false) {
+    vscode.window.showInformationMessage(projectYamlFilepath.toString());
+    wsedit.createFile(projectYamlFilepath, {ignoreIfExists: true});
+    const projectYamlTemplate = `homepage: "${projectGithubRepository}"
+language: ${language}
+primary_contact: "<primary_contact_email>"
+main_repo: "${projectGithubRepository}"
+file_github_issue: true
+    `;
+
+    const projectYamlTemplateCFLite = `language: ${language}`;
+
+    const yamlContentToWrite = isOssFuzz
+      ? projectYamlTemplate
+      : projectYamlTemplateCFLite;
+
+    wsedit.insert(
+      projectYamlFilepath,
+      new vscode.Position(0, 0),
+      yamlContentToWrite
+    );
+  }
+}
+
+function getLicenseHeader() {
+  const todaysDate = new Date();
+  const currentYear = todaysDate.getFullYear();
+
+  const licenseHeader = `# Copyright ${currentYear} Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+`;
+
+  return licenseHeader;
+}
+
+function getBaseDockerFile(language: string) {
+  const languageToBasebuilder: {[id: string]: string} = {
+    java: 'ghcr.io/aixcc-finals/base-builder-jvm',
+    cpp: 'ghcr.io/aixcc-finals/base-builder',
+    c: 'ghcr.io/aixcc-finals/base-builder',
+    python: 'ghcr.io/aixcc-finals/base-builder-python',
+  };
+  let dockerFileContent = getLicenseHeader();
+  dockerFileContent += '\n' + 'FROM ' + languageToBasebuilder[language] + '\n';
+
+  return dockerFileContent;
+}
+
+function createReadmeFile(
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  isOssFuzz: boolean
+) {
+  const readmeFile = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + '/README.md'
+  );
+  //vscode.window.showInformationMessage(readmeFile.toString());
+  if (fs.existsSync(readmeFile.path) === false) {
+    const readmeContents = `# OSS-Fuzz set up
+This folder is the OSS-Fuzz set up.
+    `;
+
+    const readmeContentsCFLite = `# ClusterFuzzLite set up
+This folder contains a fuzzing set for [ClusterFuzzLite](https://google.github.io/clusterfuzzlite).
+        `;
+
+    const readmeContentsToWrite = isOssFuzz
+      ? readmeContents
+      : readmeContentsCFLite;
+
+    wsedit.createFile(readmeFile, {ignoreIfExists: true});
+
+    wsedit.insert(readmeFile, new vscode.Position(0, 0), readmeContentsToWrite);
+  }
+}
+
+async function setupJavaProjectInitialFiles(
+  projectGithubRepository: string,
+  projectNameFromRepo: string,
+  ossfuzzDockerFilepath: vscode.Uri,
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  isOssFuzz: boolean
+) {
+  // Dockerfile
+  const dockerfileTemplate =
+    getBaseDockerFile('java') +
+    ` 
+RUN curl -L https://archive.apache.org/dist/maven/maven-3/3.6.3/binaries/apache-maven-3.6.3-bin.zip -o maven.zip && \\
+    unzip maven.zip -d $SRC/maven && \\
+    rm -rf maven.zip
+
+ENV MVN $SRC/maven/apache-maven-3.6.3/bin/mvn
+RUN git clone --depth 1 ${projectGithubRepository} ${projectNameFromRepo}
+WORKDIR ${projectNameFromRepo}
+COPY build.sh *.java $SRC/`;
+  wsedit.insert(
+    ossfuzzDockerFilepath,
+    new vscode.Position(0, 0),
+    dockerfileTemplate
+  );
+
+  // build.sh
+  const ossfuzzBuildFilepath = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/build.sh'
+  );
+  vscode.window.showInformationMessage(ossfuzzBuildFilepath.toString());
+  wsedit.createFile(ossfuzzBuildFilepath, {ignoreIfExists: true});
+  const buildTemplate =
+    `#!/bin/bash -eu
+  ` +
+    getLicenseHeader() +
+    `
+# Supply build instructions
+# Copy all fuzzer executables to $OUT/
+`;
+  wsedit.insert(ossfuzzBuildFilepath, new vscode.Position(0, 0), buildTemplate);
+
+  // project.yaml
+  createProjectYamlContent(
+    wsedit,
+    wsPath,
+    baseFolder,
+    isOssFuzz,
+    projectGithubRepository,
+    projectNameFromRepo,
+    'jvm'
+  );
+
+  /* Sample template fuzzer */
+  const sampleFuzzFile = vscode.Uri.file(
+    wsPath +
+      '/' +
+      baseFolder +
+      '/' +
+      projectNameFromRepo +
+      '/fuzzer_example.java'
+  );
+
+  wsedit.createFile(sampleFuzzFile, {ignoreIfExists: true});
+  const sampleFuzzFileContents = fuzzTemplate.javaLangBareTemplate;
+
+  wsedit.insert(
+    sampleFuzzFile,
+    new vscode.Position(0, 0),
+    sampleFuzzFileContents
+  );
+
+  createReadmeFile(wsedit, wsPath, baseFolder, isOssFuzz);
+}
+
+async function setupCProjectInitialFiles(
+  projectGithubRepository: string,
+  projectNameFromRepo: string,
+  ossfuzzDockerFilepath: vscode.Uri,
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  baseName: string,
+  isOssFuzz: boolean
+) {
+  // Dockerfile
+  if (fs.existsSync(ossfuzzDockerFilepath.path) === false) {
+    const dockerfileTemplate =
+      getBaseDockerFile('cpp') +
+      `
+RUN apt-get update && apt-get install -y make autoconf automake libtool
+RUN git clone --depth 1 ${projectGithubRepository} ${projectNameFromRepo}
+WORKDIR ${projectNameFromRepo}
+COPY build.sh *.cpp $SRC/`;
+
+    const dockerfileTemplateClusterfuzzLite = `FROM ghcr.io/aixcc-finals/base-builder
+RUN apt-get update && apt-get install -y make autoconf automake libtool
+
+COPY . $SRC/${baseName}
+COPY .clusterfuzzlite/build.sh $SRC/build.sh
+WORKDIR $SRC/${baseName}`;
+
+    const contentToWrite = isOssFuzz
+      ? dockerfileTemplate
+      : dockerfileTemplateClusterfuzzLite;
+
+    // Create the file and add the contents
+    wsedit.createFile(ossfuzzDockerFilepath, {ignoreIfExists: true});
+    wsedit.insert(
+      ossfuzzDockerFilepath,
+      new vscode.Position(0, 0),
+      contentToWrite
+    );
+  }
+
+  // build.sh
+  const ossfuzzBuildFilepath = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/build.sh'
+  );
+  // Only create the build file if it doesn't exist
+  if (fs.existsSync(ossfuzzBuildFilepath.path) === false) {
+    vscode.window.showInformationMessage(ossfuzzBuildFilepath.toString());
+    wsedit.createFile(ossfuzzBuildFilepath, {ignoreIfExists: true});
+    const buildTemplate =
+      `#!/bin/bash -eu
+  ` +
+      getLicenseHeader() +
+      `
+# Supply build instructions
+# Use the following environment variables to build the code
+# $CXX:               c++ compiler
+# $CC:                c compiler
+# CFLAGS:             compiler flags for C files
+# CXXFLAGS:           compiler flags for CPP files
+# LIB_FUZZING_ENGINE: linker flag for fuzzing harnesses
+
+# Copy all fuzzer executables to $OUT/
+$CXX $CFLAGS $LIB_FUZZING_ENGINE $SRC/fuzzer_example.c -o $OUT/fuzzer_example
+`;
+
+    const buildTemplateClusterfuzzLite = `#!/bin/bash -eu
+# Supply build instructions
+# Use the following environment variables to build the code
+# $CXX:               c++ compiler
+# $CC:                c compiler
+# CFLAGS:             compiler flags for C files
+# CXXFLAGS:           compiler flags for CPP files
+# LIB_FUZZING_ENGINE: linker flag for fuzzing harnesses
+
+# Copy all fuzzer executables to $OUT/
+$CC $CFLAGS $LIB_FUZZING_ENGINE \\
+  $SRC/${baseName}/.clusterfuzzlite/fuzzer_example.c \\
+  -o $OUT/fuzzer_example
+`;
+
+    const buildContent = isOssFuzz
+      ? buildTemplate
+      : buildTemplateClusterfuzzLite;
+    wsedit.insert(
+      ossfuzzBuildFilepath,
+      new vscode.Position(0, 0),
+      buildContent
+    );
+  }
+
+  // project.yaml
+  createProjectYamlContent(
+    wsedit,
+    wsPath,
+    baseFolder,
+    isOssFuzz,
+    projectGithubRepository,
+    projectNameFromRepo,
+    'c'
+  );
+
+  /* Sample template fuzzer */
+  const sampleFuzzFile = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/fuzzer_example.c'
+  );
+  if (fs.existsSync(sampleFuzzFile.path) === false) {
+    wsedit.createFile(sampleFuzzFile, {ignoreIfExists: true});
+    const sampleFuzzFileContents = fuzzTemplate.cLangSimpleStringFuzzer;
+
+    wsedit.insert(
+      sampleFuzzFile,
+      new vscode.Position(0, 0),
+      sampleFuzzFileContents
+    );
+  }
+
+  createReadmeFile(wsedit, wsPath, baseFolder, isOssFuzz);
+}
+
+async function setupCPPProjectInitialFiles(
+  projectGithubRepository: string,
+  projectNameFromRepo: string,
+  ossfuzzDockerFilepath: vscode.Uri,
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  baseName: string,
+  isOssFuzz: boolean
+) {
+  // Dockerfile
+  // Only create a new Dockerfile if it doesn't already exist
+  if (fs.existsSync(ossfuzzDockerFilepath.path) === false) {
+    const dockerfileTemplate =
+      getBaseDockerFile('cpp') +
+      ` 
+RUN apt-get update && apt-get install -y make autoconf automake libtool
+RUN git clone --depth 1 ${projectGithubRepository} ${projectNameFromRepo}
+WORKDIR ${projectNameFromRepo}
+COPY build.sh *.cpp $SRC/`;
+
+    const dockerfileTemplateClusterfuzzLite = `FROM ghcr.io/aixcc-finals/base-builder
+RUN apt-get update && apt-get install -y make autoconf automake libtool
+
+COPY . $SRC/${baseName}
+COPY .clusterfuzzlite/build.sh $SRC/build.sh
+WORKDIR $SRC/${baseName}`;
+
+    const contentToWrite = isOssFuzz
+      ? dockerfileTemplate
+      : dockerfileTemplateClusterfuzzLite;
+
+    // Create the file and add the contents
+    wsedit.createFile(ossfuzzDockerFilepath, {ignoreIfExists: true});
+    wsedit.insert(
+      ossfuzzDockerFilepath,
+      new vscode.Position(0, 0),
+      contentToWrite
+    );
+  }
+
+  // build.sh
+  const ossfuzzBuildFilepath = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/build.sh'
+  );
+  // Only create the build file if it doesn't exist
+  if (fs.existsSync(ossfuzzBuildFilepath.path) === false) {
+    vscode.window.showInformationMessage(ossfuzzBuildFilepath.toString());
+    wsedit.createFile(ossfuzzBuildFilepath, {ignoreIfExists: true});
+    const buildTemplate =
+      `#!/bin/bash -eu
+  ` +
+      getLicenseHeader() +
+      `
+# Supply build instructions
+# Use the following environment variables to build the code
+# $CXX:               c++ compiler
+# $CC:                c compiler
+# CFLAGS:             compiler flags for C files
+# CXXFLAGS:           compiler flags for CPP files
+# LIB_FUZZING_ENGINE: linker flag for fuzzing harnesses
+
+# Copy all fuzzer executables to $OUT/
+$CXX $CXXFLAGS $LIB_FUZZING_ENGINE $SRC/fuzzer_example.cpp -o $OUT/fuzzer_example
+`;
+    const buildTemplateClusterfuzzLite = `#!/bin/bash -eu
+# Supply build instructions
+# Use the following environment variables to build the code
+# $CXX:               c++ compiler
+# $CC:                c compiler
+# CFLAGS:             compiler flags for C files
+# CXXFLAGS:           compiler flags for CPP files
+# LIB_FUZZING_ENGINE: linker flag for fuzzing harnesses
+
+# Copy all fuzzer executables to $OUT/
+$CXX $CXXFLAGS $LIB_FUZZING_ENGINE \\
+  $SRC/${baseName}/.clusterfuzzlite/fuzzer_example.cpp \\
+  -o $OUT/fuzzer_example
+`;
+
+    const buildContent = isOssFuzz
+      ? buildTemplate
+      : buildTemplateClusterfuzzLite;
+    wsedit.insert(
+      ossfuzzBuildFilepath,
+      new vscode.Position(0, 0),
+      buildContent
+    );
+  }
+
+  // project.yaml
+  createProjectYamlContent(
+    wsedit,
+    wsPath,
+    baseFolder,
+    isOssFuzz,
+    projectGithubRepository,
+    projectNameFromRepo,
+    'c++'
+  );
+
+  /* Sample template fuzzer */
+  const sampleFuzzFile = vscode.Uri.file(
+    wsPath +
+      '/' +
+      baseFolder +
+      '/' +
+      projectNameFromRepo +
+      '/fuzzer_example.cpp'
+  );
+  if (fs.existsSync(sampleFuzzFile.path) === false) {
+    wsedit.createFile(sampleFuzzFile, {ignoreIfExists: true});
+    const sampleFuzzFileContents = fuzzTemplate.cppLangFDPTemplateFuzzer;
+
+    wsedit.insert(
+      sampleFuzzFile,
+      new vscode.Position(0, 0),
+      sampleFuzzFileContents
+    );
+  }
+
+  createReadmeFile(wsedit, wsPath, baseFolder, isOssFuzz);
+}
+
+async function setupPythonProjectInitialFiles(
+  projectGithubRepository: string,
+  projectNameFromRepo: string,
+  ossfuzzDockerFilepath: vscode.Uri,
+  wsedit: vscode.WorkspaceEdit,
+  wsPath: string,
+  baseFolder: string,
+  baseName: string,
+  isOssFuzz: boolean
+) {
+  // Only write to Dockerfile if it doesn't already exist
+  // Dockerfile
+  if (fs.existsSync(ossfuzzDockerFilepath.path) === false) {
+    const dockerfileTemplate =
+      getBaseDockerFile('python') +
+      ` 
+  RUN python3 -m pip install --upgrade pip
+  RUN git clone --depth 1 ${projectGithubRepository} ${projectNameFromRepo}
+  WORKDIR ${projectNameFromRepo}
+  COPY build.sh *.py $SRC/`;
+
+    const dockerfileTemplateClusterfuzzLite =
+      getBaseDockerFile('python') +
+      ` 
+  RUN apt-get update && apt-get install -y make autoconf automake libtool
+
+  COPY . $SRC/${baseName}
+  COPY .clusterfuzzlite/build.sh $SRC/build.sh
+  WORKDIR $SRC/${baseName}`;
+
+    const contentToWrite = isOssFuzz
+      ? dockerfileTemplate
+      : dockerfileTemplateClusterfuzzLite;
+
+    wsedit.insert(
+      ossfuzzDockerFilepath,
+      new vscode.Position(0, 0),
+      contentToWrite
+    );
+  }
+
+  // build.sh
+  const ossfuzzBuildFilepath = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/build.sh'
+  );
+  // Only create the build file if it doesn't exist
+  if (fs.existsSync(ossfuzzBuildFilepath.path) === false) {
+    vscode.window.showInformationMessage(ossfuzzBuildFilepath.toString());
+    wsedit.createFile(ossfuzzBuildFilepath, {ignoreIfExists: true});
+    const buildTemplate =
+      `#!/bin/bash -eu
+  ` +
+      getLicenseHeader() +
+      `
+python3 -m pip install .
+
+# Build fuzzers (files prefixed with fuzz_) to $OUT
+for fuzzer in $(find $SRC -name 'fuzz_*.py'); do
+  compile_python_fuzzer $fuzzer
+done`;
+
+    const buildTemplateClusterfuzzLite = `#!/bin/bash -eu
+python3 -m pip install .
+
+# Build fuzzers (files prefixed with fuzz_) to $OUT
+for fuzzer in $(find $SRC -name 'fuzz_*.py'); do
+  compile_python_fuzzer $fuzzer
+done`;
+
+    const buildContent = isOssFuzz
+      ? buildTemplate
+      : buildTemplateClusterfuzzLite;
+    wsedit.insert(
+      ossfuzzBuildFilepath,
+      new vscode.Position(0, 0),
+      buildContent
+    );
+  }
+
+  // project.yaml
+  createProjectYamlContent(
+    wsedit,
+    wsPath,
+    baseFolder,
+    isOssFuzz,
+    projectGithubRepository,
+    projectNameFromRepo,
+    'python'
+  );
+
+  // Sample template fuzzer
+  const sampleFuzzFile = vscode.Uri.file(
+    wsPath + '/' + baseFolder + '/' + projectNameFromRepo + '/fuzz_ex1.py'
+  );
+  if (fs.existsSync(sampleFuzzFile.path) === false) {
+    wsedit.createFile(sampleFuzzFile, {ignoreIfExists: true});
+    const sampleFuzzFileContents = fuzzTemplate.pythonLangFileInputFuzzer;
+
+    wsedit.insert(
+      sampleFuzzFile,
+      new vscode.Position(0, 0),
+      sampleFuzzFileContents
+    );
+  }
+
+  // README.md
+  createReadmeFile(wsedit, wsPath, baseFolder, isOssFuzz);
+}

local-test-tika-full-01-vuln_6/fuzz-tooling/tools/vscode-extension/src/utils.ts

@@ -0,0 +1,306 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+import {extensionConfig} from './config';
+import {getApi, FileDownloader} from '@microsoft/vscode-file-downloader-api';
+
+const fs = require('fs');
+const {spawn} = require('node:child_process');
+const statusBarComp = vscode.window.createStatusBarItem(
+  vscode.StatusBarAlignment.Right,
+  100
+);
+
+import {println, printRaw, debugPrintln} from './logger';
+
+export async function setStatusText(statusText: string) {
+  //let myStatusBarItem: vscode.StatusBarItem;
+  statusBarComp.text = '$(megaphone) OSS-Fuzz: ' + statusText;
+  statusBarComp.show();
+}
+
+export async function downloadRemoteURL(
+  urlString: string,
+  targetFile: string,
+  context: vscode.ExtensionContext
+) {
+  const fileDownloader: FileDownloader = await getApi();
+  println('URL: ' + urlString);
+  let codeCoverageFile: vscode.Uri;
+  try {
+    codeCoverageFile = await fileDownloader.downloadFile(
+      vscode.Uri.parse(urlString),
+      targetFile,
+      context
+    );
+  } catch (err) {
+    println('Could not get the coverage summary file');
+    return false;
+  }
+  return codeCoverageFile;
+}
+
+export async function getLocalOutBuildDir(projectName: string) {
+  const summaryCovPath =
+    extensionConfig.ossFuzzPepositoryWorkPath + '/build/out/' + projectName;
+  return summaryCovPath;
+}
+
+export async function getOSSFuzzCloudURL(projectName: string) {
+  const currentDate = new Date();
+  const yesterday = new Date(currentDate);
+  yesterday.setDate(yesterday.getDate() - 1);
+
+  const day = yesterday.getDate();
+  const month = yesterday.getMonth();
+  const year = yesterday.getFullYear();
+
+  let urlString =
+    'https://storage.googleapis.com/oss-fuzz-coverage/' +
+    projectName +
+    '/reports/' +
+    year.toString();
+
+  if (month < 10) {
+    urlString += '0';
+  }
+  urlString += month.toString();
+  if (day < 10) {
+    urlString += '0';
+  }
+  urlString += day.toString();
+
+  return urlString;
+}
+
+/**
+ * Checks if the current workspace has a generated OSS-Fuzz folder. This is the
+ * generated folder from our auto-generation capabilities.
+ *
+ * @returns boolean
+ */
+export async function hasOssFuzzInWorkspace() {
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+
+  if (!workspaceFolder) {
+    return false;
+  }
+
+  // Identify if the workspace folder has a OSS-Fuzz set up.
+  const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+  const ossfuzzDockerFilepath = vscode.Uri.file(wsPath + '/OSS-Fuzz/');
+  try {
+    if (await vscode.workspace.fs.readDirectory(ossfuzzDockerFilepath)) {
+      for (const [name, type] of await vscode.workspace.fs.readDirectory(
+        ossfuzzDockerFilepath
+      )) {
+        // If it's a directory then we know we have the project set up in there.
+        if (type === 2) {
+          // We assume this is the project folder for now.
+          println('Found the relevant directory: ' + name);
+          return true;
+        }
+      }
+    }
+  } catch {
+    /* empty */
+  }
+  return false;
+}
+
+/**
+ * Gets the project name of the integrated OSS-Fuzz project.
+ * @returns string
+ */
+export async function getOssFuzzWorkspaceProjectName() {
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    return 'N/A';
+  }
+
+  // Identify if the workspace folder has a OSS-Fuzz set up.
+  const wsPath = workspaceFolder[0].uri.fsPath; // gets the path of the first workspace folder
+  const ossfuzzDockerFilepath = vscode.Uri.file(wsPath + '/OSS-Fuzz/');
+  try {
+    if (await vscode.workspace.fs.readDirectory(ossfuzzDockerFilepath)) {
+      for (const [name, type] of await vscode.workspace.fs.readDirectory(
+        ossfuzzDockerFilepath
+      )) {
+        if (type === 2) {
+          // println('Is a directory');
+          // We assume this is the project folder for now.
+          return name;
+        }
+      }
+    }
+  } catch {
+    /* empty */
+  }
+
+  return 'N/A';
+}
+
+/**
+ * Lists the fuzzers available in the OSS-Fuzz build project.
+ *
+ * @param projectName
+ * @param ossFuzzRepositoryPath
+ * @returns
+ */
+export async function listFuzzersForProject(
+  projectName: string,
+  ossFuzzRepositoryPath: string
+) {
+  const projectOssFuzzBuildPath = vscode.Uri.file(
+    ossFuzzRepositoryPath + '/build/out/' + projectName
+  );
+  const fuzzersInProject: Array<string> = [];
+  for (const [name, type] of await vscode.workspace.fs.readDirectory(
+    projectOssFuzzBuildPath
+  )) {
+    // Is it a file?
+    if (type === 1) {
+      const filepath =
+        ossFuzzRepositoryPath + '/build/out/' + projectName + '/' + name;
+      const binary = fs.readFileSync(filepath);
+
+      // Check if fuzzer entrypoint exists in file. This is similar to how OSS-Fuzz
+      // checks whether a file is fuzzer or not.
+      if (binary.lastIndexOf('LLVMFuzzerTestOneInput') !== -1) {
+        fuzzersInProject.push(name);
+      }
+    }
+  }
+  println('Successfully build the project.');
+  println('The fuzzers in project');
+  for (const fuzzName of fuzzersInProject) {
+    println(fuzzName);
+  }
+  return fuzzersInProject;
+}
+
+/**
+ * Helper functions for identifying the primary programming language of the workspace.
+ *
+ * This is achieved by identifying the suffix of files and then sorting
+ * based on those with most of a given language supported by OSS-Fuzz.
+ *
+ * @returns
+ */
+export async function determineWorkspaceLanguage() {
+  const pythonFiles = await vscode.workspace.findFiles('**/*.py');
+  const cppFiles = await vscode.workspace.findFiles('**/*.c++');
+  const cfiles = await vscode.workspace.findFiles('**/*.c');
+  const rustFiles = await vscode.workspace.findFiles('**/*.rust');
+  const golangFiles = await vscode.workspace.findFiles('**/*.go');
+
+  println('Number of python files: ' + pythonFiles.length);
+  println('Number of C++ files: ' + cppFiles.length);
+  println('Number of C files: ' + cfiles.length);
+  println('Number of rustFiles files: ' + rustFiles.length);
+  println('Number of golangFiles files: ' + golangFiles.length);
+
+  const maxCount = Math.max(
+    pythonFiles.length,
+    cppFiles.length,
+    cfiles.length,
+    rustFiles.length,
+    golangFiles.length
+  );
+  let target = '';
+  if (maxCount === pythonFiles.length) {
+    target = 'python';
+  } else if (maxCount === cppFiles.length) {
+    target = 'c++';
+  } else if (maxCount === cfiles.length) {
+    target = 'c';
+  } else if (maxCount === rustFiles.length) {
+    target = 'rust';
+  } else if (maxCount === golangFiles.length) {
+    target = 'golang';
+  } else {
+    target = 'not implemented';
+  }
+
+  println('Target language: ' + target);
+  return target;
+}
+
+/**
+ * Helper method to execute commands on the system.
+ */
+export async function systemSync(cmd: string, args: Array<string | undefined>) {
+  debugPrintln('Running command');
+  debugPrintln(cmd);
+  debugPrintln(args.toString());
+  debugPrintln('<<<<<<<<<<<<');
+
+  // Launch the command
+  const command = spawn(cmd, args);
+
+  // Callbacks for output events, to capture stdout and stderr live.
+  command.stdout.on('data', (x: {toString: () => string}) => {
+    printRaw(x.toString());
+  });
+  command.stderr.on('data', (x: {toString: () => string}) => {
+    printRaw(x.toString());
+  });
+
+  // Monitor for child exit.
+  let hasChildExited = 0;
+  let childExitCode = 0;
+  command.on('exit', (code: any, signal: any) => {
+    // println('child process exited with ' + `code ${code} and signal ${signal}`);
+    childExitCode = code;
+    hasChildExited = 1;
+  });
+
+  // Block until the child process has exited.
+  const snooze = (ms: number) =>
+    new Promise(resolve => setTimeout(resolve, ms));
+
+  let idx = 0;
+  const maxSeconds = 1800;
+  debugPrintln('Child exited: ' + hasChildExited);
+
+  // I think we can convert the following loop to a Promise wrapping the command
+  // exeuction. TODO(David).
+  while (hasChildExited === 0 && idx < maxSeconds) {
+    idx += 1;
+    await snooze(1000);
+  }
+
+  // Command execution is done, return appropriately if success/error.
+  if (childExitCode !== 0) {
+    println('Command execution errored');
+    return [false, command.toString()];
+  }
+  // println('Succes');
+  return [true, command.toString()];
+}
+
+export async function systemSyncLogIfFailure(
+  cmd: string,
+  args: Array<string | undefined>
+): Promise<boolean> {
+  const [res, cmdMsg] = await systemSync(cmd, args);
+  if (res === false) {
+    println(cmdMsg);
+    return false;
+  }
+  return true;
+}