Module Checkers__SiofTrace

include Absint.SinkTrace.S with type Sink.Kind.t = IR.Pvar.t
include Absint.TaintTrace.S
include Absint.TaintTrace.Spec
val get_report : Source.t -> Sink.t -> Sanitizer.t list -> IBase.IssueType.t option

return Some(issue) a trace from source to sink passing through the given sanitizers should be reported, None otherwise

bottom = this trace has no source or sink data

include Absint.AbstractDomain.WithBottom
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

module Sources : sig ... end
module Sinks = Sink.Set
module Passthroughs = Absint.Passthrough.Set
type path = Passthroughs.t * (Source.t * Passthroughs.t) list * (Sink.t * Passthroughs.t) list

path from a source to a sink with passthroughs at each step in the call stack. the first set of passthroughs are the ones in the "reporting" procedure that calls the first function in both the source and sink stack

type report = {
issue : IBase.IssueType.t;
path_source : Source.t;
path_sink : Sink.t;
path_passthroughs : Passthroughs.t;
}
val sources : t -> Sources.t

get the sources of the trace.

val sinks : t -> Sinks.t

get the sinks of the trace

val passthroughs : t -> Passthroughs.t

get the passthroughs of the trace

val get_reports : ?⁠cur_site:Absint.CallSite.t -> t -> report list

get the reportable source-sink flows in this trace. specifying cur_site restricts the reported paths to ones introduced by the call at cur_site

val get_reportable_paths : ?⁠cur_site:Absint.CallSite.t -> t -> trace_of_pname:(IR.Procname.t -> t) -> path list

get a path for each of the reportable source -> sink flows in this trace. specifying cur_site restricts the reported paths to ones introduced by the call at cur_site

val to_loc_trace : ?⁠desc_of_source:(Source.t -> string) -> ?⁠source_should_nest:(Source.t -> bool) -> ?⁠desc_of_sink:(Sink.t -> string) -> ?⁠sink_should_nest:(Sink.t -> bool) -> path -> Absint.Errlog.loc_trace

create a loc_trace from a path; source_should_nest s should be true when we are going one deeper into a call-chain, ie when lt_level should be bumper in the next loc_trace_elem, and similarly for sink_should_nest

val of_source : Source.t -> t

create a trace from a source

val of_footprint : Absint.AccessPath.Abs.t -> t

create a trace from a footprint access path

val add_source : Source.t -> t -> t

add a source to the current trace

val add_sink : Sink.t -> t -> t

add a sink to the current trace.

val add_sanitizer : Sanitizer.t -> t -> t

add a sanitizer to the current trace

val update_sources : t -> Sources.t -> t
val update_sinks : t -> Sinks.t -> t

replace sinks with new ones

val get_footprint_indexes : t -> IStdlib.IntSet.t

get the footprint indexes for all of the sources in the trace

val append : t -> t -> Absint.CallSite.t -> t

append the trace for given call site to the current caller trace

val pp : Absint.TaintTrace.F.formatter -> t -> unit
val pp_path : IR.Procname.t -> Absint.TaintTrace.F.formatter -> path -> unit

pretty-print a path in the context of the given procname

type sink_path = Absint.Passthrough.Set.t * (Sink.t * Absint.Passthrough.Set.t) list

A path from some procedure via the given passthroughs to the given call stack, with passthroughs for each callee

val get_reportable_sink_paths : t -> trace_of_pname:(IR.Procname.t -> t) -> sink_path list

get a path for each of the reportable flows to a sink in this trace

val get_reportable_sink_path : Sink.t -> trace_of_pname:(IR.Procname.t -> t) -> sink_path option

get a report for a single sink

val with_callsite : t -> Absint.CallSite.t -> t

update sink with the given call site

val of_sink : Sink.t -> t
val to_sink_loc_trace : ?⁠desc_of_sink:(Sink.t -> string) -> ?⁠sink_should_nest:(Sink.t -> bool) -> sink_path -> Absint.Errlog.loc_trace_elem list
module GlobalVar : IStdlib.PrettyPrintable.PrintableOrderedType with type PrintableOrderedType.t = IR.Pvar.t
module GlobalVarSet : IStdlib.PrettyPrintable.PPSet with type PPSet.elt = IR.Pvar.t
val make_access : IR.Pvar.t -> IBase.Location.t -> Sink.t
val trace_of_error : IBase.Location.t -> string -> sink_path -> Absint.Errlog.loc_trace_elem list