doca_apsh.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES, ALL RIGHTS RESERVED.
 *
 * This software product is a proprietary product of NVIDIA CORPORATION &
 * AFFILIATES (the "Company") and all right, title, and interest in and to the
 * software product, including all associated intellectual property rights, are
 * and shall remain exclusively with the Company.
 *
 * This software product is governed by the End User License Agreement
 * provided with the software product.
 *
 */
 
#ifndef _DOCA_APSH__H_
#define _DOCA_APSH__H_
 
#include <stdint.h>
 
#include <doca_compat.h>
#include <doca_error.h>
#include <doca_apsh_attr.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/**********************************************************************************************************************
 * DOCA core opaque types
 *********************************************************************************************************************/
 
struct doca_dev;
 
struct doca_apsh_ctx;
 
struct doca_apsh_system;
 
struct doca_apsh_module;
 
struct doca_apsh_process;
 
struct doca_apsh_thread;
 
struct doca_apsh_lib;
 
struct doca_apsh_vad;
 
struct doca_apsh_attestation;
 
struct doca_apsh_privilege;
 
struct doca_apsh_envar;
 
struct doca_apsh_ldrmodule;
 
struct doca_apsh_handle;
 
struct doca_apsh_process_parameters;
 
struct doca_apsh_sid;
 
struct doca_apsh_netscan;
 
struct doca_apsh_interface;
 
struct doca_apsh_yara;
 
struct doca_apsh_injection_detect;
 
struct doca_apsh_container;
 
struct doca_apsh_proc_file_details;
 
DOCA_EXPERIMENTAL
struct doca_apsh_ctx *doca_apsh_create(void);
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_start(struct doca_apsh_ctx *ctx);
 
DOCA_EXPERIMENTAL
void doca_apsh_destroy(struct doca_apsh_ctx *ctx);
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_dma_dev_set(struct doca_apsh_ctx *ctx, struct doca_dev *dma_dev);
 
DOCA_EXPERIMENTAL
struct doca_apsh_system *doca_apsh_system_create(struct doca_apsh_ctx *ctx);
 
DOCA_EXPERIMENTAL
void doca_apsh_system_destroy(struct doca_apsh_system *system);
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_system_start(struct doca_apsh_system *system);
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_sys_os_symbol_map_set(struct doca_apsh_system *system, const char *system_os_symbol_map_path);
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_sys_os_symbol_map_folder_set(struct doca_apsh_system *system,
                            const char *system_os_symbol_folder_path);
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_sys_mem_region_set(struct doca_apsh_system *system, const char *system_mem_region_path);
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_sys_dev_set(struct doca_apsh_system *system, struct doca_dev_rep *dev);
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_sys_os_type_set(struct doca_apsh_system *system, enum doca_apsh_system_os os_type);
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_sys_kpgd_file_set(struct doca_apsh_system *system, const char *system_kpgd_file_path);
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_sys_set_scan_window_size(struct doca_apsh_system *system, uint32_t scan_window_size);
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_sys_set_scan_window_step(struct doca_apsh_system *system, uint32_t scan_window_step);
 
DOCA_EXPERIMENTAL
doca_error_t __doca_apsh_sys_config(struct doca_apsh_system *system,
                    enum doca_apsh_system_config_attr attr,
                    void *value);
 
#define doca_apsh_sys_config(system, attr, value) (__doca_apsh_sys_config(system, attr, (void *)((uintptr_t)value)))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_modules_get(struct doca_apsh_system *system,
                   struct doca_apsh_module ***modules,
                   int *modules_size);
 
DOCA_EXPERIMENTAL
void doca_apsh_module_free(struct doca_apsh_module **modules);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_module_info_get(struct doca_apsh_module *module, enum doca_apsh_module_attr attr);
 
#define doca_apsh_module_info_get(module, attr) ((attr##_TYPE)(uintptr_t)__doca_apsh_module_info_get(module, attr))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_processes_get(struct doca_apsh_system *system,
                     struct doca_apsh_process ***processes,
                     int *processes_size);
 
DOCA_EXPERIMENTAL
void doca_apsh_processes_free(struct doca_apsh_process **processes);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_process_info_get(struct doca_apsh_process *process, enum doca_apsh_process_attr attr);
 
#define doca_apsh_process_info_get(process, attr) ((attr##_TYPE)(uintptr_t)__doca_apsh_process_info_get(process, attr))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_libs_get(struct doca_apsh_process *process, struct doca_apsh_lib ***libs, int *libs_size);
 
DOCA_EXPERIMENTAL
void doca_apsh_libs_free(struct doca_apsh_lib **libs);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_lib_info_get(struct doca_apsh_lib *lib, enum doca_apsh_lib_attr attr);
 
