c
 = element c
     {
       text
     }

e
 = element e
     {
       text
     }

r
 = element r
     {
       text
     }

o
 = element o
     {
       ( c
           | e
           | r
           | g )
     }

g
 = element g
     {
       c*
       & e*
       & r*
       & o*
       & any*
     }

any
 = element any
     {
       ( c
           | e
           | r
           | g )
     }

pattern
 = element pattern
     {
       text
       & pattern_attrib*
       & c*
       & e*
       & r*
       & o*
       & g*
       & any*
       & pattern_t?
     }

pattern_attrib
 = element attrib
     {
       pattern_attrib_name
       & pattern_attrib_type
       & pattern_attrib_required
     }

pattern_attrib_name
 = element name
     {
       type_name
     }

pattern_attrib_type
 = element type
     {
       type_name
     }

pattern_attrib_required
 = element required
     {
       boolean
     }

pattern_t
 = element t
     {
       type_name
     }

command_definition
 = element command_definition
     {
       command_definition_name
       & command_definition_summary?
       & command_definition_description?
       & ( ( command_definition_pattern
           & command_definition_response )
           | ( command_definition_type
           & command_definition_ele* ) )
       & command_definition_example*
     }

command_definition_name
 = element name
     {
       type_name
     }

command_definition_summary
 = element summary
     {
       text
     }

command_definition_description
 = element description
     {
       text
       & command_definition_description_p*
     }

command_definition_description_p
 = element p
     {
       text
     }

command_definition_pattern
 = element pattern    # type pattern
     {
       text
       & pattern_attrib*
       & c*
       & e*
       & r*
       & o*
       & g*
       & any*
       & pattern_t?
     }

command_definition_response
 = element response    # type pattern
     {
       text
       & pattern_attrib*
       & c*
       & e*
       & r*
       & o*
       & g*
       & any*
       & pattern_t?
     }

command_definition_example
 = element example
     {
       command_definition_example_summary?
       & command_definition_example_description?
       & command_definition_example_request
       & command_definition_example_response
     }

command_definition_example_summary
 = element summary
     {
       text
     }

command_definition_example_description
 = element description
     {
       text
     }

command_definition_example_request
 = element request
     {
       text
     }

command_definition_example_response
 = element response
     {
       text
     }

command_definition_type
 = element type
     {
       text
     }

command_definition_ele
 = element ele    # type command_definition
     {
       command_definition_name
       & command_definition_summary?
       & command_definition_description?
       & ( ( command_definition_pattern
           & command_definition_response )
           | ( command_definition_type
           & command_definition_ele* ) )
       & command_definition_example*
     }

authenticate
 = element authenticate
     {
       authenticate_credentials
     }

authenticate_credentials
 = element credentials
     {
       authenticate_credentials_username
       & authenticate_credentials_password
     }

authenticate_credentials_username
 = element username
     {
       text
     }

authenticate_credentials_password
 = element password
     {
       text
     }

authenticate_response
 = element authenticate_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <authenticate>
   <credentials>
     <username>sally</username>
     <password>secret</password>
   </credentials>
 </authenticate>

 <authenticate_response status="200"
                        status_text="OK"/>

 <authenticate>
   <credentials>
     <username>sally</username>
     <password>secrte</password>
   </credentials>
 </authenticate>

 <authenticate_response status="400"
                        status_text="Authentication failed"/>

commands
 = element commands
     {
       ( authenticate
           | commands
           | create_agent
           | create_config
           | create_escalator
           | create_lsc_credential
           | create_note
           | create_override
           | create_schedule
           | create_slave
           | create_target
           | create_task
           | delete_agent
           | delete_config
           | delete_escalator
           | delete_lsc_credential
           | delete_note
           | delete_override
           | delete_report
           | delete_schedule
           | delete_slave
           | delete_target
           | delete_task
           | get_agents
           | get_configs
           | get_dependencies
           | get_escalators
           | get_lsc_credentials
           | get_notes
           | get_nvts
           | get_nvt_families
           | get_nvt_feed_checksum
           | get_overrides
           | get_preferences
           | get_reports
           | get_results
           | get_schedules
           | get_slaves
           | get_system_reports
           | get_target_locators
           | get_targets
           | get_tasks
           | get_version
           | help
           | modify_config
           | modify_lsc_credential
           | modify_note
           | modify_override
           | modify_report
           | modify_task
           | pause_task
           | resume_or_start_task
           | resume_paused_task
           | resume_stopped_task
           | start_task
           | stop_task
           | test_escalator )*
     }

commands_response
 = element commands_response
     {
       attribute status { status }
       & attribute status_text { text }
       & ( authenticate_response
           | commands_response
           | create_agent_response
           | create_config_response
           | create_escalator_response
           | create_lsc_credential_response
           | create_note_response
           | create_override_response
           | create_schedule_response
           | create_slave_response
           | create_target_response
           | create_task_response
           | delete_agent_response
           | delete_config_response
           | delete_escalator_response
           | delete_lsc_credential_response
           | delete_note_response
           | delete_override_response
           | delete_report_response
           | delete_schedule_response
           | delete_slave_response
           | delete_target_response
           | delete_task_response
           | get_agents_response
           | get_configs_response
           | get_dependencies_response
           | get_escalators_response
           | get_lsc_credentials_response
           | get_notes_response
           | get_nvts_response
           | get_nvt_families_response
           | get_nvt_feed_checksum_response
           | get_overrides_response
           | get_preferences_response
           | get_reports_response
           | get_results_response
           | get_slaves_response
           | get_schedules_response
           | get_system_reports_response
           | get_target_locators_response
           | get_targets_response
           | get_tasks_response
           | get_version_response
           | help_response
           | modify_config_response
           | modify_lsc_credential_response
           | modify_note_response
           | modify_override_response
           | modify_report_response
           | modify_task_response
           | pause_task_response
           | resume_or_start_task_response
           | resume_paused_task_response
           | resume_stopped_task_response
           | start_task_response
           | stop_task_response
           | test_escalator_response )*
     }

create_agent
 = element create_agent
     {
       create_agent_installer
       & create_agent_name
       & create_agent_comment?
       & create_agent_howto_install?
       & create_agent_howto_use?
     }

create_agent_installer
 = element installer
     {
       text # RNC limitation: base64
       & create_agent_installer_signature
     }

create_agent_installer_signature
 = element signature
     {
       base64
     }

create_agent_name
 = element name
     {
       name
     }

create_agent_comment
 = element comment
     {
       text
     }

create_agent_howto_install
 = element howto_install
     {
       base64
     }

create_agent_howto_use
 = element howto_use
     {
       base64
     }

create_agent_response
 = element create_agent_response
     {
       attribute status { status }
       & attribute status_text { text }
       & attribute id { uuid }
     }

 <create_agent>
   <installer>
     asdf3235saf3kjBVF...
     <signature>iEYEABECAAYFA...</signature>
   </installer>
   <name>SLAD</name>
 </create_agent>

 <create_agent_response status="201"
                        status_text="OK, resource created"
                        id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6"/>

create_config
 = element create_config
     {
       create_config_comment?
       & ( create_config_copy
           | get_configs_response
           | create_config_rcfile )
       & create_config_name
     }

create_config_comment
 = element comment
     {
       text
     }

create_config_copy
 = element copy
     {
       uuid
     }

create_config_rcfile
 = element rcfile
     {
       base64
     }

create_config_name
 = element name
     {
       name
     }

create_config_response
 = element create_config_response
     {
       attribute status { status }
       & attribute status_text { text }
       & attribute id { uuid }
     }

 <create_config>
   <copy>daba56c8-73ec-11df-a475-002264764cea</copy>
   <name>Full</name>
 </create_config>

 <create_config_response status="201"
                         status_text="OK, resource created"
                         id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6"/>

 <create_config>
   <rcfile>asdf3235saf3kjBVF...</rcfile>
   <name>Full</name>
 </create_config>

 <create_config_response status="201"
                         status_text="OK, resource created"
                         id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6"/>

 <create_config>
   <get_configs_response>
     <config id="daba56c8-73ec-11df-a475-002264764cea">
       <name>Full and fast</name>
       ...
     </config>
   </get_configs_response>
 </create_config>

 <create_config_response status="201"
                         status_text="OK, resource created"
                         id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6"/>

create_escalator
 = element create_escalator
     {
       create_escalator_name
       & create_escalator_comment?
       & create_escalator_condition
       & create_escalator_event
       & create_escalator_method
     }

create_escalator_name
 = element name
     {
       name
     }

create_escalator_comment
 = element comment
     {
       text
     }

create_escalator_condition
 = element condition
     {
       text
       & create_escalator_condition_data*
     }

create_escalator_condition_data
 = element data
     {
       text
       & create_escalator_condition_data_name
     }

create_escalator_condition_data_name
 = element name
     {
       text
     }

create_escalator_event
 = element event
     {
       text
       & create_escalator_event_data*
     }

create_escalator_event_data
 = element data
     {
       text
       & create_escalator_event_data_name
     }

create_escalator_event_data_name
 = element name
     {
       text
     }

create_escalator_method
 = element method
     {
       text
       & create_escalator_method_data*
     }

create_escalator_method_data
 = element data
     {
       text
       & create_escalator_method_data_name
     }

create_escalator_method_data_name
 = element name
     {
       text
     }

create_escalator_response
 = element create_escalator_response
     {
       attribute status { status }
       & attribute status_text { text }
       & attribute id { uuid }
     }

 <create_escalator>
   <name>emergency</name>
   <condition>
     Threat level at least
     <data>
       High
       <name>level</name>
     </data>
   </condition>
   <event>
     Task run status changed
     <data>
       Done
       <name>status</name>
     </data>
   </event>
   <method>
     Email
     <data>
       sally@example.org
       <name>to_address</name>
     </data>
     <data>
       bob@example.org
       <name>from_address</name>
     </data>
   </method>
 </create_escalator>

 <create_escalator_response status="201"
                            status_text="OK, resource created"
                            id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6"/>

create_lsc_credential
 = element create_lsc_credential
     {
       create_lsc_credential_name
       & create_lsc_credential_comment?
       & create_lsc_credential_login
       & create_lsc_credential_password?
     }

create_lsc_credential_name
 = element name
     {
       name
     }

create_lsc_credential_comment
 = element comment
     {
       text
     }

create_lsc_credential_login
 = element login
     {
       text
     }

create_lsc_credential_password
 = element password
     {
       text
     }

create_lsc_credential_response
 = element create_lsc_credential_response
     {
       attribute status { status }
       & attribute status_text { text }
       & attribute id { uuid }
     }

 <create_lsc_credential>
   <name>cluster sally</name>
   <login>sally</login>
   <password>secret</password>
   <comment>Sally's login to the cluster.</comment>
 </create_lsc_credential>

 <create_lsc_credential_response status="201"
                                 status_text="OK, resource created"
                                 id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6"/>

create_note
 = element create_note
     {
       create_note_text
       & create_note_nvt
       & create_note_comment?
       & create_note_hosts?
       & create_note_port?
       & create_note_result?
       & create_note_task?
       & create_note_threat?
     }

create_note_text
 = element text
     {
       text
     }

create_note_nvt
 = element nvt
     {
       attribute oid { oid }
     }

create_note_comment
 = element comment
     {
       text
     }

create_note_hosts
 = element hosts
     {
       text
     }

create_note_port
 = element port
     {
       text
     }

create_note_result
 = element result
     {
       attribute id { uuid }
     }

create_note_task
 = element task
     {
       attribute id { uuid }
     }

create_note_threat
 = element threat
     {
       threat
     }

create_note_response
 = element create_note_response
     {
       attribute status { status }
       & attribute status_text { text }
       & attribute id { uuid }
     }

 <create_note>
   <text>This issue should be resolved after the upgrade.</text>
   <nvt>1.3.6.1.4.1.25623.1.0.10330</nvt>
   <result>254cd3ef-bbe1-4d58-859d-21b8d0c046c6</result>
 </create_note>

 <create_note_response status="202"
                       status_text="OK, resource created"
                       id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6"/>

create_override
 = element create_override
     {
       create_override_text
       & create_override_nvt
       & create_override_comment?
       & create_override_hosts?
       & create_override_new_threat?
       & create_override_port?
       & create_override_result?
       & create_override_task?
       & create_override_threat?
     }

create_override_text
 = element text
     {
       text
     }

create_override_nvt
 = element nvt
     {
       attribute oid { oid }
     }

create_override_comment
 = element comment
     {
       text
     }

create_override_hosts
 = element hosts
     {
       text
     }

create_override_new_threat
 = element new_threat
     {
       threat
     }

create_override_port
 = element port
     {
       text
     }

create_override_result
 = element result
     {
       attribute id { uuid }
     }

create_override_task
 = element task
     {
       attribute id { uuid }
     }

create_override_threat
 = element threat
     {
       threat
     }

create_override_response
 = element create_override_response
     {
       attribute status { status }
       & attribute status_text { text }
       & attribute id { uuid }
     }

 <create_override>
   <text>This is actually of little concern.</text>
   <nvt>1.3.6.1.4.1.25623.1.0.10330</nvt>
   <new_threat>Low</new_threat>
   <result>254cd3ef-bbe1-4d58-859d-21b8d0c046c6</result>
 </create_override>

 <create_override_response status="201"
                           status_text="OK, resource created"
                           id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6"/>

create_report_format
 = element create_report_format
     {
       get_report_formats_response
     }

create_report_format_response
 = element create_report_format_response
     {
       attribute status { status }
       & attribute status_text { text }
       & attribute id { uuid }
     }

 <create_report_format>
   <get_report_formats_response>
     <report_format id="a0704abb-2120-489f-959f-251c9f4ffebd">
       <name>CPE</name>
       <extension>csv</extension>
       <content_type>text/csv</content_type>
       <summary>Common Product Enumeration CSV table.</summary>
       <description>
         CPE stands for Common Product Enumeration. It is a
         ...
       </description>
       <global>1</global>
       <trust>
         yes
         <time>Thu Dec 2 13:22:26 2010</time>
       </trust>
       <active>1</active>
     </report_format>
   </get_report_formats_response>
 </create_report_format>

 <create_report_format_response status="201"
                                status_text="OK, resource created"
                                id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6"/>

create_schedule
 = element create_schedule
     {
       create_schedule_name
       & create_schedule_comment?
       & create_schedule_first_time
       & create_schedule_duration
       & create_schedule_period
     }

create_schedule_name
 = element name
     {
       name
     }

create_schedule_comment
 = element comment
     {
       text
     }

create_schedule_first_time
 = element first_time
     {
       create_schedule_first_time_minute
       & create_schedule_first_time_hour
       & create_schedule_first_time_day_of_month
       & create_schedule_first_time_month
       & create_schedule_first_time_year
     }

create_schedule_first_time_minute
 = element minute
     {
       integer
     }

create_schedule_first_time_hour
 = element hour
     {
       integer
     }

create_schedule_first_time_day_of_month
 = element day_of_month
     {
       integer
     }

create_schedule_first_time_month
 = element month
     {
       integer
     }

create_schedule_first_time_year
 = element year
     {
       integer
     }

create_schedule_duration
 = element duration
     {
       create_schedule_duration_unit
     }

create_schedule_duration_unit
 = element unit
     {
       time_unit
     }

create_schedule_period
 = element period
     {
       create_schedule_period_unit
     }

