def resolve(self, host, port): """ <method internal="yes"> </method> """ try: ip_list = gethostbyname_ex(host)[2] if self.multi: return map(lambda ip: SockAddrInet(ip, port), ip_list) else: return (SockAddrInet(ip_list[0], port), ) except IOError: return None
def __init__(self, **kw): """<method internal="yes"> </method> """ self.bindto = [] self.bindto.append( DBSockAddr(SockAddrInet("127.0.0.1", 0), ZD_PROTO_TCP)) self.bindto.append( DBSockAddr(SockAddrInet("127.0.0.1", 0), ZD_PROTO_UDP)) self.bindto.append(DBSockAddr(SockAddrInet6("::1", 0), ZD_PROTO_TCP)) self.bindto.append(DBSockAddr(SockAddrInet6("::1", 0), ZD_PROTO_UDP)) kw['transparent'] = TRUE super(RuleDispatcher, self).__init__(Globals.instance_name, self.bindto, **kw)
def performTranslation(self, session, addrs, nat_type): """ <method internal="yes"> </method> """ try: ip = self.ip_hash[addrs[nat_type].ip_s] if nat_type == NAT_SNAT: return SockAddrInet(ip, 0) else: return SockAddrInet(ip, addr.port) except KeyError: if self.default_reject: raise DACException, 'IP not within the required range.' else: return addr
def create_sockaddr(addrinfo, port): """ <function internal="yes"/> """ addr = addrinfo[4][0] family = addrinfo[0] if (family == socket.AF_INET): return SockAddrInet(addr, port) elif (family == socket.AF_INET6): return SockAddrInet6(addr, port)
def mapAddress(self, addr, from_domain, to_domain, nat_type): """ <method internal="yes"> <summary> Function to map an address to another subnet. </summary> <description> <para> This function maps the address 'addr' in the domain 'from_domain' to another domain 'to_domain'. Returns a SockAddrInet in the destination domain or None </para> </description> <metainfo> <arguments> <argument maturity="stable"> <name>from_domain</name> <type></type> <description>source domain</description> </argument> <argument maturity="stable"> <name>to_domain</name> <type></type> <description>destination domain</description> </argument> <argument maturity="stable"> <name>nat_type</name> <type></type> <description>specifies the NAT type</description> </argument> </arguments> </metainfo> </method> """ if addr < from_domain: ip = (addr.ip & ~to_domain.netmask()) + (to_domain.netaddr() & to_domain.netmask()) if nat_type == NAT_SNAT: return SockAddrInet(inet_ntoa(ip), 0) elif nat_type == NAT_DNAT: return SockAddrInet(inet_ntoa(ip), addr.port)
def resolve(self, host, port): """ <method internal="yes"> </method> """ try: ip_list = self.mapping[host] if type(ip_list) == types.StringType: ip_list = (ip_list, ) return map(lambda ip: SockAddrInet(ip, port), ip_list) except KeyError: return None
class NAT64(AbstractNAT): """ <class maturity="stable"> <summary> Class that performs translation from IPv6 to IPv4 addresses (NAT64) </summary> <description> NAT64 maps specific bits of the IPv6 address to IPv4 addresses according to the NAT64 specification as described in RFC6052 (http://tools.ietf.org/html/rfc6052#section-2.2). </description> <metainfo> <attributes/> </metainfo> </class> """ def __init__(self, prefix_mask=96): """ <method maturity="stable"> <summary> Constructor to initialize a NAT64 instance. </summary> <description> <para> This constructor initializes a NAT64 instance. </para> </description> <metainfo> <arguments> <argument maturity="stable"> <name>prefix_mask</name> <type> <integer display_name="Prefix netmask"/> </type> <default>96</default> <description>This parameter specifies the length of the IPv6 address to consider and must be one of 32, 40, 48, 56, 64, or 96.</description> </argument> </arguments> </metainfo> </method> """ super(NAT64, self).__init__() permitted_masks = (32, 40, 48, 56, 64, 96) if prefix_mask not in permitted_masks: raise UserException, "Prefix mask must be one of: %s; mask='%s'" % ( permitted_masks, prefix_mask) self.prefix_mask = prefix_mask def performTranslation(self, session, addrs, nat_type): """ <method internal="yes"> </method> """ if addrs[nat_type].family != socket.AF_INET6: raise UserException, "NAT64 might only be used to translate IPv6 addresses; family='%s'" % addrs[ nat_type].family v6addr = addrs[nat_type].pack() translate = { 96: lambda mask: v6addr[-4:], 64: lambda mask: v6addr[-7:-3], 56: lambda mask: v6addr[-9:-8] + v6addr[-7:-4], 48: lambda mask: v6addr[-10:-8] + v6addr[-7:-5], 40: lambda mask: v6addr[-11:-8] + v6addr[-7], 32: lambda mask: v6addr[-12:-8], } v4addr = translate[self.prefix_mask](self) try: unwrapped = socket.inet_ntop(socket.AF_INET, v4addr) except socket.error, e: log(None, CORE_ERROR, 2, "Unable to perform NAT mapping; error='%s'", (e, )) return None return SockAddrInet(unwrapped, addrs[nat_type].port)