Current Symbian^3 public API header files (from PDK 3.0.h)
This is the epoc32/include tree with the "platform" subtrees removed, and
all but a selected few mbg and rsg files removed.
// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// in_pkt.h - packet handling routines
// Generic packet handling utility for mapping packet handling to the RMBufChain.
//
/**
@file in_pkt.h
@publishedAll
@released
*/
#ifndef __IN_PKT_H__
#define __IN_PKT_H__
#include "ip6_hdr.h" // ..should eventually be <inet/ip6_hdr.h>? -- msa
#include "ip4_hdr.h"
class RMBufChain;
#define TPACKETHEAD_FRAGMENT 1 //< Enable iFragment in TPacketHead
/**
TScopeType is only provided so that "magic" constants can be
avoided in the source code. However, the max value cannot be changed
to anything from 0xF. The scope type is assumed to be 4 bits long
in many occasions.
The value of the scope type is directly bound the the IPv6 Scope
level - 1. This can be done, as IPv6 Scope level 0 is not legal
(or usable) in any context within the stack.
This allows our non-standard network scope (= 0x10) to
be coded internally in 4 bits (as 0xF).
@publishedAll
@released
@since v7.0s
*/
enum TScopeType
{
EScopeType_IF = 0x0, //< (= #KIp6AddrScopeNodeLocal - 1), id is interface index
EScopeType_IAP = 0x1, //< (= #KIp6AddrScopeLinkLocal - 1). id is IAP number
EScopeType_GLOBAL = 0xD,//< (= #KIp6AddrScopeGlobal - 1). id is global scope id
//
// no symbols defined for types 2..14 (they are also valid)
//
EScopeType_NET = 0xF //< (= #KIp6AddrScopeNetwork - 1), id is network number (must be the last entry)
};
//
// TIpHeader
// *********
class TIpHeader
/**
A simple help class that uses a union to merge handling of either an IPv4 or
an IPv6 header.
@since v7.0
@publishedAll
@released
*/
{
public:
/**
Gets the minimum header length.
IPv6 header is longer than minimum IPv4 header, thus
returned value is for IPv4. This function only defined
because it is required when this class is used as template
parameter in TInet6Packet.
@return Minimum IPv4 header length
*/
inline static TInt MinHeaderLength() {return TInet6HeaderIP4::MinHeaderLength(); }
/**
Gets the maximum header length.
IPv6 header always shorter than maximum IPv4 header, thus
returned value is for IPv4. This function is only defined
because "header mapping" classes are expected to have it.
@return Maximum IPv4 header length
*/
inline static TInt MaxHeaderLength() {return TInet6HeaderIP4::MaxHeaderLength(); }
union
{
TInet6HeaderIP4 ip4;
TInet6HeaderIP ip6;
};
};
class TInet6PacketBase
/**
* Thin base class for the TInet6Packet.
*/
{
public:
enum TAlign
{
EAlign1 = 0, //< Align to byte (no align requirement)
EAlign2 = 1, //< Align to 2 byte unit (even address)
EAlign4 = 3, //< Align to 4 byte unit
EAlign8 = 7 //< Align to 8 byte unit
};
/**
Constructor.
@param aAlign The align requirement.
*/
TInet6PacketBase(TAlign aAlign) : iLength(0), iAlign(aAlign) {}
/**
Length of the mapped region.
The real mapped length as computed by the Access function.
If access returned non-NULL, the following is always TRUE:
@li aMin <= iLength
*/
TInt iLength;
IMPORT_C TUint8 *Access(RMBufChain &aPacket, TInt aOffset, TInt aSize, TInt aMin);
inline void SetAlign(TAlign aAlign)
/**
* Changes the align requirement.
*
* @param aAlign The new align requirement.
*/
{
iAlign = aAlign;
}
protected:
/**
The align requirement.
*/
TAlign iAlign;
};
// TInet6Packet template
// *********************
template <class T>
class TInet6Packet : public TInet6PacketBase
/**
Encapsulates an IPv6 packet header as a section of an RMBufChain.
The T template parameter should represent a packet header type. It should
support static functions MaxHeaderLength() and MinHeaderLength() that return
TInt values for maximum and minimum header lengths respectively.
@publishedAll
@released
@since v7.0
*/
{
public:
TInet6Packet(TAlign aAlign = EAlign4) : TInet6PacketBase(aAlign), iHdr(NULL)
/**
Default constructor.
Construct an empty mapping. To be usable, the Set() function
must be used.
*/
{}
TInet6Packet(RMBufChain &aPacket) : TInet6PacketBase(EAlign4)
/**
Constructor specifying a RMBufChain object.
Verify and arrange it so that a class T can be mapped
to a contiguous octets from the beginning of the RMBufChain
content, and set iHdr to point this area.
If this is not possible, iHdr is initialized to NULL.
@param aPacket
Packet containing the header T at offset = 0
*/
{
iHdr = (T *)Access(aPacket, 0, T::MaxHeaderLength(), T::MinHeaderLength());
}
TInet6Packet(RMBufChain &aPacket, TInt aOffset, TAlign aAlign = EAlign4) : TInet6PacketBase(aAlign)
/**
Constructor specifying a RMBufChain object and an offset.
Verify and arrange it so that a class T can be mapped
to a contiguous octets starting at specified offset of
the RMBufChain content, and set iHdr to point this area.
If this is not possible, iHdr is initialized to NULL.
@param aPacket
Packet containing the header T at aOffset
@param aOffset
Offset of the header to be mapped.
@param aAlign
The alignement requirement.
*/
{
iHdr = (T *)Access(aPacket, aOffset, T::MaxHeaderLength(), T::MinHeaderLength());
}
void Set(RMBufChain &aPacket, TInt aOffset, TInt aSize)
/**
Sets the packet header from a specified RMBufChain object.
Verify and arrange it so that a aSize octets can be mapped
to a contiguous octets starting at specified offset of
the RMBufChain content, and set iHdr to point this area.
If this is not possible, iHdr is initialized to NULL.
Note that this differs from the contructors: the required
size is a parameter, and not determined by the T::MinHeaderLength().
However, the "T* iHdr" is set to point the start of the requested
area. It's a responsibility of the user of this method to know
whether using this pointer is safe with the specified size parameter.
@param aPacket
Packet containing the header T at aOffset
@param aOffset
Offset (position) of the header to be mapped
@param aSize
Length of required contiguous memory
*/
{
iHdr = (T *)Access(aPacket, aOffset, aSize, aSize);
}
inline T& operator()()
{
return *iHdr;
}
/**
The pointer to the mapped region (if non-NULL). If NULL,
then there is no mapping, and iLength == 0.
*/
T *iHdr;
};
#endif