/*
 * Copyright 2010, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */

#include <NetworkInterface.h>

#include <errno.h>
#include <net/if.h>
#include <sys/sockio.h>

#include <AutoDeleter.h>
#include <Messenger.h>
#include <NetServer.h>
#include <NetworkRoute.h>


static int
family_from_interface_address(const BNetworkInterfaceAddress& address)
{
        if (address.Address().Family() != AF_UNSPEC)
                return address.Address().Family();
        if (address.Mask().Family() != AF_UNSPEC)
                return address.Mask().Family();
        if (address.Destination().Family() != AF_UNSPEC)
                return address.Destination().Family();

        return AF_INET;
}


static status_t
do_ifaliasreq(const char* name, int32 option, BNetworkInterfaceAddress& address,
        bool readBack = false)
{
        int family = AF_INET;
        if (!readBack)
                family = family_from_interface_address(address);

        FileDescriptorCloser socket(::socket(family, SOCK_DGRAM, 0));
        if (!socket.IsSet())
                return errno;

        ifaliasreq request;
        strlcpy(request.ifra_name, name, IF_NAMESIZE);
        request.ifra_index = address.Index();
        request.ifra_flags = address.Flags();

        memcpy(&request.ifra_addr, &address.Address().SockAddr(),
                address.Address().Length());
        memcpy(&request.ifra_mask, &address.Mask().SockAddr(),
                address.Mask().Length());
        memcpy(&request.ifra_broadaddr, &address.Broadcast().SockAddr(),
                address.Broadcast().Length());

        if (ioctl(socket.Get(), option, &request, sizeof(struct ifaliasreq)) < 0)
                return errno;

        if (readBack) {
                address.SetFlags(request.ifra_flags);
                address.Address().SetTo(request.ifra_addr);
                address.Mask().SetTo(request.ifra_mask);
                address.Broadcast().SetTo(request.ifra_broadaddr);
        }

        return B_OK;
}


static status_t
do_ifaliasreq(const char* name, int32 option,
        const BNetworkInterfaceAddress& address)
{
        return do_ifaliasreq(name, option,
                const_cast<BNetworkInterfaceAddress&>(address));
}


template<typename T> status_t
do_request(int family, T& request, const char* name, int option)
{
        FileDescriptorCloser socket(::socket(family, SOCK_DGRAM, 0));
        if (!socket.IsSet())
                return errno;

        strlcpy(((struct ifreq&)request).ifr_name, name, IF_NAMESIZE);

        if (ioctl(socket.Get(), option, &request, sizeof(T)) < 0)
                return errno;

        return B_OK;
}


// #pragma mark -


BNetworkInterfaceAddress::BNetworkInterfaceAddress()
        :
        fIndex(-1),
        fFlags(0)
{
}


BNetworkInterfaceAddress::~BNetworkInterfaceAddress()
{
}


status_t
BNetworkInterfaceAddress::SetTo(const BNetworkInterface& interface, int32 index)
{
        fIndex = index;
        return do_ifaliasreq(interface.Name(), B_SOCKET_GET_ALIAS, *this, true);
}


void
BNetworkInterfaceAddress::SetAddress(const BNetworkAddress& address)
{
        fAddress = address;
}


void
BNetworkInterfaceAddress::SetMask(const BNetworkAddress& mask)
{
        fMask = mask;
}


void
BNetworkInterfaceAddress::SetBroadcast(const BNetworkAddress& broadcast)
{
        fBroadcast = broadcast;
}


void
BNetworkInterfaceAddress::SetDestination(const BNetworkAddress& destination)
{
        fBroadcast = destination;
}


void
BNetworkInterfaceAddress::SetFlags(uint32 flags)
{
        fFlags = flags;
}


// #pragma mark -


BNetworkInterface::BNetworkInterface()
{
        Unset();
}


BNetworkInterface::BNetworkInterface(const char* name)
{
        SetTo(name);
}


BNetworkInterface::BNetworkInterface(uint32 index)
{
        SetTo(index);
}


BNetworkInterface::~BNetworkInterface()
{
}


void
BNetworkInterface::Unset()
{
        fName[0] = '\0';
}


void
BNetworkInterface::SetTo(const char* name)
{
        strlcpy(fName, name, IF_NAMESIZE);
}


status_t
BNetworkInterface::SetTo(uint32 index)
{
        ifreq request;
        request.ifr_index = index;

        status_t status = do_request(AF_INET, request, "", SIOCGIFNAME);
        if (status != B_OK)
                return status;

        strlcpy(fName, request.ifr_name, IF_NAMESIZE);
        return B_OK;
}


