netif.hpp

Go to the documentation of this file.

/*
 *  Copyright (c) 2016, The OpenThread Authors.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the copyright holder nor the
 *     names of its contributors may be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef NET_NETIF_HPP_
#define NET_NETIF_HPP_

#include "openthread-core-config.h"

#include "common/locator.hpp"
#include "common/message.hpp"
#include "common/tasklet.hpp"
#include "mac/mac_frame.hpp"
#include "net/ip6_address.hpp"
#include "net/socket.hpp"

namespace ot {
namespace Ip6 {

class Ip6;

class LinkAddress
{
public :
    enum HardwareType
    {
        kEui64 = 27,
    };
    HardwareType   mType;       
    uint8_t        mLength;     
    Mac::ExtAddress mExtAddress;  
};

class NetifUnicastAddress: public otNetifAddress
{
    friend class Netif;

public:
    const Address &GetAddress(void) const { return *static_cast<const Address *>(&mAddress); }

    Address &GetAddress(void) { return *static_cast<Address *>(&mAddress); }

    uint8_t GetScope(void) const {
        return mScopeOverrideValid ? static_cast<uint8_t>(mScopeOverride) : GetAddress().GetScope();
    }

    const NetifUnicastAddress *GetNext(void) const { return static_cast<const NetifUnicastAddress *>(mNext); }

    NetifUnicastAddress *GetNext(void) { return static_cast<NetifUnicastAddress *>(mNext); }
};

class NetifMulticastAddress: public otNetifMulticastAddress
{
    friend class Netif;

public:
    const Address &GetAddress(void) const { return *static_cast<const Address *>(&mAddress); }

    Address &GetAddress(void) { return *static_cast<Address *>(&mAddress); }

    const NetifMulticastAddress *GetNext(void) const { return static_cast<const NetifMulticastAddress *>(mNext); }

    NetifMulticastAddress *GetNext(void) {
        return static_cast<NetifMulticastAddress *>(const_cast<otNetifMulticastAddress *>(mNext));
    }
};

class NetifCallback
{
    friend class Netif;

public:
    NetifCallback(void):
        mCallback(NULL),
        mContext(NULL),
        mNext(NULL) {
    }

    void Set(otStateChangedCallback aCallback, void *aContext) {
        mCallback = aCallback;
        mContext = aContext;
    }

    bool IsFree(void) { return (mCallback == NULL); }

    void Free(void) {
        mCallback = NULL;
        mContext = NULL;
        mNext = NULL;
    }

    bool IsServing(otStateChangedCallback aCallback, void *aContext) {
        return (aCallback == mCallback && aContext == mContext);
    }

private:
    void Callback(uint32_t aFlags) {
        if (mCallback != NULL) {
            mCallback(aFlags, mContext);
        }
    }

    otStateChangedCallback mCallback;
    void *mContext;
    NetifCallback *mNext;
};

class Netif: public InstanceLocator
{
    friend class Ip6;

public:
    Netif(otInstance &aInstance, int8_t aInterfaceId);

    Netif *GetNext(void) const { return mNext; }

    int8_t GetInterfaceId(void) const { return mInterfaceId; }

    const NetifUnicastAddress *GetUnicastAddresses(void) const { return mUnicastAddresses; }

    otError AddUnicastAddress(NetifUnicastAddress &aAddress);

    otError RemoveUnicastAddress(const NetifUnicastAddress &aAddress);

    otError AddExternalUnicastAddress(const NetifUnicastAddress &aAddress);

    otError RemoveExternalUnicastAddress(const Address &aAddress);

    void RemoveAllExternalUnicastAddresses(void);

    bool IsUnicastAddress(const Address &aAddress) const;

    bool IsMulticastSubscribed(const Address &aAddress) const;

    otError SubscribeAllRoutersMulticast(void);

    otError UnsubscribeAllRoutersMulticast(void);

    const NetifMulticastAddress *GetMulticastAddresses(void) const { return mMulticastAddresses; }

    otError SubscribeMulticast(NetifMulticastAddress &aAddress);

    otError UnsubscribeMulticast(const NetifMulticastAddress &aAddress);

    otError SubscribeExternalMulticast(const Address &aAddress);

    otError UnsubscribeExternalMulticast(const Address &aAddress);

    void UnsubscribeAllExternalMulticastAddresses(void);

    bool IsMulticastPromiscuousEnabled(void) { return mMulticastPromiscuous; }

    void SetMulticastPromiscuous(bool aEnabled) { mMulticastPromiscuous = aEnabled; }

    otError RegisterCallback(NetifCallback &aCallback);

    otError RemoveCallback(NetifCallback &aCallback);

    bool IsStateChangedCallbackPending(void) { return mStateChangedFlags != 0; }

    void SetStateChangedFlags(uint32_t aFlags);

    virtual otError SendMessage(Message &aMessage) = 0;

    virtual otError GetLinkAddress(LinkAddress &aAddress) const = 0;

    virtual otError RouteLookup(const Address &aSource, const Address &aDestination,
                                uint8_t *aPrefixMatch) = 0;

private:
    static void HandleStateChangedTask(Tasklet &aTasklet);
    void HandleStateChangedTask(void);
    static Netif &GetOwner(const Context &aContext);

    NetifCallback *mCallbacks;
    NetifUnicastAddress *mUnicastAddresses;
    NetifMulticastAddress *mMulticastAddresses;
    int8_t mInterfaceId;
    bool mMulticastPromiscuous;
    Tasklet mStateChangedTask;
    Netif *mNext;

    uint32_t mStateChangedFlags;

    NetifUnicastAddress mExtUnicastAddresses[OPENTHREAD_CONFIG_MAX_EXT_IP_ADDRS];
    NetifMulticastAddress mExtMulticastAddresses[OPENTHREAD_CONFIG_MAX_EXT_MULTICAST_IP_ADDRS];

    static const otNetifMulticastAddress kRealmLocalAllMplForwardersMulticastAddress;
    static const otNetifMulticastAddress kLinkLocalAllNodesMulticastAddress;
    static const otNetifMulticastAddress kRealmLocalAllNodesMulticastAddress;
    static const otNetifMulticastAddress kLinkLocalAllRoutersMulticastAddress;
    static const otNetifMulticastAddress kRealmLocalAllRoutersMulticastAddress;
};

}  // namespace Ip6
}  // namespace ot

#endif  // NET_NETIF_HPP_