;; ! THIS FILE CONTAINS AN INITIALIZATION SCHEME FOR CONFIG READER
;; ! PLEASE DO NOT MODIFY THIS FILE

(version 1000)

(serializator "logdaemon"
    (define "fast" 3u ["compress/rate"])
    (define "best" 7u ["compress/rate"])
    (define "without" 0u ["compress/rate"])

    (define "ban" 0u ["acl"])
    (define "unban" 1u ["acl"])
    (define "reload" 2u ["acl"])
    (define "load" 3u ["acl"])
    (define "lookup" 4u ["acl"])
    (define "status" 5u ["acl"])
    
    (define "sha1" "SCRAM-SHA-1" ["password"])
    (define "sha256" "SCRAM-SHA-256" ["password"])
    (define "sha512" "SCRAM-SHA-512" ["password"])
    
    ;; ---- Scheme declaration
    
    ;; --- GLOBAL
    (procedure "search/window"
        (arg "l_searchwindow" (int))
    )
    
    (procedure "retry"
        (arg "l_retry" (uint))
    )
    
    (procedure "score"
        (arg "l_score" (uint))
    )
    
    (procedure "bantime" 
        (arg "l_bantime" (int))
    )
    
    (procedure "ignore/hosts"
        (arg "l_ignore_hosts" (vector (string)))
    )
    
    (procedure "ignore/users"
        (arg "l_ignore_users" (vector (string)))
    )
    
    (procedure "global"
        (proc "lp_searchwindow" ["search/window"])
        (proc "lp_retry" ["retry"])
        (proc "lp_score" ["score"])
        (proc "lp_bantime" ["bantime"])
        (proc "lp_ignore_hosts" ["ignore/hosts"])
        (proc "lp_ignore_users" ["ignore/users"])
    )
    
    ;; --- JAIL
    
    (procedure "pwuser"
        (arg "l_pwuser" (string))
    )
    
    (procedure "chroot"
        (arg "l_chroot" (boolean))
    )
    (procedure "capsicum"
        (arg "l_capsicum" (boolean))
    )
    (procedure "signalguard"
        (arg "l_signalguard" (uint))
    )
    
    (procedure "jail"
        (proc "lp_pwuser" ["pwuser"] (proc-allow [optional]))
        (proc "lp_chroot" ["chroot"])
        (proc "lp_capsicum" ["capsicum"] (proc-allow [optional]))
        (proc "lp_signalguard" ["signalguard"])
    )

    ;; --- ACTION

    (procedure "threads/worker"
        (arg "l_threads_worker" (uint))
    )

    (procedure "threads/blocking"
        (arg "l_threads_blocking" (uint))
    )

    (procedure "parallel-actions"
        (arg "l_parallel_actions" (uint))
    )

    (procedure "action"
        (proc "lp_threads_worker" ["threads/worker"])
        (proc "lp_threads_blocking" ["threads/blocking"] (proc-allow [optional]))
        (proc "lp_parallel_actions" ["parallel-actions"] (proc-allow [optional]))
    )

    
    ;; --- CONTROL
    
    (procedure "unix"
        (arg "l_source" (string))
        (arg "l_mod" (uint))
    )
    
    (procedure "tcp"
        (arg "l_source" (string))
        (arg "l_mod" (uint))
    )
    
    (procedure "limit-requests"
        (arg "l_limit_req" (uint))
    )
    
    (procedure "timeout-read"
        (arg "l_tm_rd" (uint))
    )
    
    (procedure "password"
        (arg "l_sha" (symbol (string)))
        (arg "l_b64_salted_passwd" (string))
        (arg "l_b64_salt" (string))
        (arg "l_iterations" (uint))
    )
    
    (procedure "log"
        (arg "l_log" (boolean))
    )

    (procedure "force-acl"
        (arg "l_force_acl" (boolean))
    )
    
    (procedure "path"
        (arg "l_path" (string))
    )

    (procedure "name"
        (arg "l_name" (string))
    )
    
    (procedure "cidr"
        (arg "l_cidr" (string))
    )
    
    (procedure "acl"
        (arg "l_title" (string))
        (arg "l_caps" (vector (symbol (uint))))
        (proc "lp_ent_source" ["cidr" "path"])
        (proc "lp_limit_req" ["limit-requests"])
    )
 
    (procedure "control"
        (arg "l_ctrl_flag" (boolean))
        (proc "lp_socket" ["unix" "tcp"])
        (proc "lp_limit_req" ["limit-requests"])
        (proc "lp_rd_tm" ["timeout-read"])
        (proc "lp_name" ["name"])
        (proc "lp_password" ["password"] (proc-allow [optional]))
        (proc "lp_force_acl" ["force-acl"])
        (proc "lp_log" ["log"])
        (proc "lp_acl" ["acl"] (proc-allow [optional collection]))
    )

    ;;; ---- SOCKTHREAD
    
    (procedure "threads"
        (arg "l_threads" (uint))
    )
    
    (procedure "sockthread"
        (proc "lp_threads" ["threads"])
    )
    
    ;;; --- ENTITY-WORKER
    
    (procedure "limit/treesize"
        (arg "l_lim" (uint))
    )
    
    (procedure "logging"
        (arg "l_logging" (vector (string)))
    )
    
    ;;;; -- DB
    (procedure "rotate" (arg "l_rotate" (uint)))
    (procedure "compress" (arg "l_compress" (boolean)))
    
    (procedure "none" (procedure_empty))
    
    (procedure "file"
        (proc "lp_dir_path" ["path"])
        (proc "lp_rotate" ["rotate"] (proc-allow [optional]))
        (proc "lp_compress" ["compress"])
    )
    
    (procedure "sqlite"
        (proc "lp_sqlite_dir_path" ["path"])
    )
    
    (procedure "network"
        (arg "l_addr" (string))
        (arg "l_port" (uint))
    )
    
    (procedure "local"
        (arg "l_path" (string))
    )
    
    (procedure "db/name" (arg "l_dbname" (string)))
    (procedure "db/username" (arg "l_username" (string)))
    (procedure "db/password" (arg "l_password" (string)))
    (procedure "compress/rate" (arg "l_comp_rate" (symbol (uint))))
    
    (procedure "pkcs12"
        (arg "l_cert_path" (string))
        (arg "l_cert_pass" (string))
    )
    
    (procedure "rootca" (arg "l_rootca" (string)))
    (procedure "accept_inv_certs" (arg "l_acpt" (boolean)))
    (procedure "skip_dom_validation" (arg "l_skip" (boolean)))
    
    (procedure "usessl"
        (proc "lp_pkcs12" ["pkcs12"] (proc-allow [optional]))
        (proc "lp_rootca" ["rootca"] (proc-allow [optional]))
        (proc "lp_acpt" ["accept_inv_certs"])
        (proc "lp_skip" ["skip_dom_validation"])
    )
    
    (procedure "mysql"
        (proc "lp_dest" ["network" "local"])
        (proc "lp_dbname" ["db/name"])
        (proc "lp_username" ["db/username"])
        (proc "lp_password" ["db/password"] (proc-allow [optional]))
        (proc "lp_comp_rate" ["compress/rate"] (proc-allow [optional]))
        (proc "lp_usessl" ["usessl"] (proc-allow [optional]))
    )

    (enum "DestinationType" ["network" "local"]
        (enum-opt-struct "network" "Network"
            (enum-opt-fields
                (field "addr" (f/string ["l_addr"]))
                (field "port" (f/uint16 ["l_port"]))
            )
        )
        (enum-opt-struct "local" "Local"
            (enum-opt-fields
                (field "path" (f/string ["l_path"]))
                (field "chmod" (f/uint16 ["l_mod"]))
            )
        )
    )
    
    (procedure "database"
        (proc "lp_db" ["none" "file" "sqlite" "mysql"])
    )
    
    (procedure "entity-worker"
        (proc "lpa_lim" ["limit/treesize"])
        (proc "lpa_logging" ["logging"] (proc-allow [optional]))
        (proc "lpa_database" ["database"])
    )
    

    
    ;;; ---- PARSER
    
    ;; -- (threads) from LOGFETCH
    
    ;; -- (logging) from ACCESSMAN
    
    ;; -- (database) from ACCESSMAN
    
    (procedure "parser"
        (proc "lpa_logging" ["logging"] (proc-allow [optional]))
        (proc "lpa_database" ["database"])
    )
    
    (rootprocedure
        (proc "lpm_global" ["global"])
        (proc "lpm_jail" ["jail"])
        (proc "lpm_action" ["action"])
        (proc "lpm_control" ["control"])
        (proc "lpm_ent_worker" ["entity-worker"])
        (proc "lpm_sockthread" ["sockthread"])
        (proc "lpm_parser" ["parser"])
    )
    
    ;; ---- Serialization logic -----
    
    (enum "SocketType" ["unix" "tcp"]
        (enum-opt-struct "unix" "Unix"
            (enum-opt-fields
                (field "path" (f/string ["l_source"]))
                (field "chmod"  (f/uint16 ["l_mod"]))
            )
        )
        (enum-opt-struct "tcp" "Tcp"
            (enum-opt-fields
                (field "addr" (f/string ["l_source"]))
                (field "port" (f/uint16 ["l_mod"]))
            )
        )
    )
    
    (enum "LdAclEntity" ["cidr" "path"]
        (enum-opt-tuple "cidr" "Cidr"
            (enum-opt-fields (field "cidr" (f/string ["l_cidr"])))
        )
        (enum-opt-tuple "path" "Lfs"
            (enum-opt-fields (field "path" (f/string ["l_path"])))
        )
    )
    
    (enum "Database" ["none" "file" "sqlite" "mysql"]
        (enum-opt-empty "none" "None")
        
        (enum-opt-struct "file" "File"
            (enum-opt-fields
                (field "dir_path" (f/string ["lp_dir_path" "l_path"]))
                (field "rotate_size" (f/optional (f/uint64 ["lp_rotate" "l_rotate"])))
                (field "compress" (f/optional (f/boolean ["lp_compress" "l_compress"])))
            )
        )
        
        (enum-opt-struct "sqlite" "Sqlite"
            (enum-opt-fields
                (field "dir_path" (f/string ["lp_sqlite_dir_path"  "l_path"]))
            )
        )
        
        (enum-opt-struct "mysql" "Mysql"
            (enum-opt-fields
                (field "dest" (f/enum ["lp_dest"]))
                (field "dbname" (f/string ["lp_dbname" "l_dbname"]))
                (field "username" (f/string ["lp_username" "l_username"]))
                (field "password" (f/optional (f/string ["lp_password" "l_password"])))
                (field "compr" (f/optional (f/uint64 ["lp_comp_rate" "l_comp_rate"])))
                (field "ssl" (f/optional (f/struct ["lp_usessl"])))
            )
        )
        
    )
    
    (struct "MysqlSslPkcs" "pkcs12"
        (field "path_to_cert" (f/string ["l_cert_path"]))
        (field "password" (f/string ["l_cert_pass"]))
    )
    
    (struct "MysqlSsl" "usessl"
        (field "pkcs12" (f/optional (f/struct ["lp_pkcs12"])))
        (field "path_to_ca" (f/optional (f/string ["lp_rootca"] )))
        (field "accpet_inv_certs" (f/boolean ["lp_acpt" "l_acpt"]))
        (field "skip_dom_validation" (f/boolean ["lp_skip" "l_skip"]))
    )
    
    (struct "LdCtrlAcl" "acl"
        (field "aclname" (f/string ["l_title"]))
        (field "caplist" (f/vector (f/uint16 ["l_caps"] )))
        (field "entity" (f/enum ["lp_ent_source"]))
        (field "limit" (f/uint64 ["lp_limit_req" "l_limit_req"]))
    )
    
    (struct "LdCtrlPassword" "password"
        (field "shatype" (f/string ["l_sha"]))
        (field "salted_password_b64" (f/string ["l_b64_salted_passwd"]))
        (field "salt_b64" (f/string ["l_b64_salt"]))
        (field "iterations" (f/uint16 ["l_iterations"]))
    )
    
    (struct "LdGlobal" "global"
        (field "searchwin" (f/int64 ["lp_searchwindow" "l_searchwindow"]))
        (field "retrycnt" (f/uint64 ["lp_retry" "l_retry"]))
        (field "maxscore" (f/uint64 ["lp_score" "l_score"]))
        (field "bantime" (f/int64 ["lp_bantime" "l_bantime"]))
        (field "ignhosts" (f/vector (f/string ["lp_ignore_hosts" "l_ignore_hosts"])))
        (field "ignusers" (f/vector (f/string ["lp_ignore_users" "l_ignore_users"])))
    )
    
    (struct "LdJail" "jail"
        (field "pwuser" (f/optional (f/string ["lp_pwuser" "l_pwuser"])))
        (field "chroot" (f/optional (f/boolean ["lp_chroot" "l_chroot"])))
        (field "capsicum_flag" (f/optional (f/boolean ["lp_capsicum" "l_capsicum"])))
        (field "sigguard_max" (f/optional (f/uint32 ["lp_signalguard" "l_signalguard"])))
    )

    (struct "LdActionThreadExec" "action"
        (field "thr_worker" (f/uint64 ["lp_threads_worker" "l_threads_worker"]))
        (field "thr_block" (f/optional (f/uint64 ["lp_threads_blocking" "l_threads_blocking"])))
        (field "par_acts" (f/optional (f/uint64 ["lp_parallel_actions" "l_parallel_actions"])))
    )
    
    (struct "LdControl" "control"
        (field "enabled" (f/boolean ["l_ctrl_flag"]))
        (field "source" (f/enum ["lp_socket"]))
        (field "limitconn" (f/uint16 ["lp_limit_req" "l_limit_req"]))
        (field "readtimeout" (f/uint64 ["lp_rd_tm" "l_tm_rd"]))
        (field "servname" (f/string ["lp_name" "l_name"]))
        (field "password" (f/optional (f/struct ["lp_password"])))
        (field "force_acl" (f/boolean ["lp_force_acl" "l_force_acl"]))
        (field "enablelog" (f/boolean ["lp_log" "l_log"]))
        (field "acls" (f/optional (f/vector (f/struct ["lp_acl"]))))
    )
    
    (struct "LdEntityWorker" "entity-worker"
        (field "ramlimit" (f/uint64 ["lpa_lim" "l_lim"]))
        (field "log_facilities" (f/optional (f/vector (f/string ["lpa_logging" "l_logging"]))))
        (field "database" (f/enum ["lpa_database" "lp_db"]))
    )
    
    (struct "LdSockThread" "sockthread"
        (field "threads" (f/uint64 ["lp_threads" "l_threads"]))
    )
    
    (struct "LdParser" "parser"
        (field "log_facilities" (f/optional (f/vector (f/string ["lpa_logging" "l_logging"]))))
        (field "database" (f/enum ["lpa_database" "lp_db"]))
    )
    
    (rootstruct "LdLogDaemon"
        (field "global" (f/struct ["lpm_global"]))
        (field "jail" (f/struct ["lpm_jail"]))
        (field "action_exec" (f/struct ["lpm_action"]))
        (field "control" (f/struct ["lpm_control"]))
        (field "ent_worker" (f/struct ["lpm_ent_worker"]))
        (field "sockthread" (f/struct ["lpm_sockthread"]))
        (field "parser" (f/struct ["lpm_parser"]))
    ) 
)