bool
BNetworkInterface::Exists() const
{
        ifreq request;
        return do_request(AF_INET, request, Name(), SIOCGIFINDEX) == B_OK;
}


const char*
BNetworkInterface::Name() const
{
        return fName;
}


uint32
BNetworkInterface::Index() const
{
        ifreq request;
        if (do_request(AF_INET, request, Name(), SIOCGIFINDEX) != B_OK)
                return 0;

        return request.ifr_index;
}


uint32
BNetworkInterface::Flags() const
{
        ifreq request;
        if (do_request(AF_INET, request, Name(), SIOCGIFFLAGS) != B_OK)
                return 0;

        return request.ifr_flags;
}


uint32
BNetworkInterface::MTU() const
{
        ifreq request;
        if (do_request(AF_INET, request, Name(), SIOCGIFMTU) != B_OK)
                return 0;

        return request.ifr_mtu;
}


int32
BNetworkInterface::Media() const
{
        ifreq request;
        if (do_request(AF_INET, request, Name(), SIOCGIFMEDIA) != B_OK)
                return -1;

        return request.ifr_media;
}


uint32
BNetworkInterface::Metric() const
{
        ifreq request;
        if (do_request(AF_INET, request, Name(), SIOCGIFMETRIC) != B_OK)
                return 0;

        return request.ifr_metric;
}


uint32
BNetworkInterface::Type() const
{
        ifreq request;
        if (do_request(AF_INET, request, Name(), SIOCGIFTYPE) != B_OK)
                return 0;

        return request.ifr_type;
}


status_t
BNetworkInterface::GetStats(ifreq_stats& stats)
{
        ifreq request;
        status_t status = do_request(AF_INET, request, Name(), SIOCGIFSTATS);
        if (status != B_OK)
                return status;

        memcpy(&stats, &request.ifr_stats, sizeof(ifreq_stats));
        return B_OK;
}


bool
BNetworkInterface::HasLink() const
{
        return (Flags() & IFF_LINK) != 0;
}


status_t
BNetworkInterface::SetFlags(uint32 flags)
{
        ifreq request;
        request.ifr_flags = flags;
        return do_request(AF_INET, request, Name(), SIOCSIFFLAGS);
}


status_t
BNetworkInterface::SetMTU(uint32 mtu)
{
        ifreq request;
        request.ifr_mtu = mtu;
        return do_request(AF_INET, request, Name(), SIOCSIFMTU);
}


status_t
BNetworkInterface::SetMedia(int32 media)
{
        ifreq request;
        request.ifr_media = media;
        return do_request(AF_INET, request, Name(), SIOCSIFMEDIA);
}


status_t
BNetworkInterface::SetMetric(uint32 metric)
{
        ifreq request;
        request.ifr_metric = metric;
        return do_request(AF_INET, request, Name(), SIOCSIFMETRIC);
}


int32
BNetworkInterface::CountAddresses() const
{
        ifreq request;
        if (do_request(AF_INET, request, Name(), B_SOCKET_COUNT_ALIASES) != B_OK)
                return 0;

        return request.ifr_count;
}


status_t
BNetworkInterface::GetAddressAt(int32 index, BNetworkInterfaceAddress& address)
{
        return address.SetTo(*this, index);
}


int32
BNetworkInterface::FindAddress(const BNetworkAddress& address)
{
        FileDescriptorCloser socket(::socket(address.Family(), SOCK_DGRAM, 0));
        if (!socket.IsSet())
                return -1;

        ifaliasreq request;
        memset(&request, 0, sizeof(ifaliasreq));

        strlcpy(request.ifra_name, Name(), IF_NAMESIZE);
        request.ifra_index = -1;
        memcpy(&request.ifra_addr, &address.SockAddr(), address.Length());

        if (ioctl(socket.Get(), B_SOCKET_GET_ALIAS, &request,
                sizeof(struct ifaliasreq)) < 0) {
                return -1;
        }

        return request.ifra_index;
}


int32
BNetworkInterface::FindFirstAddress(int family)
{
        FileDescriptorCloser socket(::socket(family, SOCK_DGRAM, 0));
        if (!socket.IsSet())
                return -1;

        ifaliasreq request;
        memset(&request, 0, sizeof(ifaliasreq));

        strlcpy(request.ifra_name, Name(), IF_NAMESIZE);
        request.ifra_index = -1;
        request.ifra_addr.ss_family = AF_UNSPEC;

        if (ioctl(socket.Get(), B_SOCKET_GET_ALIAS, &request,
                sizeof(struct ifaliasreq)) < 0) {
                return -1;
        }

        return request.ifra_index;
}