create_schedule_period_unit
 = element unit
     {
       time_unit
     }

create_schedule_response
 = element create_schedule_response
     {
       attribute status { status }
       & attribute status_text { text }
       & attribute id { uuid }
     }

 <create_schedule>
   <name>Every night</name>
   <first_time>
     <day_of_month>1</day_of_month>
     <hour>0</hour>
     <minute>0</minute>
     <month>1</month>
     <year>2011</year>
   </first_time>
   <duration>
     3
     <unit>hour</unit>
   </duration>
   <period>
     1
     <unit>day</unit>
   </period>
 </create_schedule>

 <create_schedule_response status="201"
                           status_text="OK, resource created"
                           id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6"/>

create_slave
 = element create_slave
     {
       create_slave_name
       & create_slave_comment?
       & create_slave_host
       & create_slave_port
       & create_slave_login
       & create_slave_password
     }

create_slave_name
 = element name
     {
       name
     }

create_slave_comment
 = element comment
     {
       text
     }

create_slave_host
 = element host
     {
       text
     }

create_slave_port
 = element port
     {
       text
     }

create_slave_login
 = element login
     {
       text
     }

create_slave_password
 = element password
     {
       text
     }

create_slave_response
 = element create_slave_response
     {
       attribute status { status }
       & attribute status_text { text }
       & attribute id { uuid }
     }

 <create_slave>
   <name>Bangkok</name>
   <comment>Manager in Bangkok department.</comment>
   <host>192.0.32.10</host>
   <login>sally</login>
   <password>secret</password>
 </create_slave>

 <create_slave_response status="201"
                        status_text="OK, resource created"
                        id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6"/>

create_target
 = element create_target
     {
       create_target_name
       & create_target_comment?
       & create_target_hosts
       & create_target_ssh_lsc_credential
       & create_target_smb_lsc_credential
       & create_target_target_locator
       & create_target_port_range?
     }

create_target_name
 = element name
     {
       name
     }

create_target_comment
 = element comment
     {
       text
     }

create_target_hosts
 = element hosts
     {
       text
     }

create_target_ssh_lsc_credential
 = element ssh_lsc_credential
     {
       attribute id { uuid }
     }

create_target_smb_lsc_credential
 = element smb_lsc_credential
     {
       attribute id { uuid }
     }

create_target_target_locator
 = element target_locator
     {
       create_target_target_locator_username?
       & create_target_target_locator_password?
     }

create_target_target_locator_username
 = element username
     {
       text
     }

create_target_target_locator_password
 = element password
     {
       text
     }

create_target_port_range
 = element port_range
     {
       text
     }

create_target_response
 = element create_target_response
     {
       attribute status { status }
       & attribute status_text { text }
       & attribute id { uuid }
     }

 <create_target>
   <name>All GNU/Linux machines</name>
   <hosts>192.168.1.0/24</hosts>
 </create_target>

 <create_target_response status="201"
                         status_text="OK, resource created"
                         id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6"/>

create_task
 = element create_task
     {
       create_task_name
       & create_task_comment?
       & create_task_config
       & create_task_target
       & create_task_escalator?
       & create_task_schedule?
       & create_task_slave?
       & create_task_rcfile?
     }

create_task_name
 = element name
     {
       name
     }

create_task_comment
 = element comment
     {
       text
     }

create_task_config
 = element config
     {
       attribute id { uuid }
     }

create_task_target
 = element target
     {
       attribute id { uuid }
     }

create_task_escalator
 = element escalator
     {
       attribute id { uuid }
     }

create_task_schedule
 = element schedule
     {
       attribute id { uuid }
     }

create_task_slave
 = element slave
     {
       attribute id { uuid }
     }

create_task_rcfile
 = element rcfile
     {
       base64
     }

create_task_response
 = element create_task_response
     {
       attribute status { status }
       & attribute status_text { text }
       & attribute id { uuid }
     }

 <create_task>
   <name>Scan Webserver</name>
   <comment>Hourly scan of the webserver</comment>
   <config id="daba56c8-73ec-11df-a475-002264764cea"/>
   <target id="b493b7a8-7489-11df-a3ec-002264764cea"/>
 </create_task>

 <create_task_response status="201"
                       status_text="OK, resource created"
                       id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6"/>

delete_agent
 = element delete_agent
     {
       attribute agent_id { uuid }
     }

delete_agent_response
 = element delete_agent_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <delete_agent agent_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <delete_agent_response status="200"
                        status_text="OK"/>

delete_config
 = element delete_config
     {
       attribute config_id { uuid }
     }

delete_config_response
 = element delete_config_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <delete_config config_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <delete_config_response status="200"
                         status_text="OK"/>

delete_escalator
 = element delete_escalator
     {
       attribute escalator_id { uuid }
     }

delete_escalator_response
 = element delete_escalator_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <delete_escalator escalator_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <delete_escalator_response status="200"
                            status_text="OK"/>

delete_lsc_credential
 = element delete_lsc_credential
     {
       attribute lsc_credential_id { uuid }
     }

delete_lsc_credential_response
 = element delete_lsc_credential_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <delete_lsc_credential lsc_credential_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <delete_lsc_credential_response status="200"
                                 status_text="OK"/>

delete_note
 = element delete_note
     {
       attribute note_id { uuid }
     }

delete_note_response
 = element delete_note_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <delete_note note_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <delete_note_response status="200"
                       status_text="OK"/>

delete_override
 = element delete_override
     {
       attribute override_id { uuid }
     }

delete_override_response
 = element delete_override_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <delete_override override_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <delete_override_response status="200"
                           status_text="OK"/>

delete_report
 = element delete_report
     {
       attribute report_id { uuid }
     }

delete_report_response
 = element delete_report_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <delete_report report_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <delete_report_response status="200"
                         status_text="OK"/>

delete_report_format
 = element delete_report_format
     {
       attribute report_format_id { uuid }
     }

delete_report_format_response
 = element delete_report_format_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <delete_report_format report_format_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <delete_report_format_response status="200"
                                status_text="OK"/>

delete_schedule
 = element delete_schedule
     {
       attribute schedule_id { uuid }
     }

delete_schedule_response
 = element delete_schedule_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <delete_schedule schedule_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <delete_schedule_response status="200"
                           status_text="OK"/>

delete_slave
 = element delete_slave
     {
       attribute slave_id { uuid }
     }

delete_slave_response
 = element delete_slave_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <delete_slave slave_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <delete_slave_response status="200"
                        status_text="OK"/>

delete_target
 = element delete_target
     {
       attribute target_id { uuid }
     }

delete_target_response
 = element delete_target_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <delete_target target_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <delete_target_response status="200"
                         status_text="OK"/>

delete_task
 = element delete_task
     {
       attribute task_id { uuid }
     }

delete_task_response
 = element delete_task_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <delete_task task_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <delete_task_response status="200"
                       status_text="OK"/>

get_agents
 = element get_agents
     {
       attribute agent_id { uuid }?
       & attribute format { xsd:token { pattern = "installer|howto_install|howto_use" } }?
       & attribute sort_order { sort_order }?
       & attribute sort_field { text }?
     }

get_agents_response
 = element get_agents_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_agents_response_agent*
     }

get_agents_response_agent
 = element agent
     {
       attribute id { uuid }
       & get_agents_response_agent_name
       & get_agents_response_agent_comment
       & get_agents_response_agent_in_use
       & ( get_agents_response_agent_installer
           | get_agents_response_agent_package )
     }

get_agents_response_agent_name
 = element name
     {
       name
     }

get_agents_response_agent_comment
 = element comment
     {
       text
     }

get_agents_response_agent_in_use
 = element in_use
     {
       boolean
     }

get_agents_response_agent_installer
 = element installer
     {
       get_agents_response_agent_installer_trust
     }

get_agents_response_agent_installer_trust
 = element trust
     {
       text # RNC limitation: xsd:token { pattern = "yes|no|unknown" }
       & get_agents_response_agent_installer_trust_time
     }

get_agents_response_agent_installer_trust_time
 = element time
     {
       ctime
     }

get_agents_response_agent_package
 = element package
     {
       text # RNC limitation: base64
       & get_agents_response_agent_package_filename
     }

get_agents_response_agent_package_filename
 = element filename
     {
       text
     }

 <get_agents/>

 <get_agents_response status="200"
                      status_text="OK">
   <agent id="c33864a9-d3fd-44b3-8717-972bfb01dfcf">
     <name>Custom Scan Agent</name>
     <comment>Custom agent for use on the Web servers.</comment>
     <in_use>1</in_use>
     <installer>
       <trust>
         yes
         <time>Wed Jun 30 21:49:08 1993</time>
       </trust>
     </installer>
   </agent>
   ...
 </get_agents_response>

 <get_agents agent_id="c33864a9-d3fd-44b3-8717-972bfb01dfcf"/>

 <get_agents_response status="200"
                      status_text="OK">
   <agent id="c33864a9-d3fd-44b3-8717-972bfb01dfcf">
     <name>Custom Scan Agent</name>
     <comment>Custom agent for use on the Web servers.</comment>
     <in_use>1</in_use>
     <installer>
       <trust>
         yes
         <time>Wed Jun 30 21:49:08 1993</time>
       </trust>
     </installer>
   </agent>
 </get_agents_response>

 <get_agents agent_id="c33864a9-d3fd-44b3-8717-972bfb01dfcf"
             format="installer"/>

 <get_agents_response status="200"
                      status_text="OK">
   <agent id="c33864a9-d3fd-44b3-8717-972bfb01dfcf">
     <name>Custom Scan Agent</name>
     <comment>Custom agent for use on the Web servers.</comment>
     <in_use>1</in_use>
     <package format="installer">
       CgoKCgoKCgoKCgoKCSAgI...
       <filename>agent.deb</filename>
     </package>
   </agent>
 </get_agents_response>

get_configs
 = element get_configs
     {
       attribute config_id { uuid }?
       & attribute families { boolean }?
       & attribute preferences { boolean }?
       & attribute sort_order { sort_order }?
       & attribute sort_field { text }?
     }

get_configs_response
 = element get_configs_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_configs_response_config*
     }

get_configs_response_config
 = element config
     {
       get_configs_response_config_name
       & get_configs_response_config_comment
       & get_configs_response_config_family_count
       & get_configs_response_config_nvt_count
       & get_configs_response_config_max_nvt_count
       & get_configs_response_config_known_nvt_count
       & get_configs_response_config_in_use
       & get_configs_response_config_tasks
       & get_configs_response_config_families?
       & get_configs_response_config_preferences?
     }

get_configs_response_config_name
 = element name
     {
       name
     }

get_configs_response_config_comment
 = element comment
     {
       text
     }

get_configs_response_config_family_count
 = element family_count
     {
       text # RNC limitation: integer
       & get_configs_response_config_family_count_growing
     }

get_configs_response_config_family_count_growing
 = element growing
     {
       boolean
     }

get_configs_response_config_nvt_count
 = element nvt_count
     {
       text # RNC limitation: integer
       & get_configs_response_config_nvt_count_growing
     }

get_configs_response_config_nvt_count_growing
 = element growing
     {
       boolean
     }

get_configs_response_config_max_nvt_count
 = element max_nvt_count
     {
       integer
     }

get_configs_response_config_known_nvt_count
 = element known_nvt_count
     {
       integer
     }

get_configs_response_config_in_use
 = element in_use
     {
       boolean
     }

get_configs_response_config_tasks
 = element tasks
     {
       get_configs_response_config_tasks_task*
     }

get_configs_response_config_tasks_task
 = element task
     {
       attribute id { uuid }
       & get_configs_response_config_tasks_task_name
     }

get_configs_response_config_tasks_task_name
 = element name
     {
       name
     }

get_configs_response_config_families
 = element families
     {
       get_configs_response_config_families_family*
     }

get_configs_response_config_families_family
 = element family
     {
       get_configs_response_config_families_family_name
       & get_configs_response_config_families_family_nvt_count
       & get_configs_response_config_families_family_max_nvt_count
       & get_configs_response_config_families_family_growing
     }

get_configs_response_config_families_family_name
 = element name
     {
       name
     }

get_configs_response_config_families_family_nvt_count
 = element nvt_count
     {
       integer
     }

get_configs_response_config_families_family_max_nvt_count
 = element max_nvt_count
     {
       integer
     }

get_configs_response_config_families_family_growing
 = element growing
     {
       boolean
     }

get_configs_response_config_preferences
 = element preferences
     {
       get_configs_response_config_preferences_preference*
     }

get_configs_response_config_preferences_preference
 = element preference
     {
       get_configs_response_config_preferences_preference_nvt
       & get_configs_response_config_preferences_preference_name
       & get_configs_response_config_preferences_preference_type
       & get_configs_response_config_preferences_preference_value
     }

get_configs_response_config_preferences_preference_nvt
 = element nvt
     {
       attribute oid { oid }
       & get_configs_response_config_preferences_preference_nvt_name
     }

get_configs_response_config_preferences_preference_nvt_name
 = element name
     {
       name
     }

get_configs_response_config_preferences_preference_name
 = element name
     {
       name
     }

get_configs_response_config_preferences_preference_type
 = element type
     {
       text
     }

get_configs_response_config_preferences_preference_value
 = element value
     {
       text
     }

 <get_configs/>

 <get_configs_response status="200"
                       status_text="OK">
   <config id="daba56c8-73ec-11df-a475-002264764cea">
     <name>Full and fast</name>
     <comment>
       All NVT's; optimized by using previously collected information.
     </comment>
     <family_count>
       4
       <growing>1</growing>
     </family_count>
     <nvt_count>
       12
       <growing>1</growing>
     </nvt_count>
     <in_use>1</in_use>
     <tasks>
       <task id="13bb418a-4220-4575-b35b-ec398bff7417">
         <name>Web Servers</name>
       </task>
       ...
     </tasks>
   </config>
   ...
 </get_configs_response>

 <get_configs config_id="daba56c8-73ec-11df-a475-002264764cea"
              preferences="1"
              families="1"/>

 <get_configs_response status="200"
                       status_text="OK">
   <config id="daba56c8-73ec-11df-a475-002264764cea">
     <name>Full and fast</name>
     <comment>
       All NVT's; optimized by using previously collected information.
     </comment>
     <family_count>
       4
       <growing>1</growing>
     </family_count>
     <nvt_count>
       12
       <growing>1</growing>
     </nvt_count>
     <in_use>1</in_use>
     <tasks>
       <task id="13bb418a-4220-4575-b35b-ec398bff7417">
         <name>Web Servers</name>
       </task>
       ...
     </tasks>
     <families>
       <family>
         <name>Credentials</name>
         <nvt_count>8</nvt_count>
         <max_nvt_count>8</max_nvt_count>
         <growing>1</growing>
       </family>
       ...
     </families>
     <preferences>
       <preference>
         <nvt oid="1.3.6.1.4.1.25623.1.0.10330">
           <name>Services</name>
         </nvt>
         <name>Network connection timeout :</name>
         <type>entry</type>
         <value>5</value>
       </preference>
       ...
     </preferences>
   </config>
   ...
 </get_configs_response>

get_dependencies
 = element get_dependencies
     {
       attribute nvt_oid { oid }?
     }

get_dependencies_response
 = element get_dependencies_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_dependencies_response_nvt*
     }

get_dependencies_response_nvt
 = element nvt
     {
       attribute oid { oid }
       & get_dependencies_response_nvt_name
       & get_dependencies_response_nvt_requires
     }

