Struct SubmissionParams 

pub struct SubmissionParams {

    pub classification: ClassificationString,
    pub deep_scan: bool,
    pub description: Option<Text>,
    pub generate_alert: bool,
    pub groups: Vec<UpperString>,
    pub ignore_cache: bool,
    pub ignore_recursion_prevention: bool,
    pub ignore_filtering: bool,
    pub ignore_size: bool,
    pub never_drop: bool,
    pub malicious: bool,
    pub max_extracted: i32,
    pub max_supplementary: i32,
    pub priority: u16,
    pub quota_item: bool,
    pub services: ServiceSelection,
    pub service_spec: HashMap<String, JsonMap>,
    pub submitter: String,
    pub trace: bool,
    pub ttl: i32,
    pub submission_type: String,
    pub initial_data: Option<Text>,
    pub auto_archive: bool,
    pub delete_after_archive: bool,
    pub psid: Option<Sid>,
    pub use_archive_alternate_dtl: bool,
}

Submission Parameters

Fields

classification: ClassificationString

classification of the submission

deep_scan: bool

Should a deep scan be performed?

description: Option<Text>

Description of the submission

generate_alert: bool

Should this submission generate an alert?

groups: Vec<UpperString>

List of groups related to this scan

ignore_cache: bool

Ignore the cached service results?

ignore_recursion_prevention: bool

Should we ignore dynamic recursion prevention?

ignore_filtering: bool

Should we ignore filtering services?

ignore_size: bool

Ignore the file size limits?

never_drop: bool

Exempt from being dropped by ingester?

malicious: bool

Is the file submitted already known to be malicious?

max_extracted: i32

Max number of extracted files

max_supplementary: i32

Max number of supplementary files

priority: u16

Priority of the scan

quota_item: bool

Does this submission count against quota?

services: ServiceSelection

Service selection

service_spec: HashMap<String, JsonMap>

Service-specific parameters

submitter: String

User who submitted the file

trace: bool

Collect extra logging information during dispatching

ttl: i32

Time, in days, to live for this submission

submission_type: String

Type of submission

initial_data: Option<Text>

Initialization for temporary submission data

auto_archive: bool

Does the submission automatically goes into the archive when completed?

delete_after_archive: bool

When the submission is archived, should we delete it from hot storage right away?

psid: Option<Sid>

Parent submission ID

use_archive_alternate_dtl: bool

Should we use the alternate dtl while archiving?

Implementations

impl SubmissionParams

pub fn new(classification: ClassificationString) -> Self

pub fn set_description(self, text: &str) -> Self

pub fn set_services_selected(self, selected: &[&str]) -> Self

pub fn set_submitter(self, submitter: &str) -> Self

pub fn set_groups(self, groups: &[&str]) -> Self

pub fn set_max_extracted(self, max_extracted: i32) -> Self

pub fn set_generate_alert(self, alert: bool) -> Self

pub fn create_filescore_key( &self, sha256: &Sha256, services: Option<Vec<String>>, ) -> String

This is the key used to store the final score of a submission for fast lookup.

This lookup is one of the methods used to check for duplication in ingestion process, so this key is fairly sensitive.

Trait Implementations

impl Clone for SubmissionParams

fn clone(&self) -> SubmissionParams

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SubmissionParams

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Described<ElasticMeta> for SubmissionParams

fn metadata() -> Descriptor<ElasticMeta>

Get self description of this type

impl<'de> Deserialize<'de> for SubmissionParams

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SubmissionParams

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.