Annotation of embedaddon/strongswan/src/libcharon/kernel/kernel_net.h, revision 1.1

1.1     ! misho       1: /*
        !             2:  * Copyright (C) 2008-2016 Tobias Brunner
        !             3:  * Copyright (C) 2007 Martin Willi
        !             4:  * HSR Hochschule fuer Technik Rapperswil
        !             5:  *
        !             6:  * This program is free software; you can redistribute it and/or modify it
        !             7:  * under the terms of the GNU General Public License as published by the
        !             8:  * Free Software Foundation; either version 2 of the License, or (at your
        !             9:  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
        !            10:  *
        !            11:  * This program is distributed in the hope that it will be useful, but
        !            12:  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
        !            13:  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
        !            14:  * for more details.
        !            15:  */
        !            16: 
        !            17: /**
        !            18:  * @defgroup kernel_net kernel_net
        !            19:  * @{ @ingroup kernel
        !            20:  */
        !            21: 
        !            22: #ifndef KERNEL_NET_H_
        !            23: #define KERNEL_NET_H_
        !            24: 
        !            25: typedef struct kernel_net_t kernel_net_t;
        !            26: typedef enum kernel_address_type_t kernel_address_type_t;
        !            27: 
        !            28: #include <collections/enumerator.h>
        !            29: #include <networking/host.h>
        !            30: #include <plugins/plugin.h>
        !            31: #include <kernel/kernel_interface.h>
        !            32: 
        !            33: /**
        !            34:  * Type of addresses (e.g. when enumerating them)
        !            35:  */
        !            36: enum kernel_address_type_t {
        !            37:        /** normal addresses (on regular, up, non-ignored) interfaces */
        !            38:        ADDR_TYPE_REGULAR = (1 << 0),
        !            39:        /** addresses on down interfaces */
        !            40:        ADDR_TYPE_DOWN =  (1 << 1),
        !            41:        /** addresses on ignored interfaces */
        !            42:        ADDR_TYPE_IGNORED = (1 << 2),
        !            43:        /** addresses on loopback interfaces */
        !            44:        ADDR_TYPE_LOOPBACK = (1 << 3),
        !            45:        /** virtual IP addresses */
        !            46:        ADDR_TYPE_VIRTUAL = (1 << 4),
        !            47:        /** to enumerate all available addresses */
        !            48:        ADDR_TYPE_ALL = (1 << 5) - 1,
        !            49: };
        !            50: 
        !            51: /**
        !            52:  * Interface to the network subsystem of the kernel.
        !            53:  *
        !            54:  * The kernel network interface handles the communication with the kernel
        !            55:  * for interface and IP address management.
        !            56:  */
        !            57: struct kernel_net_t {
        !            58: 
        !            59:        /**
        !            60:         * Get the feature set supported by this kernel backend.
        !            61:         *
        !            62:         * @return                              ORed feature-set of backend
        !            63:         */
        !            64:        kernel_feature_t (*get_features)(kernel_net_t *this);
        !            65: 
        !            66:        /**
        !            67:         * Get our outgoing source address for a destination.
        !            68:         *
        !            69:         * Does a route lookup to get the source address used to reach dest.
        !            70:         * The returned host is allocated and must be destroyed.
        !            71:         * An optional src address can be used to check if a route is available
        !            72:         * for the given source to dest.
        !            73:         *
        !            74:         * @param dest                  target destination address
        !            75:         * @param src                   source address to check, or NULL
        !            76:         * @return                              outgoing source address, NULL if unreachable
        !            77:         */
        !            78:        host_t* (*get_source_addr)(kernel_net_t *this, host_t *dest, host_t *src);
        !            79: 
        !            80:        /**
        !            81:         * Get the next hop for a destination.
        !            82:         *
        !            83:         * Does a route lookup to get the next hop used to reach dest.
        !            84:         * The returned host is allocated and must be destroyed.
        !            85:         * An optional src address can be used to check if a route is available
        !            86:         * for the given source to dest.
        !            87:         *
        !            88:         * @param dest                  target destination address
        !            89:         * @param prefix                prefix length if dest is a subnet, -1 for auto
        !            90:         * @param src                   source address to check, or NULL
        !            91:         * @param[out] iface    allocated name of the interface to reach dest, if
        !            92:         *                                              available (optional)
        !            93:         * @return                              next hop address, NULL if unreachable
        !            94:         */
        !            95:        host_t* (*get_nexthop)(kernel_net_t *this, host_t *dest, int prefix,
        !            96:                                                   host_t *src, char **iface);
        !            97: 
        !            98:        /**
        !            99:         * Get the interface name of a local address. Interfaces that are down or
        !           100:         * ignored by config are not considered.
        !           101:         *
        !           102:         * @param host                  address to get interface name from
        !           103:         * @param name                  allocated interface name (optional)
        !           104:         * @return                              TRUE if interface found and usable
        !           105:         */
        !           106:        bool (*get_interface) (kernel_net_t *this, host_t *host, char **name);
        !           107: 
        !           108:        /**
        !           109:         * Creates an enumerator over all local addresses.
        !           110:         *
        !           111:         * This function blocks an internal cached address list until the
        !           112:         * enumerator gets destroyed.
        !           113:         * The hosts are read-only, do not modify of free.
        !           114:         *
        !           115:         * @param which                 a combination of address types to enumerate
        !           116:         * @return                              enumerator over host_t's
        !           117:         */
        !           118:        enumerator_t *(*create_address_enumerator) (kernel_net_t *this,
        !           119:                                                                                                kernel_address_type_t which);
        !           120: 
        !           121:        /**
        !           122:         * Creates an enumerator over all local subnets.
        !           123:         *
        !           124:         * Local subnets are subnets the host is directly connected to.
        !           125:         *
        !           126:         * The enumerator returns the network, subnet mask and interface.
        !           127:         *
        !           128:         * @return                              enumerator over host_t*, uint8_t, char*
        !           129:         */
        !           130:        enumerator_t *(*create_local_subnet_enumerator)(kernel_net_t *this);
        !           131: 
        !           132:        /**
        !           133:         * Add a virtual IP to an interface.
        !           134:         *
        !           135:         * Virtual IPs are attached to an interface. If an IP is added multiple
        !           136:         * times, the IP is refcounted and not removed until del_ip() was called
        !           137:         * as many times as add_ip().
        !           138:         *
        !           139:         * @param virtual_ip    virtual ip address to assign
        !           140:         * @param prefix                prefix length to install with IP address, -1 for auto
        !           141:         * @param iface                 interface to install virtual IP on
        !           142:         * @return                              SUCCESS if operation completed
        !           143:         */
        !           144:        status_t (*add_ip) (kernel_net_t *this, host_t *virtual_ip, int prefix,
        !           145:                                                char *iface);
        !           146: 
        !           147:        /**
        !           148:         * Remove a virtual IP from an interface.
        !           149:         *
        !           150:         * The kernel interface uses refcounting, see add_ip().
        !           151:         *
        !           152:         * @param virtual_ip    virtual ip address to remove
        !           153:         * @param prefix                prefix length of the IP to uninstall, -1 for auto
        !           154:         * @param wait                  TRUE to wait until IP is gone
        !           155:         * @return                              SUCCESS if operation completed
        !           156:         */
        !           157:        status_t (*del_ip) (kernel_net_t *this, host_t *virtual_ip, int prefix,
        !           158:                                                bool wait);
        !           159: 
        !           160:        /**
        !           161:         * Add a route.
        !           162:         *
        !           163:         * @param dst_net               destination net
        !           164:         * @param prefixlen             destination net prefix length
        !           165:         * @param gateway               gateway for this route
        !           166:         * @param src_ip                source ip of the route
        !           167:         * @param if_name               name of the interface the route is bound to
        !           168:         * @param pass                  TRUE if route is installed for passthrough policy
        !           169:         * @return                              SUCCESS if operation completed
        !           170:         *                                              ALREADY_DONE if the route already exists
        !           171:         */
        !           172:        status_t (*add_route) (kernel_net_t *this, chunk_t dst_net,
        !           173:                                                   uint8_t prefixlen, host_t *gateway, host_t *src_ip,
        !           174:                                                   char *if_name, bool pass);
        !           175: 
        !           176:        /**
        !           177:         * Delete a route.
        !           178:         *
        !           179:         * @param dst_net               destination net
        !           180:         * @param prefixlen             destination net prefix length
        !           181:         * @param gateway               gateway for this route
        !           182:         * @param src_ip                source ip of the route
        !           183:         * @param if_name               name of the interface the route is bound to
        !           184:         * @param pass                  TRUE if route was installed for passthrough policy
        !           185:         * @return                              SUCCESS if operation completed
        !           186:         */
        !           187:        status_t (*del_route) (kernel_net_t *this, chunk_t dst_net,
        !           188:                                                   uint8_t prefixlen, host_t *gateway, host_t *src_ip,
        !           189:                                                   char *if_name, bool pass);
        !           190: 
        !           191:        /**
        !           192:         * Destroy the implementation.
        !           193:         */
        !           194:        void (*destroy) (kernel_net_t *this);
        !           195: };
        !           196: 
        !           197: /**
        !           198:  * Helper function to (un-)register net kernel interfaces from plugin features.
        !           199:  *
        !           200:  * This function is a plugin_feature_callback_t and can be used with the
        !           201:  * PLUGIN_CALLBACK macro to register an net kernel interface constructor.
        !           202:  *
        !           203:  * @param plugin               plugin registering the kernel interface
        !           204:  * @param feature              associated plugin feature
        !           205:  * @param reg                  TRUE to register, FALSE to unregister
        !           206:  * @param data                 data passed to callback, an kernel_net_constructor_t
        !           207:  */
        !           208: bool kernel_net_register(plugin_t *plugin, plugin_feature_t *feature,
        !           209:                                                 bool reg, void *data);
        !           210: 
        !           211: #endif /** KERNEL_NET_H_ @}*/

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>