--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/networkprotocols/tcpipv4v6prt/inc/inet.h Tue Jan 26 15:23:49 2010 +0200
@@ -0,0 +1,289 @@
+// 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:
+// inet.h - main definitions for inet protocols
+//
+
+
+
+/**
+ @internalComponent
+*/
+#ifndef __INET_H__
+#define __INET_H__
+
+#include <f32file.h>
+#include <e32math.h>
+
+#include <es_sock.h>
+#include <es_prot.h>
+#include <es_mbuf.h>
+#include <es_ver.h>
+#include <in_sock.h>
+#include <nifman.h> // For Nif:: calls!
+# include <comms-infras/nifif.h> // ..for CNifIfBase in Epoc R6 and later
+
+#include <nifmbuf.h>
+
+#include <flow.h>
+#include <in_bind.h>
+#include "in_fmly.h"
+#include "inet6log.h"
+#include <es_prot_internal.h>
+
+// Minimum MTU that must be supported by all IPv4 links
+const TUint KInetStandardMtu = 576;
+
+// Minimum MTU that must be supported by all IPv6 links
+const TUint KInet6StandardMtu = 1280;
+
+// Size of SAP hash table.
+const TUint KInet6SAPTableSize = 67;
+
+class CProtocolInet6Base;
+class CProtocolInet6Transport;
+class CProviderInet6Base;
+class TInet6SAPIter;
+
+//
+// RMBuf paket queue with automatic asynchronous notification.
+//
+class RMBufAsyncPktQ : public RMBufPktQ
+ {
+public:
+ RMBufAsyncPktQ() : iCallBack(NULL) {}
+ ~RMBufAsyncPktQ() { Cancel(); delete iCallBack; }
+ void InitL(TCallBack& aCallBack, TInt aPriority = KInet6DefaultPriority)
+ {
+ RMBufPktQ::Init();
+ iCallBack = new (ELeave) CAsyncCallBack(aCallBack, aPriority);
+ }
+
+ //
+ // The automatic wakeup of the reader has been removed.
+ // Call Wake() explicitly when you want to wake up the
+ // reader, e.g., after adding packets to the queue. -ML
+ //
+ void Wake() { if (iCallBack != NULL) iCallBack->CallBack(); }
+ void Cancel() { if (iCallBack != NULL) iCallBack->Cancel(); }
+ CAsyncCallBack *AsyncCallBack() { return iCallBack; }
+
+private:
+ CAsyncCallBack* iCallBack;
+ };
+
+//
+// Base for Internet Protocols
+//
+
+class CProtocolInet6Base : public CProtocolInet6Binder
+ {
+ friend class TInet6SAPIter;
+
+public:
+ CProtocolInet6Base();
+ virtual ~CProtocolInet6Base();
+ virtual void InitL(TDesC& aTag);
+ virtual void StartL();
+
+ virtual void BindL(CProtocolBase *aProtocol, TUint aId);
+ virtual void Unbind(CProtocolBase *aProtocol, TUint aId = 0);
+ virtual void Error(TInt anError,CProtocolBase* aSourceProtocol=NULL);
+
+ virtual void BindProvider(CProviderInet6Base* aSAP);
+ virtual void QueueBindProvider(CProviderInet6Base* aSAP);
+ virtual void UnbindProvider(CProviderInet6Base* aSAP);
+ virtual CProviderInet6Base* LocateProvider(TUint aPort);
+ inline MInterfaceManager *Interfacer() const { return iNetwork->Interfacer(); }
+ inline TUint SapCount() const { return iSapCount; }
+ void IncSAPs();
+ void DecSAPs();
+protected:
+ virtual TUint ProviderHashKey(TUint aPort) { return aPort % KInet6SAPTableSize; }
+ TUint iSapCount;// SAP count for this protocol. Includes embryonic sockets.
+private:
+ CProviderInet6Base* iSAP[KInet6SAPTableSize];
+#ifdef _LOG
+ // The protocol name is cached here for log purposes
+ // (to avoid exessive stack use for TServerProtocolDesc).
+ // Initilized in base InitL from a call to Identify.
+ TProtocolName iName;
+public:
+ const TDesC &ProtocolName() const { return iName; }
+#endif
+ };
+
+
+//
+// Internet Socket Provider Base
+//
+
+class CProviderInet6Base : public CServProviderBase, public MProviderNotify
+ , public MProvdSecurityChecker
+ {
+ friend class CProtocolInet6Base;
+ friend class CProtocolInet6Transport;
+ friend class TInet6SAPIter;
+
+public:
+ virtual void InitL();
+ CProviderInet6Base(CProtocolInet6Base* aProtocol);
+ virtual ~CProviderInet6Base();
+
+ virtual void AutoBind() { }
+ virtual void LocalName(TSockAddr &aAddr) const { aAddr = iFlow.FlowContext()->LocalAddr(); }
+ virtual TInt SetLocalName(TSockAddr &aAddr) { iFlow.SetLocalAddr(aAddr); return 0; }
+ virtual void RemName(TSockAddr &aAddr) const { aAddr = iFlow.FlowContext()->RemoteAddr(); }
+ virtual TInt SetRemName(TSockAddr &aAddr) { iFlow.SetRemoteAddr(aAddr); return 0; }
+ virtual void ActiveOpen();
+ virtual void ActiveOpen(const TDesC8 &aConnectionData);
+ virtual TInt PassiveOpen(TUint aQueSize);
+ virtual TInt PassiveOpen(TUint aQueSize,const TDesC8 &aConnectionData);
+ virtual void Shutdown(TCloseType option,const TDesC8 &aDisconnectionData);
+ virtual TInt SetOption(TUint aLevel, TUint aName, const TDesC8& aOption);
+ virtual TInt GetOption(TUint aLevel, TUint aName, TDes8& aOption) const;
+ virtual void Ioctl(TUint aLevel, TUint aName, TDes8* anOption);
+ virtual void CancelIoctl(TUint aLevel, TUint aName);
+ virtual void Start();
+
+ virtual void Process(RMBufChain& aPacket, CProtocolBase *aSourceProtocol = NULL);
+
+ virtual TUint Write(const TDesC8& aDesc,TUint options, TSockAddr* anAddr=NULL);
+ virtual TInt Write(RMBufChain& aData, TUint aOptions, TSockAddr* anAddr=NULL);
+
+ virtual void CanSend();
+ virtual void NoBearer(const TDesC8& aConnectionParams);
+ virtual void Bearer(const TDesC8 &aConnectionInfo);
+ virtual TInt SecurityCheck(MProvdSecurityChecker *aSecurityChecker);
+ inline void NoSecurityChecker() { iSecurityChecker = NULL;}
+ inline TBool HasNetworkServices() { return iHasNetworkServices; }
+ virtual void Error(TInt aError, TUint aOperationMask = MSocketNotify::EErrorAllOperations);
+ virtual void SaveIcmpError(TInt aType, TInt aCode, const TInetAddr& aSrcAddr,
+ const TInetAddr& aDstAddr, const TInetAddr& aErrAddr);
+
+ inline TBool FatalState() { return (iErrorMask & (MSocketNotify::EErrorFatal|MSocketNotify::EErrorConnect)) != 0; }
+protected:
+ static TInt GetOptionInt(const TDesC8 &anOption, TInt &aVal);
+ static TInt SetOptionInt(TDes8 &anOption, TInt aVal);
+
+ virtual TInt CheckPolicy(const TSecurityPolicy& aPolicy, const char *aDiagnostic);
+ /**
+ * Complete write processing for a datagram protocol
+ *
+ * The base class Write() implements a common processing for simple datagram
+ * socket. After this setup work, the Write() calls DoWrite.
+ *
+ * @param aPacket The packet to be sent
+ * @param aInfo The info block of the packet
+ * @param aOptions The options as defined for CServProviderBase::Write
+ * @param aOffset Offset to the beginning of the upper layer header
+ * @return Result of the write
+ *
+ * The aOffset has following semantics:
+ * - aOffset == 0, normal datagram without header included (DoWrite needs to add upper layer header)
+ * - aOffset > 0, header included was present, and offset indicates upper layer header in packet).
+ *
+ * RMBufSendPacket has been prepared from the parameters of the Write
+ * function and the information block is initialized as follows:
+ *
+ * - iSrcAddr Family() == 0, Port() == 0
+ * - iDstAddr Family() == 0, Port() == 0
+ * - iProtocol == aProtocol
+ * - iFlags == aOptions & (KIpHeaderIncluded | KIpDontFragment)
+ * - iLength == aPacket.Length()
+ * - iFlow == 0
+ *
+ * If KIpHeaderIncluded is set, the following is true
+ *
+ * - iSrcAddr Family() == KAfInet6 and address is loaded from the IPv4 or IPv6 header
+ * - iDstAddr Family() == KAfInet6 and address is loaded from the IPv4 or IPv6 header
+ * - iProtocol == KProtocolInetIP or KProtocolInet6Ip, depending on IP version.
+ *
+ * If aToAddr and KIpHeaderIncluded are both set, the aToAddr overrides whatever is
+ * stored in the destination address of the included header.
+ *
+ * If aToAddr is defined, the scope and flow label (if present) are preserved in
+ * the iDstAddr.
+ *
+ * The return value, 'err'
+ * - err == KErrNoRMBufs, a special error return that blocks the socket
+ * - err < 0, causes Error(err, MSocketNotify::EErrorSend) to be called for the socket.
+ * - err == 0, the aPacket is sent out
+ * - err > 0, blocks the socket (current packet is retried later)
+ */
+ virtual TInt DoWrite(RMBufSendPacket &/*aPacket*/, RMBufSendInfo &/*aInfo*/, TUint /*aOptions*/, TUint /*aOffset*/)
+ {
+ return KErrNotSupported;
+ }
+
+#ifdef _LOG
+ inline const TDesC &ProtocolName() const {return iProtocol->ProtocolName();}
+#endif
+
+ // Basic socket info
+ CProtocolInet6Base *const iProtocol;
+
+ // Socket error status
+ TSoInetLastErr iLastError;
+ TUint iErrorMask;
+
+ // Flow context
+ RFlowContext iFlow;
+
+ // SAP db hash link
+ CProviderInet6Base* iNextSAP;
+
+ // Interface and route enumeration state
+ TUint iInterfaceIndex;
+ TUint iRouteIndex;
+ MProvdSecurityChecker *iSecurityChecker;
+private:
+
+ // iIsUser = 1, when SAP is counted as a "user" for the network layer (IncUsers done)
+ // iIsUser = 0, when SAP is not counted as a "user" for the network layer
+ // By default, the this class reqisters all SAPs as users for the network layer, and
+ // this state can be explicitly cancelled by the application through a socket option.
+ // (the user count affects the automatic shutdown process of the stack)
+ TUint iIsUser:1;
+protected:
+ TUint iHasNetworkServices:1;// If true, socket has NetworkServices capability
+ TUint iRawMode:1; // If true, user receives datagram packets with IP header
+ TUint iHeaderIncluded:1; // If true, user sends datagram packets with IP header
+ TUint iSynchSend:1; // If true, block socket write to UDP socket in PENDING and HOLD states
+ TInt iProtocolId;
+ };
+
+class TInet6SAPIter
+ {
+public:
+ inline TInet6SAPIter(CProtocolInet6Base *aProto) : iProto(aProto), iSap(NULL), iKey(0) {}
+ inline CProviderInet6Base* operator++(TInt)
+ {
+ CProviderInet6Base *ptr;
+ for (ptr = iSap; ptr == NULL; ptr = iProto->iSAP[iKey++])
+ if (iKey >= KInet6SAPTableSize)
+ return NULL;
+ iSap = ptr->iNextSAP;
+ return ptr;
+ }
+private:
+ CProtocolInet6Base *iProto;
+ CProviderInet6Base *iSap;
+ TUint iKey;
+ };
+
+// security policies
+_LIT_SECURITY_POLICY_C1(KPolicyNetworkServices, ECapabilityNetworkServices);
+_LIT_SECURITY_POLICY_C1(KPolicyNetworkControl, ECapabilityNetworkControl);
+
+#endif