/*
 * Copyright 2006-2010, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef NET_DATALINK_H
#define NET_DATALINK_H


#include <net/if.h>

#include <net_buffer.h>
#include <net_routing_info.h>

#include <util/list.h>


#define NET_DATALINK_MODULE_NAME "network/stack/datalink/v1"


class Checksum;
struct net_protocol;


typedef struct net_datalink_protocol net_datalink_protocol;


typedef struct net_domain {
        const char*                     name;
        int                                     family;

        struct net_protocol_module_info* module;
        struct net_address_module_info* address_module;
} net_domain;

typedef struct net_interface_address {
        struct net_domain*      domain;
        struct net_interface* interface;
        struct sockaddr*        local;
        struct sockaddr*        destination;
        struct sockaddr*        mask;
        uint32_t                        flags;
} net_interface_address;

typedef struct net_interface {
        struct net_device*      device;

        char                            name[IF_NAMESIZE];
        uint32                          index;
        uint32                          flags;
        uint8                           type;
        uint32                          metric;
} net_interface;

typedef struct net_route {
        struct sockaddr*        destination;
        struct sockaddr*        mask;
        struct sockaddr*        gateway;
        uint32                          flags;
        uint32                          mtu;
        struct net_interface_address* interface_address;
} net_route;

typedef struct net_route_info {
        struct list_link        link;
        struct net_route*       route;
        struct sockaddr         address;
} net_route_info;


struct net_datalink_module_info {
        module_info info;

        status_t                (*control)(net_domain* domain, int32 option, void* value,
                                                size_t* _length);
        status_t                (*send_routed_data)(net_route* route, net_buffer* buffer);
        status_t                (*send_data)(struct net_protocol* protocol,
                                                net_domain* domain, net_buffer* buffer);

        bool                    (*is_local_address)(net_domain* domain,
                                                const struct sockaddr* address,
                                                net_interface_address** _interfaceAddress,
                                                uint32* _matchedType);
        bool                    (*is_local_link_address)(net_domain* domain,
                                                bool unconfigured, const struct sockaddr* address,
                                                net_interface_address** _interfaceAddress);

        net_interface*  (*get_interface)(net_domain* domain, uint32 index);
        net_interface*  (*get_interface_with_address)(
                                                const struct sockaddr* address);
        void                    (*put_interface)(net_interface* interface);

        net_interface_address* (*get_interface_address)(
                                                const struct sockaddr* address);
        bool                    (*get_next_interface_address)(net_interface* interface,
                                                net_interface_address** _address);
        void                    (*put_interface_address)(net_interface_address* address);

        status_t                (*join_multicast)(net_interface* interface,
                                                net_domain* domain, const struct sockaddr* address);
        status_t                (*leave_multicast)(net_interface* interface,
                                                net_domain* domain, const struct sockaddr* address);

        // routes
        status_t                (*add_route)(net_domain* domain, const net_route* route);
        status_t                (*remove_route)(net_domain* domain, const net_route* route);
        net_route*              (*get_route)(net_domain* domain,
                                                const struct sockaddr* address);
        status_t                (*get_buffer_route)(net_domain* domain,
                                                struct net_buffer* buffer, net_route** _route);
        void                    (*put_route)(net_domain* domain, net_route* route);

        status_t                (*register_route_info)(net_domain* domain,
                                                net_route_info* info);
        status_t                (*unregister_route_info)(net_domain* domain,
                                                net_route_info* info);
        status_t                (*update_route_info)(net_domain* domain,
                                                net_route_info* info);
};

#define NET_ADDRESS_MODULE_FLAG_BROADCAST_ADDRESS               0x01

struct net_address_module_info {
        module_info info;
        uint32 flags;

        status_t                (*copy_address)(const struct sockaddr* from,
                                                struct sockaddr** to, bool replaceWithZeros,
                                                const struct sockaddr* mask);

        status_t                (*mask_address)(const struct sockaddr* address,
                                                const struct sockaddr* mask, struct sockaddr* result);

        bool                    (*equal_addresses)(const struct sockaddr* a,
                                                const struct sockaddr* b);
        bool                    (*equal_ports)(const struct sockaddr* a,
                                                const struct sockaddr* b);
        bool                    (*equal_addresses_and_ports)(const struct sockaddr* a,
                                                const struct sockaddr* b);
        bool                    (*equal_masked_addresses)(const struct sockaddr* a,
                                                const struct sockaddr* b, const struct sockaddr* mask);
        bool                    (*is_empty_address)(const struct sockaddr* address,
                                                bool checkPort);
        bool                    (*is_same_family)(const struct sockaddr* address);

        int32                   (*first_mask_bit)(const struct sockaddr* mask);

        bool                    (*check_mask)(const struct sockaddr* address);

        status_t                (*print_address)(const struct sockaddr* address,
                                                char** buffer, bool printPort);
        status_t                (*print_address_buffer)(const struct sockaddr* address,
                                                char* buffer, size_t bufferSize, bool printPort);

        uint16                  (*get_port)(const struct sockaddr* address);
        status_t                (*set_port)(struct sockaddr* address, uint16 port);

        status_t                (*set_to)(struct sockaddr* address,
                                                const struct sockaddr* from);
        status_t                (*set_to_empty_address)(struct sockaddr* address);
        status_t                (*set_to_defaults)(struct sockaddr* defaultMask,
                                                struct sockaddr* defaultBroadcast,
                                                const struct sockaddr* address,
                                                const struct sockaddr* netmask);

        status_t                (*update_to)(struct sockaddr* address,
                                                const struct sockaddr* from);

        uint32                  (*hash_address)(const struct sockaddr* address,
                                                bool includePort);
        uint32                  (*hash_address_pair)(const struct sockaddr* ourAddress,
                                                const struct sockaddr* peerAddress);

        status_t                (*checksum_address)(Checksum* checksum,
                                                const struct sockaddr* address);

        void                    (*get_loopback_address)(struct sockaddr* result);
};


#endif  // NET_DATALINK_H