#define doca_apsh_lib_info_get(lib, attr) ((attr##_TYPE)(uintptr_t)__doca_apsh_lib_info_get(lib, attr))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_threads_get(struct doca_apsh_process *process,
                   struct doca_apsh_thread ***threads,
                   int *threads_size);
 
DOCA_EXPERIMENTAL
void doca_apsh_threads_free(struct doca_apsh_thread **threads);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_thread_info_get(struct doca_apsh_thread *thread, enum doca_apsh_thread_attr attr);
 
#define doca_apsh_thread_info_get(thread, attr) ((attr##_TYPE)(uintptr_t)__doca_apsh_thread_info_get(thread, attr))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_vads_get(struct doca_apsh_process *process, struct doca_apsh_vad ***vads, int *vads_size);
 
DOCA_EXPERIMENTAL
void doca_apsh_vads_free(struct doca_apsh_vad **vads);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_vad_info_get(struct doca_apsh_vad *vad, enum doca_apsh_vad_attr attr);
 
#define doca_apsh_vad_info_get(vad, attr) ((attr##_TYPE)(uintptr_t)__doca_apsh_vad_info_get(vad, attr))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_attestation_get(struct doca_apsh_process *process,
                       const char *exec_hash_map_path,
                       struct doca_apsh_attestation ***attestation,
                       int *attestation_size);
 
DOCA_EXPERIMENTAL
void doca_apsh_attestation_free(struct doca_apsh_attestation **attestation);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_attst_info_get(struct doca_apsh_attestation *attestation, enum doca_apsh_attestation_attr attr);
 