get_dependencies_response_nvt_name
 = element name
     {
       name
     }

get_dependencies_response_nvt_requires
 = element requires
     {
       get_dependencies_response_nvt_requires_nvt*
     }

get_dependencies_response_nvt_requires_nvt
 = element nvt
     {
       attribute oid { oid }
       & get_dependencies_response_nvt_requires_nvt_name
     }

get_dependencies_response_nvt_requires_nvt_name
 = element name
     {
       name
     }

 <get_dependencies/>

 <get_dependencies_response status="200"
                            status_text="OK">
   <nvt oid="1.3.6.1.4.1.25623.1.0.114664">
     <name>Dependency Test</name>
     <requires>
       <nvt oid="1.3.6.1.4.1.25623.1.0.114663">
         <name>File Upload Test</name>
       </nvt>
     </requires>
   </nvt>
   ...
 </get_dependencies_response>

 <get_dependencies nvt_oid="1.3.6.1.4.1.25623.1.0.114664"/>

 <get_dependencies_response status="200"
                            status_text="OK">
   <nvt oid="1.3.6.1.4.1.25623.1.0.114664">
     <name>Dependency Test</name>
     <requires>
       <nvt oid="1.3.6.1.4.1.25623.1.0.114663">
         <name>File Upload Test</name>
       </nvt>
     </requires>
   </nvt>
 </get_dependencies_response>

get_escalators
 = element get_escalators
     {
       attribute escalator_id { uuid }?
       & attribute sort_order { sort_order }?
       & attribute sort_field { text }?
     }

get_escalators_response
 = element get_escalators_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_escalators_response_escalator*
     }

get_escalators_response_escalator
 = element escalator
     {
       get_escalators_response_escalator_name
       & get_escalators_response_escalator_comment
       & get_escalators_response_escalator_in_use
       & get_escalators_response_escalator_condition
       & get_escalators_response_escalator_event
       & get_escalators_response_escalator_method
     }

get_escalators_response_escalator_name
 = element name
     {
       name
     }

get_escalators_response_escalator_comment
 = element comment
     {
       text
     }

get_escalators_response_escalator_in_use
 = element in_use
     {
       boolean
     }

get_escalators_response_escalator_condition
 = element condition
     {
       text
       & get_escalators_response_escalator_condition_data*
     }

get_escalators_response_escalator_condition_data
 = element data
     {
       text
       & get_escalators_response_escalator_condition_data_name
     }

get_escalators_response_escalator_condition_data_name
 = element name
     {
       text
     }

get_escalators_response_escalator_event
 = element event
     {
       text
       & get_escalators_response_escalator_event_data*
     }

get_escalators_response_escalator_event_data
 = element data
     {
       text
       & get_escalators_response_escalator_event_data_name
     }

get_escalators_response_escalator_event_data_name
 = element name
     {
       text
     }

get_escalators_response_escalator_method
 = element method
     {
       text
       & get_escalators_response_escalator_method_data*
     }

get_escalators_response_escalator_method_data
 = element data
     {
       text
       & get_escalators_response_escalator_method_data_name
     }

get_escalators_response_escalator_method_data_name
 = element name
     {
       text
     }

 <get_escalators/>

 <get_escalators_response status="200"
                          status_text="OK">
   <escalator id="6181e65d-8ba0-4937-9c44-8f2b10b0def7">
     <name>Team alert</name>
     <comment/>
     <in_use>1</in_use>
     <condition>
       Threat level at least
       <data>
         High
         <name>level</name>
       </data>
     </condition>
     <event>
       Task run status changed
       <data>
         Done
         <name>status</name>
       </data>
     </event>
     <method>
       Email
       <data>
         team@example.org
         <name>to_address</name>
       </data>
       <data>
         admin@example.org
         <name>from_address</name>
       </data>
       <data>
         0
         <name>notice</name>
       </data>
     </method>
   </escalator>
   ...
 </get_escalators_response>

get_lsc_credentials
 = element get_lsc_credentials
     {
       attribute lsc_credential_id { uuid }?
       & attribute format { xsd:token { pattern = "key|rpm|deb|exe" } }?
       & attribute sort_order { sort_order }?
       & attribute sort_field { text }?
     }

get_lsc_credentials_response
 = element get_lsc_credentials_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_lsc_credentials_response_lsc_credential*
     }

get_lsc_credentials_response_lsc_credential
 = element lsc_credential
     {
       attribute id { uuid }
       & get_lsc_credentials_response_lsc_credential_name
       & get_lsc_credentials_response_lsc_credential_login
       & get_lsc_credentials_response_lsc_credential_comment
       & get_lsc_credentials_response_lsc_credential_in_use
       & get_lsc_credentials_response_lsc_credential_type
       & get_lsc_credentials_response_lsc_credential_targets
       & get_lsc_credentials_response_lsc_credential_public_key?
       & get_lsc_credentials_response_lsc_credential_package?
     }

get_lsc_credentials_response_lsc_credential_name
 = element name
     {
       name
     }

get_lsc_credentials_response_lsc_credential_login
 = element login
     {
       name
     }

get_lsc_credentials_response_lsc_credential_comment
 = element comment
     {
       text
     }

get_lsc_credentials_response_lsc_credential_in_use
 = element in_use
     {
       boolean
     }

get_lsc_credentials_response_lsc_credential_type
 = element type
     {
       xsd:token { pattern = "gen|pass" }
     }

get_lsc_credentials_response_lsc_credential_targets
 = element targets
     {
       get_lsc_credentials_response_lsc_credential_targets_target*
     }

get_lsc_credentials_response_lsc_credential_targets_target
 = element target
     {
       attribute id { uuid }
       & get_lsc_credentials_response_lsc_credential_targets_target_name
     }

get_lsc_credentials_response_lsc_credential_targets_target_name
 = element name
     {
       name
     }

get_lsc_credentials_response_lsc_credential_public_key
 = element public_key
     {
       text
     }

get_lsc_credentials_response_lsc_credential_package
 = element package
     {
       base64
       & attribute format { xsd:token { pattern = "rpm|deb|exe" } }
     }

 <get_lsc_credentials/>

 <get_lsc_credentials_response status="200"
                               status_text="OK">
   <lsc_credential id="c33864a9-d3fd-44b3-8717-972bfb01dfcf">
     <name>sally</name>
     <login>sally</login>
     <comment/>
     <in_use>0</in_use>
     <type>gen</type>
     <targets/>
   </lsc_credential>
   <lsc_credential id="8e305b0b-260d-450d-91a8-dadf0b144e15">
     <name>bob</name>
     <login>bob</login>
     <comment>Bob on the web server.</comment>
     <in_use>1</in_use>
     <type>pass</type>
     <targets>
       <target id="1f28d970-17ef-4c69-ba8a-13827059f2b9">
         <name>Web server</name>
       </target>
     </targets>
   </lsc_credential>
   ...
 </get_lsc_credentials_response>

 <get_lsc_credentials lsc_credential_id="8e305b0b-260d-450d-91a8-dadf0b144e15"
                      format="key"/>

 <get_lsc_credentials_response status="200"
                               status_text="OK">
   <lsc_credential id="8e305b0b-260d-450d-91a8-dadf0b144e15">
     <name>bob</name>
     <login>bob</login>
     <comment>Bob on the web server.</comment>
     <in_use>1</in_use>
     <type>pass</type>
     <targets>
       <target id="1f28d970-17ef-4c69-ba8a-13827059f2b9">
         <name>Web server</name>
       </target>
     </targets>
     <public_key>
       ssh-rsa AAAAB3...Z64IcQ== Key generated by OpenVAS Manager
     </public_key>
   </lsc_credential>
 </get_lsc_credentials_response>

 <get_lsc_credentials lsc_credential_id="8e305b0b-260d-450d-91a8-dadf0b144e15"
                      format="deb"/>

 <get_lsc_credentials_response status="200"
                               status_text="OK">
   <lsc_credential id="8e305b0b-260d-450d-91a8-dadf0b144e15">
     <name>bob</name>
     <login>bob</login>
     <comment>Bob on the web server.</comment>
     <in_use>1</in_use>
     <type>pass</type>
     <targets>
       <target id="1f28d970-17ef-4c69-ba8a-13827059f2b9">
         <name>Web server</name>
       </target>
     </targets>
     <package format="deb">ITxhcmNoPgpk...DmvF0AKAAACg==</package>
   </lsc_credential>
 </get_lsc_credentials_response>

get_notes
 = element get_notes
     {
       attribute note_id { uuid }?
       & attribute nvt_oid { oid }?
       & attribute task_id { uuid }?
       & attribute details { boolean }?
       & attribute result { boolean }?
       & attribute sort_order { sort_order }?
       & attribute sort_field { text }?
     }

get_notes_response
 = element get_notes_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_notes_response_note*
     }

get_notes_response_note
 = element note
     {
       get_notes_response_note_nvt
       & get_notes_response_note_text
       & get_notes_response_note_orphan
       & ( get_notes_response_note_creation_time
           & get_notes_response_note_modification_time
           & get_notes_response_note_hosts
           & get_notes_response_note_port
           & get_notes_response_note_threat
           & get_notes_response_note_task
           & get_notes_response_note_result? )?
     }

get_notes_response_note_nvt
 = element nvt
     {
       attribute oid { oid }
       & get_notes_response_note_nvt_name
     }

get_notes_response_note_nvt_name
 = element name
     {
       name
     }

get_notes_response_note_text
 = element text
     {
       text
       & attribute excerpt { boolean }
     }

get_notes_response_note_orphan
 = element orphan
     {
       boolean
     }

get_notes_response_note_creation_time
 = element creation_time
     {
       ctime
     }

get_notes_response_note_modification_time
 = element modification_time
     {
       ctime
     }

get_notes_response_note_hosts
 = element hosts
     {
       text
     }

get_notes_response_note_port
 = element port
     {
       text
     }

get_notes_response_note_threat
 = element threat
     {
       threat
     }

get_notes_response_note_task
 = element task
     {
       attribute id { uuid }
     }

get_notes_response_note_result
 = element result
     {
       attribute id { uuid }
       & get_notes_response_note_result_subnet
       & get_notes_response_note_result_host
       & get_notes_response_note_result_port
       & get_notes_response_note_result_nvt
       & get_notes_response_note_result_threat
       & get_notes_response_note_result_description
     }

get_notes_response_note_result_subnet
 = element subnet
     {
       text
     }

get_notes_response_note_result_host
 = element host
     {
       text
     }

get_notes_response_note_result_port
 = element port
     {
       text
     }

get_notes_response_note_result_nvt
 = element nvt
     {
       attribute oid { oid }
       & get_notes_response_note_result_nvt_name
       & get_notes_response_note_result_nvt_cvss_base
       & get_notes_response_note_result_nvt_risk_factor
       & get_notes_response_note_result_nvt_cve?
       & get_notes_response_note_result_nvt_bid?
     }

get_notes_response_note_result_nvt_name
 = element name
     {
       name
     }

get_notes_response_note_result_nvt_cvss_base
 = element cvss_base
     {
       text
     }

get_notes_response_note_result_nvt_risk_factor
 = element risk_factor
     {
       text
     }

get_notes_response_note_result_nvt_cve
 = element cve
     {
       text
     }

get_notes_response_note_result_nvt_bid
 = element bid
     {
       integer
     }

get_notes_response_note_result_threat
 = element threat
     {
       threat
     }

get_notes_response_note_result_description
 = element description
     {
       text
     }

 <get_notes/>

 <get_notes_response status="200"
                     status_text="OK">
   <note id="b76b81a7-9df8-42df-afff-baa9d4620128">
     <nvt oid="1.3.6.1.4.1.25623.1.0.75">
       <name>Test NVT: long lines</name>
     </nvt>
     <text excerpt="0">This is the full text of the note.</text>
     <orphan>1</orphan>
   </note>
   ...
 </get_notes_response>

 <get_notes note_id="7f618bbb-4664-419e-9bbf-367d93954cb0"
            details="1"
            result="1"/>

 <get_notes_response status="200"
                     status_text="OK">
   <note id="7f618bbb-4664-419e-9bbf-367d93954cb0">
     <nvt oid="1.3.6.1.4.1.25623.1.0.77">
       <name>Test NVT: control chars in report result</name>
     </nvt>
     <creation_time>Sun Jun 27 08:49:46 2010</creation_time>
     <modification_time>Sun Jun 27 08:49:46 2010</modification_time>
     <text>note fixed to result</text>
     <hosts>127.0.0.1</hosts>
     <port>general/tcp</port>
     <threat>Medium</threat>
     <task id="40b236a9-2b0f-4813-b8c7-bc2b98d9d7e4">
       <name>test</name>
     </task>
     <orphan>0</orphan>
     <result id="0c95e6b3-1100-4dfd-88f1-4bed1fad29de">
       <subnet>127.0.0.1</subnet>
       <host>127.0.0.1</host>
       <port>general/tcp</port>
       <nvt oid="1.3.6.1.4.1.25623.1.0.77">
         <name>Test NVT: control chars in report result</name>
         <cvss_base/>
         <risk_factor/>
         <cve/>
         <bid/>
       </nvt>
       <threat>Medium</threat>
       <description>Warning with control char between fullstops: . .</description>
     </result>
   </note>
   ...
 </get_notes_response>

get_nvts
 = element get_nvts
     {
       attribute nvt_oid { oid }
       & attribute details { boolean }?
       & attribute preferences { boolean }?
       & attribute preference_count { boolean }?
       & attribute timeout { boolean }?
       & attribute config_id { uuid }?
       & attribute family { text }?
       & attribute sort_order { sort_order }?
       & attribute sort_field { text }?
     }

get_nvts_response
 = element get_nvts_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_nvts_response_nvt
     }

get_nvts_response_nvt
 = element nvt
     {
       attribute id { uuid }
       & get_nvts_response_nvt_name
       & get_nvts_response_nvt_checksum
       & ( get_nvts_response_nvt_category
           & get_nvts_response_nvt_copyright
           & get_nvts_response_nvt_description
           & get_nvts_response_nvt_summary
           & get_nvts_response_nvt_family
           & get_nvts_response_nvt_version
           & get_nvts_response_nvt_cvss_base
           & get_nvts_response_nvt_risk_factor
           & get_nvts_response_nvt_cve_id
           & get_nvts_response_nvt_bugtraq_id
           & get_nvts_response_nvt_xrefs
           & get_nvts_response_nvt_fingerprints
           & get_nvts_response_nvt_tags
           & get_nvts_response_nvt_preference_count?
           & get_nvts_response_nvt_timeout?
           & get_nvts_response_nvt_preferences? )?
     }

get_nvts_response_nvt_name
 = element name
     {
       name
     }

get_nvts_response_nvt_category
 = element category
     {
       text
     }

get_nvts_response_nvt_copyright
 = element copyright
     {
       text
     }

get_nvts_response_nvt_description
 = element description
     {
       text
     }

get_nvts_response_nvt_summary
 = element summary
     {
       text
     }

get_nvts_response_nvt_family
 = element family
     {
       text
     }

get_nvts_response_nvt_version
 = element version
     {
       text
     }

get_nvts_response_nvt_cvss_base
 = element cvss_base
     {
       text
     }

get_nvts_response_nvt_risk_factor
 = element risk_factor
     {
       text
     }

