| # Copyright 2019 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 |
| # |
| # https://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. |
| |
| add_subdirectory(examples) |
| add_subdirectory(unwind) |
| add_subdirectory(util) |
| add_subdirectory(network_proxy) |
| |
| # sandboxed_api/sandbox2:allow_all_syscalls |
| add_library(sandbox2_allow_all_syscalls ${SAPI_LIB_TYPE} |
| allow_all_syscalls.h |
| ) |
| add_library(sandbox2::allow_all_syscalls ALIAS sandbox2_allow_all_syscalls) |
| target_link_libraries(sandbox2_allow_all_syscalls PRIVATE |
| sapi::base |
| ) |
| |
| # sandboxed_api/sandbox2:allow_unrestricted_networking |
| add_library(sandbox2_allow_unrestricted_networking ${SAPI_LIB_TYPE} |
| allow_unrestricted_networking.h |
| ) |
| add_library(sandbox2::allow_unrestricted_networking ALIAS sandbox2_allow_unrestricted_networking) |
| target_link_libraries(sandbox2_allow_unrestricted_networking PRIVATE |
| sapi::base |
| ) |
| |
| # sandboxed_api/sandbox2:bpfdisassembler |
| add_library(sandbox2_bpfdisassembler ${SAPI_LIB_TYPE} |
| bpfdisassembler.cc |
| bpfdisassembler.h |
| ) |
| add_library(sandbox2::bpfdisassembler ALIAS sandbox2_bpfdisassembler) |
| target_link_libraries(sandbox2_bpfdisassembler |
| PUBLIC absl::span |
| PRIVATE absl::strings |
| sapi::base |
| ) |
| |
| # sandboxed_api/sandbox2:regs |
| add_library(sandbox2_regs ${SAPI_LIB_TYPE} |
| regs.cc |
| regs.h |
| ) |
| add_library(sandbox2::regs ALIAS sandbox2_regs) |
| target_link_libraries(sandbox2_regs |
| PUBLIC absl::status |
| sapi::config |
| sandbox2::syscall |
| sandbox2::violation_proto |
| PRIVATE absl::core_headers |
| absl::strings |
| sapi::strerror |
| sapi::base |
| sapi::status |
| ) |
| |
| # sandboxed_api/sandbox2:syscall |
| add_library(sandbox2_syscall ${SAPI_LIB_TYPE} |
| syscall.cc |
| syscall.h |
| syscall_defs.cc |
| syscall_defs.h |
| ) |
| add_library(sandbox2::syscall ALIAS sandbox2_syscall) |
| target_link_libraries(sandbox2_syscall |
| PRIVATE absl::algorithm_container |
| absl::span |
| absl::str_format |
| absl::strings |
| sandbox2::util |
| sapi::base |
| PUBLIC absl::log |
| ) |
| |
| # sandboxed_api/sandbox2:result |
| add_library(sandbox2_result ${SAPI_LIB_TYPE} |
| result.cc |
| result.h |
| ) |
| add_library(sandbox2::result ALIAS sandbox2_result) |
| target_link_libraries(sandbox2_result PRIVATE |
| absl::base |
| absl::strings |
| sapi::config |
| sandbox2::regs |
| sandbox2::syscall |
| sandbox2::util |
| sapi::base |
| sapi::status |
| ) |
| |
| # sandboxed_api/sandbox2:logserver_proto |
| sapi_protobuf_generate_cpp(_sandbox2_logserver_pb_h _sandbox2_logserver_pb_cc |
| logserver.proto |
| ) |
| add_library(sandbox2_logserver_proto ${SAPI_LIB_TYPE} |
| ${_sandbox2_logserver_pb_cc} |
| ${_sandbox2_logserver_pb_h} |
| ) |
| add_library(sandbox2::logserver_proto ALIAS sandbox2_logserver_proto) |
| target_link_libraries(sandbox2_logserver_proto |
| PRIVATE sapi::base |
| PUBLIC protobuf::libprotobuf |
| ) |
| |
| # sandboxed_api/sandbox2:logserver |
| add_library(sandbox2_logserver ${SAPI_LIB_TYPE} |
| logserver.cc |
| logserver.h |
| ) |
| add_library(sandbox2::logserver ALIAS sandbox2_logserver) |
| target_link_libraries(sandbox2_logserver |
| PRIVATE sandbox2::comms |
| sandbox2::logserver_proto |
| sapi::base |
| PUBLIC absl::log |
| ) |
| |
| # sandboxed_api/sandbox2:logsink |
| add_library(sandbox2_logsink ${SAPI_LIB_TYPE} |
| logsink.cc |
| logsink.h |
| ) |
| add_library(sandbox2::logsink ALIAS sandbox2_logsink) |
| target_link_libraries(sandbox2_logsink |
| PRIVATE absl::strings |
| sandbox2::comms |
| sandbox2::logserver_proto |
| sapi::base |
| PUBLIC absl::synchronization |
| absl::log |
| ) |
| |
| # sandboxed_api/sandbox2:ipc |
| add_library(sandbox2_ipc ${SAPI_LIB_TYPE} |
| ipc.cc |
| ipc.h |
| ) |
| add_library(sandbox2::ipc ALIAS sandbox2_ipc) |
| target_link_libraries(sandbox2_ipc PRIVATE |
| absl::core_headers |
| absl::strings |
| sandbox2::comms |
| sandbox2::logserver |
| sandbox2::logsink |
| sandbox2::network_proxy_client |
| sandbox2::network_proxy_server |
| sapi::base |
| ) |
| |
| # sandboxed_api/sandbox2:policy |
| add_library(sandbox2_policy ${SAPI_LIB_TYPE} |
| policy.cc |
| policy.h |
| ) |
| add_library(sandbox2::policy ALIAS sandbox2_policy) |
| target_link_libraries(sandbox2_policy PRIVATE |
| absl::core_headers |
| absl::optional |
| sandbox2::bpf_helper |
| sandbox2::bpfdisassembler |
| sandbox2::comms |
| sandbox2::namespace |
| sandbox2::regs |
| sandbox2::syscall |
| sandbox2::violation_proto |
| sapi::base |
| sapi::config |
| ) |
| |
| # sandboxed_api/sandbox2:notify |
| add_library(sandbox2_notify ${SAPI_LIB_TYPE} |
| notify.h |
| ) |
| add_library(sandbox2::notify ALIAS sandbox2_notify) |
| target_link_libraries(sandbox2_notify |
| PUBLIC absl::core_headers |
| absl::log |
| sandbox2::comms |
| sandbox2::result |
| sandbox2::syscall |
| sandbox2::util |
| PRIVATE sapi::base |
| sapi::config |
| ) |
| |
| # sandboxed_api/sandbox2:limits |
| add_library(sandbox2_limits ${SAPI_LIB_TYPE} |
| limits.h |
| ) |
| add_library(sandbox2::limits ALIAS sandbox2_limits) |
| target_link_libraries(sandbox2_limits PRIVATE |
| absl::core_headers |
| absl::time |
| sapi::base |
| ) |
| |
| # sandboxed_api/sandbox2:forkserver_bin |
| add_executable(sandbox2_forkserver_bin |
| forkserver_bin.cc |
| ) |
| set_target_properties(sandbox2_forkserver_bin PROPERTIES |
| OUTPUT_NAME forkserver_bin) |
| add_executable(sandbox2::forkserver_bin ALIAS sandbox2_forkserver_bin) |
| target_link_libraries(sandbox2_forkserver_bin PRIVATE |
| absl::log_globals |
| absl::flags |
| absl::flags_parse |
| sandbox2::client |
| sandbox2::comms |
| sandbox2::forkserver |
| sandbox2::sanitizer |
| sandbox2::util |
| sapi::base |
| sapi::raw_logging |
| ) |
| |
| # sandboxed_api/sandbox2:forkserver_bin_embed |
| sapi_cc_embed_data(NAME sandbox2_forkserver_bin_embed |
| OUTPUT_NAME forkserver_bin_embed |
| NAMESPACE "" |
| SOURCES sandbox2::forkserver_bin |
| ) |
| add_library(sandbox2::forkserver_bin_embed ALIAS sandbox2_forkserver_bin_embed) |
| |
| # sandboxed_api/sandbox2:global_forkserver |
| add_library(sandbox2_global_forkserver ${SAPI_LIB_TYPE} |
| global_forkclient.cc |
| global_forkclient.h |
| ) |
| add_library(sandbox2::global_forkserver ALIAS sandbox2_global_forkserver) |
| target_link_libraries(sandbox2_global_forkserver |
| PRIVATE absl::cleanup |
| absl::strings |
| absl::status |
| absl::statusor |
| absl::log |
| sandbox2::client |
| sandbox2::forkserver_bin_embed |
| sandbox2::util |
| sapi::strerror |
| sapi::base |
| sapi::config |
| sapi::embed_file |
| sapi::fileops |
| sapi::raw_logging |
| sapi::status |
| PUBLIC absl::core_headers |
| absl::flags |
| absl::synchronization |
| sandbox2::comms |
| sandbox2::fork_client |
| sandbox2::forkserver_proto |
| ) |
| |
| # sandboxed_api/sandbox2:start_global_forkserver_lib_constructor |
| # Use only if Sandbox2 global forkserver has to be started very early on. |
| # By default the forkserver is started on demand. |
| add_library(sandbox2_start_global_forkserver_lib_constructor STATIC |
| global_forkclient_lib_ctor.cc |
| ) |
| add_library(sandbox2::start_global_forkserver_lib_constructor ALIAS |
| sandbox2_start_global_forkserver_lib_constructor) |
| target_link_libraries(sandbox2_start_global_forkserver_lib_constructor PRIVATE |
| absl::core_headers |
| sapi::base |
| sandbox2::fork_client |
| sandbox2::global_forkserver |
| ) |
| |
| # sandboxed_api/sandbox2:executor |
| add_library(sandbox2_executor ${SAPI_LIB_TYPE} |
| executor.cc |
| executor.h |
| ) |
| add_library(sandbox2::executor ALIAS sandbox2_executor) |
| target_link_libraries(sandbox2_executor |
| PRIVATE absl::core_headers |
| sandbox2::forkserver_proto |
| sandbox2::ipc |
| sandbox2::limits |
| sandbox2::namespace |
| sandbox2::util |
| sapi::base |
| sapi::status_proto |
| PUBLIC absl::log |
| absl::span |
| absl::status |
| absl::strings |
| sapi::config |
| sapi::fileops |
| sapi::status |
| sandbox2::fork_client |
| sandbox2::global_forkserver |
| ) |
| |
| # sandboxed_api/sandbox2:sandbox2 |
| add_library(sandbox2_sandbox2 ${SAPI_LIB_TYPE} |
| sandbox2.cc |
| sandbox2.h |
| ) |
| add_library(sandbox2::sandbox2 ALIAS sandbox2_sandbox2) |
| target_link_libraries(sandbox2_sandbox2 |
| PRIVATE absl::core_headers |
| absl::flat_hash_set |
| absl::memory |
| absl::optional |
| absl::str_format |
| absl::strings |
| sandbox2::forkserver_proto |
| sandbox2::monitor_ptrace |
| sandbox2::monitor_unotify |
| sapi::base |
| PUBLIC absl::flat_hash_map |
| absl::status |
| absl::statusor |
| absl::time |
| sapi::config |
| sapi::fileops |
| sapi::temp_file |
| sandbox2::client |
| sandbox2::comms |
| sandbox2::executor |
| sandbox2::fork_client |
| sandbox2::global_forkserver |
| sandbox2::ipc |
| sandbox2::limits |
| sandbox2::logsink |
| sandbox2::monitor_base |
| sandbox2::mounts |
| sandbox2::mount_tree_proto |
| sandbox2::namespace |
| sandbox2::network_proxy_client |
| sandbox2::network_proxy_server |
| sandbox2::notify |
| sandbox2::policy |
| sandbox2::policybuilder |
| sandbox2::regs |
| sandbox2::result |
| sandbox2::syscall |
| sandbox2::util |
| sandbox2::violation_proto |
| ) |
| |
| |
| # sandboxed_api/sandbox2:stack_trace |
| add_library(sandbox2_stack_trace ${SAPI_LIB_TYPE} |
| stack_trace.cc |
| stack_trace.h |
| ) |
| add_library(sandbox2::stack_trace ALIAS sandbox2_stack_trace) |
| target_link_libraries(sandbox2_stack_trace |
| PRIVATE absl::cleanup |
| absl::flags |
| absl::log |
| absl::memory |
| absl::status |
| absl::strings |
| sandbox2::client |
| sandbox2::limits |
| sandbox2::policybuilder |
| sandbox2::util |
| sandbox2::unwind |
| sandbox2::unwind_proto |
| sapi::base |
| sapi::config |
| sapi::file_base |
| sapi::fileops |
| sapi::raw_logging |
| sapi::status |
| PUBLIC absl::statusor |
| sandbox2::comms |
| sandbox2::executor |
| sandbox2::namespace |
| sandbox2::policy |
| sandbox2::result |
| sandbox2::regs |
| ) |
| |
| |
| # sandboxed_api/sandbox2:monitor_base |
| add_library(sandbox2_monitor_base ${SAPI_LIB_TYPE} |
| monitor_base.cc |
| monitor_base.h |
| ) |
| add_library(sandbox2::monitor_base ALIAS sandbox2_monitor_base) |
| target_link_libraries(sandbox2_monitor_base |
| PRIVATE absl::cleanup |
| absl::status |
| absl::time |
| sandbox2::client |
| sandbox2::limits |
| sandbox2::mounts |
| sandbox2::namespace |
| sandbox2::stack_trace |
| sandbox2::util |
| sapi::file_helpers |
| sapi::temp_file |
| sapi::base |
| sapi::raw_logging |
| PUBLIC absl::statusor |
| absl::synchronization |
| sandbox2::comms |
| sandbox2::executor |
| sandbox2::fork_client |
| sandbox2::ipc |
| sandbox2::network_proxy_server |
| sandbox2::notify |
| sandbox2::policy |
| sandbox2::result |
| sandbox2::syscall |
| ) |
| |
| # sandboxed_api/sandbox2:monitor_ptrace |
| add_library(sandbox2_monitor_ptrace ${SAPI_LIB_TYPE} |
| monitor_ptrace.cc |
| monitor_ptrace.h |
| ) |
| add_library(sandbox2::monitor_ptrace ALIAS sandbox2_monitor_ptrace) |
| target_link_libraries(sandbox2_monitor_ptrace |
| PRIVATE absl::cleanup |
| absl::flat_hash_set |
| absl::flags |
| absl::status |
| absl::strings |
| absl::time |
| sapi::base |
| sapi::config |
| sapi::status |
| sandbox2::client |
| sandbox2::comms |
| sandbox2::result |
| sandbox2::sanitizer |
| sandbox2::util |
| PUBLIC sandbox2::executor |
| sandbox2::monitor_base |
| sandbox2::notify |
| sandbox2::policy |
| sandbox2::regs |
| sandbox2::syscall |
| absl::synchronization |
| absl::flat_hash_map |
| sapi::raw_logging |
| ) |
| |
| # sandboxed_api/sandbox2:monitor_unotify |
| add_library(sandbox2_monitor_unotify ${SAPI_LIB_TYPE} |
| monitor_unotify.cc |
| monitor_unotify.h |
| ) |
| add_library(sandbox2::monitor_unotify ALIAS sandbox2_monitor_unotify) |
| target_link_libraries(sandbox2_monitor_unotify |
| PRIVATE absl::cleanup |
| absl::log |
| absl::status |
| absl::time |
| sapi::base |
| sandbox2::client |
| sandbox2::forkserver_proto |
| sapi::fileops |
| sapi::raw_logging |
| PUBLIC sandbox2::executor |
| sandbox2::monitor_base |
| sandbox2::notify |
| sandbox2::policy |
| absl::statusor |
| absl::synchronization |
| sapi::raw_logging |
| ) |
| |
| # sandboxed_api/sandbox2:policybuilder |
| add_library(sandbox2_policybuilder ${SAPI_LIB_TYPE} |
| policybuilder.cc |
| policybuilder.h |
| ) |
| add_library(sandbox2::policybuilder ALIAS sandbox2_policybuilder) |
| target_link_libraries(sandbox2_policybuilder |
| PRIVATE absl::log |
| absl::memory |
| absl::status |
| sapi::base |
| sapi::config |
| sandbox2::bpf_helper |
| sandbox2::namespace |
| sapi::file_base |
| sapi::status |
| PUBLIC absl::check |
| absl::core_headers |
| absl::flat_hash_set |
| absl::span |
| absl::strings |
| absl::statusor |
| sandbox2::mounts |
| sandbox2::network_proxy_filtering |
| sandbox2::policy |
| ) |
| |
| # sandboxed_api/sandbox2:client |
| add_library(sandbox2_client ${SAPI_LIB_TYPE} |
| client.cc |
| client.h |
| ) |
| add_library(sandbox2::client ALIAS sandbox2_client) |
| target_link_libraries(sandbox2_client |
| PRIVATE absl::core_headers |
| absl::strings |
| sandbox2::bpf_helper |
| sandbox2::policy |
| sandbox2::sanitizer |
| sandbox2::syscall |
| sapi::strerror |
| sapi::base |
| sapi::raw_logging |
| PUBLIC absl::flat_hash_map |
| sandbox2::comms |
| sandbox2::logsink |
| sandbox2::network_proxy_client |
| ) |
| |
| # sandboxed_api/sandbox2:sanitizer |
| add_library(sandbox2_sanitizer ${SAPI_LIB_TYPE} |
| sanitizer.cc |
| sanitizer.h |
| ) |
| add_library(sandbox2::sanitizer ALIAS sandbox2_sanitizer) |
| target_link_libraries(sandbox2_sanitizer |
| PRIVATE absl::strings |
| sandbox2::util |
| sapi::file_helpers |
| sapi::fileops |
| sapi::strerror |
| sapi::raw_logging |
| sapi::base |
| PUBLIC absl::core_headers |
| absl::flat_hash_set |
| absl::status |
| absl::statusor |
| ) |
| |
| # sandboxed_api/sandbox2:forkserver |
| add_library(sandbox2_forkserver ${SAPI_LIB_TYPE} |
| forkserver.cc |
| forkserver.h |
| ) |
| add_library(sandbox2::forkserver ALIAS sandbox2_forkserver) |
| target_link_libraries(sandbox2_forkserver |
| PRIVATE absl::flat_hash_map |
| absl::flat_hash_set |
| absl::status |
| absl::statusor |
| absl::strings |
| libcap::libcap |
| sandbox2::bpf_helper |
| sandbox2::client |
| sandbox2::comms |
| sapi::fileops |
| sandbox2::fork_client |
| sandbox2::forkserver_proto |
| sandbox2::namespace |
| sandbox2::policy |
| sapi::strerror |
| sandbox2::sanitizer |
| sandbox2::syscall |
| sandbox2::unwind |
| sandbox2::util |
| sapi::base |
| sapi::raw_logging |
| PUBLIC absl::core_headers |
| absl::log |
| ) |
| |
| # sandboxed_api/sandbox2:fork_client |
| add_library(sandbox2_fork_client ${SAPI_LIB_TYPE} |
| fork_client.cc |
| fork_client.h |
| ) |
| add_library(sandbox2::fork_client ALIAS sandbox2_fork_client) |
| target_link_libraries(sandbox2_fork_client |
| PRIVATE sandbox2::comms |
| sandbox2::forkserver_proto |
| PUBLIC absl::core_headers |
| absl::flags |
| absl::synchronization |
| sapi::base |
| sapi::fileops |
| ) |
| |
| # sandboxed_api/sandbox2:mounts |
| add_library(sandbox2_mounts ${SAPI_LIB_TYPE} |
| mounts.cc |
| mounts.h |
| ) |
| add_library(sandbox2::mounts ALIAS sandbox2_mounts) |
| target_link_libraries(sandbox2_mounts |
| PRIVATE absl::flat_hash_set |
| absl::str_format |
| protobuf::libprotobuf |
| sapi::config |
| sapi::file_base |
| sapi::fileops |
| sandbox2::minielf |
| sapi::strerror |
| sapi::base |
| sapi::raw_logging |
| sapi::status |
| PUBLIC absl::core_headers |
| absl::status |
| absl::statusor |
| absl::strings |
| sandbox2::mount_tree_proto |
| ) |
| |
| # sandboxed_api/sandbox2:namespace |
| add_library(sandbox2_namespace ${SAPI_LIB_TYPE} |
| namespace.cc |
| namespace.h |
| ) |
| add_library(sandbox2::namespace ALIAS sandbox2_namespace) |
| target_link_libraries(sandbox2_namespace |
| PRIVATE absl::strings |
| sapi::file_base |
| sapi::fileops |
| sapi::base |
| sapi::raw_logging |
| PUBLIC sandbox2::violation_proto |
| sandbox2::mounts |
| ) |
| |
| # sandboxed_api/sandbox2:forkingclient |
| add_library(sandbox2_forkingclient ${SAPI_LIB_TYPE} |
| forkingclient.cc |
| forkingclient.h |
| ) |
| add_library(sandbox2::forkingclient ALIAS sandbox2_forkingclient) |
| target_link_libraries(sandbox2_forkingclient |
| PRIVATE absl::memory |
| absl::log |
| sandbox2::sanitizer |
| sapi::base |
| sapi::raw_logging |
| PUBLIC sandbox2::client |
| sandbox2::comms |
| sandbox2::forkserver |
| ) |
| |
| # sandboxed_api/sandbox2:util |
| add_library(sandbox2_util ${SAPI_LIB_TYPE} |
| util.cc |
| util.h |
| ) |
| add_library(sandbox2::util ALIAS sandbox2_util) |
| target_link_libraries(sandbox2_util |
| PRIVATE absl::algorithm_container |
| absl::core_headers |
| absl::str_format |
| absl::strings |
| sapi::config |
| sapi::file_base |
| sapi::file_helpers |
| sapi::fileops |
| sapi::status |
| sapi::base |
| sapi::raw_logging |
| PUBLIC absl::status |
| absl::statusor |
| ) |
| target_compile_options(sandbox2_util PRIVATE |
| # The default is 16384, however we need to do a clone with a |
| # stack-allocated buffer -- and PTHREAD_STACK_MIN also happens to be 16384. |
| # Thus the slight increase. |
| -Wframe-larger-than=17000 |
| ) |
| |
| # sandboxed_api/sandbox2:buffer |
| add_library(sandbox2_buffer ${SAPI_LIB_TYPE} |
| buffer.cc |
| buffer.h |
| ) |
| add_library(sandbox2::buffer ALIAS sandbox2_buffer) |
| target_link_libraries(sandbox2_buffer |
| PRIVATE absl::core_headers |
| absl::memory |
| absl::status |
| absl::strings |
| sapi::strerror |
| sandbox2::util |
| sapi::base |
| sapi::status |
| PUBLIC absl::statusor |
| ) |
| |
| # sandboxed_api/sandbox2:forkserver_proto |
| sapi_protobuf_generate_cpp(_sandbox2_forkserver_pb_h _sandbox2_forkserver_pb_cc |
| forkserver.proto |
| ) |
| add_library(sandbox2_forkserver_proto ${SAPI_LIB_TYPE} |
| ${_sandbox2_forkserver_pb_cc} |
| ${_sandbox2_forkserver_pb_h} |
| ) |
| add_library(sandbox2::forkserver_proto ALIAS sandbox2_forkserver_proto) |
| target_link_libraries(sandbox2_forkserver_proto PRIVATE |
| protobuf::libprotobuf |
| sandbox2::mount_tree_proto |
| sapi::base |
| ) |
| |
| # sandboxed_api/sandbox2:mount_tree_proto |
| sapi_protobuf_generate_cpp(_sandbox2_mount_tree_pb_h _sandbox2_mount_tree_pb_cc |
| mount_tree.proto |
| ) |
| add_library(sandbox2_mount_tree_proto ${SAPI_LIB_TYPE} |
| ${_sandbox2_mount_tree_pb_cc} |
| ${_sandbox2_mount_tree_pb_h} |
| ) |
| add_library(sandbox2::mount_tree_proto ALIAS sandbox2_mount_tree_proto) |
| target_link_libraries(sandbox2_mount_tree_proto PRIVATE |
| protobuf::libprotobuf |
| sapi::base |
| ) |
| |
| # sandboxed_api/sandbox2:comms |
| add_library(sandbox2_comms ${SAPI_LIB_TYPE} |
| comms.cc |
| comms.h |
| ) |
| add_library(sandbox2::comms ALIAS sandbox2_comms) |
| target_link_libraries(sandbox2_comms |
| PRIVATE absl::die_if_null |
| absl::status |
| absl::statusor |
| absl::str_format |
| absl::strings |
| sapi::strerror |
| sandbox2::util |
| sapi::base |
| sapi::raw_logging |
| sapi::status_proto |
| PUBLIC absl::core_headers |
| absl::status |
| absl::synchronization |
| protobuf::libprotobuf |
| sapi::status |
| ) |
| |
| # sandboxed_api/sandbox2:violation_proto |
| sapi_protobuf_generate_cpp(_sandbox2_violation_pb_cc _sandbox2_violation_pb_h |
| violation.proto |
| ) |
| add_library(sandbox2_violation_proto ${SAPI_LIB_TYPE} |
| ${_sandbox2_violation_pb_cc} |
| ${_sandbox2_violation_pb_h} |
| ) |
| add_library(sandbox2::violation_proto ALIAS sandbox2_violation_proto) |
| target_link_libraries(sandbox2_violation_proto PRIVATE |
| protobuf::libprotobuf |
| sandbox2::mount_tree_proto |
| sapi::base |
| ) |
| |
| if(BUILD_TESTING AND SAPI_BUILD_TESTING) |
| add_subdirectory(testcases) |
| |
| # sandboxed_api/sandbox2:regs_test |
| add_executable(sandbox2_regs_test |
| regs_test.cc |
| ) |
| set_target_properties(sandbox2_regs_test PROPERTIES |
| OUTPUT_NAME regs_test |
| ) |
| target_link_libraries(sandbox2_regs_test PRIVATE |
| absl::check |
| sapi::config |
| sapi::status_matchers |
| sandbox2::bpf_helper |
| sandbox2::regs |
| sandbox2::sanitizer |
| sandbox2::util |
| sapi::test_main |
| ) |
| gtest_discover_tests_xcompile(sandbox2_regs_test) |
| |
| # sandboxed_api/sandbox2:syscall_test |
| add_executable(sandbox2_syscall_test |
| syscall_test.cc |
| ) |
| set_target_properties(sandbox2_syscall_test PROPERTIES |
| OUTPUT_NAME syscall_test |
| ) |
| target_link_libraries(sandbox2_syscall_test PRIVATE |
| absl::strings |
| sapi::config |
| sandbox2::syscall |
| sapi::test_main |
| ) |
| gtest_discover_tests_xcompile(sandbox2_syscall_test) |
| |
| # sandboxed_api/sandbox2:mounts_test |
| add_executable(sandbox2_mounts_test |
| mounts_test.cc |
| ) |
| set_target_properties(sandbox2_mounts_test PROPERTIES |
| OUTPUT_NAME mounts_test |
| ) |
| add_dependencies(sandbox2_mounts_test |
| sandbox2::testcase_minimal_dynamic |
| ) |
| target_link_libraries(sandbox2_mounts_test PRIVATE |
| absl::strings |
| sapi::file_base |
| sandbox2::mounts |
| sandbox2::mount_tree_proto |
| sapi::temp_file |
| sapi::testing |
| sapi::status_matchers |
| sapi::test_main |
| ) |
| gtest_discover_tests_xcompile(sandbox2_mounts_test PROPERTIES |
| ENVIRONMENT "TEST_TMPDIR=/tmp" |
| ENVIRONMENT "TEST_SRCDIR=${PROJECT_BINARY_DIR}" |
| ) |
| |
| # sandboxed_api/sandbox2:namespace_test |
| add_executable(sandbox2_namespace_test |
| namespace_test.cc |
| ) |
| set_target_properties(sandbox2_namespace_test PROPERTIES |
| OUTPUT_NAME namespace_test |
| ) |
| add_dependencies(sandbox2_namespace_test |
| sandbox2::testcase_namespace |
| ) |
| target_link_libraries(sandbox2_namespace_test PRIVATE |
| absl::strings |
| sandbox2::allow_all_syscalls |
| sandbox2::allow_unrestricted_networking |
| sapi::config |
| sapi::fileops |
| sandbox2::namespace |
| sandbox2::sandbox2 |
| sapi::testing |
| sapi::temp_file |
| sapi::status_matchers |
| sapi::test_main |
| ) |
| gtest_discover_tests_xcompile(sandbox2_namespace_test PROPERTIES |
| ENVIRONMENT "TEST_TMPDIR=/tmp" |
| ENVIRONMENT "TEST_SRCDIR=${PROJECT_BINARY_DIR}" |
| ) |
| |
| # sandboxed_api/sandbox2:buffer_test |
| add_executable(sandbox2_buffer_test |
| buffer_test.cc |
| ) |
| set_target_properties(sandbox2_buffer_test PROPERTIES |
| OUTPUT_NAME buffer_test |
| ) |
| add_dependencies(sandbox2_buffer_test |
| sandbox2::testcase_buffer |
| ) |
| target_link_libraries(sandbox2_buffer_test PRIVATE |
| sandbox2::buffer |
| sandbox2::comms |
| sandbox2::ipc |
| sandbox2::sandbox2 |
| sapi::testing |
| sapi::status_matchers |
| sapi::test_main |
| ) |
| gtest_discover_tests_xcompile(sandbox2_buffer_test PROPERTIES |
| ENVIRONMENT "TEST_SRCDIR=${PROJECT_BINARY_DIR}" |
| ) |
| |
| # sandboxed_api/sandbox2:comms_test_proto |
| sapi_protobuf_generate_cpp( |
| _sandbox2_comms_test_pb_h _sandbox2_comms_test_pb_cc |
| comms_test.proto |
| ) |
| add_library(sandbox2_comms_test_proto ${SAPI_LIB_TYPE} |
| ${_sandbox2_comms_test_pb_cc} |
| ${_sandbox2_comms_test_pb_h} |
| ) |
| add_library(sandbox2::comms_test_proto ALIAS sandbox2_comms_test_proto) |
| target_link_libraries(sandbox2_comms_test_proto |
| PRIVATE sapi::base |
| PUBLIC protobuf::libprotobuf |
| ) |
| |
| # sandboxed_api/sandbox2:comms_test |
| add_executable(sandbox2_comms_test |
| comms_test.cc |
| ) |
| target_link_libraries(sandbox2_comms_test PRIVATE |
| absl::check |
| absl::fixed_array |
| absl::log |
| absl::strings |
| sandbox2::comms |
| sandbox2::comms_test_proto |
| sapi::status_matchers |
| sapi::test_main |
| ) |
| gtest_discover_tests_xcompile(sandbox2_comms_test) |
| |
| # sandboxed_api/sandbox2:forkserver_test |
| add_executable(sandbox2_forkserver_test |
| forkserver_test.cc |
| global_forkclient.h |
| ) |
| set_target_properties(sandbox2_forkserver_test PROPERTIES |
| OUTPUT_NAME forkserver_test |
| ) |
| add_dependencies(sandbox2_forkserver_test |
| sandbox2::testcase_minimal |
| ) |
| target_link_libraries(sandbox2_forkserver_test PRIVATE |
| absl::check |
| absl::log |
| absl::strings |
| sandbox2::forkserver |
| sandbox2::forkserver_proto |
| sandbox2::sandbox2 |
| sapi::raw_logging |
| sapi::testing |
| sapi::test_main |
| ) |
| gtest_discover_tests_xcompile(sandbox2_forkserver_test PROPERTIES |
| ENVIRONMENT "TEST_TMPDIR=/tmp" |
| ENVIRONMENT "TEST_SRCDIR=${PROJECT_BINARY_DIR}" |
| ) |
| |
| # sandboxed_api/sandbox2:limits_test |
| add_executable(sandbox2_limits_test |
| limits_test.cc |
| ) |
| set_target_properties(sandbox2_limits_test PROPERTIES |
| OUTPUT_NAME limits_test |
| ) |
| add_dependencies(sandbox2_limits_test |
| sandbox2::testcase_limits |
| sandbox2::testcase_minimal |
| ) |
| target_link_libraries(sandbox2_limits_test PRIVATE |
| sandbox2::bpf_helper |
| sapi::config |
| sandbox2::limits |
| sandbox2::sandbox2 |
| sapi::testing |
| sapi::status_matchers |
| sapi::test_main |
| ) |
| gtest_discover_tests_xcompile(sandbox2_limits_test PROPERTIES |
| ENVIRONMENT "TEST_TMPDIR=/tmp" |
| ENVIRONMENT "TEST_SRCDIR=${PROJECT_BINARY_DIR}" |
| ) |
| |
| # sandboxed_api/sandbox2:notify_test |
| add_executable(sandbox2_notify_test |
| notify_test.cc |
| ) |
| set_target_properties(sandbox2_notify_test PROPERTIES |
| OUTPUT_NAME notify_test |
| ) |
| add_dependencies(sandbox2_notify_test |
| sandbox2::testcase_personality |
| sandbox2::testcase_pidcomms |
| ) |
| target_link_libraries(sandbox2_notify_test PRIVATE |
| absl::strings |
| sandbox2::bpf_helper |
| sandbox2::comms |
| sandbox2::regs |
| sandbox2::sandbox2 |
| sapi::testing |
| sapi::test_main |
| ) |
| gtest_discover_tests_xcompile(sandbox2_notify_test PROPERTIES |
| ENVIRONMENT "TEST_TMPDIR=/tmp" |
| ENVIRONMENT "TEST_SRCDIR=${PROJECT_BINARY_DIR}" |
| ) |
| |
| # sandboxed_api/sandbox2:policy_test |
| add_executable(sandbox2_policy_test |
| policy_test.cc |
| ) |
| set_target_properties(sandbox2_policy_test PROPERTIES |
| OUTPUT_NAME policy_test |
| ) |
| add_dependencies(sandbox2_policy_test |
| sandbox2::testcase_add_policy_on_syscalls |
| sandbox2::testcase_malloc_system |
| sandbox2::testcase_minimal |
| sandbox2::testcase_minimal_dynamic |
| sandbox2::testcase_policy |
| ) |
| target_link_libraries(sandbox2_policy_test PRIVATE |
| absl::strings |
| sandbox2::bpf_helper |
| sapi::config |
| sandbox2::limits |
| sandbox2::regs |
| sandbox2::sandbox2 |
| sapi::status_matchers |
| sapi::testing |
| sapi::test_main |
| ) |
| gtest_discover_tests_xcompile(sandbox2_policy_test PROPERTIES |
| ENVIRONMENT "TEST_TMPDIR=/tmp" |
| ENVIRONMENT "TEST_SRCDIR=${PROJECT_BINARY_DIR}" |
| ) |
| |
| # sandboxed_api/sandbox2:sandbox2_test |
| add_executable(sandbox2_sandbox2_test |
| sandbox2_test.cc |
| ) |
| set_target_properties(sandbox2_sandbox2_test PROPERTIES |
| OUTPUT_NAME sandbox2_test |
| ) |
| add_dependencies(sandbox2_sandbox2_test |
| sandbox2::testcase_abort |
| sandbox2::testcase_minimal |
| sandbox2::testcase_sleep |
| sandbox2::testcase_tsync |
| ) |
| target_link_libraries(sandbox2_sandbox2_test PRIVATE |
| absl::strings |
| sapi::config |
| sandbox2::sandbox2 |
| sapi::testing |
| sapi::status_matchers |
| sapi::test_main |
| ) |
| gtest_discover_tests_xcompile(sandbox2_sandbox2_test PROPERTIES |
| ENVIRONMENT "TEST_TMPDIR=/tmp" |
| ENVIRONMENT "TEST_SRCDIR=${PROJECT_BINARY_DIR}" |
| ) |
| |
| # sandboxed_api/sandbox2:sanitizer_test |
| add_executable(sandbox2_sanitizer_test |
| sanitizer_test.cc |
| ) |
| set_target_properties(sandbox2_sanitizer_test PROPERTIES |
| OUTPUT_NAME sanitizer_test |
| ) |
| add_dependencies(sandbox2_sanitizer_test |
| sandbox2::testcase_sanitizer |
| sandbox2::testcase_close_fds |
| ) |
| target_link_libraries(sandbox2_sanitizer_test PRIVATE |
| absl::strings |
| sandbox2::bpf_helper |
| sandbox2::client |
| sandbox2::comms |
| sandbox2::sandbox2 |
| sandbox2::sanitizer |
| sapi::testing |
| sandbox2::util |
| sapi::status_matchers |
| sapi::test_main |
| ) |
| gtest_discover_tests_xcompile(sandbox2_sanitizer_test PROPERTIES |
| ENVIRONMENT "TEST_TMPDIR=/tmp" |
| ENVIRONMENT "TEST_SRCDIR=${PROJECT_BINARY_DIR}" |
| ) |
| |
| # sandboxed_api/sandbox2:util_test |
| add_executable(sandbox2_util_test |
| util_test.cc |
| ) |
| set_target_properties(sandbox2_util_test PROPERTIES |
| OUTPUT_NAME util_test |
| ) |
| target_link_libraries(sandbox2_util_test PRIVATE |
| sandbox2::util |
| absl::strings |
| absl::cleanup |
| sapi::status_matchers |
| sapi::test_main |
| ) |
| gtest_discover_tests_xcompile(sandbox2_util_test) |
| |
| # sandboxed_api/sandbox2:stack_trace_test |
| add_executable(sandbox2_stack_trace_test |
| stack_trace_test.cc |
| ) |
| set_target_properties(sandbox2_stack_trace_test PROPERTIES |
| OUTPUT_NAME stack_trace_test |
| ) |
| add_dependencies(sandbox2_stack_trace_test |
| sandbox2::testcase_symbolize |
| ) |
| target_link_libraries(sandbox2_stack_trace_test PRIVATE |
| absl::flags |
| absl::status |
| absl::strings |
| absl::time |
| sandbox2::global_forkserver |
| sandbox2::namespace |
| sandbox2::sandbox2 |
| sandbox2::stack_trace |
| sandbox2::util |
| sapi::fileops |
| sapi::testing |
| sapi::status_matchers |
| sapi::test_main |
| ) |
| gtest_discover_tests_xcompile(sandbox2_stack_trace_test PROPERTIES |
| ENVIRONMENT "TEST_TMPDIR=/tmp" |
| ENVIRONMENT "TEST_SRCDIR=${PROJECT_BINARY_DIR}" |
| ) |
| |
| # sandboxed_api/sandbox2:ipc_test |
| add_executable(sandbox2_ipc_test |
| ipc_test.cc |
| ) |
| set_target_properties(sandbox2_ipc_test PROPERTIES |
| OUTPUT_NAME ipc_test |
| ) |
| add_dependencies(sandbox2_ipc_test |
| sandbox2::testcase_ipc |
| ) |
| target_link_libraries(sandbox2_ipc_test PRIVATE |
| sandbox2::comms |
| sandbox2::ipc |
| sandbox2::sandbox2 |
| sapi::testing |
| sapi::status_matchers |
| sapi::test_main |
| ) |
| gtest_discover_tests_xcompile(sandbox2_ipc_test PROPERTIES |
| ENVIRONMENT "TEST_TMPDIR=/tmp" |
| ENVIRONMENT "TEST_SRCDIR=${PROJECT_BINARY_DIR}" |
| ) |
| |
| # sandboxed_api/sandbox2:policybuilder_test |
| add_executable(sandbox2_policybuilder_test |
| policybuilder_test.cc |
| ) |
| set_target_properties(sandbox2_policybuilder_test PROPERTIES |
| OUTPUT_NAME policybuilder_test |
| ) |
| target_link_libraries(sandbox2_policybuilder_test |
| PRIVATE absl::strings |
| absl::log |
| absl::status |
| absl::statusor |
| sandbox2::bpf_helper |
| sandbox2::policybuilder |
| sapi::testing |
| sapi::status_matchers |
| sapi::test_main |
| ) |
| gtest_discover_tests_xcompile(sandbox2_policybuilder_test PROPERTIES |
| ENVIRONMENT "TEST_TMPDIR=/tmp" |
| ENVIRONMENT "TEST_SRCDIR=${PROJECT_BINARY_DIR}" |
| ) |
| |
| # sandboxed_api/sandbox2:bpfdisassembler_test |
| add_executable(sandbox2_bpfdisassembler_test |
| bpfdisassembler_test.cc |
| ) |
| set_target_properties(sandbox2_bpfdisassembler_test PROPERTIES |
| OUTPUT_NAME bpfdisassembler_test |
| ) |
| target_link_libraries(sandbox2_bpfdisassembler_test |
| PRIVATE sandbox2::bpfdisassembler |
| sandbox2::bpf_helper |
| sapi::test_main |
| ) |
| gtest_discover_tests_xcompile(sandbox2_bpfdisassembler_test PROPERTIES |
| ENVIRONMENT "TEST_TMPDIR=/tmp" |
| ENVIRONMENT "TEST_SRCDIR=${PROJECT_BINARY_DIR}" |
| ) |
| endif() |
| |
| configure_file( |
| "${PROJECT_SOURCE_DIR}/cmake/sandbox2.pc.in" |
| "${PROJECT_BINARY_DIR}/sandbox2.pc" |
| @ONLY |
| ) |
| |
| install(FILES "${PROJECT_BINARY_DIR}/sandbox2.pc" |
| DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig") |