NetworkStack.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef MACHINE_NETWORK_STACK_H
#define MACHINE_NETWORK_STACK_H

#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/machine/Network.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/MemoryPool.h"
#include "pedigree/kernel/utilities/RequestQueue.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/Tree.h"
#include "pedigree/kernel/utilities/Vector.h"

// lwIP network interface type
struct netif;

class EXPORTED_PUBLIC NetworkStack : public RequestQueue
{
  public:
    NetworkStack();
    virtual ~NetworkStack();

    static NetworkStack &instance()
    {
        return *stack;
    }

    void
    receive(size_t nBytes, uintptr_t packet, Network *pCard, uint32_t offset);

    void registerDevice(Network *pDevice);

    Network *getDevice(size_t n);

    size_t getNumDevices();

    void deRegisterDevice(Network *pDevice);

    void setLoopback(Network *pCard)
    {
        m_pLoopback = pCard;
    }

    inline Network *getLoopback()
    {
        return m_pLoopback;
    }

    inline MemoryPool &getMemPool()
    {
        return m_MemPool;
    }

    class Packet
    {
        friend class NetworkStack;

      public:
        Packet();
        virtual ~Packet();

        uintptr_t getBuffer() const
        {
            return m_Buffer;
        }

        size_t getLength() const
        {
            return m_PacketLength;
        }

        Network *getCard() const
        {
            return m_pCard;
        }

        uint32_t getOffset() const
        {
            return m_Offset;
        }

      private:
        bool copyFrom(uintptr_t otherPacket, size_t size);

        uintptr_t m_Buffer;
        size_t m_PacketLength;
        Network *m_pCard;
        uint32_t m_Offset;
        Mutex m_Pushed;
    };

    struct netif *getInterface(Network *pCard) const
    {
        return m_Interfaces.lookup(pCard);
    }

  private:
    static NetworkStack *stack;

    virtual uint64_t executeRequest(
        uint64_t p1, uint64_t p2, uint64_t p3, uint64_t p4, uint64_t p5,
        uint64_t p6, uint64_t p7, uint64_t p8);

    Network *m_pLoopback;

    Vector<Network *> m_Children;

    MemoryPool m_MemPool;

#if defined(THREADS) || defined(UTILITY_LINUX)
    Mutex m_Lock;
#endif

    Tree<Network *, struct netif *> m_Interfaces;

    size_t m_NextInterfaceNumber;
};

#endif