get_nvts_response_nvt_cve_id
 = element cve_id
     {
       text
     }

get_nvts_response_nvt_bugtraq_id
 = element bugtraq_id
     {
       text
     }

get_nvts_response_nvt_xrefs
 = element xrefs
     {
       text
     }

get_nvts_response_nvt_fingerprints
 = element fingerprints
     {
       text
     }

get_nvts_response_nvt_tags
 = element tags
     {
       text
     }

get_nvts_response_nvt_preference_count
 = element preference_count
     {
       text
     }

get_nvts_response_nvt_timeout
 = element timeout
     {
       text
     }

get_nvts_response_nvt_checksum
 = element checksum
     {
       text
       & get_nvts_response_nvt_checksum_algorithm
     }

get_nvts_response_nvt_checksum_algorithm
 = element algorithm
     {
       text
     }

get_nvts_response_nvt_preferences
 = element preferences
     {
       text
       & get_nvts_response_nvt_preferences_timeout
       & get_nvts_response_nvt_preferences_preference*
     }

get_nvts_response_nvt_preferences_timeout
 = element timeout
     {
       text
     }

get_nvts_response_nvt_preferences_preference
 = element preference
     {
       get_nvts_response_nvt_preferences_preference_nvt
       & get_nvts_response_nvt_preferences_preference_name
       & get_nvts_response_nvt_preferences_preference_type
       & get_nvts_response_nvt_preferences_preference_value
     }

get_nvts_response_nvt_preferences_preference_nvt
 = element nvt
     {
       oid
     }

get_nvts_response_nvt_preferences_preference_name
 = element name
     {
       text
     }

get_nvts_response_nvt_preferences_preference_type
 = element type
     {
       text
     }

get_nvts_response_nvt_preferences_preference_value
 = element value
     {
       text
     }

 <get_nvts details="1"
           timeout="1"
           preference_count="1"
           preferences="1"/>

 <get_nvts_response status="200"
                    status_text="OK">
   <nvt oid="1.3.6.1.4.1.25623.1.7.13005">
     <name>Services</name>
     <category>Services</category>
     <copyright>GNU GPL v2</copyright>
     <description>
       This script attepts to detects with service is running on which port.
     </description>
     <summary>Find what is listening on which port</summary>
     <family>Service detection</family>
     <version>$Revision: 1852 $</version>
     <cvss_base/>
     <risk_factor>None</risk_factor>
     <cve_id>NOCVE</cve_id>
     <bugtraq_id>NOBID</bugtraq_id>
     <xrefs>NOXREF</xrefs>
     <fingerprints>NOSIGNKEYS</fingerprints>
     <tags>NOTAG</tags>
     <preference_count>-1</preference_count>
     <timeout/>
     <checksum>
       2397586ea5cd3a69f953836f7be9ef7b
       <algorithm>md5</algorithm>
     </checksum>
     <preferences>
       <timeout/>
       <preference>
         <nvt oid="1.3.6.1.4.1.25623.1.0.10330">
           <name>Services</name>
         </nvt>
         <name>Network connection timeout :</name>
         <type>entry</type>
         <value>5</value>
       </preference>
       ...
     </preferences>
   </nvt>
   <nvt oid="1.3.6.1.4.1.25623.1.7.13006">
     <name>FooBar 21</name>
     <category>Services</category>
     <copyright>GNU GPL v2</copyright>
     <description>
       This script detects whether the FooBar 2.1 XSS vulnerability is present.
     </description>
     ...
   </nvt>
   ...
 </get_nvts_response>

 <get_nvts nvt_oid="1.3.6.1.4.1.25623.1.0.10330"/>

 <get_nvts_response status="200"
                    status_text="OK">
   <nvt oid="1.3.6.1.4.1.25623.1.0.10330">
     <name>Services</name>
     <checksum>
       2397586ea5cd3a69f953836f7be9ef7b
       <algorithm>md5</algorithm>
     </checksum>
   </nvt>
 </get_nvts_response>

get_nvt_families
 = element get_nvt_families
     {
       attribute sort_order { sort_order }?
     }

get_nvt_families_response
 = element get_nvt_families_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_nvt_families_response_families
     }

get_nvt_families_response_families
 = element families
     {
       get_nvt_families_response_families_family*
     }

get_nvt_families_response_families_family
 = element family
     {
       get_nvt_families_response_families_family_name
       & get_nvt_families_response_families_family_max_nvt_count
     }

get_nvt_families_response_families_family_name
 = element name
     {
       name
     }

get_nvt_families_response_families_family_max_nvt_count
 = element max_nvt_count
     {
       integer
     }

 <get_nvt_families/>

 <get_nvt_families_response status="200"
                            status_text="OK">
   <families>
     <family>
       <name>Credentials</name>
       <max_nvt_count>8</max_nvt_count>
     </family>
     <family>
       <name>Port scanners</name>
       <max_nvt_count>12</max_nvt_count>
     </family>
     ...
   </families>
 </get_nvt_families_response>

get_nvt_feed_checksum
 = element get_nvt_feed_checksum
     {
       attribute algorithm { text }?
     }

get_nvt_feed_checksum_response
 = element get_nvt_feed_checksum_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_nvt_feed_checksum_response_checksum
     }

get_nvt_feed_checksum_response_checksum
 = element checksum
     {
       text # RNC limitation: base64
       & attribute algorithm { text }
     }

 <get_nvt_feed_checksum/>

 <get_nvt_feed_checksum_response status="200"
                                 status_text="OK">
   <checksum algorithm="md5">931db829a06b9a440a2ecaeb68c03715</checksum>
 </get_nvt_feed_checksum_response>

get_overrides
 = element get_overrides
     {
       attribute override_id { uuid }?
       & attribute nvt_oid { oid }?
       & attribute task_id { uuid }?
       & attribute details { boolean }?
       & attribute result { boolean }?
       & attribute sort_order { sort_order }?
       & attribute sort_field { text }?
     }

get_overrides_response
 = element get_overrides_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_overrides_response_override*
     }

get_overrides_response_override
 = element override
     {
       get_overrides_response_override_nvt
       & get_overrides_response_override_text
       & get_overrides_response_override_threat
       & get_overrides_response_override_new_threat
       & get_overrides_response_override_orphan
       & ( get_overrides_response_override_creation_time
           & get_overrides_response_override_modification_time
           & get_overrides_response_override_hosts
           & get_overrides_response_override_port
           & get_overrides_response_override_task
           & get_overrides_response_override_result? )?
     }

get_overrides_response_override_nvt
 = element nvt
     {
       attribute oid { oid }
       & get_overrides_response_override_nvt_name
     }

get_overrides_response_override_nvt_name
 = element name
     {
       name
     }

get_overrides_response_override_text
 = element text
     {
       text
       & attribute excerpt { boolean }
     }

get_overrides_response_override_threat
 = element threat
     {
       threat
     }

get_overrides_response_override_new_threat
 = element new_threat
     {
       threat
     }

get_overrides_response_override_orphan
 = element orphan
     {
       boolean
     }

get_overrides_response_override_creation_time
 = element creation_time
     {
       ctime
     }

get_overrides_response_override_modification_time
 = element modification_time
     {
       ctime
     }

get_overrides_response_override_hosts
 = element hosts
     {
       text
     }

get_overrides_response_override_port
 = element port
     {
       text
     }

get_overrides_response_override_task
 = element task
     {
       attribute id { uuid }
     }

get_overrides_response_override_result
 = element result
     {
       attribute id { uuid }
       & get_overrides_response_override_result_subnet
       & get_overrides_response_override_result_host
       & get_overrides_response_override_result_port
       & get_overrides_response_override_result_nvt
       & get_overrides_response_override_result_threat
       & get_overrides_response_override_result_description
     }

get_overrides_response_override_result_subnet
 = element subnet
     {
       text
     }

get_overrides_response_override_result_host
 = element host
     {
       text
     }

get_overrides_response_override_result_port
 = element port
     {
       text
     }

get_overrides_response_override_result_nvt
 = element nvt
     {
       attribute oid { oid }
       & get_overrides_response_override_result_nvt_name
       & get_overrides_response_override_result_nvt_cvss_base
       & get_overrides_response_override_result_nvt_risk_factor
       & get_overrides_response_override_result_nvt_cve?
       & get_overrides_response_override_result_nvt_bid?
     }

get_overrides_response_override_result_nvt_name
 = element name
     {
       name
     }

get_overrides_response_override_result_nvt_cvss_base
 = element cvss_base
     {
       text
     }

get_overrides_response_override_result_nvt_risk_factor
 = element risk_factor
     {
       text
     }

get_overrides_response_override_result_nvt_cve
 = element cve
     {
       text
     }

get_overrides_response_override_result_nvt_bid
 = element bid
     {
       integer
     }

get_overrides_response_override_result_threat
 = element threat
     {
       threat
     }

get_overrides_response_override_result_description
 = element description
     {
       text
     }

 <get_overrides/>

 <get_overrides_response status="200"
                         status_text="OK">
   <override id="b76b81a7-9df8-42df-afff-baa9d4620128">
     <nvt oid="1.3.6.1.4.1.25623.1.0.75">
       <name>Test NVT: long lines</name>
     </nvt>
     <text excerpt="0">This is the full text of the override.</text>
     <threat>High</threat>
     <new_threat>Log</new_threat>
     <orphan>1</orphan>
   </override>
   ...
 </get_overrides_response>

 <get_overrides override_id="7f618bbb-4664-419e-9bbf-367d93954cb0"
                details="1"/>

 <get_overrides_response status="200"
                         status_text="OK">
   <override id="7f618bbb-4664-419e-9bbf-367d93954cb0">
     <nvt oid="1.3.6.1.4.1.25623.1.0.77">
       <name>Test NVT: control chars in report result</name>
     </nvt>
     <creation_time>Sun Jun 27 08:49:46 2010</creation_time>
     <modification_time>Sun Jun 27 08:49:46 2010</modification_time>
     <text>override fixed to result</text>
     <hosts>127.0.0.1</hosts>
     <port>general/tcp</port>
     <threat>Medium</threat>
     <new_threat>Low</new_threat>
     <task id="40b236a9-2b0f-4813-b8c7-bc2b98d9d7e4">
       <name>test</name>
     </task>
     <orphan>0</orphan>
     <result id="0c95e6b3-1100-4dfd-88f1-4bed1fad29de"/>
   </override>
   ...
 </get_overrides_response>

get_preferences
 = element get_preferences
     {
       attribute nvt_oid { oid }?
       & attribute config_id { uuid }?
       & attribute preference { text }?
     }

get_preferences_response
 = element get_preferences_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_preferences_response_preference*
     }

get_preferences_response_preference
 = element preference
     {
       get_preferences_response_preference_nvt?
       & get_preferences_response_preference_name
       & get_preferences_response_preference_type?
       & get_preferences_response_preference_value
     }

get_preferences_response_preference_nvt
 = element nvt
     {
       attribute oid { oid }
       & get_preferences_response_preference_nvt_name
     }

get_preferences_response_preference_nvt_name
 = element name
     {
       name
     }

get_preferences_response_preference_name
 = element name
     {
       name
     }

get_preferences_response_preference_type
 = element type
     {
       text
     }

get_preferences_response_preference_value
 = element value
     {
       text
     }

 <get_preferences/>

 <get_preferences_response status="200"
                           status_text="OK">
   <preference>
     <name>Services[entry]:Network connection timeout :</name>
     <value>5</value>
   </preference>
   ...
 </get_preferences_response>

 <get_preferences nvt_oid="1.3.6.1.4.1.25623.1.0.10330"/>

 <get_preferences_response status="200"
                           status_text="OK">
   <preference>
     <name>Services[entry]:Network connection timeout :</name>
     <value>5</value>
   </preference>
   ...
 </get_preferences_response>

 <get_preferences config_id="daba56c8-73ec-11df-a475-002264764cea"/>

 <get_preferences_response status="200"
                           status_text="OK">
   <preference>
     <nvt oid="1.3.6.1.4.1.25623.1.0.10330">
       <name>Services</name>
     </nvt>
     <name>Network connection timeout :</name>
     <type>entry</type>
     <value>5</value>
   </preference>
   ...
 </get_preferences_response>

 <get_preferences config_id="daba56c8-73ec-11df-a475-002264764cea"
                  nvt_oid="1.3.6.1.4.1.25623.1.0.10330"/>

 <get_preferences nvt_oid="1.3.6.1.4.1.25623.1.0.10330">
   <preference>
     <nvt oid="1.3.6.1.4.1.25623.1.0.10330">
       <name>Services</name>
     </nvt>
     <name>Network connection timeout :</name>
     <type>entry</type>
     <value>5</value>
   </preference>
 </get_preferences>

get_reports
 = element get_reports
     {
       attribute report_id { uuid }?
       & attribute format_id { uuid }?
       & attribute first_result { integer }?
       & attribute max_results { integer }?
       & attribute sort_order { sort_order }?
       & attribute sort_field { text }?
       & attribute levels { levels }?
       & attribute search_phrase { text }?
       & attribute min_cvss_base { integer }?
       & attribute notes { boolean }?
       & attribute note_details { boolean }?
       & attribute overrides { boolean }?
       & attribute override_details { boolean }?
       & attribute result_hosts_only { boolean }?
     }

get_reports_response
 = element get_reports_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_reports_response_report*
     }

get_reports_response_report
 = element report
     {
       text # RNC limitation: base64
       & attribute id { uuid }
       & attribute format_id { uuid }
       & attribute extension { text }
       & attribute content_type { text }
       & get_reports_response_report_report
     }

get_reports_response_report_report
 = element report
     {
       attribute id { uuid }
       & ( get_reports_response_report_report_sort
           & get_reports_response_report_report_filters
           & get_reports_response_report_report_scan_run_status
           & get_reports_response_report_report_result_count
           & get_reports_response_report_report_task
           & get_reports_response_report_report_ports
           & get_reports_response_report_report_results
           & get_reports_response_report_report_scan_start
           & get_reports_response_report_report_host_start*
           & get_reports_response_report_report_host_end*
           & get_reports_response_report_report_scan_end )?
     }

get_reports_response_report_report_sort
 = element sort
     {
       get_reports_response_report_report_sort_field
     }

get_reports_response_report_report_sort_field
 = element field
     {
       text
       & get_reports_response_report_report_sort_field_order
     }

get_reports_response_report_report_sort_field_order
 = element order
     {
       xsd:token { pattern = "ascending|descending" }
     }

get_reports_response_report_report_filters
 = element filters
     {
       text # RNC limitation: levels
       & get_reports_response_report_report_filters_phrase
       & get_reports_response_report_report_filters_notes
       & get_reports_response_report_report_filters_overrides
       & get_reports_response_report_report_filters_apply_overrides
       & get_reports_response_report_report_filters_result_hosts_only
       & get_reports_response_report_report_filters_min_cvss_base
       & get_reports_response_report_report_filters_filter*
     }

get_reports_response_report_report_filters_phrase
 = element phrase
     {
       text
     }

get_reports_response_report_report_filters_notes
 = element notes
     {
       xsd:token { pattern = "0|1" }
     }

get_reports_response_report_report_filters_overrides
 = element overrides
     {
       xsd:token { pattern = "0|1" }
     }

get_reports_response_report_report_filters_apply_overrides
 = element apply_overrides
     {
       xsd:token { pattern = "0|1" }
     }

