nsmcp::AccessDiagnosticTool method options (protected)

 <instance of nsmcp::AccessDiagnosticTool> options arguments

Defined in /usr/local/ns/tcl/nsmcp/traffic-tools.tcl

Parameters:

arguments (required)

Testcases:

No testcase defined.

Source code:

if {[lindex $arguments 1] ne "object"} {
    error "Expected an arguments object"
}
set options {lastMinutes 60 limit 20 pool bots module nslog includePeerAddresses false category {} scanStrategy window aggregateTraffic false}
dict set options mode [expr {${:operation} eq "bot" ? ${:defaultMode} : "page"}]
set seen {}
foreach {key type value} [lindex $arguments 2] {
    if {$key in $seen} {
        error "Duplicate argument: $key"
    }
    lappend seen $key
    switch -- $key {
        lastMinutes -
        limit -
        beforeOffset -
        sourceBytes {
            if {$type ne "number" || ![string is entier -strict $value] || $value<0} {
                error "Invalid $key"
            }
            if {$key eq "lastMinutes" && ($value<1 || $value>1440)} {
                error "lastMinutes must be 1..1440"
            }
            if {$key eq "limit" && ($value<1 || $value>100)} {
                error "limit must be 1..100"
            }
        }
        from -
        to {
            if {$type ne "number" || ![string is double -strict $value] || $value<0 || $value>[clock seconds]} {
                error "Invalid $key"
            }
        }
        pool -
        module {
            if {$type ne "string" || ![regexp {^[A-Za-z0-9_.-]+$} $value]} {
                error "Invalid $key"
            }
        }
        mode {
            if {$type ne "string" || $value ni {scan page} || (${:operation} ne "bot" && $value ne "page")} {
                error "Invalid diagnostic mode"
            }
        }
        scanStrategy {
            if {$type ne "string" || $value ni {window full}} {
                error "Invalid scanStrategy"
            }
        }
        category {
            if {${:operation} ne "bot" || $type ne "string" || $value ni {
                matching-rule-in-target matching-rule-other-pool-candidate
                bot-like-unmatched-heuristic no-target-rule-match unknown
                native-target-in-target native-target-other-pool-candidate
                bot-like-routed-elsewhere-heuristic native-other-pool
            }} {
                error "Invalid routing category"
            }
        }
        sourceIdentity -
        mappingIdentity {
            if {$type ne "string" || ![regexp {^[a-f0-9]{64}$} $value]} {
                error "Invalid $key"
            }
        }
        authenticationState {
            if {$type ne "string" || $value ni {anonymous authenticated unknown}} {
                error "Invalid authenticationState"
            }
        }
        path {
            if {$type ne "string" || ![string match /* $value] || [string length $value]>2048 || [string first ? $value]>=0 || [string first \x00 $value]>=0} {
                error "Expected exact queryless path"
            }
        }
        aggregateTraffic -
        includePeerAddresses {
            if {$type ne "boolean"} {
                error "Expected a boolean"
            }
        }
        default {
            error "Unknown argument: $key"
        }
    }
    dict set options $key $value
}
if {[dict exists $options from] != [dict exists $options to]} {
    error "Specify both from and to"
}
if {[dict exists $options from]} {
    if {"lastMinutes" in $seen || [dict get $options to]<=[dict get $options from] || [dict get $options to]-[dict get $options from]>86400} {
        error "Invalid or conflicting time selectors"
    }
} else {
    dict set options to [clock seconds]
    dict set options from [expr {[dict get $options to]-60*[dict get $options lastMinutes]}]
}
set paging 0
foreach key {beforeOffset sourceBytes sourceIdentity} {
    incr paging [dict exists $options $key]
}
if {$paging ni {0 3}} {
    error "Paging requires beforeOffset, sourceBytes and sourceIdentity"
}
if {$paging && [dict get $options beforeOffset]>[dict get $options sourceBytes]} {
    error "Invalid cursor"
}
return $options

XQL Not present:

Generic, PostgreSQL, Oracle