def __init__(self, *args, **kwargs):
super(SNAT, self).__init__(*args, **kwargs)
wsgi = kwargs['wsgi']
wsgi.register(SNATRest, {nat_instance_name: self})
self.ingress_table_id = service_config.service_sequence['nat_ingress']
self.egress_table_id = service_config.service_sequence['nat_egress']
self.forward_table_id = service_config.service_sequence['forwarding']
self.goto_table_priority = service_config.service_priority[
'goto_table']
self.service_priority = service_config.service_priority['nat']
settings = nat_settings.load()
self.wan_port = settings['wan_port']
self.public_ip = str(settings['public_ip'])
self.public_gateway = str(settings['public_gateway'])
self.public_ip_subnetwork = settings['public_ip_subnetwork']
self.private_gateway = settings['private_gateway']
self.private_subnetwork = settings['private_subnetwork']
self.mac_on_wan = settings['mac_on_wan']
self.mac_on_lan = settings['mac_on_lan']
self.IDLE_TIME = 100
self.port_counter = -1
self.ports_pool = range(2000, 65536)
def nat_config_save(self, req, **kwargs):
json_body = json.loads(req.body)
save_dict = nat_settings.load()
if save_dict is None:
save_dict = {}
save_dict['wan_port'] = json_body.get('wanPort')
save_dict['public_ip'] = IPAddress(json_body.get('publicIP'))
public_gateway = json_body.get('publicGateway')
save_dict['public_gateway'] = IPAddress(public_gateway)
save_dict['public_ip_subnetwork'] = IPNetwork(public_gateway + '/24')
net = json_body.get('privateNetwork') + '/24'
save_dict['private_subnetwork'] = IPNetwork(net)
save_dict['private_gateway'] = IPNetwork(net)[1]
save_dict['broadcast_ip'] = IPNetwork(net)[255]
save_dict['dns_ip'] = IPAddress('8.8.8.8')
save_dict['mac_on_dhcp'] = '08:00:27:b8:0f:8d'
save_dict['mac_on_wan'] = '00:0e:c6:87:a6:fb'
save_dict['mac_on_lan'] = '00:0e:c6:87:a6:fa'
if nat_settings.save(save_dict):
pp = pprint.PrettyPrinter(indent=2)
pp.pprint(save_dict)
return Response(status=200)
else:
return Response(status=400)
def __init__(self, *args, **kwargs):
super(SimpleDHCPServer, self).__init__(*args, **kwargs)
self.table_id = service_config.service_sequence['dhcp']
self.service_priority = service_config.service_priority['dhcp']
self.dhcp_msg_type_code = {
1: 'DHCP_DISCOVER',
2: 'DHCP_OFFER',
3: 'DHCP_REQUEST',
4: 'DHCP_DECLINE',
5: 'DHCP_ACK',
6: 'DHCP_NAK',
7: 'DHCP_RELEASE',
8: 'DHCP_INFORM',
}
dhcp_settings = nat_settings.load()
self.private_gateway = dhcp_settings['private_gateway']
self.broadcast_ip = dhcp_settings['broadcast_ip']
self.private_subnetwork = dhcp_settings['private_subnetwork']
self.ip_pool_list = list(self.private_subnetwork)
print self.ip_pool_list
print self.broadcast_ip
self.dns_ip = dhcp_settings['dns_ip']
self.mac_on_dhcp = dhcp_settings['mac_on_dhcp']
self.mac_to_client_ip = {}
assert self.private_gateway in self.ip_pool_list
# self.ip_pool_list.remove(self.private_gateway)
self.ip_pool_list.remove(self.private_gateway)
self.ip_pool_list.remove(self.broadcast_ip)
self.ip_pool_list.remove(self.private_subnetwork[0])
def nat_config_save(self, req, **kwargs):
json_body = json.loads(req.body)
save_dict = nat_settings.load()
if save_dict is None:
save_dict = {}
save_dict['wan_port'] = json_body.get('wanPort')
save_dict['nat_public_ip'] = IPAddress(json_body.get('natPublicIp'))
save_dict['default_gateway'] = IPAddress(json_body.get('defaultGateway'))
net = json_body.get('natPrivateNetwork') + '/24'
save_dict['ip_network'] = IPNetwork(net)
save_dict['dhcp_gw_addr'] = IPNetwork(net)[1]
save_dict['broadcast_addr'] = IPAddress('192.168.8.255')
save_dict['dns_addr'] = IPAddress('8.8.8.8')
save_dict['dhcp_hw_addr'] = '08:00:27:b8:0f:8d'
save_dict['MAC_ON_WAN'] = '00:0e:c6:87:a6:fb'
save_dict['MAC_ON_LAN'] = '00:0e:c6:87:a6:fa'
if nat_settings.save(save_dict):
pp = pprint.PrettyPrinter(indent=2)
pp.pprint(save_dict)
return Response(status=200)
else:
return Response(status=400)
def __init__(self, *args, **kwargs):
super(SNAT, self).__init__(*args, **kwargs)
wsgi = kwargs['wsgi']
wsgi.register(SNATRest, {nat_instance_name: self})
settings = nat_settings.load()
self.wan_port = settings['wan_port']
self.gateway = str(settings['default_gateway'])
self.nat_public_ip = str(settings['nat_public_ip'])
self.nat_private_ip = settings['dhcp_gw_addr']
self.private_subnetwork = settings['ip_network']
self.MAC_ON_WAN = settings['MAC_ON_WAN']
self.MAC_ON_LAN = settings['MAC_ON_LAN']
self.IDLE_TIME = 100
self.port_counter = -1
self.ports_pool = range(2000, 65536)
pp = pprint.PrettyPrinter(indent=2)
pp.pprint(settings)
def dhcp_config_get(self, req, **kwargs):
dhcp_settings = nat_settings.load()
dic = {}
dic['privateGateway'] = str(dhcp_settings['private_gateway'])
dic['broadcastIP'] = str(dhcp_settings['broadcast_ip'])
dic['dnsIP'] = str(dhcp_settings['dns_ip'])
dic['macDhcp'] = str(dhcp_settings['mac_on_dhcp'])
body = json.dumps(dic)
return Response(status=200, content_type='application/json', body=body)
def dhcp_config_get(self, req, **kwargs):
dhcp_settings = nat_settings.load()
dic = {}
dic['dhcp_gw_addr'] = str(dhcp_settings['dhcp_gw_addr'])
dic['broadcast_addr'] = str(dhcp_settings['broadcast_addr'])
dic['dns_addr'] = str(dhcp_settings['dns_addr'])
dic['dhcp_hw_addr'] = str(dhcp_settings['dhcp_hw_addr'])
body = json.dumps(dic)
return Response(status=200, content_type='application/json', body=body)
def _packet_in_handler(self, ev):
msg = ev.msg
datapath = msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
in_port = msg.match['in_port']
settings = nat_settings.load()
if in_port == settings['wan_port']:
return
pkt = packet.Packet(msg.data)
eth = pkt.get_protocols(ethernet.ethernet)[0]
if eth.ethertype == ether_types.ETH_TYPE_LLDP:
# ignore lldp packet
return
dst = eth.dst
src = eth.src
dpid = datapath.id
self.mac_to_port.setdefault(dpid, {})
# self.logger.info("packet in %s %s %s %s", dpid, src, dst, in_port)
# learn a mac address to avoid FLOOD next time.
self.mac_to_port[dpid][src] = in_port
if dst in self.mac_to_port[dpid]:
out_port = self.mac_to_port[dpid][dst]
else:
out_port = ofproto.OFPP_FLOOD
actions = [parser.OFPActionOutput(out_port)]
# install a flow to avoid packet_in next time
if out_port != ofproto.OFPP_FLOOD:
match = parser.OFPMatch(in_port=in_port, eth_dst=dst)
# verify if we have a valid buffer_id, if yes avoid to send both
# flow_mod & packet_out
if msg.buffer_id != ofproto.OFP_NO_BUFFER:
ofp_helper.add_flow(datapath, 1, match, actions, msg.buffer_id)
return
else:
ofp_helper.add_flow(datapath, 1, match, actions)
data = None
if msg.buffer_id == ofproto.OFP_NO_BUFFER:
data = msg.data
out = parser.OFPPacketOut(datapath=datapath,
buffer_id=msg.buffer_id,
in_port=in_port,
actions=actions,
data=data)
datapath.send_msg(out)
def _packet_in_handler(self, ev):
msg = ev.msg
datapath = msg.datapath
ofproto = datapath.ofproto
parser = datapath.ofproto_parser
in_port = msg.match['in_port']
settings = nat_settings.load()
if in_port == settings['wan_port']:
return
pkt = packet.Packet(msg.data)
eth = pkt.get_protocols(ethernet.ethernet)[0]
if eth.ethertype == ether_types.ETH_TYPE_LLDP:
# ignore lldp packet
return
dst = eth.dst
src = eth.src
dpid = datapath.id
self.mac_to_port.setdefault(dpid, {})
# self.logger.info("packet in %s %s %s %s", dpid, src, dst, in_port)
# learn a mac address to avoid FLOOD next time.
self.mac_to_port[dpid][src] = in_port
if dst in self.mac_to_port[dpid]:
out_port = self.mac_to_port[dpid][dst]
else:
out_port = ofproto.OFPP_FLOOD
actions = [parser.OFPActionOutput(out_port)]
# install a flow to avoid packet_in next time
if out_port != ofproto.OFPP_FLOOD:
match = parser.OFPMatch(in_port=in_port, eth_dst=dst)
# verify if we have a valid buffer_id, if yes avoid to send both
# flow_mod & packet_out
if msg.buffer_id != ofproto.OFP_NO_BUFFER:
ofp_helper.add_flow(datapath, 1, match, actions, msg.buffer_id)
return
else:
ofp_helper.add_flow(datapath, 1, match, actions)
data = None
if msg.buffer_id == ofproto.OFP_NO_BUFFER:
data = msg.data
out = parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id,
in_port=in_port, actions=actions, data=data)
datapath.send_msg(out)
def nat_config_get(self, req, **kwargs):
settings = nat_settings.load()
dic = {}
# local network
ip = settings['private_subnetwork'].ip
mask = settings['private_subnetwork'].netmask
mask_len = mask.bits().replace('.', '').find('0')
dic['privateNetwork'] = str(ip) + '/' + str(mask_len)
dic['wanPort'] = settings['wan_port']
dic['publicGateway'] = str(settings['public_gateway'])
dic['publicIP'] = str(settings['public_ip'])
body = json.dumps(dic)
return Response(status=200, content_type='application/json', body=body)
def nat_config_get(self, req, **kwargs):
settings = nat_settings.load()
dic = {}
# local network
ip = settings['ip_network'].ip
mask = settings['ip_network'].netmask
mask_len = mask.bits().replace('.', '').find('0')
dic['ip_network'] = str(ip) + '/' + str(mask_len)
dic['wan_port'] = settings['wan_port']
dic['default_gateway'] = str(settings['default_gateway'])
dic['nat_public_ip'] = str(settings['nat_public_ip'])
body = json.dumps(dic)
return Response(status=200, content_type='application/json', body=body)
def __init__(self, *args, **kwargs):
super(SimpleDHCPServer, self).__init__(*args, **kwargs)
self.dhcp_msg_type_code = {
1: 'DHCP_DISCOVER',
2: 'DHCP_OFFER',
3: 'DHCP_REQUEST',
4: 'DHCP_DECLINE',
5: 'DHCP_ACK',
6: 'DHCP_NAK',
7: 'DHCP_RELEASE',
8: 'DHCP_INFORM',
}
dhcp_settings = nat_settings.load()
self.dhcp_addr = dhcp_settings['dhcp_gw_addr']
self.gw_addr = dhcp_settings['dhcp_gw_addr']
self.broadcast_addr = dhcp_settings['broadcast_addr']
self.ip_network = dhcp_settings['ip_network']
self.ip_pool_list = list(self.ip_network)
print self.ip_pool_list
print self.broadcast_addr
self.dns_addr = dhcp_settings['dns_addr']
self.dhcp_hw_addr = dhcp_settings['dhcp_hw_addr']
self.mac_to_client_ip = {}
assert self.dhcp_addr in self.ip_pool_list
assert self.gw_addr in self.ip_pool_list
# self.ip_pool_list.remove(self.dhcp_addr)
self.ip_pool_list.remove(self.gw_addr)
self.ip_pool_list.remove(self.broadcast_addr)
self.ip_pool_list.remove(self.ip_network[0])
def __init__(self, *args, **kwargs):
super(SimpleDHCPServer, self).__init__(*args, **kwargs)
self.dhcp_msg_type_code = {
1: 'DHCP_DISCOVER',
2: 'DHCP_OFFER',
3: 'DHCP_REQUEST',
4: 'DHCP_DECLINE',
5: 'DHCP_ACK',
6: 'DHCP_NAK',
7: 'DHCP_RELEASE',
8: 'DHCP_INFORM',
}
dhcp_settings = nat_settings.load()
self.dhcp_addr = dhcp_settings['dhcp_gw_addr']
self.gw_addr = dhcp_settings['dhcp_gw_addr']
self.broadcast_addr = dhcp_settings['broadcast_addr']
self.ip_network = dhcp_settings['ip_network']
self.ip_pool_list = list(self.ip_network)
print self.ip_pool_list
print self.broadcast_addr
self.dns_addr = dhcp_settings['dns_addr']
self.dhcp_hw_addr = dhcp_settings['dhcp_hw_addr']
self.mac_to_client_ip = {}
assert self.dhcp_addr in self.ip_pool_list
assert self.gw_addr in self.ip_pool_list
# self.ip_pool_list.remove(self.dhcp_addr)
self.ip_pool_list.remove(self.gw_addr)
self.ip_pool_list.remove(self.broadcast_addr)
self.ip_pool_list.remove(self.ip_network[0])