get_reports_response_report_report_filters_result_hosts_only
 = element result_hosts_only
     {
       xsd:token { pattern = "0|1" }
     }

get_reports_response_report_report_filters_min_cvss_base
 = element min_cvss_base
     {
       text
     }

get_reports_response_report_report_filters_filter
 = element filter
     {
       xsd:token { pattern = "High|Medium|Low|Log|Debug" }
     }

get_reports_response_report_report_scan_run_status
 = element scan_run_status
     {
       task_status
     }

get_reports_response_report_report_result_count
 = element result_count
     {
       get_reports_response_report_report_result_count_full
       & get_reports_response_report_report_result_count_filtered
       & get_reports_response_report_report_result_count_debug
       & get_reports_response_report_report_result_count_hole
       & get_reports_response_report_report_result_count_info
       & get_reports_response_report_report_result_count_log
       & get_reports_response_report_report_result_count_warning
     }

get_reports_response_report_report_result_count_full
 = element full
     {
       integer
     }

get_reports_response_report_report_result_count_filtered
 = element filtered
     {
       integer
     }

get_reports_response_report_report_result_count_debug
 = element debug
     {
       get_reports_response_report_report_result_count_debug_full
       & get_reports_response_report_report_result_count_debug_filtered
     }

get_reports_response_report_report_result_count_debug_full
 = element full
     {
       integer
     }

get_reports_response_report_report_result_count_debug_filtered
 = element filtered
     {
       integer
     }

get_reports_response_report_report_result_count_hole
 = element hole
     {
       get_reports_response_report_report_result_count_hole_full
       & get_reports_response_report_report_result_count_hole_filtered
     }

get_reports_response_report_report_result_count_hole_full
 = element full
     {
       integer
     }

get_reports_response_report_report_result_count_hole_filtered
 = element filtered
     {
       integer
     }

get_reports_response_report_report_result_count_info
 = element info
     {
       get_reports_response_report_report_result_count_info_full
       & get_reports_response_report_report_result_count_info_filtered
     }

get_reports_response_report_report_result_count_info_full
 = element full
     {
       integer
     }

get_reports_response_report_report_result_count_info_filtered
 = element filtered
     {
       integer
     }

get_reports_response_report_report_result_count_log
 = element log
     {
       get_reports_response_report_report_result_count_log_full
       & get_reports_response_report_report_result_count_log_filtered
     }

get_reports_response_report_report_result_count_log_full
 = element full
     {
       integer
     }

get_reports_response_report_report_result_count_log_filtered
 = element filtered
     {
       integer
     }

get_reports_response_report_report_result_count_warning
 = element warning
     {
       get_reports_response_report_report_result_count_warning_full
       & get_reports_response_report_report_result_count_warning_filtered
     }

get_reports_response_report_report_result_count_warning_full
 = element full
     {
       integer
     }

get_reports_response_report_report_result_count_warning_filtered
 = element filtered
     {
       integer
     }

get_reports_response_report_report_task
 = element task
     {
       attribute id { uuid }
       & get_reports_response_report_report_task_name
     }

get_reports_response_report_report_task_name
 = element name
     {
       name
     }

get_reports_response_report_report_ports
 = element ports
     {
       attribute start { integer }
       & attribute max { integer }
       & get_reports_response_report_report_ports_port*
     }

get_reports_response_report_report_ports_port
 = element port
     {
       text
       & get_reports_response_report_report_ports_port_host
       & get_reports_response_report_report_ports_port_threat
     }

get_reports_response_report_report_ports_port_host
 = element host
     {
       text
     }

get_reports_response_report_report_ports_port_threat
 = element threat
     {
       threat
     }

get_reports_response_report_report_results
 = element results
     {
       attribute start { integer }
       & attribute max { integer }
       & get_reports_response_report_report_results_result*
     }

get_reports_response_report_report_results_result
 = element result
     {
       attribute id { uuid }
       & get_reports_response_report_report_results_result_subnet
       & get_reports_response_report_report_results_result_host
       & get_reports_response_report_report_results_result_port
       & get_reports_response_report_report_results_result_nvt
       & get_reports_response_report_report_results_result_threat
       & get_reports_response_report_report_results_result_description
     }

get_reports_response_report_report_results_result_subnet
 = element subnet
     {
       text
     }

get_reports_response_report_report_results_result_host
 = element host
     {
       text
     }

get_reports_response_report_report_results_result_port
 = element port
     {
       text
     }

get_reports_response_report_report_results_result_nvt
 = element nvt
     {
       attribute oid { oid }
       & get_reports_response_report_report_results_result_nvt_name
       & get_reports_response_report_report_results_result_nvt_cvss_base
       & get_reports_response_report_report_results_result_nvt_risk_factor
     }

get_reports_response_report_report_results_result_nvt_name
 = element name
     {
       name
     }

get_reports_response_report_report_results_result_nvt_cvss_base
 = element cvss_base
     {
       integer
     }

get_reports_response_report_report_results_result_nvt_risk_factor
 = element risk_factor
     {
       integer
     }

get_reports_response_report_report_results_result_threat
 = element threat
     {
       threat
     }

get_reports_response_report_report_results_result_description
 = element description
     {
       text
     }

get_reports_response_report_report_scan_start
 = element scan_start
     {
       ctime
     }

get_reports_response_report_report_host_start
 = element host_start
     {
       text # RNC limitation: ctime
       & get_reports_response_report_report_host_start_host
     }

get_reports_response_report_report_host_start_host
 = element host
     {
       text
     }

get_reports_response_report_report_host_end
 = element host_end
     {
       text # RNC limitation: ctime
       & get_reports_response_report_report_host_end_host
     }

get_reports_response_report_report_host_end_host
 = element host
     {
       text
     }

get_reports_response_report_report_scan_end
 = element scan_end
     {
       ctime
     }

 <get_reports report_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"
              format_id="1a60a67e-97d0-4cbf-bc77-f71b08e7043d"/>

 <get_reports_response status="200"
                       status_text="OK">
   <report id="267a3405-e84a-47da-97b2-5fa0d2e8995e"
           format_id="1a60a67e-97d0-4cbf-bc77-f71b08e7043d"
           extension="pdf"
           content_type="application/pdf">hsisn3qaVFhkjFRG4...</report>
 </get_reports_response>

 <get_reports report_id="f0fdf522-276d-4893-9274-fb8699dc2270"/>

 <get_reports_response status="200"
                       status_text="OK">
   <report id="f0fdf522-276d-4893-9274-fb8699dc2270"
           format_id="d5da9f67-8551-4e51-807b-b6a873d70e34"
           extension="xml"
           content_type="text/xml">
     <report id="f0fdf522-276d-4893-9274-fb8699dc2270">
       <sort>
         <field>
           type
           <order>descending</order>
         </field>
       </sort>
       <filters>
         hmlgd
         <phrase/>
         <notes>0</notes>
         <overrides>0</overrides>
         <apply_overrides>0</apply_overrides>
         <result_hosts_only>1</result_hosts_only>
         <min_cvss_base/>
         <filter>High</filter>
         <filter>Medium</filter>
         <filter>Low</filter>
         <filter>Log</filter>
         <filter>Debug</filter>
       </filters>
       <scan_run_status>Done</scan_run_status>
       <result_count>
         <full>10</full>
         <filtered>10</filtered>
         <debug>
           <full>0</full>
           <filtered>0</filtered>
         </debug>
         <hole>
           <full>0</full>
           <filtered>0</filtered>
         </hole>
         <info>
           <full>7</full>
           <filtered>7</filtered>
         </info>
         <log>
           <full>0</full>
           <filtered>0</filtered>
         </log>
         <warning>
           <full>3</full>
           <filtered>3</filtered>
         </warning>
       </result_count>
       <task id="13bb418a-4220-4575-b35b-ec398bff7417">
         <name>dik mm</name>
       </task>
       <ports start="1"
              max="-1">
         <port>
           general/tcp
           <host>127.0.1.1</host>
           <threat>Medium</threat>
         </port>
         ...
       </ports>
       <results start="1"
                max="-1">
         <result id="634f7a2e-8ca1-43b7-b6d7-0d4841449508">
           <subnet>127.0.1.1</subnet>
           <host>127.0.1.1</host>
           <port>general/tcp</port>
           <nvt oid="1.3.6.1.4.1.25623.1.0.74">
             <name>Test NVT: fields with ISO-8859-1 chars ()</name>
             <cvss_base>5.0</cvss_base>
             <risk_factor>Medium</risk_factor>
           </nvt>
           <threat>Medium</threat>
           <description>Test with umlaut Warning Port 0.</description>
         </result>
         ...
       </results>
       <scan_start>Mon Feb 1 19:11:21 2010</scan_start>
       <host_start>
         Mon Feb 1 19:11:21 2010
         <host>127.0.1.1</host>
       </host_start>
       <host_end>
         Mon Feb 1 19:11:52 2010
         <host>127.0.1.1</host>
       </host_end>
       <scan_end>Mon Feb 1 19:11:52 2010</scan_end>
     </report>
   </report>
 </get_reports_response>

get_report_formats
 = element get_report_formats
     {
       attribute report_format_id { uuid }?
       & attribute export { boolean }?
       & attribute params { boolean }?
       & attribute sort_order { sort_order }?
       & attribute sort_field { text }?
     }

get_report_formats_response
 = element get_report_formats_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_report_formats_response_report_format*
     }

get_report_formats_response_report_format
 = element report_format
     {
       attribute id { uuid }
       & get_report_formats_response_report_format_name
       & get_report_formats_response_report_format_summary
       & get_report_formats_response_report_format_description
       & get_report_formats_response_report_format_extension
       & get_report_formats_response_report_format_content_type
       & get_report_formats_response_report_format_global
       & get_report_formats_response_report_format_param*
       & ( get_report_formats_response_report_format_file*
           | ( get_report_formats_response_report_format_trust
           & get_report_formats_response_report_format_active ) )
     }

get_report_formats_response_report_format_name
 = element name
     {
       name
     }

get_report_formats_response_report_format_summary
 = element summary
     {
       text
     }

get_report_formats_response_report_format_description
 = element description
     {
       text
     }

get_report_formats_response_report_format_extension
 = element extension
     {
       text
     }

get_report_formats_response_report_format_global
 = element global
     {
       boolean
     }

get_report_formats_response_report_format_content_type
 = element content_type
     {
       text
     }

get_report_formats_response_report_format_param
 = element param
     {
       get_report_formats_response_report_format_param_name
       & get_report_formats_response_report_format_param_type
       & get_report_formats_response_report_format_param_value
       & get_report_formats_response_report_format_param_default
     }

get_report_formats_response_report_format_param_name
 = element name
     {
       name
     }

get_report_formats_response_report_format_param_type
 = element type
     {
       text # RNC limitation: xsd:token { pattern = "boolean|integer|selection|string|text" }
       & get_report_formats_response_report_format_param_type_min?
       & get_report_formats_response_report_format_param_type_max?
       & get_report_formats_response_report_format_param_type_options?
     }

get_report_formats_response_report_format_param_type_min
 = element min
     {
       text
     }

get_report_formats_response_report_format_param_type_max
 = element max
     {
       text
     }

get_report_formats_response_report_format_param_type_options
 = element options
     {
       get_report_formats_response_report_format_param_type_options_option*
     }

get_report_formats_response_report_format_param_type_options_option
 = element option
     {
       text
     }

get_report_formats_response_report_format_param_value
 = element value
     {
       text
     }

get_report_formats_response_report_format_param_default
 = element default
     {
       text
     }

get_report_formats_response_report_format_file
 = element file
     {
       text # RNC limitation: base64
       & attribute name { text }
     }

get_report_formats_response_report_format_trust
 = element trust
     {
       text # RNC limitation: xsd:token { pattern = "yes|no|unknown" }
       & attribute name { text }
       & get_report_formats_response_report_format_trust_time
     }

get_report_formats_response_report_format_trust_time
 = element time
     {
       ctime
     }

get_report_formats_response_report_format_active
 = element active
     {
       boolean
     }

 <get_report_formats report_format_id="b993b6f5-f9fb-4e6e-9c94-dd46c00e058d"/>

 <get_report_formats_response status="200"
                              status_text="OK">
   <report_format id="b993b6f5-f9fb-4e6e-9c94-dd46c00e058d">
     <name>HTML</name>
     <extension>html</extension>
     <content_type>text/html</content_type>
     <summary>Single page HTML report.</summary>
     <description>
       A single HTML page listing results of a scan. Style information
       ...
     </description>
     <global>1</global>
     <trust>
       no
       <time>Thu Dec 2 13:22:26 2010</time>
     </trust>
     <active>1</active>
   </report_format>
 </get_report_formats_response>

 <get_report_formats report_format_id="b993b6f5-f9fb-4e6e-9c94-dd46c00e058d"
                     export="1"/>

 <get_report_formats_response status="200"
                              status_text="OK">
   <report_format id="b993b6f5-f9fb-4e6e-9c94-dd46c00e058d">
     <name>HTML</name>
     <extension>html</extension>
     <content_type>text/html</content_type>
     <summary>Single page HTML report.</summary>
     <description>
       A single HTML page listing results of a scan. Style information
       ...
     </description>
     <global>1</global>
     <file name="HTML.xsl">
       PD9ldD4K
       ...
     </file>
     <file name="generate">
       IyEvAk
       ...
     </file>
     <signature/>
   </report_format>
 </get_report_formats_response>

get_results
 = element get_results
     {
       attribute result_id { uuid }?
       & attribute task_id { uuid }?
       & attribute notes { boolean }?
       & attribute note_details { boolean }?
       & attribute overrides { boolean }?
       & attribute override_details { boolean }?
       & attribute apply_overrides { boolean }?
     }

get_results_response
 = element get_results_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_results_response_results
     }

get_results_response_results
 = element results
     {
       get_results_response_results_result*
     }

get_results_response_results_result
 = element result
     {
       attribute id { uuid }
       & get_results_response_results_result_subnet
       & get_results_response_results_result_host
       & get_results_response_results_result_port
       & get_results_response_results_result_nvt
       & get_results_response_results_result_threat
       & get_results_response_results_result_description
       & get_results_response_results_result_notes?
       & get_results_response_results_result_overrides?
     }

get_results_response_results_result_subnet
 = element subnet
     {
       text
     }

get_results_response_results_result_host
 = element host
     {
       text
     }

get_results_response_results_result_port
 = element port
     {
       text
     }

get_results_response_results_result_nvt
 = element nvt
     {
       attribute oid { oid }
       & get_results_response_results_result_nvt_name
       & get_results_response_results_result_nvt_cvss_base
       & get_results_response_results_result_nvt_risk_factor
       & get_results_response_results_result_nvt_cve
       & get_results_response_results_result_nvt_bid
     }

get_results_response_results_result_nvt_name
 = element name
     {
       name
     }

get_results_response_results_result_nvt_cvss_base
 = element cvss_base
     {
       integer
     }

get_results_response_results_result_nvt_risk_factor
 = element risk_factor
     {
       integer
     }

get_results_response_results_result_nvt_cve
 = element cve
     {
       text
     }

get_results_response_results_result_nvt_bid
 = element bid
     {
       integer
     }

get_results_response_results_result_threat
 = element threat
     {
       threat
     }

get_results_response_results_result_description
 = element description
     {
       text
     }