#define doca_apsh_attst_info_get(attestation, attr) \
    ((attr##_TYPE)(uintptr_t)__doca_apsh_attst_info_get(attestation, attr))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_attst_refresh(struct doca_apsh_attestation ***attestation, int *attestation_size);
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_privileges_get(struct doca_apsh_process *process,
                      struct doca_apsh_privilege ***privileges,
                      int *privileges_size);
 
DOCA_EXPERIMENTAL
void doca_apsh_privileges_free(struct doca_apsh_privilege **privileges);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_privilege_info_get(struct doca_apsh_privilege *privilege, enum doca_apsh_privilege_attr attr);
 
#define doca_apsh_privilege_info_get(privilege, attr) \
    ((attr##_TYPE)(uintptr_t)__doca_apsh_privilege_info_get(privilege, attr))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_envars_get(struct doca_apsh_process *process,
                  struct doca_apsh_envar ***envars,
                  int *envars_size);
 
DOCA_EXPERIMENTAL
void doca_apsh_envars_free(struct doca_apsh_envar **envars);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_envar_info_get(struct doca_apsh_envar *envar, enum doca_apsh_envar_attr attr);
 
#define doca_apsh_envar_info_get(envar, attr) ((attr##_TYPE)(uintptr_t)__doca_apsh_envar_info_get(envar, attr))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_ldrmodules_get(struct doca_apsh_process *process,
                      struct doca_apsh_ldrmodule ***ldrmodules,
                      int *ldrmodules_size);
 
DOCA_EXPERIMENTAL
void doca_apsh_ldrmodules_free(struct doca_apsh_ldrmodule **ldrmodules);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_ldrmodule_info_get(struct doca_apsh_ldrmodule *ldrmodule, enum doca_apsh_ldrmodule_attr attr);
 
#define doca_apsh_ldrmodule_info_get(ldrmodule, attr) \
    ((attr##_TYPE)(uintptr_t)__doca_apsh_ldrmodule_info_get(ldrmodule, attr))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_handles_get(struct doca_apsh_process *process,
                   struct doca_apsh_handle ***handles,
                   int *handles_size);
 
DOCA_EXPERIMENTAL
void doca_apsh_handles_free(struct doca_apsh_handle **handles);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_handle_info_get(struct doca_apsh_handle *handle, enum doca_apsh_handle_attr attr);
 
#define doca_apsh_handle_info_get(handle, attr) ((attr##_TYPE)(uintptr_t)__doca_apsh_handle_info_get(handle, attr))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_process_parameters_get(struct doca_apsh_process *process,
                          struct doca_apsh_process_parameters **process_parameters);
 
DOCA_EXPERIMENTAL
void doca_apsh_process_parameters_free(struct doca_apsh_process_parameters *process_parameters);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_process_parameters_info_get(struct doca_apsh_process_parameters *process_parameters,
                            enum doca_apsh_process_parameters_attr attr);
 
#define doca_apsh_process_parameters_info_get(process_parameters, attr) \
    ((attr##_TYPE)(uintptr_t)__doca_apsh_process_parameters_info_get(process_parameters, attr))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_sids_get(struct doca_apsh_process *process, struct doca_apsh_sid ***sids, int *sids_size);
 
DOCA_EXPERIMENTAL
void doca_apsh_sids_free(struct doca_apsh_sid **sids);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_sid_info_get(struct doca_apsh_sid *sid, enum doca_apsh_sid_attr attr);
 
#define doca_apsh_sid_info_get(sid, attr) ((attr##_TYPE)(uintptr_t)__doca_apsh_sid_info_get(sid, attr))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_netscan_get(struct doca_apsh_system *system,
                   struct doca_apsh_netscan ***connections,
                   int *connections_size);
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_process_netscan_get(struct doca_apsh_process *process,
                       struct doca_apsh_netscan ***connections,
                       int *connections_size);
 
DOCA_EXPERIMENTAL
void doca_apsh_netscan_free(struct doca_apsh_netscan **connections);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_netscan_info_get(struct doca_apsh_netscan *connection, enum doca_apsh_netscan_attr attr);
 
#define doca_apsh_netscan_info_get(connection, attr) \
    ((attr##_TYPE)(uintptr_t)__doca_apsh_netscan_info_get(connection, attr))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_interfaces_get(struct doca_apsh_system *system,
                      struct doca_apsh_interface ***interfaces,
                      int *interfaces_size);
 
DOCA_EXPERIMENTAL
void doca_apsh_interfaces_free(struct doca_apsh_interface **interfaces);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_interface_info_get(struct doca_apsh_interface *interface, enum doca_apsh_interface_attr attr);
 
#define doca_apsh_interface_info_get(interface, attr) \
    ((attr##_TYPE)(uintptr_t)__doca_apsh_interface_info_get(interface, attr))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_yara_get(struct doca_apsh_process *process,
                enum doca_apsh_yara_rule *yara_rules_arr,
                uint32_t yara_rules_arr_size,
                uint64_t scan_type,
                struct doca_apsh_yara ***yara_matches,
                int *yara_matches_size);
 
DOCA_EXPERIMENTAL
void doca_apsh_yara_free(struct doca_apsh_yara **yara_matches);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_yara_info_get(struct doca_apsh_yara *yara, enum doca_apsh_yara_attr attr);
 
#define doca_apsh_yara_info_get(yara, attr) ((attr##_TYPE)(uintptr_t)__doca_apsh_yara_info_get(yara, attr))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_injection_detect_get(struct doca_apsh_process *process,
                        struct doca_apsh_injection_detect ***suspected_injections,
                        int *suspected_injections_size);
 
DOCA_EXPERIMENTAL
void doca_apsh_injection_detect_free(struct doca_apsh_injection_detect **suspected_injections);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_injection_detect_info_get(struct doca_apsh_injection_detect *suspected_injection,
                          enum doca_apsh_injection_detect_attr attr);
 
#define doca_apsh_injection_detect_info_get(suspected_injection, attr) \
    ((attr##_TYPE)(uintptr_t)__doca_apsh_injection_detect_info_get(suspected_injection, attr))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_containers_get(struct doca_apsh_system *system,
                      struct doca_apsh_container ***containers,
                      int *containers_size);
 
DOCA_EXPERIMENTAL
void doca_apsh_containers_free(struct doca_apsh_container **containers);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_container_info_get(struct doca_apsh_container *container, enum doca_apsh_container_attr attr);
 
#define doca_apsh_container_info_get(container, attr) \
    ((attr##_TYPE)(uintptr_t)__doca_apsh_container_info_get(container, attr))
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_container_processes_get(struct doca_apsh_container *container,
                           struct doca_apsh_process ***processes,
                           int *processes_size);
 
DOCA_EXPERIMENTAL
doca_error_t doca_apsh_proc_files_details_get(struct doca_apsh_process *process,
                          struct doca_apsh_proc_file_details ***files_details,
                          int *files_details_size);
 
DOCA_EXPERIMENTAL
void doca_apsh_proc_files_details_free(struct doca_apsh_proc_file_details **files_details);
 
DOCA_EXPERIMENTAL
const void *__doca_apsh_proc_file_details_info_get(struct doca_apsh_proc_file_details *file_details,
                           enum doca_apsh_proc_file_details_attr attr);
 
#define doca_apsh_proc_file_details_info_get(file_details, attr) \
    ((attr##_TYPE)(uintptr_t)__doca_apsh_proc_file_details_info_get(file_details, attr))
 
#ifdef __cplusplus
}
#endif
 
#endif