status_t
BNetworkInterface::AddAddress(const BNetworkInterfaceAddress& address)
{
        return do_ifaliasreq(Name(), B_SOCKET_ADD_ALIAS, address);
}


status_t
BNetworkInterface::AddAddress(const BNetworkAddress& local)
{
        BNetworkInterfaceAddress address;
        address.SetAddress(local);

        return do_ifaliasreq(Name(), B_SOCKET_ADD_ALIAS, address);
}


status_t
BNetworkInterface::SetAddress(const BNetworkInterfaceAddress& address)
{
        return do_ifaliasreq(Name(), B_SOCKET_SET_ALIAS, address);
}


status_t
BNetworkInterface::RemoveAddress(const BNetworkInterfaceAddress& address)
{
        ifreq request;
        memcpy(&request.ifr_addr, &address.Address().SockAddr(),
                address.Address().Length());

        return do_request(family_from_interface_address(address), request, Name(),
                B_SOCKET_REMOVE_ALIAS);
}


status_t
BNetworkInterface::RemoveAddress(const BNetworkAddress& address)
{
        ifreq request;
        memcpy(&request.ifr_addr, &address.SockAddr(), address.Length());

        return do_request(address.Family(), request, Name(), B_SOCKET_REMOVE_ALIAS);
}


status_t
BNetworkInterface::RemoveAddressAt(int32 index)
{
        BNetworkInterfaceAddress address;
        status_t status = GetAddressAt(index, address);
        if (status != B_OK)
                return status;

        return RemoveAddress(address);
}


status_t
BNetworkInterface::GetHardwareAddress(BNetworkAddress& address)
{
        FileDescriptorCloser socket(::socket(AF_LINK, SOCK_DGRAM, 0));
        if (!socket.IsSet())
                return errno;

        ifreq request;
        strlcpy(request.ifr_name, Name(), IF_NAMESIZE);

        if (ioctl(socket.Get(), SIOCGIFADDR, &request, sizeof(struct ifreq)) < 0)
                return errno;

        address.SetTo(request.ifr_addr);
        return B_OK;
}


status_t
BNetworkInterface::AddRoute(const BNetworkRoute& route)
{
        int family = route.AddressFamily();
        if (family == AF_UNSPEC)
                return B_BAD_VALUE;

        ifreq request;
        request.ifr_route = route.RouteEntry();
        return do_request(family, request, Name(), SIOCADDRT);
}


status_t
BNetworkInterface::AddDefaultRoute(const BNetworkAddress& gateway)
{
        BNetworkRoute route;
        status_t result = route.SetGateway(gateway);
        if (result != B_OK)
                return result;

        route.SetFlags(RTF_STATIC | RTF_DEFAULT | RTF_GATEWAY);
        return AddRoute(route);
}


status_t
BNetworkInterface::RemoveRoute(const BNetworkRoute& route)
{
        int family = route.AddressFamily();
        if (family == AF_UNSPEC)
                return B_BAD_VALUE;

        return RemoveRoute(family, route);
}


status_t
BNetworkInterface::RemoveRoute(int family, const BNetworkRoute& route)
{
        ifreq request;
        request.ifr_route = route.RouteEntry();
        return do_request(family, request, Name(), SIOCDELRT);
}


status_t
BNetworkInterface::RemoveDefaultRoute(int family)
{
        BNetworkRoute route;
        route.SetFlags(RTF_STATIC | RTF_DEFAULT);
        return RemoveRoute(family, route);
}


status_t
BNetworkInterface::GetRoutes(int family,
        BObjectList<BNetworkRoute, true>& routes) const
{
        return BNetworkRoute::GetRoutes(family, Name(), routes);
}


status_t
BNetworkInterface::GetDefaultRoute(int family, BNetworkRoute& route) const
{
        return BNetworkRoute::GetDefaultRoute(family, Name(), route);
}


status_t
BNetworkInterface::GetDefaultGateway(int family, BNetworkAddress& gateway) const
{
        return BNetworkRoute::GetDefaultGateway(family, Name(), gateway);
}


status_t
BNetworkInterface::AutoConfigure(int family)
{
        BMessage message(kMsgConfigureInterface);
        message.AddString("device", Name());

        BMessage address;
        address.AddInt32("family", family);
        address.AddBool("auto_config", true);
        message.AddMessage("address", &address);

        BMessenger networkServer(kNetServerSignature);
        BMessage reply;
        status_t status = networkServer.SendMessage(&message, &reply);
        if (status == B_OK)
                reply.FindInt32("status", &status);

        return status;
}