get_results_response_results_result_notes
 = element notes
     {
       get_results_response_results_result_notes_note*
     }

get_results_response_results_result_notes_note
 = element note
     {
       get_results_response_results_result_notes_note_nvt
       & get_results_response_results_result_notes_note_text
       & get_results_response_results_result_notes_note_orphan
     }

get_results_response_results_result_notes_note_nvt
 = element nvt
     {
       attribute oid { oid }
       & get_results_response_results_result_notes_note_nvt_name
     }

get_results_response_results_result_notes_note_nvt_name
 = element name
     {
       name
     }

get_results_response_results_result_notes_note_text
 = element text
     {
       text
       & attribute excerpt { boolean }
     }

get_results_response_results_result_notes_note_orphan
 = element orphan
     {
       boolean
     }

get_results_response_results_result_overrides
 = element overrides
     {
       get_results_response_results_result_overrides_override*
     }

get_results_response_results_result_overrides_override
 = element override
     {
       get_results_response_results_result_overrides_override_nvt
       & get_results_response_results_result_overrides_override_text
       & get_results_response_results_result_overrides_override_threat
       & get_results_response_results_result_overrides_override_new_threat
       & get_results_response_results_result_overrides_override_orphan
     }

get_results_response_results_result_overrides_override_nvt
 = element nvt
     {
       attribute oid { oid }
       & get_results_response_results_result_overrides_override_nvt_name
     }

get_results_response_results_result_overrides_override_nvt_name
 = element name
     {
       name
     }

get_results_response_results_result_overrides_override_text
 = element text
     {
       text
       & attribute excerpt { boolean }
     }

get_results_response_results_result_overrides_override_threat
 = element threat
     {
       threat
     }

get_results_response_results_result_overrides_override_new_threat
 = element new_threat
     {
       threat
     }

get_results_response_results_result_overrides_override_orphan
 = element orphan
     {
       boolean
     }

 <get_results/>

 <get_results_response status="200"
                       status_text="OK">
   <results>
     <result id="634f7a2e-8ca1-43b7-b6d7-0d4841449508">
       <subnet>127.0.1.1</subnet>
       <host>127.0.1.1</host>
       <port>general/tcp</port>
       <nvt oid="1.3.6.1.4.1.25623.1.0.74">
         <name>Test NVT: fields with ISO-8859-1 chars</name>
         <cvss_base>5.0</cvss_base>
         <risk_factor>Medium</risk_factor>
         <cve>CVE-2009-3095</cve>
         <bid>36254</bid>
       </nvt>
       <threat>Medium</threat>
       <description>Test with umlaut.</description>
     </result>
     ...
   </results>
 </get_results_response>

 <get_results result_id="cac9e7c8-c726-49fd-a710-5f99079ab93e"
              task_id="40b236a9-2b0f-4813-b8c7-bc2b98d9d7e4"
              notes="1"
              overrides="1"/>

 <get_results_response status="200"
                       status_text="OK">
   <results>
     <result id="cac9e7c8-c726-49fd-a710-5f99079ab93e">
       <subnet>127.0.0.1</subnet>
       <host>127.0.0.1</host>
       <port>general/tcp</port>
       <nvt oid="1.3.6.1.4.1.25623.1.0.75">
         <name>Test NVT: long lines</name>
         <cvss_base>9</cvss_base>
         <risk_factor>High</risk_factor>
         <cve>CVE-2009-3095</cve>
         <bid>36254</bid>
       </nvt>
       <threat>High</threat>
       <description>Test with very long warning.</description>
       <original_threat>Medium</original_threat>
       <notes/>
       <overrides>
         <override id="b0832812-75f1-45eb-b676-99c6e6bf2b24">
           <nvt oid="1.3.6.1.4.1.25623.1.0.75">
             <name>Test NVT: long lines</name>
           </nvt>
           <text excerpt="0">Test override</text>
           <new_threat>High</new_threat>
           <orphan>0</orphan>
         </override>
       </overrides>
     </result>
   </results>
 </get_results_response>

get_schedules
 = element get_schedules
     {
       attribute schedule_id { uuid }?
       & attribute details { boolean }?
       & attribute sort_order { sort_order }?
       & attribute sort_field { text }?
     }

get_schedules_response
 = element get_schedules_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_schedules_response_schedule*
     }

get_schedules_response_schedule
 = element schedule
     {
       attribute id { uuid }
       & get_schedules_response_schedule_name
       & ( get_schedules_response_schedule_comment
           & get_schedules_response_schedule_first_time
           & get_schedules_response_schedule_next_time
           & get_schedules_response_schedule_period
           & get_schedules_response_schedule_period_months
           & get_schedules_response_schedule_duration
           & get_schedules_response_schedule_in_use
           & get_schedules_response_schedule_tasks )?
     }

get_schedules_response_schedule_name
 = element name
     {
       name
     }

get_schedules_response_schedule_comment
 = element comment
     {
       text
     }

get_schedules_response_schedule_first_time
 = element first_time
     {
       ctime
     }

get_schedules_response_schedule_next_time
 = element next_time
     {
       ctime
     }

get_schedules_response_schedule_period
 = element period
     {
       integer
     }

get_schedules_response_schedule_period_months
 = element period_months
     {
       integer
     }

get_schedules_response_schedule_duration
 = element duration
     {
       integer
     }

get_schedules_response_schedule_in_use
 = element in_use
     {
       boolean
     }

get_schedules_response_schedule_tasks
 = element tasks
     {
       get_schedules_response_schedule_tasks_task*
     }

get_schedules_response_schedule_tasks_task
 = element task
     {
       attribute id { uuid }
       & get_schedules_response_schedule_tasks_task_name
     }

get_schedules_response_schedule_tasks_task_name
 = element name
     {
       name
     }

 <get_schedules/>

 <get_schedules_response status="200"
                         status_text="OK">
   <schedule id="c33864a9-d3fd-44b3-8717-972bfb01dfcf">
     <name>Overnight</name>
   </schedule>
   ...
 </get_schedules_response>

 <get_schedules schedule_id="c33864a9-d3fd-44b3-8717-972bfb01dfcf"
                details="1"/>

 <get_schedules_response status="200"
                         status_text="OK">
   <schedule id="c33864a9-d3fd-44b3-8717-972bfb01dfcf">
     <name>Overnight</name>
     <comment>3 hours, starting at 12h00.</comment>
     <first_time>Tue Jun 29 00:00:00 2010</first_time>
     <next_time>Tue Jun 29 00:00:00 2010</next_time>
     <period>86400</period>
     <period_months>0</period_months>
     <duration>10800</duration>
     <in_use>1</in_use>
     <tasks>
       <task id="d4daf4c4-25c7-40ac-87d3-38e489f34330">
         <name>kk</name>
       </task>
     </tasks>
   </schedule>
 </get_schedules_response>

get_slaves
 = element get_slaves
     {
       attribute slave_id { uuid }?
       & attribute tasks { boolean }?
       & attribute sort_order { sort_order }?
       & attribute sort_field { text }?
     }

get_slaves_response
 = element get_slaves_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_slaves_response_slave*
     }

get_slaves_response_slave
 = element slave
     {
       attribute id { uuid }
       & get_slaves_response_slave_name
       & get_slaves_response_slave_comment
       & get_slaves_response_slave_host
       & get_slaves_response_slave_port
       & get_slaves_response_slave_login
       & get_slaves_response_slave_password
       & get_slaves_response_slave_in_use
       & get_slaves_response_slave_tasks?
     }

get_slaves_response_slave_name
 = element name
     {
       name
     }

get_slaves_response_slave_comment
 = element comment
     {
       text
     }

get_slaves_response_slave_host
 = element host
     {
       text
     }

get_slaves_response_slave_port
 = element port
     {
       text
     }

get_slaves_response_slave_login
 = element login
     {
       text
     }

get_slaves_response_slave_password
 = element password
     {
       text
     }

get_slaves_response_slave_in_use
 = element in_use
     {
       boolean
     }

get_slaves_response_slave_tasks
 = element tasks
     {
       get_slaves_response_slave_tasks_task*
     }

get_slaves_response_slave_tasks_task
 = element task
     {
       attribute id { uuid }
       & get_slaves_response_slave_tasks_task_name
     }

get_slaves_response_slave_tasks_task_name
 = element name
     {
       name
     }

 <get_slaves tasks="1"/>

 <get_slaves_response status="200"
                      status_text="OK">
   <slave id="c33864a9-d3fd-44b3-8717-972bfb01dfcf">
     <name>Bangkok</name>
     <comment>Manager in Bangkok department.</comment>
     <host>192.0.32.10</host>
     <login>sally</login>
     <password>secret</password>
     <tasks>
       <task id="c33864a9-d3fd-44b3-8717-972bfb01dfc0">
         <name>Debian desktops</name>
       </task>
       ...
     </tasks>
   </slave>
   ...
 </get_slaves_response>

get_system_reports
 = element get_system_reports
     {
       attribute name { text }?
       & attribute duration { integer }?
       & attribute brief { boolean }?
       & attribute slave_id { uuid }?
     }

get_system_reports_response
 = element get_system_reports_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_system_reports_response_system_report*
     }

get_system_reports_response_system_report
 = element system_report
     {
       get_system_reports_response_system_report_name
       & get_system_reports_response_system_report_title
       & get_system_reports_response_system_report_report?
     }

get_system_reports_response_system_report_name
 = element name
     {
       name
     }

get_system_reports_response_system_report_title
 = element title
     {
       text
     }

get_system_reports_response_system_report_report
 = element report
     {
       text # RNC limitation: base64
       & attribute format { "png" }
       & attribute duration { integer }
     }

 <get_system_reports brief="1"/>

 <get_system_reports_response status="200"
                              status_text="OK">
   <system_report>
     <name>proc</name>
     <title>Processes</title>
   </system_report>
   <system_report>
     <name>load</name>
     <title>System Load</title>
   </system_report>
   <system_report>
     <name>cpu_0</name>
     <title>CPU Usage: CPU 0</title>
   </system_report>
   ...
 </get_system_reports_response>

 <get_system_reports name="proc"/>

 <get_system_reports_response status="200"
                              status_text="OK">
   <system_report>
     <name>proc</name>
     <title>Processes</title>
     <report format="png"
             duration="86400">
       iVBORw0KGgoAAAANSUhEUgAAArkAAAE...2bEdAAAAAElFTkSuQmCC
     </report>
   </system_report>
 </get_system_reports_response>

get_target_locators
 = element get_target_locators
     {
       ""
     }

get_target_locators_response
 = element get_target_locators_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_target_locators_response_target_locator*
     }

get_target_locators_response_target_locator
 = element target_locator
     {
       get_target_locators_response_target_locator_name
     }

get_target_locators_response_target_locator_name
 = element name
     {
       name
     }

 <get_target_locators/>

 <get_target_locators_response status="200"
                               status_text="OK">
   <target_locator>
     <name>ldap</name>
   </target_locator>
   ...
 </get_target_locators_response>

get_targets
 = element get_targets
     {
       attribute target_id { uuid }?
       & attribute tasks { boolean }?
       & attribute sort_order { sort_order }?
       & attribute sort_field { text }?
     }

get_targets_response
 = element get_targets_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_targets_response_target*
     }

get_targets_response_target
 = element target
     {
       get_targets_response_target_name
       & get_targets_response_target_comment
       & get_targets_response_target_hosts
       & get_targets_response_target_max_hosts
       & get_targets_response_target_in_use
       & get_targets_response_target_ssh_lsc_credential
       & get_targets_response_target_smb_lsc_credential
       & get_targets_response_target_port_range
       & get_targets_response_target_tasks?
     }

get_targets_response_target_name
 = element name
     {
       name
     }

get_targets_response_target_comment
 = element comment
     {
       text
     }

get_targets_response_target_hosts
 = element hosts
     {
       text
     }

get_targets_response_target_max_hosts
 = element max_hosts
     {
       integer
     }

get_targets_response_target_in_use
 = element in_use
     {
       boolean
     }

get_targets_response_target_ssh_lsc_credential
 = element ssh_lsc_credential
     {
       attribute id { uuid_or_empty }
       & get_targets_response_target_ssh_lsc_credential_name
     }

get_targets_response_target_ssh_lsc_credential_name
 = element name
     {
       name
     }

get_targets_response_target_smb_lsc_credential
 = element smb_lsc_credential
     {
       attribute id { uuid_or_empty }
       & get_targets_response_target_smb_lsc_credential_name
     }

get_targets_response_target_smb_lsc_credential_name
 = element name
     {
       name
     }

get_targets_response_target_port_range
 = element port_range
     {
       name
     }

get_targets_response_target_tasks
 = element tasks
     {
       get_targets_response_target_tasks_task*
     }

get_targets_response_target_tasks_task
 = element task
     {
       attribute id { uuid }
       & get_targets_response_target_tasks_task_name
     }

get_targets_response_target_tasks_task_name
 = element name
     {
       name
     }

 <get_targets/>

 <get_targets_response status="200"
                       status_text="OK">
   <target id="b493b7a8-7489-11df-a3ec-002264764cea">
     <name>Localhost</name>
     <hosts>localhost</hosts>
     <max_hosts>1</max_hosts>
     <comment/>
     <in_use>7</in_use>
     <ssh_lsc_credential id="">
       <name/>
     </ssh_lsc_credential>
     <smb_lsc_credential id="">
       <name/>
     </smb_lsc_credential>
   </target>
   ...
 </get_targets_response>

 <get_targets target_id="c33864a9-d3fd-44b3-8717-972bfb01dfcf"
              tasks="1"/>

 <get_targets_response status="200"
                       status_text="OK">
   <target id="1f28d970-17ef-4c69-ba8a-13827059f2b9">
     <name>dik</name>
     <hosts>dik.example.org</hosts>
     <max_hosts>1</max_hosts>
     <comment>dik mm</comment>
     <in_use>4</in_use>
     <ssh_lsc_credential id="58ff2793-2dc7-43fe-85f9-20bfac5a87e4">
       <name>mm</name>
     </ssh_lsc_credential>
     <smb_lsc_credential id="">
       <name/>
     </smb_lsc_credential>
     <tasks>
       <task id="13bb418a-4220-4575-b35b-ec398bff7417">
         <name>dik mm</name>
       </task>
       ...
     </tasks>
   </target>
 </get_targets_response>

get_tasks
 = element get_tasks
     {
       attribute task_id { uuid }?
       & attribute details { boolean }?
       & attribute rcfile { boolean }?
       & attribute apply_overrides { boolean }?
       & attribute sort_order { sort_order }?
       & attribute sort_field { text }?
     }

get_tasks_response
 = element get_tasks_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_tasks_response_task_count
       & get_tasks_response_sort
       & get_tasks_response_apply_overrides
       & get_tasks_response_task*
     }

get_tasks_response_task_count
 = element task_count
     {
       integer
     }

get_tasks_response_sort
 = element sort
     {
       get_tasks_response_sort_field*
     }

get_tasks_response_sort_field
 = element field
     {
       text
       & get_tasks_response_sort_field_order
     }

get_tasks_response_sort_field_order
 = element order
     {
       xsd:token { pattern = "ascending|descending" }
     }

get_tasks_response_apply_overrides
 = element apply_overrides
     {
       xsd:token { pattern = "0|1" }
     }

