ibrcommon/ibrcommon/net/NetInterface.cpp

Go to the documentation of this file.

/*
 * File:   NetInterface.cpp
 * Author: morgenro
 *
 * Created on 12. November 2009, 14:57
 */

#include "ibrcommon/config.h"
#include "ibrcommon/net/NetInterface.h"

#include <sys/types.h>
#include <netinet/ip.h>
#include <netinet/ip6.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#include <stdlib.h>
#include <net/if.h>
#include <ifaddrs.h>
#include <errno.h>

#ifdef HAVE_LOWPAN_SUPPORT
extern "C" {
#include <netlink/netlink.h>
#include <netlink/attr.h>
#include <netlink/genl/genl.h>
#include <netlink/genl/ctrl.h>

#include "ibrcommon/net/ieee802154.h"
#include "ibrcommon/net/nl802154.h"
extern struct nla_policy ieee802154_policy[IEEE802154_ATTR_MAX + 1];
};
#endif

#include <unistd.h>

using namespace std;

namespace ibrcommon
{
        NetInterface::NetInterface(std::string interface)
        : _interface(interface)
        {
        }

        NetInterface::~NetInterface()
        {

        }

        bool NetInterface::operator<(const NetInterface &other) const
        {
                if (_interface < other._interface) return true;
                return false;
        }

        bool NetInterface::operator==(const NetInterface &other) const
        {
                if (_interface == other._interface) return true;
                return false;
        }

        std::string NetInterface::getInterface() const
        {
                return _interface;
        }

        std::string NetInterface::getAddress() const
        {
                return NetInterface::getAddress(_interface);
        }

        std::string NetInterface::getBroadcast() const
        {
                return NetInterface::getBroadcast(_interface);
        }

        void NetInterface::getAddress(struct in_addr *ret) const
        {
                NetInterface::getAddress(_interface, ret);
        }

        void NetInterface::getAddress(struct ieee802154_addr *ret) const
        {
                NetInterface::getAddress(_interface, ret);
        }

        void NetInterface::getBroadcast(struct in_addr *ret) const
        {
                NetInterface::getBroadcast(_interface, ret);
        }

        void NetInterface::getAddress(std::string interface, struct in_addr *ret)
        {
                // define the return value
                ret->s_addr = htonl(INADDR_ANY);

                struct ifaddrs *ifap = NULL;
                int status = getifaddrs(&ifap);

                if ((status != 0) || (ifap == NULL))
                {
                                // error, return with default address
                                return;
                }

                for (struct ifaddrs *iter = ifap; iter != NULL; iter = iter->ifa_next)
                {
                                if (iter->ifa_addr == NULL) continue;
                                if ((iter->ifa_flags & IFF_UP) == 0) continue;

                                sockaddr *addr = iter->ifa_addr;

                                // currently only IPv4 is supported
                                if (addr->sa_family != AF_INET) continue;

                                // check the name of the interface
                                if (string(iter->ifa_name).compare(interface) != 0) continue;

                                sockaddr_in *ip = (sockaddr_in*)iter->ifa_addr;

                                ret->s_addr = ip->sin_addr.s_addr;
                                break;
                }

                freeifaddrs(ifap);
        }

        /* The Linux MAC802152 stack speaks netlink to userspace. Use it to get
         * the current address and PAN ID */
        void NetInterface::getAddress(std::string interface, struct ieee802154_addr *ret)
        {
#ifdef HAVE_LOWPAN_SUPPORT
                struct nl_handle *nl = nl_handle_alloc();
                unsigned char *buf = NULL;
                struct sockaddr_nl nla;
                struct nlattr *attrs[IEEE802154_ATTR_MAX+1];
                struct genlmsghdr *ghdr;
                struct nlmsghdr *nlh;
                struct nl_msg *msg;
                int family;

                if (!nl)
                        return;

                genl_connect(nl);

                /* Build and send message */
                msg = nlmsg_alloc();
                family = genl_ctrl_resolve(nl, "802.15.4 MAC");
                genlmsg_put(msg, NL_AUTO_PID, NL_AUTO_SEQ, family, 0, NLM_F_ECHO, IEEE802154_LIST_IFACE, 1);
                nla_put_string(msg, IEEE802154_ATTR_DEV_NAME, interface.c_str());
                nl_send_auto_complete(nl, msg);
                nlmsg_free(msg);

                /* Receive and parse answer */
                nl_recv(nl, &nla, &buf, NULL);
                nlh = (struct nlmsghdr*)buf;
                genlmsg_parse(nlh, 0, attrs, IEEE802154_ATTR_MAX, ieee802154_policy);
                ghdr = (genlmsghdr*)nlmsg_data(nlh);
                if (!attrs[IEEE802154_ATTR_SHORT_ADDR] || !attrs[IEEE802154_ATTR_SHORT_ADDR])
                        return;

                // We only handle short addresses right now
                ret->addr_type = IEEE802154_ADDR_SHORT;
                ret->pan_id = nla_get_u16(attrs[IEEE802154_ATTR_PAN_ID]);
                ret->short_addr = nla_get_u16(attrs[IEEE802154_ATTR_SHORT_ADDR]);

                free(buf);
                nl_close(nl);
#endif
        }

        void NetInterface::getBroadcast(std::string interface, struct in_addr *ret)
        {
                // define the return value
                ret->s_addr = htonl(INADDR_BROADCAST);

                struct ifaddrs *ifap = NULL;
                int status = getifaddrs(&ifap);

                if ((status != 0) || (ifap == NULL))
                {
                                // error, return with default address
                                return;
                }

                for (struct ifaddrs *iter = ifap; iter != NULL; iter = iter->ifa_next)
                {
                                if (iter->ifa_addr == NULL) continue;
                                if ((iter->ifa_flags & IFF_UP) == 0) continue;

                                sockaddr *addr = iter->ifa_addr;

                                // currently only IPv4 is supported
                                if (addr->sa_family != AF_INET) continue;

                                // check the name of the interface
                                if (string(iter->ifa_name).compare(interface) != 0) continue;

                                if (iter->ifa_flags & IFF_BROADCAST)
                                {
                                                sockaddr_in *broadcast = (sockaddr_in*)iter->ifa_broadaddr;
                                                ret->s_addr = broadcast->sin_addr.s_addr;
                                                break;
                                }
                }

                freeifaddrs(ifap);
        }

        std::string NetInterface::getAddress(std::string interface)
        {
                struct in_addr addr;
                NetInterface::getAddress(interface, &addr);
                return string(inet_ntoa(addr));
        }

        std::string NetInterface::getBroadcast(std::string interface)
        {
                struct in_addr addr;
                NetInterface::getBroadcast(interface, &addr);
                return string(inet_ntoa(addr));
        }
}

---