ip6.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 IP6_HPP_
#define IP6_HPP_

#include "openthread-core-config.h"

#include <stddef.h>

#include <openthread/ip6.h>
#include <openthread/udp.h>

#include "common/encoding.hpp"
#include "common/locator.hpp"
#include "common/message.hpp"
#include "net/icmp6.hpp"
#include "net/ip6_address.hpp"
#include "net/ip6_headers.hpp"
#include "net/ip6_mpl.hpp"
#include "net/ip6_routes.hpp"
#include "net/netif.hpp"
#include "net/socket.hpp"
#include "net/udp6.hpp"

using ot::Encoding::BigEndian::HostSwap16;
using ot::Encoding::BigEndian::HostSwap32;

namespace ot {

namespace Ip6 {

class Ip6 : public InstanceLocator
{
public:
    enum
    {
        kDefaultHopLimit = 64,
        kMaxDatagramLength = 1280,
    };

    Message *NewMessage(uint16_t aReserved);

    Ip6(otInstance &aInstance);

    otError SendDatagram(Message &aMessage, MessageInfo &aMessageInfo, IpProto aIpProto);

    otError SendRaw(Message &aMessage, int8_t aInterfaceId);

    otError HandleDatagram(Message &aMessage, Netif *aNetif, int8_t aInterfaceId,
                           const void *aLinkMessageInfo, bool aFromNcpHost);


    void EnqueueDatagram(Message &aMessage);

    static uint16_t UpdateChecksum(uint16_t aChecksum, const Address &aAddress);

    static uint16_t ComputePseudoheaderChecksum(const Address &aSource, const Address &aDestination,
                                                uint16_t aLength, IpProto aProto);

    void SetReceiveDatagramCallback(otIp6ReceiveCallback aCallback, void *aCallbackContext);

    bool IsReceiveIp6FilterEnabled(void) { return mIsReceiveIp6FilterEnabled; }

    void SetReceiveIp6FilterEnabled(bool aEnabled) { mIsReceiveIp6FilterEnabled = aEnabled; }

    bool IsForwardingEnabled(void) { return mForwardingEnabled; }

    void SetForwardingEnabled(bool aEnable) { mForwardingEnabled = aEnable; }

    otError AddNetif(Netif &aNetif);

    otError RemoveNetif(Netif &aNetif);

    Netif *GetNetifList(void) { return mNetifListHead; }

    Netif *GetNetifById(int8_t aInterfaceId);

    bool IsUnicastAddress(const Address &aAddress);

    const NetifUnicastAddress *SelectSourceAddress(MessageInfo &aMessageInfo);

    int8_t GetOnLinkNetif(const Address &aAddress);

    const PriorityQueue &GetSendQueue(void) const { return mSendQueue; }

    Routes &GetRoutes(void) { return mRoutes; }

    Icmp &GetIcmp(void) { return mIcmp; }

    Udp &GetUdp(void) { return mUdp; }

    Mpl &GetMpl(void) { return mMpl; }

    static const char *IpProtoToString(IpProto aIpProto);

private:
    static void HandleSendQueue(Tasklet &aTasklet);
    void HandleSendQueue(void);

    otError ProcessReceiveCallback(const Message &aMessage, const MessageInfo &aMessageInfo, uint8_t aIpProto,
                                   bool aFromNcpHost);
    otError HandleExtensionHeaders(Message &aMessage, Header &aHeader, uint8_t &aNextHeader, bool aForward,
                                   bool aReceive);
    otError HandleFragment(Message &aMessage);
    otError AddMplOption(Message &aMessage, Header &aHeader);
    otError AddTunneledMplOption(Message &aMessage, Header &aHeader, MessageInfo &aMessageInfo);
    otError InsertMplOption(Message &aMessage, Header &aHeader, MessageInfo &aMessageInfo);
    otError RemoveMplOption(Message &aMessage);
    otError HandleOptions(Message &aMessage, Header &aHeader, bool &aForward);
    otError HandlePayload(Message &aMessage, MessageInfo &aMessageInfo, uint8_t aIpProto);
    int8_t FindForwardInterfaceId(const MessageInfo &aMessageInfo);

    static Ip6 &GetOwner(const Context &aContext);

    bool mForwardingEnabled;
    bool mIsReceiveIp6FilterEnabled;
    otIp6ReceiveCallback mReceiveIp6DatagramCallback;
    void *mReceiveIp6DatagramCallbackContext;
    Netif *mNetifListHead;

    PriorityQueue mSendQueue;
    Tasklet mSendQueueTask;

    Routes mRoutes;
    Icmp mIcmp;
    Udp mUdp;
    Mpl mMpl;

};

}  // namespace Ip6
}  // namespace ot

#endif  // NET_IP6_HPP_