get_tasks_response_task
 = element task
     {
       get_tasks_response_task_name
       & get_tasks_response_task_comment
       & get_tasks_response_task_status
       & get_tasks_response_task_progress
       & get_tasks_response_task_config
       & get_tasks_response_task_target
       & get_tasks_response_task_escalator
       & get_tasks_response_task_schedule
       & get_tasks_response_task_slave
       & get_tasks_response_task_report_count
       & get_tasks_response_task_trend
       & get_tasks_response_task_first_report?
       & get_tasks_response_task_last_report?
       & get_tasks_response_task_second_last_report?
       & get_tasks_response_task_rcfile?
       & get_tasks_response_task_reports*
     }

get_tasks_response_task_name
 = element name
     {
       name
     }

get_tasks_response_task_comment
 = element comment
     {
       text
     }

get_tasks_response_task_status
 = element status
     {
       task_status
     }

get_tasks_response_task_progress
 = element progress
     {
       text # RNC limitation: integer
       & get_tasks_response_task_progress_host_progress*
     }

get_tasks_response_task_progress_host_progress
 = element host_progress
     {
       text # RNC limitation: integer
       & get_tasks_response_task_progress_host_progress_host
     }

get_tasks_response_task_progress_host_progress_host
 = element host
     {
       text
     }

get_tasks_response_task_config
 = element config
     {
       attribute id { uuid }
       & get_tasks_response_task_config_name
     }

get_tasks_response_task_config_name
 = element name
     {
       name
     }

get_tasks_response_task_target
 = element target
     {
       attribute id { uuid }
       & get_tasks_response_task_target_name
     }

get_tasks_response_task_target_name
 = element name
     {
       name
     }

get_tasks_response_task_escalator
 = element escalator
     {
       attribute id { uuid_or_empty }
       & get_tasks_response_task_escalator_name
     }

get_tasks_response_task_escalator_name
 = element name
     {
       name
     }

get_tasks_response_task_schedule
 = element schedule
     {
       attribute id { uuid_or_empty }
       & get_tasks_response_task_schedule_name
     }

get_tasks_response_task_schedule_name
 = element name
     {
       name
     }

get_tasks_response_task_slave
 = element slave
     {
       attribute id { uuid }
       & get_tasks_response_task_slave_name
     }

get_tasks_response_task_slave_name
 = element name
     {
       name
     }

get_tasks_response_task_report_count
 = element report_count
     {
       text # RNC limitation: integer
       & get_tasks_response_task_report_count_finished
     }

get_tasks_response_task_report_count_finished
 = element finished
     {
       integer
     }

get_tasks_response_task_trend
 = element trend
     {
       task_trend
     }

get_tasks_response_task_first_report
 = element first_report
     {
       get_tasks_response_task_first_report_report
     }

get_tasks_response_task_first_report_report
 = element report
     {
       attribute id { uuid }
       & get_tasks_response_task_first_report_report_timestamp
       & get_tasks_response_task_first_report_report_result_count
     }

get_tasks_response_task_first_report_report_timestamp
 = element timestamp
     {
       ctime
     }

get_tasks_response_task_first_report_report_result_count
 = element result_count
     {
       get_tasks_response_task_first_report_report_result_count_debug
       & get_tasks_response_task_first_report_report_result_count_log
       & get_tasks_response_task_first_report_report_result_count_info
       & get_tasks_response_task_first_report_report_result_count_warning
       & get_tasks_response_task_first_report_report_result_count_hole
     }

get_tasks_response_task_first_report_report_result_count_debug
 = element debug
     {
       integer
     }

get_tasks_response_task_first_report_report_result_count_log
 = element log
     {
       integer
     }

get_tasks_response_task_first_report_report_result_count_info
 = element info
     {
       integer
     }

get_tasks_response_task_first_report_report_result_count_warning
 = element warning
     {
       integer
     }

get_tasks_response_task_first_report_report_result_count_hole
 = element hole
     {
       integer
     }

get_tasks_response_task_last_report
 = element last_report
     {
       get_tasks_response_task_last_report_report
     }

get_tasks_response_task_last_report_report
 = element report
     {
       attribute id { uuid }
       & get_tasks_response_task_last_report_report_timestamp
       & get_tasks_response_task_last_report_report_result_count
     }

get_tasks_response_task_last_report_report_timestamp
 = element timestamp
     {
       ctime
     }

get_tasks_response_task_last_report_report_result_count
 = element result_count
     {
       get_tasks_response_task_last_report_report_result_count_debug
       & get_tasks_response_task_last_report_report_result_count_log
       & get_tasks_response_task_last_report_report_result_count_info
       & get_tasks_response_task_last_report_report_result_count_warning
       & get_tasks_response_task_last_report_report_result_count_hole
     }

get_tasks_response_task_last_report_report_result_count_debug
 = element debug
     {
       integer
     }

get_tasks_response_task_last_report_report_result_count_log
 = element log
     {
       integer
     }

get_tasks_response_task_last_report_report_result_count_info
 = element info
     {
       integer
     }

get_tasks_response_task_last_report_report_result_count_warning
 = element warning
     {
       integer
     }

get_tasks_response_task_last_report_report_result_count_hole
 = element hole
     {
       integer
     }

get_tasks_response_task_second_last_report
 = element second_last_report
     {
       get_tasks_response_task_second_last_report_report
     }

get_tasks_response_task_second_last_report_report
 = element report
     {
       attribute id { uuid }
       & get_tasks_response_task_second_last_report_report_timestamp
       & get_tasks_response_task_second_last_report_report_result_count
     }

get_tasks_response_task_second_last_report_report_timestamp
 = element timestamp
     {
       ctime
     }

get_tasks_response_task_second_last_report_report_result_count
 = element result_count
     {
       get_tasks_response_task_second_last_report_report_result_count_debug
       & get_tasks_response_task_second_last_report_report_result_count_log
       & get_tasks_response_task_second_last_report_report_result_count_info
       & get_tasks_response_task_second_last_report_report_result_count_warning
       & get_tasks_response_task_second_last_report_report_result_count_hole
     }

get_tasks_response_task_second_last_report_report_result_count_debug
 = element debug
     {
       integer
     }

get_tasks_response_task_second_last_report_report_result_count_log
 = element log
     {
       integer
     }

get_tasks_response_task_second_last_report_report_result_count_info
 = element info
     {
       integer
     }

get_tasks_response_task_second_last_report_report_result_count_warning
 = element warning
     {
       integer
     }

get_tasks_response_task_second_last_report_report_result_count_hole
 = element hole
     {
       integer
     }

get_tasks_response_task_rcfile
 = element rcfile
     {
       base64
     }

get_tasks_response_task_reports
 = element reports
     {
       get_tasks_response_task_reports_report*
     }

get_tasks_response_task_reports_report
 = element report
     {
       attribute id { uuid }
       & get_tasks_response_task_reports_report_timestamp
       & get_tasks_response_task_reports_report_scan_run_status
       & get_tasks_response_task_reports_report_result_count
     }

get_tasks_response_task_reports_report_timestamp
 = element timestamp
     {
       ctime
     }

get_tasks_response_task_reports_report_scan_run_status
 = element scan_run_status
     {
       task_status
     }

get_tasks_response_task_reports_report_result_count
 = element result_count
     {
       get_tasks_response_task_reports_report_result_count_debug
       & get_tasks_response_task_reports_report_result_count_log
       & get_tasks_response_task_reports_report_result_count_info
       & get_tasks_response_task_reports_report_result_count_warning
       & get_tasks_response_task_reports_report_result_count_hole
     }

get_tasks_response_task_reports_report_result_count_debug
 = element debug
     {
       integer
     }

get_tasks_response_task_reports_report_result_count_log
 = element log
     {
       integer
     }

get_tasks_response_task_reports_report_result_count_info
 = element info
     {
       integer
     }

get_tasks_response_task_reports_report_result_count_warning
 = element warning
     {
       integer
     }

get_tasks_response_task_reports_report_result_count_hole
 = element hole
     {
       integer
     }

 <get_tasks/>

 <get_tasks_response status="200"
                     status_text="OK">
   <task_count>2</task_count>
   <sort>
     <field>
       ROWID
       <order>ascending</order>
     </field>
   </sort>
   <apply_overrides>0</apply_overrides>
   <task id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6">
     <name>Scan Webserver</name>
     <comment>Scan of the web server.</comment>
     <status>Done</status>
     <progress>-1</progress>
     <config id="daba56c8-73ec-11df-a475-002264764cea">
       <name>Full and fast</name>
     </config>
     <escalator id="">
       <name/>
     </escalator>
     <target id="1f28d970-17ef-4c69-ba8a-13827059f2b9">
       <name>dik</name>
     </target>
     <schedule id="">
       <name/>
       <next_time>over</next_time>
     </schedule>
     <slave id="">
       <name/>
     </slave>
     <report_count>
       2
       <finished>2</finished>
     </report_count>
     <trend/>
     <first_report>
       <report id="f0fdf522-276d-4893-9274-fb8699dc2270">
         <timestamp>Mon Feb 1 19:11:20 2010</timestamp>
         <result_count>
           <debug>0</debug>
           <hole>0</hole>
           <info>7</info>
           <log>0</log>
           <warning>3</warning>
         </result_count>
       </report>
     </first_report>
     <last_report>
       <report id="f0fdf522-276d-4893-9274-fb8699dc2270">
         <timestamp>Mon Feb 1 19:11:20 2010</timestamp>
         <result_count>
           <debug>0</debug>
           <hole>0</hole>
           <info>7</info>
           <log>0</log>
           <warning>3</warning>
         </result_count>
       </report>
     </last_report>
     <second_last_report>
       <report id="f0fdf522-276d-4893-9274-fb8699dc2270">
         <timestamp>Mon Feb 1 19:11:20 2010</timestamp>
         <result_count>
           <debug>0</debug>
           <hole>0</hole>
           <info>7</info>
           <log>0</log>
           <warning>3</warning>
         </result_count>
       </report>
     </second_last_report>
   </task>
   <task id="f14747d3-a4d7-4e79-99bb-a0a1276cb78c">
     <name>Scan Mailserver</name>
     ...
   </task>
 </get_tasks_response>

 <get_tasks task_id="f14747d3-a4d7-4e79-99bb-a0a1276cb78c"
            details="1"/>

 <get_tasks_response status="200"
                     status_text="OK">
   <task_count>1</task_count>
   <sort>
     <field>
       ROWID
       <order>ascending</order>
     </field>
   </sort>
   <apply_overrides>0</apply_overrides>
   <task id="13bb418a-4220-4575-b35b-ec398bff7417">
     <name>Scan Mailserver</name>
     <comment>Scan of the web server.</comment>
     <status>Done</status>
     <progress>-1</progress>
     <config id="daba56c8-73ec-11df-a475-002264764cea">
       <name>Full and fast</name>
     </config>
     <escalator id="">
       <name/>
     </escalator>
     <target id="1f28d970-17ef-4c69-ba8a-13827059f2b9">
       <name>dik</name>
     </target>
     <schedule id="">
       <name/>
       <next_time>over</next_time>
     </schedule>
     <slave id="">
       <name/>
     </slave>
     <report_count>
       2
       <finished>2</finished>
     </report_count>
     <trend/>
     <first_report>
       <report id="f0fdf522-276d-4893-9274-fb8699dc2270">
         <timestamp>Mon Feb 1 19:11:20 2010</timestamp>
         <result_count>
           <debug>0</debug>
           <hole>0</hole>
           <info>7</info>
           <log>0</log>
           <warning>3</warning>
         </result_count>
       </report>
     </first_report>
     <last_report>
       <report id="2688e6c7-db29-4505-80f1-0fd4a09e1011">
         <timestamp>Mon Feb 1 19:11:20 2010</timestamp>
         <result_count>
           <debug>0</debug>
           <hole>0</hole>
           <info>7</info>
           <log>0</log>
           <warning>3</warning>
         </result_count>
       </report>
     </last_report>
     <second_last_report>
       <report id="f0fdf522-276d-4893-9274-fb8699dc2270">
         <timestamp>Mon Feb 1 19:11:20 2010</timestamp>
         <result_count>
           <debug>0</debug>
           <hole>0</hole>
           <info>7</info>
           <log>0</log>
           <warning>3</warning>
         </result_count>
       </report>
     </second_last_report>
     <reports>
       <report id="f0fdf522-276d-4893-9274-fb8699dc2270">
         <timestamp>Mon Feb 1 18:51:38 2010</timestamp>
         <scan_run_status>Done</scan_run_status>
         <result_count>
           <debug>0</debug>
           <hole>0</hole>
           <info>7</info>
           <log>0</log>
           <warning>3</warning>
         </result_count>
       </report>
       <report id="2688e6c7-db29-4505-80f1-0fd4a09e1011">
         <timestamp>Mon Feb 1 19:11:20 2010</timestamp>
         <scan_run_status>Done</scan_run_status>
         <result_count>
           <debug>0</debug>
           <hole>0</hole>
           <info>7</info>
           <log>0</log>
           <warning>3</warning>
         </result_count>
       </report>
     </reports>
   </task>
 </get_tasks_response>

get_version
 = element get_version
     {
       ""
     }

get_version_response
 = element get_version_response
     {
       attribute status { status }
       & attribute status_text { text }
       & get_version_response_version
     }

get_version_response_version
 = element version
     {
       text
     }

 <get_version/>

 <get_version_response status="200"
                       status_text="OK">
   <version>1.0</version>
 </get_version_response>

help
 = element help
     {
       attribute format { xsd:token { pattern = "html|HTML|rnc|RNC|text|TEXT|xml|XML" } }?
     }

help_response
 = element help_response
     {
       text
       & attribute status { status }
       & attribute status_text { text }
       & help_response_schema?
     }

help_response_schema
 = element schema
     {
       help_response_schema_protocol
     }

help_response_schema_protocol
 = element protocol
     {
       help_response_schema_protocol_name
       & help_response_schema_protocol_abbreviation?
       & help_response_schema_protocol_summary?
       & help_response_schema_protocol_version?
       & help_response_schema_protocol_type*
       & help_response_schema_protocol_command*
     }

help_response_schema_protocol_name
 = element name
     {
       text
     }

help_response_schema_protocol_abbreviation
 = element abbreviation
     {
       text
     }

help_response_schema_protocol_summary
 = element summary
     {
       text
     }

help_response_schema_protocol_version
 = element version
     {
       text
     }

help_response_schema_protocol_type
 = element type
     {
       help_response_schema_protocol_type_name
       & help_response_schema_protocol_type_summary?
       & help_response_schema_protocol_type_description?
       & help_response_schema_protocol_type_pattern
     }

help_response_schema_protocol_type_name
 = element name
     {
       type_name
     }

help_response_schema_protocol_type_summary
 = element summary
     {
       text
     }

help_response_schema_protocol_type_description
 = element description
     {
       text
       & help_response_schema_protocol_type_description_p*
     }

help_response_schema_protocol_type_description_p
 = element p
     {
       text
     }

help_response_schema_protocol_type_pattern
 = element pattern
     {
       text
     }

