mirror of
https://github.com/thegeeklab/ansible-later.git
synced 2024-07-06 09:00:58 +02:00
1716 lines
72 KiB
Python
1716 lines
72 KiB
Python
#!/usr/bin/python
|
|
#
|
|
# This file is part of Ansible
|
|
#
|
|
# Ansible is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# Ansible is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
|
|
ANSIBLE_METADATA = {'metadata_version': '1.1',
|
|
'status': ['preview'],
|
|
'supported_by': 'community'}
|
|
|
|
DOCUMENTATION = '''
|
|
---
|
|
module: ce_acl_advance
|
|
version_added: "2.4"
|
|
short_description: Manages advanced ACL configuration on HUAWEI CloudEngine switches.
|
|
description:
|
|
- Manages advanced ACL configurations on HUAWEI CloudEngine switches.
|
|
author:
|
|
- wangdezhuang (@CloudEngine-Ansible)
|
|
options:
|
|
state:
|
|
description:
|
|
- Specify desired state of the resource.
|
|
required: false
|
|
default: present
|
|
choices: ['present','absent','delete_acl']
|
|
acl_name:
|
|
description:
|
|
- ACL number or name.
|
|
For a numbered rule group, the value ranging from 3000 to 3999 indicates a advance ACL.
|
|
For a named rule group, the value is a string of 1 to 32 case-sensitive characters starting
|
|
with a letter, spaces not supported.
|
|
required: true
|
|
acl_num:
|
|
description:
|
|
- ACL number.
|
|
The value is an integer ranging from 3000 to 3999.
|
|
acl_step:
|
|
description:
|
|
- ACL step.
|
|
The value is an integer ranging from 1 to 20. The default value is 5.
|
|
acl_description:
|
|
description:
|
|
- ACL description.
|
|
The value is a string of 1 to 127 characters.
|
|
rule_name:
|
|
description:
|
|
- Name of a basic ACL rule.
|
|
The value is a string of 1 to 32 characters.
|
|
rule_id:
|
|
description:
|
|
- ID of a basic ACL rule in configuration mode.
|
|
The value is an integer ranging from 0 to 4294967294.
|
|
rule_action:
|
|
description:
|
|
- Matching mode of basic ACL rules.
|
|
choices: ['permit','deny']
|
|
protocol:
|
|
description:
|
|
- Protocol type.
|
|
choices: ['ip', 'icmp', 'igmp', 'ipinip', 'tcp', 'udp', 'gre', 'ospf']
|
|
source_ip:
|
|
description:
|
|
- Source IP address.
|
|
The value is a string of 0 to 255 characters.The default value is 0.0.0.0.
|
|
The value is in dotted decimal notation.
|
|
src_mask:
|
|
description:
|
|
- Source IP address mask.
|
|
The value is an integer ranging from 1 to 32.
|
|
src_pool_name:
|
|
description:
|
|
- Name of a source pool.
|
|
The value is a string of 1 to 32 characters.
|
|
dest_ip:
|
|
description:
|
|
- Destination IP address.
|
|
The value is a string of 0 to 255 characters.The default value is 0.0.0.0.
|
|
The value is in dotted decimal notation.
|
|
dest_mask:
|
|
description:
|
|
- Destination IP address mask.
|
|
The value is an integer ranging from 1 to 32.
|
|
dest_pool_name:
|
|
description:
|
|
- Name of a destination pool.
|
|
The value is a string of 1 to 32 characters.
|
|
src_port_op:
|
|
description:
|
|
- Range type of the source port.
|
|
choices: ['lt','eq', 'gt', 'range']
|
|
src_port_begin:
|
|
description:
|
|
- Start port number of the source port.
|
|
The value is an integer ranging from 0 to 65535.
|
|
src_port_end:
|
|
description:
|
|
- End port number of the source port.
|
|
The value is an integer ranging from 0 to 65535.
|
|
src_port_pool_name:
|
|
description:
|
|
- Name of a source port pool.
|
|
The value is a string of 1 to 32 characters.
|
|
dest_port_op:
|
|
description:
|
|
- Range type of the destination port.
|
|
choices: ['lt','eq', 'gt', 'range']
|
|
dest_port_begin:
|
|
description:
|
|
- Start port number of the destination port.
|
|
The value is an integer ranging from 0 to 65535.
|
|
dest_port_end:
|
|
description:
|
|
- End port number of the destination port.
|
|
The value is an integer ranging from 0 to 65535.
|
|
dest_port_pool_name:
|
|
description:
|
|
- Name of a destination port pool.
|
|
The value is a string of 1 to 32 characters.
|
|
frag_type:
|
|
description:
|
|
- Type of packet fragmentation.
|
|
choices: ['fragment', 'clear_fragment']
|
|
precedence:
|
|
description:
|
|
- Data packets can be filtered based on the priority field.
|
|
The value is an integer ranging from 0 to 7.
|
|
tos:
|
|
description:
|
|
- ToS value on which data packet filtering is based.
|
|
The value is an integer ranging from 0 to 15.
|
|
dscp:
|
|
description:
|
|
- Differentiated Services Code Point.
|
|
The value is an integer ranging from 0 to 63.
|
|
icmp_name:
|
|
description:
|
|
- ICMP name.
|
|
choices: ['unconfiged', 'echo', 'echo-reply', 'fragmentneed-DFset', 'host-redirect',
|
|
'host-tos-redirect', 'host-unreachable', 'information-reply', 'information-request',
|
|
'net-redirect', 'net-tos-redirect', 'net-unreachable', 'parameter-problem',
|
|
'port-unreachable', 'protocol-unreachable', 'reassembly-timeout', 'source-quench',
|
|
'source-route-failed', 'timestamp-reply', 'timestamp-request', 'ttl-exceeded',
|
|
'address-mask-reply', 'address-mask-request', 'custom']
|
|
icmp_type:
|
|
description:
|
|
- ICMP type. This parameter is available only when the packet protocol is ICMP.
|
|
The value is an integer ranging from 0 to 255.
|
|
icmp_code:
|
|
description:
|
|
- ICMP message code. Data packets can be filtered based on the ICMP message code.
|
|
The value is an integer ranging from 0 to 255.
|
|
ttl_expired:
|
|
description:
|
|
- Whether TTL Expired is matched, with the TTL value of 1.
|
|
type: bool
|
|
default: 'no'
|
|
vrf_name:
|
|
description:
|
|
- VPN instance name.
|
|
The value is a string of 1 to 31 characters.The default value is _public_.
|
|
syn_flag:
|
|
description:
|
|
- TCP flag value.
|
|
The value is an integer ranging from 0 to 63.
|
|
tcp_flag_mask:
|
|
description:
|
|
- TCP flag mask value.
|
|
The value is an integer ranging from 0 to 63.
|
|
established:
|
|
description:
|
|
- Match established connections.
|
|
type: bool
|
|
default: 'no'
|
|
time_range:
|
|
description:
|
|
- Name of a time range in which an ACL rule takes effect.
|
|
rule_description:
|
|
description:
|
|
- Description about an ACL rule.
|
|
igmp_type:
|
|
description:
|
|
- Internet Group Management Protocol.
|
|
choices: ['host-query', 'mrouter-adver', 'mrouter-solic', 'mrouter-termi', 'mtrace-resp', 'mtrace-route',
|
|
'v1host-report', 'v2host-report', 'v2leave-group', 'v3host-report']
|
|
log_flag:
|
|
description:
|
|
- Flag of logging matched data packets.
|
|
type: bool
|
|
default: 'no'
|
|
'''
|
|
|
|
EXAMPLES = '''
|
|
|
|
- name: CloudEngine advance acl test
|
|
hosts: cloudengine
|
|
connection: local
|
|
gather_facts: no
|
|
vars:
|
|
cli:
|
|
host: "{{ inventory_hostname }}"
|
|
port: "{{ ansible_ssh_port }}"
|
|
username: "{{ username }}"
|
|
password: "{{ password }}"
|
|
transport: cli
|
|
|
|
tasks:
|
|
|
|
- name: "Config ACL"
|
|
ce_acl_advance:
|
|
state: present
|
|
acl_name: 3200
|
|
provider: "{{ cli }}"
|
|
|
|
- name: "Undo ACL"
|
|
ce_acl_advance:
|
|
state: delete_acl
|
|
acl_name: 3200
|
|
provider: "{{ cli }}"
|
|
|
|
- name: "Config ACL advance rule"
|
|
ce_acl_advance:
|
|
state: present
|
|
acl_name: test
|
|
rule_name: test_rule
|
|
rule_id: 111
|
|
rule_action: permit
|
|
protocol: tcp
|
|
source_ip: 10.10.10.10
|
|
src_mask: 24
|
|
frag_type: fragment
|
|
provider: "{{ cli }}"
|
|
|
|
- name: "Undo ACL advance rule"
|
|
ce_acl_advance:
|
|
state: absent
|
|
acl_name: test
|
|
rule_name: test_rule
|
|
rule_id: 111
|
|
rule_action: permit
|
|
protocol: tcp
|
|
source_ip: 10.10.10.10
|
|
src_mask: 24
|
|
frag_type: fragment
|
|
provider: "{{ cli }}"
|
|
'''
|
|
|
|
RETURN = '''
|
|
changed:
|
|
description: check to see if a change was made on the device
|
|
returned: always
|
|
type: boolean
|
|
sample: true
|
|
proposed:
|
|
description: k/v pairs of parameters passed into module
|
|
returned: always
|
|
type: dict
|
|
sample: {"acl_name": "test", "state": "delete_acl"}
|
|
existing:
|
|
description: k/v pairs of existing aaa server
|
|
returned: always
|
|
type: dict
|
|
sample: {"aclNumOrName": "test", "aclType": "Advance"}
|
|
end_state:
|
|
description: k/v pairs of aaa params after module execution
|
|
returned: always
|
|
type: dict
|
|
sample: {}
|
|
updates:
|
|
description: command sent to the device
|
|
returned: always
|
|
type: list
|
|
sample: ["undo acl name test"]
|
|
'''
|
|
|
|
from xml.etree import ElementTree
|
|
from ansible.module_utils.basic import AnsibleModule
|
|
from ansible.module_utils.network.cloudengine.ce import get_nc_config, set_nc_config, ce_argument_spec, check_ip_addr
|
|
|
|
|
|
# get acl
|
|
CE_GET_ACL_HEADER = """
|
|
<filter type="subtree">
|
|
<acl xmlns="http://www.huawei.com/netconf/vrp" content-version="1.0" format-version="1.0">
|
|
<aclGroups>
|
|
<aclGroup>
|
|
<aclNumOrName></aclNumOrName>
|
|
"""
|
|
CE_GET_ACL_TAIL = """
|
|
</aclGroup>
|
|
</aclGroups>
|
|
</acl>
|
|
</filter>
|
|
"""
|
|
# merge acl
|
|
CE_MERGE_ACL_HEADER = """
|
|
<config>
|
|
<acl xmlns="http://www.huawei.com/netconf/vrp" content-version="1.0" format-version="1.0">
|
|
<aclGroups>
|
|
<aclGroup operation="merge">
|
|
<aclNumOrName>%s</aclNumOrName>
|
|
"""
|
|
CE_MERGE_ACL_TAIL = """
|
|
</aclGroup>
|
|
</aclGroups>
|
|
</acl>
|
|
</config>
|
|
"""
|
|
# delete acl
|
|
CE_DELETE_ACL_HEADER = """
|
|
<config>
|
|
<acl xmlns="http://www.huawei.com/netconf/vrp" content-version="1.0" format-version="1.0">
|
|
<aclGroups>
|
|
<aclGroup operation="delete">
|
|
<aclNumOrName>%s</aclNumOrName>
|
|
"""
|
|
CE_DELETE_ACL_TAIL = """
|
|
</aclGroup>
|
|
</aclGroups>
|
|
</acl>
|
|
</config>
|
|
"""
|
|
|
|
# get acl advance rule
|
|
CE_GET_ACL_ADVANCE_RULE_HEADER = """
|
|
<filter type="subtree">
|
|
<acl xmlns="http://www.huawei.com/netconf/vrp" content-version="1.0" format-version="1.0">
|
|
<aclGroups>
|
|
<aclGroup>
|
|
<aclNumOrName>%s</aclNumOrName>
|
|
<aclRuleAdv4s>
|
|
<aclRuleAdv4>
|
|
<aclRuleName></aclRuleName>
|
|
"""
|
|
CE_GET_ACL_ADVANCE_RULE_TAIL = """
|
|
</aclRuleAdv4>
|
|
</aclRuleAdv4s>
|
|
</aclGroup>
|
|
</aclGroups>
|
|
</acl>
|
|
</filter>
|
|
"""
|
|
# merge acl advance rule
|
|
CE_MERGE_ACL_ADVANCE_RULE_HEADER = """
|
|
<config>
|
|
<acl xmlns="http://www.huawei.com/netconf/vrp" content-version="1.0" format-version="1.0">
|
|
<aclGroups>
|
|
<aclGroup>
|
|
<aclNumOrName>%s</aclNumOrName>
|
|
<aclRuleAdv4s>
|
|
<aclRuleAdv4 operation="merge">
|
|
<aclRuleName>%s</aclRuleName>
|
|
"""
|
|
CE_MERGE_ACL_ADVANCE_RULE_TAIL = """
|
|
</aclRuleAdv4>
|
|
</aclRuleAdv4s>
|
|
</aclGroup>
|
|
</aclGroups>
|
|
</acl>
|
|
</config>
|
|
"""
|
|
# delete acl advance rule
|
|
CE_DELETE_ACL_ADVANCE_RULE_HEADER = """
|
|
<config>
|
|
<acl xmlns="http://www.huawei.com/netconf/vrp" content-version="1.0" format-version="1.0">
|
|
<aclGroups>
|
|
<aclGroup>
|
|
<aclNumOrName>%s</aclNumOrName>
|
|
<aclRuleAdv4s>
|
|
<aclRuleAdv4 operation="delete">
|
|
<aclRuleName>%s</aclRuleName>
|
|
"""
|
|
CE_DELETE_ACL_ADVANCE_RULE_TAIL = """
|
|
</aclRuleAdv4>
|
|
</aclRuleAdv4s>
|
|
</aclGroup>
|
|
</aclGroups>
|
|
</acl>
|
|
</config>
|
|
"""
|
|
|
|
|
|
PROTOCOL_NUM = {"ip": "0",
|
|
"icmp": "1",
|
|
"igmp": "2",
|
|
"ipinip": "4",
|
|
"tcp": "6",
|
|
"udp": "17",
|
|
"gre": "47",
|
|
"ospf": "89"}
|
|
|
|
IGMP_TYPE_NUM = {"host-query": "17",
|
|
"mrouter-adver": "48",
|
|
"mrouter-solic": "49",
|
|
"mrouter-termi": "50",
|
|
"mtrace-resp": "30",
|
|
"mtrace-route": "31",
|
|
"v1host-report": "18",
|
|
"v2host-report": "22",
|
|
"v2leave-group": "23",
|
|
"v3host-report": "34"}
|
|
|
|
|
|
def get_wildcard_mask(mask):
|
|
""" convert mask length to ip address wildcard mask, i.e. 24 to 0.0.0.255 """
|
|
|
|
mask_int = ["255"] * 4
|
|
value = int(mask)
|
|
|
|
if value > 32:
|
|
return None
|
|
if value < 8:
|
|
mask_int[0] = str(int(~(0xFF << (8 - value % 8)) & 0xFF))
|
|
if value >= 8:
|
|
mask_int[0] = '0'
|
|
mask_int[1] = str(int(~(0xFF << (16 - (value % 16))) & 0xFF))
|
|
if value >= 16:
|
|
mask_int[1] = '0'
|
|
mask_int[2] = str(int(~(0xFF << (24 - (value % 24))) & 0xFF))
|
|
if value >= 24:
|
|
mask_int[2] = '0'
|
|
mask_int[3] = str(int(~(0xFF << (32 - (value % 32))) & 0xFF))
|
|
if value == 32:
|
|
mask_int[3] = '0'
|
|
|
|
return '.'.join(mask_int)
|
|
|
|
|
|
class AdvanceAcl(object):
|
|
""" Manages advance acl configuration """
|
|
|
|
def __init__(self, **kwargs):
|
|
""" Class init """
|
|
|
|
# argument spec
|
|
argument_spec = kwargs["argument_spec"]
|
|
self.spec = argument_spec
|
|
self.module = AnsibleModule(argument_spec=self.spec, supports_check_mode=True)
|
|
|
|
# module args
|
|
self.state = self.module.params['state']
|
|
self.acl_name = self.module.params['acl_name'] or None
|
|
self.acl_num = self.module.params['acl_num'] or None
|
|
self.acl_type = None
|
|
self.acl_step = self.module.params['acl_step'] or None
|
|
self.acl_description = self.module.params['acl_description'] or None
|
|
self.rule_name = self.module.params['rule_name'] or None
|
|
self.rule_id = self.module.params['rule_id'] or None
|
|
self.rule_action = self.module.params['rule_action'] or None
|
|
self.protocol = self.module.params['protocol'] or None
|
|
self.protocol_num = None
|
|
self.source_ip = self.module.params['source_ip'] or None
|
|
self.src_mask = self.module.params['src_mask'] or None
|
|
self.src_wild = None
|
|
self.src_pool_name = self.module.params['src_pool_name'] or None
|
|
self.dest_ip = self.module.params['dest_ip'] or None
|
|
self.dest_mask = self.module.params['dest_mask'] or None
|
|
self.dest_wild = None
|
|
self.dest_pool_name = self.module.params['dest_pool_name'] or None
|
|
self.src_port_op = self.module.params['src_port_op'] or None
|
|
self.src_port_begin = self.module.params['src_port_begin'] or None
|
|
self.src_port_end = self.module.params['src_port_end'] or None
|
|
self.src_port_pool_name = self.module.params[
|
|
'src_port_pool_name'] or None
|
|
self.dest_port_op = self.module.params['dest_port_op'] or None
|
|
self.dest_port_begin = self.module.params['dest_port_begin'] or None
|
|
self.dest_port_end = self.module.params['dest_port_end'] or None
|
|
self.dest_port_pool_name = self.module.params[
|
|
'dest_port_pool_name'] or None
|
|
self.frag_type = self.module.params['frag_type'] or None
|
|
self.precedence = self.module.params['precedence'] or None
|
|
self.tos = self.module.params['tos'] or None
|
|
self.dscp = self.module.params['dscp'] or None
|
|
self.icmp_name = self.module.params['icmp_name'] or None
|
|
self.icmp_type = self.module.params['icmp_type'] or None
|
|
self.icmp_code = self.module.params['icmp_code'] or None
|
|
self.ttl_expired = self.module.params['ttl_expired']
|
|
self.vrf_name = self.module.params['vrf_name'] or None
|
|
self.syn_flag = self.module.params['syn_flag'] or None
|
|
self.tcp_flag_mask = self.module.params['tcp_flag_mask'] or None
|
|
self.established = self.module.params['established']
|
|
self.time_range = self.module.params['time_range'] or None
|
|
self.rule_description = self.module.params['rule_description'] or None
|
|
self.igmp_type = self.module.params['igmp_type'] or None
|
|
self.igmp_type_num = None
|
|
self.log_flag = self.module.params['log_flag']
|
|
|
|
self.precedence_name = dict()
|
|
self.precedence_name["0"] = "routine"
|
|
self.precedence_name["1"] = "priority"
|
|
self.precedence_name["2"] = "immediate"
|
|
self.precedence_name["3"] = "flash"
|
|
self.precedence_name["4"] = "flash-override"
|
|
self.precedence_name["5"] = "critical"
|
|
self.precedence_name["6"] = "internet"
|
|
self.precedence_name["7"] = "network"
|
|
|
|
# cur config
|
|
self.cur_acl_cfg = dict()
|
|
self.cur_advance_rule_cfg = dict()
|
|
|
|
# state
|
|
self.changed = False
|
|
self.updates_cmd = list()
|
|
self.results = dict()
|
|
self.proposed = dict()
|
|
self.existing = dict()
|
|
self.end_state = dict()
|
|
|
|
def netconf_get_config(self, conf_str):
|
|
""" Get configure by netconf """
|
|
|
|
xml_str = get_nc_config(self.module, conf_str)
|
|
|
|
return xml_str
|
|
|
|
def netconf_set_config(self, conf_str):
|
|
""" Set configure by netconf """
|
|
|
|
xml_str = set_nc_config(self.module, conf_str)
|
|
|
|
return xml_str
|
|
|
|
def get_protocol_num(self):
|
|
""" Get protocol num by name """
|
|
|
|
if self.protocol:
|
|
self.protocol_num = PROTOCOL_NUM.get(self.protocol)
|
|
|
|
def get_igmp_type_num(self):
|
|
""" Get igmp type num by type """
|
|
|
|
if self.igmp_type:
|
|
self.igmp_type_num = IGMP_TYPE_NUM.get(self.igmp_type)
|
|
|
|
def check_acl_args(self):
|
|
""" Check acl invalid args """
|
|
|
|
need_cfg = False
|
|
find_flag = False
|
|
self.cur_acl_cfg["acl_info"] = []
|
|
|
|
if self.acl_name:
|
|
|
|
if self.acl_name.isdigit():
|
|
if int(self.acl_name) < 3000 or int(self.acl_name) > 3999:
|
|
self.module.fail_json(
|
|
msg='Error: The value of acl_name is out of [3000-3999] for advance ACL.')
|
|
|
|
if self.acl_num:
|
|
self.module.fail_json(
|
|
msg='Error: The acl_name is digit, so should not input acl_num at the same time.')
|
|
else:
|
|
|
|
self.acl_type = "Advance"
|
|
|
|
if len(self.acl_name) < 1 or len(self.acl_name) > 32:
|
|
self.module.fail_json(
|
|
msg='Error: The len of acl_name is out of [1 - 32].')
|
|
|
|
if self.state == "present":
|
|
if not self.acl_num and not self.acl_type and not self.rule_name:
|
|
self.module.fail_json(
|
|
msg='Error: Please input acl_num or acl_type when config ACL.')
|
|
|
|
if self.acl_num:
|
|
if self.acl_num.isdigit():
|
|
if int(self.acl_num) < 3000 or int(self.acl_num) > 3999:
|
|
self.module.fail_json(
|
|
msg='Error: The value of acl_name is out of [3000-3999] for advance ACL.')
|
|
else:
|
|
self.module.fail_json(
|
|
msg='Error: The acl_num is not digit.')
|
|
|
|
if self.acl_step:
|
|
if self.acl_step.isdigit():
|
|
if int(self.acl_step) < 1 or int(self.acl_step) > 20:
|
|
self.module.fail_json(
|
|
msg='Error: The value of acl_step is out of [1 - 20].')
|
|
else:
|
|
self.module.fail_json(
|
|
msg='Error: The acl_step is not digit.')
|
|
|
|
if self.acl_description:
|
|
if len(self.acl_description) < 1 or len(self.acl_description) > 127:
|
|
self.module.fail_json(
|
|
msg='Error: The len of acl_description is out of [1 - 127].')
|
|
|
|
conf_str = CE_GET_ACL_HEADER
|
|
|
|
if self.acl_type:
|
|
conf_str += "<aclType></aclType>"
|
|
if self.acl_num:
|
|
conf_str += "<aclNumber></aclNumber>"
|
|
if self.acl_step:
|
|
conf_str += "<aclStep></aclStep>"
|
|
if self.acl_description:
|
|
conf_str += "<aclDescription></aclDescription>"
|
|
|
|
conf_str += CE_GET_ACL_TAIL
|
|
recv_xml = self.netconf_get_config(conf_str=conf_str)
|
|
|
|
if "<data/>" in recv_xml:
|
|
find_flag = False
|
|
|
|
else:
|
|
xml_str = recv_xml.replace('\r', '').replace('\n', '').\
|
|
replace('xmlns="urn:ietf:params:xml:ns:netconf:base:1.0"', "").\
|
|
replace('xmlns="http://www.huawei.com/netconf/vrp"', "")
|
|
|
|
root = ElementTree.fromstring(xml_str)
|
|
|
|
# parse acl
|
|
acl_info = root.findall(
|
|
"data/acl/aclGroups/aclGroup")
|
|
if acl_info:
|
|
for tmp in acl_info:
|
|
tmp_dict = dict()
|
|
for site in tmp:
|
|
if site.tag in ["aclNumOrName", "aclType", "aclNumber", "aclStep", "aclDescription"]:
|
|
tmp_dict[site.tag] = site.text
|
|
|
|
self.cur_acl_cfg["acl_info"].append(tmp_dict)
|
|
|
|
if self.cur_acl_cfg["acl_info"]:
|
|
for tmp in self.cur_acl_cfg["acl_info"]:
|
|
find_flag = True
|
|
|
|
if self.acl_name and tmp.get("aclNumOrName") != self.acl_name:
|
|
find_flag = False
|
|
if self.acl_type and tmp.get("aclType") != self.acl_type:
|
|
find_flag = False
|
|
if self.acl_num and tmp.get("aclNumber") != self.acl_num:
|
|
find_flag = False
|
|
if self.acl_step and tmp.get("aclStep") != self.acl_step:
|
|
find_flag = False
|
|
if self.acl_description and tmp.get("aclDescription") != self.acl_description:
|
|
find_flag = False
|
|
|
|
if find_flag:
|
|
break
|
|
else:
|
|
find_flag = False
|
|
|
|
if self.state == "present":
|
|
need_cfg = bool(not find_flag)
|
|
elif self.state == "delete_acl":
|
|
need_cfg = bool(find_flag)
|
|
else:
|
|
need_cfg = False
|
|
|
|
self.cur_acl_cfg["need_cfg"] = need_cfg
|
|
|
|
def check_advance_rule_args(self):
|
|
""" Check advance rule invalid args """
|
|
|
|
need_cfg = False
|
|
find_flag = False
|
|
self.cur_advance_rule_cfg["adv_rule_info"] = []
|
|
|
|
if self.acl_name:
|
|
|
|
if self.state == "absent":
|
|
if not self.rule_name:
|
|
self.module.fail_json(
|
|
msg='Error: Please input rule_name when state is absent.')
|
|
|
|
# config rule
|
|
if self.rule_name:
|
|
if len(self.rule_name) < 1 or len(self.rule_name) > 32:
|
|
self.module.fail_json(
|
|
msg='Error: The len of rule_name is out of [1 - 32].')
|
|
|
|
if self.state != "delete_acl" and not self.rule_id:
|
|
self.module.fail_json(
|
|
msg='Error: Please input rule_id.')
|
|
|
|
if self.rule_id:
|
|
if self.rule_id.isdigit():
|
|
if int(self.rule_id) < 0 or int(self.rule_id) > 4294967294:
|
|
self.module.fail_json(
|
|
msg='Error: The value of rule_id is out of [0 - 4294967294].')
|
|
else:
|
|
self.module.fail_json(
|
|
msg='Error: The rule_id is not digit.')
|
|
|
|
if self.rule_action and not self.protocol:
|
|
self.module.fail_json(
|
|
msg='Error: The rule_action and the protocol must input at the same time.')
|
|
|
|
if not self.rule_action and self.protocol:
|
|
self.module.fail_json(
|
|
msg='Error: The rule_action and the protocol must input at the same time.')
|
|
|
|
if self.protocol:
|
|
self.get_protocol_num()
|
|
|
|
if self.source_ip:
|
|
if not check_ip_addr(self.source_ip):
|
|
self.module.fail_json(
|
|
msg='Error: The source_ip %s is invalid.' % self.source_ip)
|
|
if not self.src_mask:
|
|
self.module.fail_json(
|
|
msg='Error: Please input src_mask.')
|
|
|
|
if self.src_mask:
|
|
if self.src_mask.isdigit():
|
|
if int(self.src_mask) < 1 or int(self.src_mask) > 32:
|
|
self.module.fail_json(
|
|
msg='Error: The value of src_mask is out of [1 - 32].')
|
|
self.src_wild = get_wildcard_mask(self.src_mask)
|
|
else:
|
|
self.module.fail_json(
|
|
msg='Error: The src_mask is not digit.')
|
|
|
|
if self.src_pool_name:
|
|
if len(self.src_pool_name) < 1 or len(self.src_pool_name) > 32:
|
|
self.module.fail_json(
|
|
msg='Error: The len of src_pool_name is out of [1 - 32].')
|
|
|
|
if self.dest_ip:
|
|
if not check_ip_addr(self.dest_ip):
|
|
self.module.fail_json(
|
|
msg='Error: The dest_ip %s is invalid.' % self.dest_ip)
|
|
if not self.dest_mask:
|
|
self.module.fail_json(
|
|
msg='Error: Please input dest_mask.')
|
|
|
|
if self.dest_mask:
|
|
if self.dest_mask.isdigit():
|
|
if int(self.dest_mask) < 1 or int(self.dest_mask) > 32:
|
|
self.module.fail_json(
|
|
msg='Error: The value of dest_mask is out of [1 - 32].')
|
|
self.dest_wild = get_wildcard_mask(self.dest_mask)
|
|
else:
|
|
self.module.fail_json(
|
|
msg='Error: The dest_mask is not digit.')
|
|
|
|
if self.dest_pool_name:
|
|
if len(self.dest_pool_name) < 1 or len(self.dest_pool_name) > 32:
|
|
self.module.fail_json(
|
|
msg='Error: The len of dest_pool_name is out of [1 - 32].')
|
|
|
|
if self.src_port_op:
|
|
if self.src_port_op == "lt":
|
|
if not self.src_port_end:
|
|
self.module.fail_json(
|
|
msg='Error: The src_port_end must input.')
|
|
if self.src_port_begin:
|
|
self.module.fail_json(
|
|
msg='Error: The src_port_begin should not input.')
|
|
if self.src_port_op == "eq" or self.src_port_op == "gt":
|
|
if not self.src_port_begin:
|
|
self.module.fail_json(
|
|
msg='Error: The src_port_begin must input.')
|
|
if self.src_port_end:
|
|
self.module.fail_json(
|
|
msg='Error: The src_port_end should not input.')
|
|
if self.src_port_op == "range":
|
|
if not self.src_port_begin or not self.src_port_end:
|
|
self.module.fail_json(
|
|
msg='Error: The src_port_begin and src_port_end must input.')
|
|
|
|
if self.src_port_begin:
|
|
if self.src_port_begin.isdigit():
|
|
if int(self.src_port_begin) < 0 or int(self.src_port_begin) > 65535:
|
|
self.module.fail_json(
|
|
msg='Error: The value of src_port_begin is out of [0 - 65535].')
|
|
else:
|
|
self.module.fail_json(
|
|
msg='Error: The src_port_begin is not digit.')
|
|
|
|
if self.src_port_end:
|
|
if self.src_port_end.isdigit():
|
|
if int(self.src_port_end) < 0 or int(self.src_port_end) > 65535:
|
|
self.module.fail_json(
|
|
msg='Error: The value of src_port_end is out of [0 - 65535].')
|
|
else:
|
|
self.module.fail_json(
|
|
msg='Error: The src_port_end is not digit.')
|
|
|
|
if self.src_port_pool_name:
|
|
if len(self.src_port_pool_name) < 1 or len(self.src_port_pool_name) > 32:
|
|
self.module.fail_json(
|
|
msg='Error: The len of src_port_pool_name is out of [1 - 32].')
|
|
|
|
if self.dest_port_op:
|
|
if self.dest_port_op == "lt":
|
|
if not self.dest_port_end:
|
|
self.module.fail_json(
|
|
msg='Error: The dest_port_end must input.')
|
|
if self.dest_port_begin:
|
|
self.module.fail_json(
|
|
msg='Error: The dest_port_begin should not input.')
|
|
if self.dest_port_op == "eq" or self.dest_port_op == "gt":
|
|
if not self.dest_port_begin:
|
|
self.module.fail_json(
|
|
msg='Error: The dest_port_begin must input.')
|
|
if self.dest_port_end:
|
|
self.module.fail_json(
|
|
msg='Error: The dest_port_end should not input.')
|
|
if self.dest_port_op == "range":
|
|
if not self.dest_port_begin or not self.dest_port_end:
|
|
self.module.fail_json(
|
|
msg='Error: The dest_port_begin and dest_port_end must input.')
|
|
|
|
if self.dest_port_begin:
|
|
if self.dest_port_begin.isdigit():
|
|
if int(self.dest_port_begin) < 0 or int(self.dest_port_begin) > 65535:
|
|
self.module.fail_json(
|
|
msg='Error: The value of dest_port_begin is out of [0 - 65535].')
|
|
else:
|
|
self.module.fail_json(
|
|
msg='Error: The dest_port_begin is not digit.')
|
|
|
|
if self.dest_port_end:
|
|
if self.dest_port_end.isdigit():
|
|
if int(self.dest_port_end) < 0 or int(self.dest_port_end) > 65535:
|
|
self.module.fail_json(
|
|
msg='Error: The value of dest_port_end is out of [0 - 65535].')
|
|
else:
|
|
self.module.fail_json(
|
|
msg='Error: The dest_port_end is not digit.')
|
|
|
|
if self.dest_port_pool_name:
|
|
if len(self.dest_port_pool_name) < 1 or len(self.dest_port_pool_name) > 32:
|
|
self.module.fail_json(
|
|
msg='Error: The len of dest_port_pool_name is out of [1 - 32].')
|
|
|
|
if self.precedence:
|
|
if self.precedence.isdigit():
|
|
if int(self.precedence) < 0 or int(self.precedence) > 7:
|
|
self.module.fail_json(
|
|
msg='Error: The value of precedence is out of [0 - 7].')
|
|
else:
|
|
self.module.fail_json(
|
|
msg='Error: The precedence is not digit.')
|
|
|
|
if self.tos:
|
|
if self.tos.isdigit():
|
|
if int(self.tos) < 0 or int(self.tos) > 15:
|
|
self.module.fail_json(
|
|
msg='Error: The value of tos is out of [0 - 15].')
|
|
else:
|
|
self.module.fail_json(
|
|
msg='Error: The tos is not digit.')
|
|
|
|
if self.dscp:
|
|
if self.dscp.isdigit():
|
|
if int(self.dscp) < 0 or int(self.dscp) > 63:
|
|
self.module.fail_json(
|
|
msg='Error: The value of dscp is out of [0 - 63].')
|
|
else:
|
|
self.module.fail_json(
|
|
msg='Error: The dscp is not digit.')
|
|
|
|
if self.icmp_type:
|
|
if self.icmp_type.isdigit():
|
|
if int(self.icmp_type) < 0 or int(self.icmp_type) > 255:
|
|
self.module.fail_json(
|
|
msg='Error: The value of icmp_type is out of [0 - 255].')
|
|
else:
|
|
self.module.fail_json(
|
|
msg='Error: The icmp_type is not digit.')
|
|
|
|
if self.icmp_code:
|
|
if self.icmp_code.isdigit():
|
|
if int(self.icmp_code) < 0 or int(self.icmp_code) > 255:
|
|
self.module.fail_json(
|
|
msg='Error: The value of icmp_code is out of [0 - 255].')
|
|
else:
|
|
self.module.fail_json(
|
|
msg='Error: The icmp_code is not digit.')
|
|
|
|
if self.vrf_name:
|
|
if len(self.vrf_name) < 1 or len(self.vrf_name) > 31:
|
|
self.module.fail_json(
|
|
msg='Error: The len of vrf_name is out of [1 - 31].')
|
|
|
|
if self.syn_flag:
|
|
if self.syn_flag.isdigit():
|
|
if int(self.syn_flag) < 0 or int(self.syn_flag) > 63:
|
|
self.module.fail_json(
|
|
msg='Error: The value of syn_flag is out of [0 - 63].')
|
|
else:
|
|
self.module.fail_json(
|
|
msg='Error: The syn_flag is not digit.')
|
|
|
|
if self.tcp_flag_mask:
|
|
if self.tcp_flag_mask.isdigit():
|
|
if int(self.tcp_flag_mask) < 0 or int(self.tcp_flag_mask) > 63:
|
|
self.module.fail_json(
|
|
msg='Error: The value of tcp_flag_mask is out of [0 - 63].')
|
|
else:
|
|
self.module.fail_json(
|
|
msg='Error: The tcp_flag_mask is not digit.')
|
|
|
|
if self.time_range:
|
|
if len(self.time_range) < 1 or len(self.time_range) > 32:
|
|
self.module.fail_json(
|
|
msg='Error: The len of time_range is out of [1 - 32].')
|
|
|
|
if self.rule_description:
|
|
if len(self.rule_description) < 1 or len(self.rule_description) > 127:
|
|
self.module.fail_json(
|
|
msg='Error: The len of rule_description is out of [1 - 127].')
|
|
|
|
if self.igmp_type:
|
|
self.get_igmp_type_num()
|
|
|
|
conf_str = CE_GET_ACL_ADVANCE_RULE_HEADER % self.acl_name
|
|
|
|
if self.rule_id:
|
|
conf_str += "<aclRuleID></aclRuleID>"
|
|
if self.rule_action:
|
|
conf_str += "<aclAction></aclAction>"
|
|
if self.protocol:
|
|
conf_str += "<aclProtocol></aclProtocol>"
|
|
if self.source_ip:
|
|
conf_str += "<aclSourceIp></aclSourceIp>"
|
|
if self.src_wild:
|
|
conf_str += "<aclSrcWild></aclSrcWild>"
|
|
if self.src_pool_name:
|
|
conf_str += "<aclSPoolName></aclSPoolName>"
|
|
if self.dest_ip:
|
|
conf_str += "<aclDestIp></aclDestIp>"
|
|
if self.dest_wild:
|
|
conf_str += "<aclDestWild></aclDestWild>"
|
|
if self.dest_pool_name:
|
|
conf_str += "<aclDPoolName></aclDPoolName>"
|
|
if self.src_port_op:
|
|
conf_str += "<aclSrcPortOp></aclSrcPortOp>"
|
|
if self.src_port_begin:
|
|
conf_str += "<aclSrcPortBegin></aclSrcPortBegin>"
|
|
if self.src_port_end:
|
|
conf_str += "<aclSrcPortEnd></aclSrcPortEnd>"
|
|
if self.src_port_pool_name:
|
|
conf_str += "<aclSPortPoolName></aclSPortPoolName>"
|
|
if self.dest_port_op:
|
|
conf_str += "<aclDestPortOp></aclDestPortOp>"
|
|
if self.dest_port_begin:
|
|
conf_str += "<aclDestPortB></aclDestPortB>"
|
|
if self.dest_port_end:
|
|
conf_str += "<aclDestPortE></aclDestPortE>"
|
|
if self.dest_port_pool_name:
|
|
conf_str += "<aclDPortPoolName></aclDPortPoolName>"
|
|
if self.frag_type:
|
|
conf_str += "<aclFragType></aclFragType>"
|
|
if self.precedence:
|
|
conf_str += "<aclPrecedence></aclPrecedence>"
|
|
if self.tos:
|
|
conf_str += "<aclTos></aclTos>"
|
|
if self.dscp:
|
|
conf_str += "<aclDscp></aclDscp>"
|
|
if self.icmp_name:
|
|
conf_str += "<aclIcmpName></aclIcmpName>"
|
|
if self.icmp_type:
|
|
conf_str += "<aclIcmpType></aclIcmpType>"
|
|
if self.icmp_code:
|
|
conf_str += "<aclIcmpCode></aclIcmpCode>"
|
|
conf_str += "<aclTtlExpired></aclTtlExpired>"
|
|
if self.vrf_name:
|
|
conf_str += "<vrfName></vrfName>"
|
|
if self.syn_flag:
|
|
conf_str += "<aclSynFlag></aclSynFlag>"
|
|
if self.tcp_flag_mask:
|
|
conf_str += "<aclTcpFlagMask></aclTcpFlagMask>"
|
|
conf_str += "<aclEstablished></aclEstablished>"
|
|
if self.time_range:
|
|
conf_str += "<aclTimeName></aclTimeName>"
|
|
if self.rule_description:
|
|
conf_str += "<aclRuleDescription></aclRuleDescription>"
|
|
if self.igmp_type:
|
|
conf_str += "<aclIgmpType></aclIgmpType>"
|
|
conf_str += "<aclLogFlag></aclLogFlag>"
|
|
|
|
conf_str += CE_GET_ACL_ADVANCE_RULE_TAIL
|
|
recv_xml = self.netconf_get_config(conf_str=conf_str)
|
|
|
|
if "<data/>" in recv_xml:
|
|
find_flag = False
|
|
|
|
else:
|
|
xml_str = recv_xml.replace('\r', '').replace('\n', '').\
|
|
replace('xmlns="urn:ietf:params:xml:ns:netconf:base:1.0"', "").\
|
|
replace('xmlns="http://www.huawei.com/netconf/vrp"', "")
|
|
|
|
root = ElementTree.fromstring(xml_str)
|
|
|
|
# parse advance rule
|
|
adv_rule_info = root.findall(
|
|
"data/acl/aclGroups/aclGroup/aclRuleAdv4s/aclRuleAdv4")
|
|
if adv_rule_info:
|
|
for tmp in adv_rule_info:
|
|
tmp_dict = dict()
|
|
for site in tmp:
|
|
if site.tag in ["aclRuleName", "aclRuleID", "aclAction", "aclProtocol", "aclSourceIp",
|
|
"aclSrcWild", "aclSPoolName", "aclDestIp", "aclDestWild",
|
|
"aclDPoolName", "aclSrcPortOp", "aclSrcPortBegin", "aclSrcPortEnd",
|
|
"aclSPortPoolName", "aclDestPortOp", "aclDestPortB", "aclDestPortE",
|
|
"aclDPortPoolName", "aclFragType", "aclPrecedence", "aclTos",
|
|
"aclDscp", "aclIcmpName", "aclIcmpType", "aclIcmpCode", "aclTtlExpired",
|
|
"vrfName", "aclSynFlag", "aclTcpFlagMask", "aclEstablished",
|
|
"aclTimeName", "aclRuleDescription", "aclIgmpType", "aclLogFlag"]:
|
|
tmp_dict[site.tag] = site.text
|
|
|
|
self.cur_advance_rule_cfg[
|
|
"adv_rule_info"].append(tmp_dict)
|
|
|
|
if self.cur_advance_rule_cfg["adv_rule_info"]:
|
|
for tmp in self.cur_advance_rule_cfg["adv_rule_info"]:
|
|
find_flag = True
|
|
|
|
if self.rule_name and tmp.get("aclRuleName") != self.rule_name:
|
|
find_flag = False
|
|
if self.rule_id and tmp.get("aclRuleID") != self.rule_id:
|
|
find_flag = False
|
|
if self.rule_action and tmp.get("aclAction") != self.rule_action:
|
|
find_flag = False
|
|
if self.protocol and tmp.get("aclProtocol") != self.protocol_num:
|
|
find_flag = False
|
|
if self.source_ip:
|
|
tmp_src_ip = self.source_ip.split(".")
|
|
tmp_src_wild = self.src_wild.split(".")
|
|
tmp_addr_item = []
|
|
for idx in range(4):
|
|
item1 = 255 - int(tmp_src_wild[idx])
|
|
item2 = item1 & int(tmp_src_ip[idx])
|
|
tmp_addr_item.append(item2)
|
|
tmp_addr = "%s.%s.%s.%s" % (tmp_addr_item[0], tmp_addr_item[1],
|
|
tmp_addr_item[2], tmp_addr_item[3])
|
|
if tmp_addr != tmp.get("aclSourceIp"):
|
|
find_flag = False
|
|
if self.src_wild and tmp.get("aclSrcWild") != self.src_wild:
|
|
find_flag = False
|
|
if self.src_pool_name and tmp.get("aclSPoolName") != self.src_pool_name:
|
|
find_flag = False
|
|
if self.dest_ip:
|
|
tmp_src_ip = self.dest_ip.split(".")
|
|
tmp_src_wild = self.dest_wild.split(".")
|
|
tmp_addr_item = []
|
|
for idx in range(4):
|
|
item1 = 255 - int(tmp_src_wild[idx])
|
|
item2 = item1 & int(tmp_src_ip[idx])
|
|
tmp_addr_item.append(item2)
|
|
tmp_addr = "%s.%s.%s.%s" % (tmp_addr_item[0], tmp_addr_item[1],
|
|
tmp_addr_item[2], tmp_addr_item[3])
|
|
if tmp_addr != tmp.get("aclDestIp"):
|
|
find_flag = False
|
|
if self.dest_wild and tmp.get("aclDestWild") != self.dest_wild:
|
|
find_flag = False
|
|
if self.dest_pool_name and tmp.get("aclDPoolName") != self.dest_pool_name:
|
|
find_flag = False
|
|
if self.src_port_op and tmp.get("aclSrcPortOp") != self.src_port_op:
|
|
find_flag = False
|
|
if self.src_port_begin and tmp.get("aclSrcPortBegin") != self.src_port_begin:
|
|
find_flag = False
|
|
if self.src_port_end and tmp.get("aclSrcPortEnd") != self.src_port_end:
|
|
find_flag = False
|
|
if self.src_port_pool_name and tmp.get("aclSPortPoolName") != self.src_port_pool_name:
|
|
find_flag = False
|
|
if self.dest_port_op and tmp.get("aclDestPortOp") != self.dest_port_op:
|
|
find_flag = False
|
|
if self.dest_port_begin and tmp.get("aclDestPortB") != self.dest_port_begin:
|
|
find_flag = False
|
|
if self.dest_port_end and tmp.get("aclDestPortE") != self.dest_port_end:
|
|
find_flag = False
|
|
if self.dest_port_pool_name and tmp.get("aclDPortPoolName") != self.dest_port_pool_name:
|
|
find_flag = False
|
|
if self.frag_type and tmp.get("aclFragType") != self.frag_type:
|
|
find_flag = False
|
|
if self.precedence and tmp.get("aclPrecedence") != self.precedence:
|
|
find_flag = False
|
|
if self.tos and tmp.get("aclTos") != self.tos:
|
|
find_flag = False
|
|
if self.dscp and tmp.get("aclDscp") != self.dscp:
|
|
find_flag = False
|
|
if self.icmp_name and tmp.get("aclIcmpName") != self.icmp_name:
|
|
find_flag = False
|
|
if self.icmp_type and tmp.get("aclIcmpType") != self.icmp_type:
|
|
find_flag = False
|
|
if self.icmp_code and tmp.get("aclIcmpCode") != self.icmp_code:
|
|
find_flag = False
|
|
if tmp.get("aclTtlExpired").lower() != str(self.ttl_expired).lower():
|
|
find_flag = False
|
|
if self.vrf_name and tmp.get("vrfName") != self.vrf_name:
|
|
find_flag = False
|
|
if self.syn_flag and tmp.get("aclSynFlag") != self.syn_flag:
|
|
find_flag = False
|
|
if self.tcp_flag_mask and tmp.get("aclTcpFlagMask") != self.tcp_flag_mask:
|
|
find_flag = False
|
|
if self.protocol == "tcp" and \
|
|
tmp.get("aclEstablished").lower() != str(self.established).lower():
|
|
find_flag = False
|
|
if self.time_range and tmp.get("aclTimeName") != self.time_range:
|
|
find_flag = False
|
|
if self.rule_description and tmp.get("aclRuleDescription") != self.rule_description:
|
|
find_flag = False
|
|
if self.igmp_type and tmp.get("aclIgmpType") != self.igmp_type_num:
|
|
find_flag = False
|
|
if tmp.get("aclLogFlag").lower() != str(self.log_flag).lower():
|
|
find_flag = False
|
|
|
|
if find_flag:
|
|
break
|
|
else:
|
|
find_flag = False
|
|
|
|
if self.state == "present":
|
|
need_cfg = bool(not find_flag)
|
|
elif self.state == "absent":
|
|
need_cfg = bool(find_flag)
|
|
else:
|
|
need_cfg = False
|
|
|
|
self.cur_advance_rule_cfg["need_cfg"] = need_cfg
|
|
|
|
def get_proposed(self):
|
|
""" Get proposed state """
|
|
|
|
self.proposed["state"] = self.state
|
|
|
|
if self.acl_name:
|
|
self.proposed["acl_name"] = self.acl_name
|
|
if self.acl_num:
|
|
self.proposed["acl_num"] = self.acl_num
|
|
if self.acl_step:
|
|
self.proposed["acl_step"] = self.acl_step
|
|
if self.acl_description:
|
|
self.proposed["acl_description"] = self.acl_description
|
|
if self.rule_name:
|
|
self.proposed["rule_name"] = self.rule_name
|
|
if self.rule_id:
|
|
self.proposed["rule_id"] = self.rule_id
|
|
if self.rule_action:
|
|
self.proposed["rule_action"] = self.rule_action
|
|
if self.protocol:
|
|
self.proposed["protocol"] = self.protocol
|
|
if self.source_ip:
|
|
self.proposed["source_ip"] = self.source_ip
|
|
if self.src_mask:
|
|
self.proposed["src_mask"] = self.src_mask
|
|
if self.src_pool_name:
|
|
self.proposed["src_pool_name"] = self.src_pool_name
|
|
if self.dest_ip:
|
|
self.proposed["dest_ip"] = self.dest_ip
|
|
if self.dest_mask:
|
|
self.proposed["dest_mask"] = self.dest_mask
|
|
if self.dest_pool_name:
|
|
self.proposed["dest_pool_name"] = self.dest_pool_name
|
|
if self.src_port_op:
|
|
self.proposed["src_port_op"] = self.src_port_op
|
|
if self.src_port_begin:
|
|
self.proposed["src_port_begin"] = self.src_port_begin
|
|
if self.src_port_end:
|
|
self.proposed["src_port_end"] = self.src_port_end
|
|
if self.src_port_pool_name:
|
|
self.proposed["src_port_pool_name"] = self.src_port_pool_name
|
|
if self.dest_port_op:
|
|
self.proposed["dest_port_op"] = self.dest_port_op
|
|
if self.dest_port_begin:
|
|
self.proposed["dest_port_begin"] = self.dest_port_begin
|
|
if self.dest_port_end:
|
|
self.proposed["dest_port_end"] = self.dest_port_end
|
|
if self.dest_port_pool_name:
|
|
self.proposed["dest_port_pool_name"] = self.dest_port_pool_name
|
|
if self.frag_type:
|
|
self.proposed["frag_type"] = self.frag_type
|
|
if self.precedence:
|
|
self.proposed["precedence"] = self.precedence
|
|
if self.tos:
|
|
self.proposed["tos"] = self.tos
|
|
if self.dscp:
|
|
self.proposed["dscp"] = self.dscp
|
|
if self.icmp_name:
|
|
self.proposed["icmp_name"] = self.icmp_name
|
|
if self.icmp_type:
|
|
self.proposed["icmp_type"] = self.icmp_type
|
|
if self.icmp_code:
|
|
self.proposed["icmp_code"] = self.icmp_code
|
|
if self.ttl_expired:
|
|
self.proposed["ttl_expired"] = self.ttl_expired
|
|
if self.vrf_name:
|
|
self.proposed["vrf_name"] = self.vrf_name
|
|
if self.syn_flag:
|
|
self.proposed["syn_flag"] = self.syn_flag
|
|
if self.tcp_flag_mask:
|
|
self.proposed["tcp_flag_mask"] = self.tcp_flag_mask
|
|
self.proposed["established"] = self.established
|
|
if self.time_range:
|
|
self.proposed["time_range"] = self.time_range
|
|
if self.rule_description:
|
|
self.proposed["rule_description"] = self.rule_description
|
|
if self.igmp_type:
|
|
self.proposed["igmp_type"] = self.igmp_type
|
|
self.proposed["log_flag"] = self.log_flag
|
|
|
|
def get_existing(self):
|
|
""" Get existing state """
|
|
|
|
self.existing["acl_info"] = self.cur_acl_cfg["acl_info"]
|
|
self.existing["adv_rule_info"] = self.cur_advance_rule_cfg[
|
|
"adv_rule_info"]
|
|
|
|
def get_end_state(self):
|
|
""" Get end state """
|
|
|
|
self.check_acl_args()
|
|
self.end_state["acl_info"] = self.cur_acl_cfg["acl_info"]
|
|
|
|
self.check_advance_rule_args()
|
|
self.end_state["adv_rule_info"] = self.cur_advance_rule_cfg[
|
|
"adv_rule_info"]
|
|
|
|
def merge_acl(self):
|
|
""" Merge acl operation """
|
|
|
|
conf_str = CE_MERGE_ACL_HEADER % self.acl_name
|
|
|
|
if self.acl_type:
|
|
conf_str += "<aclType>%s</aclType>" % self.acl_type
|
|
if self.acl_num:
|
|
conf_str += "<aclNumber>%s</aclNumber>" % self.acl_num
|
|
if self.acl_step:
|
|
conf_str += "<aclStep>%s</aclStep>" % self.acl_step
|
|
if self.acl_description:
|
|
conf_str += "<aclDescription>%s</aclDescription>" % self.acl_description
|
|
|
|
conf_str += CE_MERGE_ACL_TAIL
|
|
|
|
recv_xml = self.netconf_set_config(conf_str=conf_str)
|
|
|
|
if "<ok/>" not in recv_xml:
|
|
self.module.fail_json(msg='Error: Merge acl failed.')
|
|
|
|
if self.acl_name.isdigit():
|
|
cmd = "acl number %s" % self.acl_name
|
|
else:
|
|
if self.acl_type and not self.acl_num:
|
|
cmd = "acl name %s %s" % (self.acl_name, self.acl_type.lower())
|
|
elif self.acl_type and self.acl_num:
|
|
cmd = "acl name %s number %s" % (self.acl_name, self.acl_num)
|
|
elif not self.acl_type and self.acl_num:
|
|
cmd = "acl name %s number %s" % (self.acl_name, self.acl_num)
|
|
self.updates_cmd.append(cmd)
|
|
|
|
if self.acl_description:
|
|
cmd = "description %s" % self.acl_description
|
|
self.updates_cmd.append(cmd)
|
|
|
|
if self.acl_step:
|
|
cmd = "step %s" % self.acl_step
|
|
self.updates_cmd.append(cmd)
|
|
|
|
self.changed = True
|
|
|
|
def delete_acl(self):
|
|
""" Delete acl operation """
|
|
|
|
conf_str = CE_DELETE_ACL_HEADER % self.acl_name
|
|
|
|
if self.acl_type:
|
|
conf_str += "<aclType>%s</aclType>" % self.acl_type
|
|
if self.acl_num:
|
|
conf_str += "<aclNumber>%s</aclNumber>" % self.acl_num
|
|
if self.acl_step:
|
|
conf_str += "<aclStep>%s</aclStep>" % self.acl_step
|
|
if self.acl_description:
|
|
conf_str += "<aclDescription>%s</aclDescription>" % self.acl_description
|
|
|
|
conf_str += CE_DELETE_ACL_TAIL
|
|
|
|
recv_xml = self.netconf_set_config(conf_str=conf_str)
|
|
|
|
if "<ok/>" not in recv_xml:
|
|
self.module.fail_json(msg='Error: Delete acl failed.')
|
|
|
|
if self.acl_description:
|
|
cmd = "undo description"
|
|
self.updates_cmd.append(cmd)
|
|
|
|
if self.acl_step:
|
|
cmd = "undo step"
|
|
self.updates_cmd.append(cmd)
|
|
|
|
if self.acl_name.isdigit():
|
|
cmd = "undo acl number %s" % self.acl_name
|
|
else:
|
|
cmd = "undo acl name %s" % self.acl_name
|
|
self.updates_cmd.append(cmd)
|
|
|
|
self.changed = True
|
|
|
|
def merge_adv_rule(self):
|
|
""" Merge advance rule operation """
|
|
|
|
conf_str = CE_MERGE_ACL_ADVANCE_RULE_HEADER % (
|
|
self.acl_name, self.rule_name)
|
|
|
|
if self.rule_id:
|
|
conf_str += "<aclRuleID>%s</aclRuleID>" % self.rule_id
|
|
if self.rule_action:
|
|
conf_str += "<aclAction>%s</aclAction>" % self.rule_action
|
|
if self.protocol:
|
|
conf_str += "<aclProtocol>%s</aclProtocol>" % self.protocol_num
|
|
if self.source_ip:
|
|
conf_str += "<aclSourceIp>%s</aclSourceIp>" % self.source_ip
|
|
if self.src_wild:
|
|
conf_str += "<aclSrcWild>%s</aclSrcWild>" % self.src_wild
|
|
if self.src_pool_name:
|
|
conf_str += "<aclSPoolName>%s</aclSPoolName>" % self.src_pool_name
|
|
if self.dest_ip:
|
|
conf_str += "<aclDestIp>%s</aclDestIp>" % self.dest_ip
|
|
if self.dest_wild:
|
|
conf_str += "<aclDestWild>%s</aclDestWild>" % self.dest_wild
|
|
if self.dest_pool_name:
|
|
conf_str += "<aclDPoolName>%s</aclDPoolName>" % self.dest_pool_name
|
|
if self.src_port_op:
|
|
conf_str += "<aclSrcPortOp>%s</aclSrcPortOp>" % self.src_port_op
|
|
if self.src_port_begin:
|
|
conf_str += "<aclSrcPortBegin>%s</aclSrcPortBegin>" % self.src_port_begin
|
|
if self.src_port_end:
|
|
conf_str += "<aclSrcPortEnd>%s</aclSrcPortEnd>" % self.src_port_end
|
|
if self.src_port_pool_name:
|
|
conf_str += "<aclSPortPoolName>%s</aclSPortPoolName>" % self.src_port_pool_name
|
|
if self.dest_port_op:
|
|
conf_str += "<aclDestPortOp>%s</aclDestPortOp>" % self.dest_port_op
|
|
if self.dest_port_begin:
|
|
conf_str += "<aclDestPortB>%s</aclDestPortB>" % self.dest_port_begin
|
|
if self.dest_port_end:
|
|
conf_str += "<aclDestPortE>%s</aclDestPortE>" % self.dest_port_end
|
|
if self.dest_port_pool_name:
|
|
conf_str += "<aclDPortPoolName>%s</aclDPortPoolName>" % self.dest_port_pool_name
|
|
if self.frag_type:
|
|
conf_str += "<aclFragType>%s</aclFragType>" % self.frag_type
|
|
if self.precedence:
|
|
conf_str += "<aclPrecedence>%s</aclPrecedence>" % self.precedence
|
|
if self.tos:
|
|
conf_str += "<aclTos>%s</aclTos>" % self.tos
|
|
if self.dscp:
|
|
conf_str += "<aclDscp>%s</aclDscp>" % self.dscp
|
|
if self.icmp_name:
|
|
conf_str += "<aclIcmpName>%s</aclIcmpName>" % self.icmp_name
|
|
if self.icmp_type:
|
|
conf_str += "<aclIcmpType>%s</aclIcmpType>" % self.icmp_type
|
|
if self.icmp_code:
|
|
conf_str += "<aclIcmpCode>%s</aclIcmpCode>" % self.icmp_code
|
|
conf_str += "<aclTtlExpired>%s</aclTtlExpired>" % str(self.ttl_expired).lower()
|
|
if self.vrf_name:
|
|
conf_str += "<vrfName>%s</vrfName>" % self.vrf_name
|
|
if self.syn_flag:
|
|
conf_str += "<aclSynFlag>%s</aclSynFlag>" % self.syn_flag
|
|
if self.tcp_flag_mask:
|
|
conf_str += "<aclTcpFlagMask>%s</aclTcpFlagMask>" % self.tcp_flag_mask
|
|
if self.protocol == "tcp":
|
|
conf_str += "<aclEstablished>%s</aclEstablished>" % str(self.established).lower()
|
|
if self.time_range:
|
|
conf_str += "<aclTimeName>%s</aclTimeName>" % self.time_range
|
|
if self.rule_description:
|
|
conf_str += "<aclRuleDescription>%s</aclRuleDescription>" % self.rule_description
|
|
if self.igmp_type:
|
|
conf_str += "<aclIgmpType>%s</aclIgmpType>" % self.igmp_type_num
|
|
conf_str += "<aclLogFlag>%s</aclLogFlag>" % str(self.log_flag).lower()
|
|
|
|
conf_str += CE_MERGE_ACL_ADVANCE_RULE_TAIL
|
|
|
|
recv_xml = self.netconf_set_config(conf_str=conf_str)
|
|
|
|
if "<ok/>" not in recv_xml:
|
|
self.module.fail_json(msg='Error: Merge acl base rule failed.')
|
|
|
|
if self.rule_action and self.protocol:
|
|
cmd = "rule"
|
|
if self.rule_id:
|
|
cmd += " %s" % self.rule_id
|
|
cmd += " %s" % self.rule_action
|
|
cmd += " %s" % self.protocol
|
|
if self.dscp:
|
|
cmd += " dscp %s" % self.dscp
|
|
if self.tos:
|
|
cmd += " tos %s" % self.tos
|
|
if self.tos:
|
|
cmd += " tos %s" % self.tos
|
|
if self.source_ip and self.src_wild:
|
|
cmd += " source %s %s" % (self.source_ip, self.src_wild)
|
|
if self.src_pool_name:
|
|
cmd += " source-pool %s" % self.src_pool_name
|
|
if self.src_port_op:
|
|
cmd += " source-port"
|
|
if self.src_port_op == "lt":
|
|
cmd += " lt %s" % self.src_port_end
|
|
elif self.src_port_op == "eq":
|
|
cmd += " eq %s" % self.src_port_begin
|
|
elif self.src_port_op == "gt":
|
|
cmd += " gt %s" % self.src_port_begin
|
|
elif self.src_port_op == "range":
|
|
cmd += " range %s %s" % (self.src_port_begin,
|
|
self.src_port_end)
|
|
if self.src_port_pool_name:
|
|
cmd += " source-port-pool %s" % self.src_port_pool_name
|
|
if self.dest_ip and self.dest_wild:
|
|
cmd += " destination %s %s" % (self.dest_ip, self.dest_wild)
|
|
if self.dest_pool_name:
|
|
cmd += " destination-pool %s" % self.dest_pool_name
|
|
if self.dest_port_op:
|
|
cmd += " destination-port"
|
|
if self.dest_port_op == "lt":
|
|
cmd += " lt %s" % self.dest_port_end
|
|
elif self.dest_port_op == "eq":
|
|
cmd += " eq %s" % self.dest_port_begin
|
|
elif self.dest_port_op == "gt":
|
|
cmd += " gt %s" % self.dest_port_begin
|
|
elif self.dest_port_op == "range":
|
|
cmd += " range %s %s" % (self.dest_port_begin,
|
|
self.dest_port_end)
|
|
if self.dest_port_pool_name:
|
|
cmd += " destination-port-pool %s" % self.dest_port_pool_name
|
|
if self.frag_type == "fragment":
|
|
cmd += " fragment-type fragment"
|
|
if self.precedence:
|
|
cmd += " precedence %s" % self.precedence_name[self.precedence]
|
|
|
|
if self.protocol == "icmp":
|
|
if self.icmp_name:
|
|
cmd += " icmp-type %s" % self.icmp_name
|
|
elif self.icmp_type and self.icmp_code:
|
|
cmd += " icmp-type %s %s" % (self.icmp_type, self.icmp_code)
|
|
elif self.icmp_type:
|
|
cmd += " icmp-type %s" % self.icmp_type
|
|
|
|
if self.time_range:
|
|
cmd += " time-range %s" % self.time_range
|
|
if self.vrf_name:
|
|
cmd += " vpn-instance %s" % self.vrf_name
|
|
if self.ttl_expired:
|
|
cmd += " ttl-expired"
|
|
if self.log_flag:
|
|
cmd += " logging"
|
|
self.updates_cmd.append(cmd)
|
|
|
|
if self.rule_description:
|
|
cmd = "rule %s description %s" % (
|
|
self.rule_id, self.rule_description)
|
|
self.updates_cmd.append(cmd)
|
|
|
|
self.changed = True
|
|
|
|
def delete_adv_rule(self):
|
|
""" Delete advance rule operation """
|
|
|
|
conf_str = CE_DELETE_ACL_ADVANCE_RULE_HEADER % (
|
|
self.acl_name, self.rule_name)
|
|
|
|
if self.rule_id:
|
|
conf_str += "<aclRuleID>%s</aclRuleID>" % self.rule_id
|
|
if self.rule_action:
|
|
conf_str += "<aclAction>%s</aclAction>" % self.rule_action
|
|
if self.protocol:
|
|
conf_str += "<aclProtocol>%s</aclProtocol>" % self.protocol_num
|
|
if self.source_ip:
|
|
conf_str += "<aclSourceIp>%s</aclSourceIp>" % self.source_ip
|
|
if self.src_wild:
|
|
conf_str += "<aclSrcWild>%s</aclSrcWild>" % self.src_wild
|
|
if self.src_pool_name:
|
|
conf_str += "<aclSPoolName>%s</aclSPoolName>" % self.src_pool_name
|
|
if self.dest_ip:
|
|
conf_str += "<aclDestIp>%s</aclDestIp>" % self.dest_ip
|
|
if self.dest_wild:
|
|
conf_str += "<aclDestWild>%s</aclDestWild>" % self.dest_wild
|
|
if self.dest_pool_name:
|
|
conf_str += "<aclDPoolName>%s</aclDPoolName>" % self.dest_pool_name
|
|
if self.src_port_op:
|
|
conf_str += "<aclSrcPortOp>%s</aclSrcPortOp>" % self.src_port_op
|
|
if self.src_port_begin:
|
|
conf_str += "<aclSrcPortBegin>%s</aclSrcPortBegin>" % self.src_port_begin
|
|
if self.src_port_end:
|
|
conf_str += "<aclSrcPortEnd>%s</aclSrcPortEnd>" % self.src_port_end
|
|
if self.src_port_pool_name:
|
|
conf_str += "<aclSPortPoolName>%s</aclSPortPoolName>" % self.src_port_pool_name
|
|
if self.dest_port_op:
|
|
conf_str += "<aclDestPortOp>%s</aclDestPortOp>" % self.dest_port_op
|
|
if self.dest_port_begin:
|
|
conf_str += "<aclDestPortB>%s</aclDestPortB>" % self.dest_port_begin
|
|
if self.dest_port_end:
|
|
conf_str += "<aclDestPortE>%s</aclDestPortE>" % self.dest_port_end
|
|
if self.dest_port_pool_name:
|
|
conf_str += "<aclDPortPoolName>%s</aclDPortPoolName>" % self.dest_port_pool_name
|
|
if self.frag_type:
|
|
conf_str += "<aclFragType>%s</aclFragType>" % self.frag_type
|
|
if self.precedence:
|
|
conf_str += "<aclPrecedence>%s</aclPrecedence>" % self.precedence
|
|
if self.tos:
|
|
conf_str += "<aclTos>%s</aclTos>" % self.tos
|
|
if self.dscp:
|
|
conf_str += "<aclDscp>%s</aclDscp>" % self.dscp
|
|
if self.icmp_name:
|
|
conf_str += "<aclIcmpName>%s</aclIcmpName>" % self.icmp_name
|
|
if self.icmp_type:
|
|
conf_str += "<aclIcmpType>%s</aclIcmpType>" % self.icmp_type
|
|
if self.icmp_code:
|
|
conf_str += "<aclIcmpCode>%s</aclIcmpCode>" % self.icmp_code
|
|
conf_str += "<aclTtlExpired>%s</aclTtlExpired>" % str(self.ttl_expired).lower()
|
|
if self.vrf_name:
|
|
conf_str += "<vrfName>%s</vrfName>" % self.vrf_name
|
|
if self.syn_flag:
|
|
conf_str += "<aclSynFlag>%s</aclSynFlag>" % self.syn_flag
|
|
if self.tcp_flag_mask:
|
|
conf_str += "<aclTcpFlagMask>%s</aclTcpFlagMask>" % self.tcp_flag_mask
|
|
if self.protocol == "tcp":
|
|
conf_str += "<aclEstablished>%s</aclEstablished>" % str(self.established).lower()
|
|
if self.time_range:
|
|
conf_str += "<aclTimeName>%s</aclTimeName>" % self.time_range
|
|
if self.rule_description:
|
|
conf_str += "<aclRuleDescription>%s</aclRuleDescription>" % self.rule_description
|
|
if self.igmp_type:
|
|
conf_str += "<aclIgmpType>%s</aclIgmpType>" % self.igmp_type
|
|
conf_str += "<aclLogFlag>%s</aclLogFlag>" % str(self.log_flag).lower()
|
|
|
|
conf_str += CE_DELETE_ACL_ADVANCE_RULE_TAIL
|
|
|
|
recv_xml = self.netconf_set_config(conf_str=conf_str)
|
|
|
|
if "<ok/>" not in recv_xml:
|
|
self.module.fail_json(msg='Error: Delete acl base rule failed.')
|
|
|
|
if self.rule_description:
|
|
if self.acl_name.isdigit():
|
|
cmd = "acl number %s" % self.acl_name
|
|
else:
|
|
cmd = "acl name %s" % self.acl_name
|
|
self.updates_cmd.append(cmd)
|
|
|
|
cmd = "undo rule %s description" % self.rule_id
|
|
self.updates_cmd.append(cmd)
|
|
|
|
if self.rule_id:
|
|
if self.acl_name.isdigit():
|
|
cmd = "acl number %s" % self.acl_name
|
|
else:
|
|
cmd = "acl name %s" % self.acl_name
|
|
self.updates_cmd.append(cmd)
|
|
|
|
cmd = "undo rule %s" % self.rule_id
|
|
self.updates_cmd.append(cmd)
|
|
elif self.rule_action and self.protocol:
|
|
if self.acl_name.isdigit():
|
|
cmd = "acl number %s" % self.acl_name
|
|
else:
|
|
cmd = "acl name %s" % self.acl_name
|
|
self.updates_cmd.append(cmd)
|
|
|
|
cmd = "undo rule"
|
|
cmd += " %s" % self.rule_action
|
|
cmd += " %s" % self.protocol
|
|
if self.dscp:
|
|
cmd += " dscp %s" % self.dscp
|
|
if self.tos:
|
|
cmd += " tos %s" % self.tos
|
|
if self.tos:
|
|
cmd += " tos %s" % self.tos
|
|
if self.source_ip and self.src_mask:
|
|
cmd += " source %s %s" % (self.source_ip, self.src_mask)
|
|
if self.src_pool_name:
|
|
cmd += " source-pool %s" % self.src_pool_name
|
|
if self.src_port_op:
|
|
cmd += " source-port"
|
|
if self.src_port_op == "lt":
|
|
cmd += " lt %s" % self.src_port_end
|
|
elif self.src_port_op == "eq":
|
|
cmd += " eq %s" % self.src_port_begin
|
|
elif self.src_port_op == "gt":
|
|
cmd += " gt %s" % self.src_port_begin
|
|
elif self.src_port_op == "range":
|
|
cmd += " range %s %s" % (self.src_port_begin,
|
|
self.src_port_end)
|
|
if self.src_port_pool_name:
|
|
cmd += " source-port-pool %s" % self.src_port_pool_name
|
|
if self.dest_ip and self.dest_mask:
|
|
cmd += " destination %s %s" % (self.dest_ip, self.dest_mask)
|
|
if self.dest_pool_name:
|
|
cmd += " destination-pool %s" % self.dest_pool_name
|
|
if self.dest_port_op:
|
|
cmd += " destination-port"
|
|
if self.dest_port_op == "lt":
|
|
cmd += " lt %s" % self.dest_port_end
|
|
elif self.dest_port_op == "eq":
|
|
cmd += " eq %s" % self.dest_port_begin
|
|
elif self.dest_port_op == "gt":
|
|
cmd += " gt %s" % self.dest_port_begin
|
|
elif self.dest_port_op == "range":
|
|
cmd += " range %s %s" % (self.dest_port_begin,
|
|
self.dest_port_end)
|
|
if self.dest_port_pool_name:
|
|
cmd += " destination-port-pool %s" % self.dest_port_pool_name
|
|
if self.frag_type == "fragment":
|
|
cmd += " fragment-type fragment"
|
|
if self.precedence:
|
|
cmd += " precedence %s" % self.precedence_name[self.precedence]
|
|
if self.time_range:
|
|
cmd += " time-range %s" % self.time_range
|
|
if self.vrf_name:
|
|
cmd += " vpn-instance %s" % self.vrf_name
|
|
if self.ttl_expired:
|
|
cmd += " ttl-expired"
|
|
if self.log_flag:
|
|
cmd += " logging"
|
|
self.updates_cmd.append(cmd)
|
|
|
|
self.changed = True
|
|
|
|
def work(self):
|
|
""" Main work function """
|
|
|
|
self.check_acl_args()
|
|
self.check_advance_rule_args()
|
|
self.get_proposed()
|
|
self.get_existing()
|
|
|
|
if self.state == "present":
|
|
if self.cur_acl_cfg["need_cfg"]:
|
|
self.merge_acl()
|
|
if self.cur_advance_rule_cfg["need_cfg"]:
|
|
self.merge_adv_rule()
|
|
|
|
elif self.state == "absent":
|
|
if self.cur_advance_rule_cfg["need_cfg"]:
|
|
self.delete_adv_rule()
|
|
|
|
elif self.state == "delete_acl":
|
|
if self.cur_acl_cfg["need_cfg"]:
|
|
self.delete_acl()
|
|
|
|
self.get_end_state()
|
|
|
|
self.results['changed'] = self.changed
|
|
self.results['proposed'] = self.proposed
|
|
self.results['existing'] = self.existing
|
|
self.results['end_state'] = self.end_state
|
|
self.results['updates'] = self.updates_cmd
|
|
|
|
self.module.exit_json(**self.results)
|
|
|
|
|
|
def main():
|
|
""" Module main """
|
|
|
|
argument_spec = dict(
|
|
state=dict(choices=['present', 'absent',
|
|
'delete_acl'], default='present'),
|
|
acl_name=dict(type='str', required=True),
|
|
acl_num=dict(type='str'),
|
|
acl_step=dict(type='str'),
|
|
acl_description=dict(type='str'),
|
|
rule_name=dict(type='str'),
|
|
rule_id=dict(type='str'),
|
|
rule_action=dict(choices=['permit', 'deny']),
|
|
protocol=dict(choices=['ip', 'icmp', 'igmp',
|
|
'ipinip', 'tcp', 'udp', 'gre', 'ospf']),
|
|
source_ip=dict(type='str'),
|
|
src_mask=dict(type='str'),
|
|
src_pool_name=dict(type='str'),
|
|
dest_ip=dict(type='str'),
|
|
dest_mask=dict(type='str'),
|
|
dest_pool_name=dict(type='str'),
|
|
src_port_op=dict(choices=['lt', 'eq', 'gt', 'range']),
|
|
src_port_begin=dict(type='str'),
|
|
src_port_end=dict(type='str'),
|
|
src_port_pool_name=dict(type='str'),
|
|
dest_port_op=dict(choices=['lt', 'eq', 'gt', 'range']),
|
|
dest_port_begin=dict(type='str'),
|
|
dest_port_end=dict(type='str'),
|
|
dest_port_pool_name=dict(type='str'),
|
|
frag_type=dict(choices=['fragment', 'clear_fragment']),
|
|
precedence=dict(type='str'),
|
|
tos=dict(type='str'),
|
|
dscp=dict(type='str'),
|
|
icmp_name=dict(choices=['unconfiged', 'echo', 'echo-reply', 'fragmentneed-DFset', 'host-redirect',
|
|
'host-tos-redirect', 'host-unreachable', 'information-reply', 'information-request',
|
|
'net-redirect', 'net-tos-redirect', 'net-unreachable', 'parameter-problem',
|
|
'port-unreachable', 'protocol-unreachable', 'reassembly-timeout', 'source-quench',
|
|
'source-route-failed', 'timestamp-reply', 'timestamp-request', 'ttl-exceeded',
|
|
'address-mask-reply', 'address-mask-request', 'custom']),
|
|
icmp_type=dict(type='str'),
|
|
icmp_code=dict(type='str'),
|
|
ttl_expired=dict(required=False, default=False, type='bool'),
|
|
vrf_name=dict(type='str'),
|
|
syn_flag=dict(type='str'),
|
|
tcp_flag_mask=dict(type='str'),
|
|
established=dict(required=False, default=False, type='bool'),
|
|
time_range=dict(type='str'),
|
|
rule_description=dict(type='str'),
|
|
igmp_type=dict(choices=['host-query', 'mrouter-adver', 'mrouter-solic', 'mrouter-termi', 'mtrace-resp',
|
|
'mtrace-route', 'v1host-report', 'v2host-report', 'v2leave-group', 'v3host-report']),
|
|
log_flag=dict(required=False, default=False, type='bool')
|
|
)
|
|
|
|
argument_spec.update(ce_argument_spec)
|
|
module = AdvanceAcl(argument_spec=argument_spec)
|
|
module.work()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|