help_response_schema_protocol_command
 = element command    # type command_definition
     {
       command_definition_name
       & command_definition_summary?
       & command_definition_description?
       & ( ( command_definition_pattern
           & command_definition_response )
           | ( command_definition_type
           & command_definition_ele* ) )
       & command_definition_example*
     }

 <help/>

 <help_response status="200"
                status_text="OK">
            AUTHENTICATE           Authenticate with the manager.
            COMMANDS               Run a list of commands.
            CREATE_AGENT           Create an agent.
            CREATE_CONFIG          Create a config.
            CREATE_ESCALATOR       Create an escalator.
            CREATE_LSC_CREDENTIAL  Create a local security check credential.
            CREATE_NOTE            Create a note.
            CREATE_OVERRIDE        Create an override.
            CREATE_REPORT_FORMAT   Create a report format.
            CREATE_SCHEDULE        Create a schedule.
            CREATE_SLAVE           Create a slave.
            CREATE_TARGET          Create a target.
            CREATE_TASK            Create a task.
            DELETE_AGENT           Delete an agent.
            DELETE_CONFIG          Delete a config.
            DELETE_ESCALATOR       Delete an escalator.
            DELETE_LSC_CREDENTIAL  Delete a local security check credential.
            DELETE_NOTE            Delete a note.
            DELETE_OVERRIDE        Delete an override.
            DELETE_REPORT          Delete a report.
            DELETE_REPORT_FORMAT   Delete a report format.
            DELETE_SCHEDULE        Delete a schedule.
            DELETE_SLAVE           Delete a slave.
            DELETE_TARGET          Delete a target.
            DELETE_TASK            Delete a task.
            GET_AGENTS             Get all agents.
            GET_CONFIGS            Get all configs.
            GET_DEPENDENCIES       Get dependencies for all available NVTs.
            GET_ESCALATORS         Get all escalators.
            GET_LSC_CREDENTIALS    Get all local security check credentials.
            GET_NOTES              Get all notes.
            GET_NVTS               Get one or all available NVTs.
            GET_NVT_FAMILIES       Get a list of all NVT families.
            GET_NVT_FEED_CHECKSUM  Get checksum for entire NVT collection.
            GET_OVERRIDES          Get all overrides.
            GET_PREFERENCES        Get preferences for all available NVTs.
            GET_REPORTS            Get all reports.
            GET_REPORT_FORMATS     Get all report formats.
            GET_RESULTS            Get results.
            GET_SCHEDULES          Get all schedules.
            GET_SLAVES             Get all slaves.
            GET_SYSTEM_REPORTS     Get all system reports.
            GET_TARGET_LOCATORS    Get configured target locators.
            GET_TARGETS            Get all targets.
            GET_TASKS              Get all tasks.
            GET_VERSION            Get the OpenVAS Manager Protocol version.
            HELP                   Get this help text.
            MODIFY_CONFIG          Update an existing config.
            MODIFY_LSC_CREDENTIAL  Modify an existing LSC credential.
            MODIFY_NOTE            Modify an existing note.
            MODIFY_OVERRIDE        Modify an existing override.
            MODIFY_REPORT          Modify an existing report.
            MODIFY_REPORT_FORMAT   Modify an existing report format.
            MODIFY_TASK            Update an existing task.
            PAUSE_TASK             Pause a running task.
            RESUME_OR_START_TASK   Resume task if stopped, else start task.
            RESUME_PAUSED_TASK     Resume a paused task.
            RESUME_STOPPED_TASK    Resume a stopped task.
            START_TASK             Manually start an existing task.
            STOP_TASK              Stop a running task.
            TEST_ESCALATOR         Run an escalator.
            VERIFY_AGENT           Verify an agent.
            VERIFY_REPORT_FORMAT   Verify a report format.
 </help_response>

 <help format="XML"/>

 <help_response status="200"
                status_text="OK">
   <schema format="XML"
           extension="xml"
           content_type="text/xml">
     <protocol>
       <name>OpenVAS Management Protocol</name>
       <abbreviation>OMP</abbreviation>
       <summary>
         The "management" protocol of the Open Vulnerability Assessment System
       </summary>
       <version>1.0</version>
       <type>
         <name>base64</name>
         <summary>Base64 encoded data</summary>
         <pattern>xsd:base64Binary</pattern>
       </type>
       ...
       <command>
         <name>authenticate</name>
         <summary>Authenticate with the manager</summary>
         <description>
           <p>
                    The client uses the authenticate command to authenticate with the
                    Manager.
           </p>
           <p>
                    The client normally executes this command at the beginning of each
                    connection.  The only commands permitted before authentication are
                    get_version and commands.
           </p>
         </description>
         <pattern>
           <e>credentials</e>
         </pattern>
         <ele>
           <name>credentials</name>
           <pattern>
             <e>username</e>
             <e>password</e>
           </pattern>
           <ele>
             <name>username</name>
             <summary>The login name of the user</summary>
             <pattern>text</pattern>
           </ele>
           <ele>
             <name>password</name>
             <summary>The user's password</summary>
             <pattern>text</pattern>
           </ele>
         </ele>
         <response>
           <pattern>
             <attrib>
               <name>status</name>
               <type>status</type>
               <required>1</required>
             </attrib>
             <attrib>
               <name>status_text</name>
               <type>text</type>
               <required>1</required>
             </attrib>
           </pattern>
         </response>
         <example>
           <summary>Authenticate with a good password</summary>
           <request>
             <authenticate>
               <credentials>
                 <username>sally</username>
                 <password>secret</password>
               </credentials>
             </authenticate>
           </request>
           <response>
             <authenticate_response status="200"
                                    status_text="OK"/>
           </response>
         </example>
         ...
       </command>
       ...
     </protocol>
   </schema>
 </help_response>

modify_config
 = element modify_config
     {
       attribute config_id { uuid }
       & ( modify_config_preference
           | modify_config_family_selection
           | modify_config_nvt_selection )
     }

modify_config_preference
 = element preference
     {
       modify_config_preference_name
       & modify_config_preference_nvt?
       & modify_config_preference_value?
     }

modify_config_preference_name
 = element name
     {
       name
     }

modify_config_preference_nvt
 = element nvt
     {
       attribute oid { oid }
     }

modify_config_preference_value
 = element value
     {
       base64
     }

modify_config_family_selection
 = element family_selection
     {
       modify_config_family_selection_growing?
       & modify_config_family_selection_family*
     }

modify_config_family_selection_growing
 = element growing
     {
       boolean_atoi
     }

modify_config_family_selection_family
 = element family
     {
       modify_config_family_selection_family_all?
       & modify_config_family_selection_family_growing?
       & modify_config_family_selection_family_name
     }

modify_config_family_selection_family_all
 = element all
     {
       boolean_atoi
     }

modify_config_family_selection_family_growing
 = element growing
     {
       boolean_atoi
     }

modify_config_family_selection_family_name
 = element name
     {
       name
     }

modify_config_nvt_selection
 = element nvt_selection
     {
       modify_config_nvt_selection_family
       & modify_config_nvt_selection_nvt*
     }

modify_config_nvt_selection_family
 = element family
     {
       name
     }

modify_config_nvt_selection_nvt
 = element nvt
     {
       attribute oid { oid }
     }

modify_config_response
 = element modify_config_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <modify_config config_id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6">
   <preference>
     <nvt oid="1.3.6.1.4.1.25623.1.0.14259"/>
     <name>Nmap (NASL wrapper)[checkbox]:UDP port scan</name>
     <value>eWVz</value>
   </preference>
 </modify_config>

 <modify_config_response status="200"
                         status_text="OK"/>

 <modify_config config_id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6">
   <family_selection>
     <growing>1</growing>
     <family>
       <name>Debian Local Security Checks</name>
       <all>1</all>
       <growing>1</growing>
     </family>
   </family_selection>
 </modify_config>

 <modify_config_response status="200"
                         status_text="OK"/>

 <modify_config config_id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6">
   <nvt_selection>
     <family>Debian Local Security Checks</family>
     <nvt oid="1.3.6.1.4.1.25623.1.0.53797"/>
     <nvt oid="1.3.6.1.4.1.25623.1.0.63272"/>
     <nvt oid="1.3.6.1.4.1.25623.1.0.55615"/>
     <nvt oid="1.3.6.1.4.1.25623.1.0.53546"/>
   </nvt_selection>
 </modify_config>

 <modify_config_response status="200"
                         status_text="OK"/>

modify_lsc_credential
 = element modify_lsc_credential
     {
       attribute lsc_credential_id { uuid }
       & modify_lsc_credential_comment?
       & modify_lsc_credential_name?
       & modify_lsc_credential_password?
       & modify_lsc_credential_login?
     }

modify_lsc_credential_name
 = element name
     {
       name
     }

modify_lsc_credential_comment
 = element comment
     {
       text
     }

modify_lsc_credential_login
 = element login
     {
       text
     }

modify_lsc_credential_password
 = element password
     {
       text
     }

modify_lsc_credential_response
 = element modify_lsc_credential_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <modify_lsc_credential lsc_credential_id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6">
   <comment>Credential for all machines in lab 4.</comment>
 </modify_lsc_credential>

 <modify_lsc_credential_response status="200"
                                 status_text="OK"/>

modify_note
 = element modify_note
     {
       attribute note_id { uuid }
       & modify_note_hosts?
       & modify_note_port?
       & modify_note_result?
       & modify_note_task?
       & modify_note_text
       & modify_note_threat?
     }

modify_note_hosts
 = element hosts
     {
       text
     }

modify_note_port
 = element port
     {
       text
     }

modify_note_text
 = element text
     {
       text
     }

modify_note_threat
 = element threat
     {
       threat
     }

modify_note_task
 = element task
     {
       attribute id { uuid }
     }

modify_note_result
 = element result
     {
       attribute id { uuid }
     }

modify_note_response
 = element modify_note_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <modify_note note_id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6">
   <text>This issue should be resolved after the upgrade.</text>
   <result result_id="254cd3ef-bbe1-4d58-859d-21b8d0c046c"/>
 </modify_note>

 <modify_note_response status="200"
                       status_text="OK"/>

modify_override
 = element modify_override
     {
       attribute override_id { uuid }
       & modify_override_hosts?
       & modify_override_new_threat?
       & modify_override_port?
       & modify_override_result?
       & modify_override_task?
       & modify_override_text
       & modify_override_threat?
     }

modify_override_hosts
 = element hosts
     {
       text
     }

modify_override_new_threat
 = element new_threat
     {
       threat
     }

modify_override_port
 = element port
     {
       text
     }

modify_override_text
 = element text
     {
       text
     }

modify_override_threat
 = element threat
     {
       threat
     }

modify_override_task
 = element task
     {
       attribute id { uuid }
     }

modify_override_result
 = element result
     {
       attribute id { uuid }
     }

modify_override_response
 = element modify_override_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <modify_override override_id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6">
   <text>This issue is less important in our setup.</text>
   <new_threat>Low</new_threat>
 </modify_override>

 <modify_override_response status="200"
                           status_text="OK"/>

modify_report
 = element modify_report
     {
       attribute report_id { uuid }
       & modify_report_comment
     }

modify_report_comment
 = element comment
     {
       text
     }

modify_report_response
 = element modify_report_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <modify_report report_id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6">
   <comment>Monthly scan of the webserver.</comment>
 </modify_report>

 <modify_report_response status="200"
                         status_text="OK"/>

modify_report_format
 = element modify_report_format
     {
       attribute report_format_id { uuid }
       & ( modify_report_format_active
           | modify_report_format_name
           | modify_report_format_summary
           | modify_report_format_param )
     }

modify_report_format_active
 = element active
     {
       boolean
     }

modify_report_format_name
 = element name
     {
       name
     }

modify_report_format_summary
 = element summary
     {
       text
     }

modify_report_format_param
 = element param
     {
       modify_report_format_param_name
       & modify_report_format_param_value?
     }

modify_report_format_param_name
 = element name
     {
       name
     }

modify_report_format_param_value
 = element value
     {
       base64
     }

modify_report_format_response
 = element modify_report_format_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <modify_report_format report_format_id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6">
   <param>
     <name>Background Colour</name>
     <value>cmVk</value>
   </param>
 </modify_report_format>

 <modify_report_format_response status="200"
                                status_text="OK"/>

 <modify_report_format report_format_id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6">
   <name>New name</name>
 </modify_report_format>

 <modify_report_format_response status="200"
                                status_text="OK"/>

modify_task
 = element modify_task
     {
       attribute task_id { uuid }
       & ( modify_task_comment
           | modify_task_escalator
           | modify_task_name
           | modify_task_rcfile
           | modify_task_schedule
           | modify_task_slave
           | modify_task_file )
     }

modify_task_comment
 = element comment
     {
       text
     }

modify_task_escalator
 = element escalator
     {
       attribute id { uuid }
     }

modify_task_name
 = element name
     {
       name
     }

modify_task_rcfile
 = element rcfile
     {
       base64
     }

modify_task_schedule
 = element schedule
     {
       attribute id { uuid }
     }

modify_task_slave
 = element slave
     {
       attribute id { uuid }
     }

modify_task_file
 = element file
     {
       text # RNC limitation: base64
       & attribute name { text }
       & attribute action { xsd:token { pattern = "update|remove" } }
     }

modify_task_response
 = element modify_task_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <modify_task task_id="254cd3ef-bbe1-4d58-859d-21b8d0c046c6">
   <comment>Monthly scan of the webserver.</comment>
 </modify_task>

 <modify_task_response status="200"
                       status_text="OK"/>

pause_task
 = element pause_task
     {
       attribute task_id { uuid }
     }

pause_task_response
 = element pause_task_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <pause_task task_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <pause_task_response status="200"
                      status_text="OK"/>

resume_or_start_task
 = element resume_or_start_task
     {
       attribute task_id { uuid }
     }

resume_or_start_task_response
 = element resume_or_start_task_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <resume_or_start_task task_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <resume_or_start_task_response status="200"
                                status_text="OK"/>

resume_paused_task
 = element resume_paused_task
     {
       attribute task_id { uuid }
     }

resume_paused_task_response
 = element resume_paused_task_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <resume_paused_task task_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <resume_paused_task_response status="200"
                              status_text="OK"/>

resume_stopped_task
 = element resume_stopped_task
     {
       attribute task_id { uuid }
     }

resume_stopped_task_response
 = element resume_stopped_task_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <resume_stopped_task task_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <resume_stopped_task_response status="200"
                               status_text="OK"/>

start_task
 = element start_task
     {
       attribute task_id { uuid }
     }

start_task_response
 = element start_task_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <start_task task_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <start_task_response status="200"
                      status_text="OK"/>

stop_task
 = element stop_task
     {
       attribute task_id { uuid }
     }

stop_task_response
 = element stop_task_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <stop_task task_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <stop_task_response status="200"
                     status_text="OK"/>

test_escalator
 = element test_escalator
     {
       attribute task_id { uuid }
     }

test_escalator_response
 = element test_escalator_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <test_escalator escalator_id="97390ade-e075-11df-9973-002264764cea"/>

 <test_escalator_response status="200"
                          status_text="OK"/>

verify_agent
 = element verify_agent
     {
       attribute agent_id { uuid }
     }

verify_agent_response
 = element verify_agent_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <verify_agent agent_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <verify_agent_response status="200"
                        status_text="OK"/>

verify_report_format
 = element verify_report_format
     {
       attribute report_format_id { uuid }
     }

verify_report_format_response
 = element verify_report_format_response
     {
       attribute status { status }
       & attribute status_text { text }
     }

 <verify_report_format report_format_id="267a3405-e84a-47da-97b2-5fa0d2e8995e"/>

 <verify_report_format_response status="200"
                                status_text="OK"/>