FCL/sf/os/networkingsrv: comparison tcpiputils/dnd/src/dns

equal deleted inserted replaced

-:bb2423252ea3
+:c1029e558ef5
 	 // Open and activate the UDP socket for DNS traffic (unless already done)
 	TInt ActivateSocket();
 	// Process socket errors
 	TInt HandleError(TInt aReason, const TInetAddr *aServer = NULL);
 	// Close and deactivate the UDP socket for DNS traffic
-	void DeactivateSocket(TInt aReason);
+	TBool DeactivateSocket(TInt aReason);
 	// Handle receive compeleted, keep receiver active
 	void RunReader(const TMsgBuf &aMsg, const TInetAddr &aFrom);
 	// Handle send completed, keep sender active (if work to do)
 	void RunWriter(TRequestStatus &aStatus);
 	//seed id generator
 	inline TBool IsListen() const { return iListen != 0; }
 	inline TBool IsOpened() const { return iOpened; }
 	inline void ResetErrorCount() { iErrorCount = 0;}
 	// A link chain used by the CDnsSocket to keep track of multiple writers
 	CDnsSocketWriter *iNext;
+#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY
+		RConnection iAttachedConn;	//< The connection on which the DNS socket may be opened on
+#endif
+	// Network ID associated with the writer;
+	TInt   iNetworkIdofWriter;
+	inline void SetDeferredDelete() { iDeferredDelete = ETrue; }
 private:
 	void RunL();
 	void DoCancel();
 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY
 	TBool CanUseConnection();
 #endif
 	CDnsSocket &iMaster;		//< The connection to the CDnsSocket owning this
 	RSocket iSocket;			//< The DNS socket
-#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY
-	RConnection iAttachedConn;	//< The connection on which the DNS socket may be opened on
-#endif
 	TUint iDeactivateCount;		//< Count number of deactivations (needed in reply processing)
 	TUint iErrorCount;			//< Count number of consecutive errors in RunL (read and write)
 	TUint iListen;				//< = 1, if socket is listening TCP socket, waiting on accept.
 	TUint iTCP;					//< = 1, if socket is a connected TCP socket
 	TUint iOpened:1;			//< = 1, if the socket is open
 	TInetAddr iTo;				//< Filled with the destination address of the query
 	TRequestQueue iSendQueue;	//< Requests waiting to be sent
 	TRequestQueue iWaitQueue;	//< Requests waiting for a reply
 	TDnsRequest *iSending;		//< The request currently being sent, if non-NULL
 	CDnsSocketReader *iReader;	//< The reader object
+	TBool iDeferredDelete;
 	};
 void TDnsRequest::Cancel()
 	{
 	CDnsSocketWriter *const writer = iQueueLink.Writer();
 	HBufC8 *iInMsg;			//< The real allocated buffer
 	TInt iAllocatedLength;	//< The real max length of the buffer
 	TPtr8 iBuf;				//< The current receive buffer
 	};
-CDnsSocketWriter::CDnsSocketWriter(CDnsSocket &aMaster) : CActive(0), iMaster(aMaster)
+CDnsSocketWriter::CDnsSocketWriter(CDnsSocket &aMaster) : CActive(0), iMaster(aMaster), iDeferredDelete(EFalse)
 	{
 	LOG(Log::Printf(_L("CDnsSocketWriter[%u]::CDnsSocketWriter([%u])"), this, &aMaster));
+	iNetworkIdofWriter = -1;
 	CActiveScheduler::Add(this);
 	TTime seed;
 	seed.UniversalTime();
 	iSequence = seed.Int64();
 				while ((rq = reply.Remove()) != NULL)
 					{
 					rq->iQueueLink.SetWriter(NULL);
 					rq->Abort(iMaster, KErrCancel);
 					}
+if (iDeferredDelete)
+{
+LOG(Log::Printf(_L("CDnsSocketWriter[%u]::RunReader() deleting itself due to deferred delete"), this));
+delete this;
+return;
+}
 				}
 			}
 		else
 			{
 			//
 	// this return must not try to reactivate the
 	// reader or writer.
 	return (mark != iDeactivateCount);
 	}
-void CDnsSocketWriter::DeactivateSocket(TInt aReason)
+TBool CDnsSocketWriter::DeactivateSocket(TInt aReason)
 	{
 	LOG(Log::Printf(_L("CDnsSocketWriter[%u]::DeactivateSocket() Entry"), this));
 	if (!iOpened )
 	    {
 	    LOG(Log::Printf(_L("CDnsSocketWriter[%u]::DeactivateSocket() return without action"), this));
-		return;			// Nothing to do if not open
+		return ETrue;			// Nothing to do if not open
 	    }
 	// Grab current set of requests away, so that
 	// potentially newly entered requests won't
 	// get affected by this...
 	//
 	while ((rq = wait.Remove()) != NULL)
 		{
 		rq->iQueueLink.SetWriter(0);
 		rq->Abort(iMaster, aReason);
 		}
-	LOG(Log::Printf(_L("CDnsSocketWriter[%u]::DeactivateSocket() complete"), this));
+if (iRunReader)
+	  {
+LOG(Log::Printf(_L("CDnsSocketWriter[%u]::DeactivateSocket() complete and defer delete"), this));
+return EFalse;
+	  }
+LOG(Log::Printf(_L("CDnsSocketWriter[%u]::DeactivateSocket() complete and allow delete"), this));
+return ETrue;
 	}
 //
 // CDnsSocketWriter::Remove
 // ************************
 }
 currentInfo = info();
 LOG(Log::Printf(_L("CDnsSocketWriter[%u]::CanUseConnection() currentInfo.NetId = %d "), this, currentInfo.iNetId));
 LOG(Log::Printf(_L("CDnsSocketWriter[%u]::CanUseConnection() iMaster.iNetworkId = %d "), this, iMaster.iNetworkId));
-if(currentInfo.iNetId == iMaster.iNetworkId)
+//if(currentInfo.iNetId == iMaster.iNetworkId)
+if(currentInfo.iNetId == this->iNetworkIdofWriter)
 {
 foundConnection = ETrue;
 break;
 }
 }
 	else
 		{
 		iWriter.ResetErrorCount();
 		iWriter.RunReader(TMsgBuf::Cast(iBuf), iFrom);
 		}
-	LOG(Log::Printf(_L("<-- CDnsSocketReader[%u]::RunL() -exit- iStatus=%d"), this, iStatus.Int()));
+	LOG(Log::Printf(_L("<-- CDnsSocketReader[%u]::RunL() -exit-"), this));
 	}
 void CDnsSocketReader::DoCancel()
 	{
 	LOG(Log::Printf(_L("CDnsSocketReader[%u]::DoCancel()"), this));
 //
 // Does nothing, if socket is already active
 //
 // Leaves, if socket cannot be activated
 */
-void CDnsSocket::ActivateSocketL(TUint aNetworkId)
+CDnsSocketWriter * CDnsSocket::ActivateSocketL(TUint aNetworkId)
 	{
 	LOG(Log::Printf(_L("CDnsSocket[%u]::ActivateSocketL([NetId = %d])"), this, aNetworkId));
+if(!iConnected)
-	if (iConnected && IsOpened())
+{
-		{
+LOG(Log::Printf(_L("CDnsSocket::ActivateSocketL([NetId = %d]) connecting socket server"),aNetworkId));
-	   LOG(Log::Printf(_L("CDnsSocket[%u]::ActivateSocketL([NetId = %d]) return without action"), this, aNetworkId));
+User::LeaveIfError(iSS.Connect());
-	    return;        // Already connected, nothing to do
+iConnected = 1;
-	    }
+}
+// use default in case of default network ID
-	User::LeaveIfError(iSS.Connect());
+if(aNetworkId == 0)
-	iConnected = 1;
+{
-	iNetworkId = aNetworkId;
+LOG(Log::Printf(_L("CDnsSocket::ActivateSocketL([NetId = %d]) using default writer"),aNetworkId));
+if(iWriter->IsOpened())
-	const TInt ret = iWriter->ActivateSocket();
+{
-	if (ret != KErrNone)
+return iWriter;
-		{
+}
-		DeactivateSocket(ret);
+else
-		User::Leave(ret);
+{
-		}
+const TInt ret = iWriter->ActivateSocket();
+if(ret != KErrNone)
+{
+DeactivateSocket(ret);
+User::Leave(ret);
+}
+else
+{
+return iWriter;
+}
+}
+}
+else
+{
+LOG(Log::Printf(_L("CDnsSocket::ActivateSocketL([NetId = %d]) Looking for"),aNetworkId));
+// Find the appropriate writer for the network Id
+CDnsSocketWriter *loopWriter = iWriter;
+while (1)
+{
+if(loopWriter->iNetworkIdofWriter == aNetworkId)
+{
+LOG(Log::Printf(_L("CDnsSocket::ActivateSocketL([NetId = %d]) found"),aNetworkId));
+if(loopWriter->IsOpened())
+{
+return loopWriter;
+}
+else
+{
+const TInt ret = loopWriter->ActivateSocket();
+if(ret != KErrNone)
+{
+DeactivateSocket(ret);
+User::Leave(ret);
+}
+else
+{
+return loopWriter;
+}
+}
+}
+if(loopWriter->iNext == NULL)
+{
+break;
+}
+else
+{
+loopWriter = loopWriter->iNext;
+}
+}
+LOG(Log::Printf(_L("CDnsSocket::ActivateSocketL([NetId = %d]) Creating new"),aNetworkId));
+// create a new writer
+loopWriter->iNext = CDnsSocketWriter::NewL(*this, -1);
+loopWriter->iNext->iNetworkIdofWriter = aNetworkId;
+const TInt ret = loopWriter->iNext->ActivateSocket();
+if(ret != KErrNone)
+{
+DeactivateSocket(ret);
+User::Leave(ret);
+}
+else
+{
+return loopWriter->iNext;
+}
+}
+	return NULL;
 	}
 /**
 // Change the current bind address and activate the
 // DNS socket. If socket is already active, the bind
 #ifdef _LOG
 	TBuf<50> tmp;
 	aBind.OutputWithScope(tmp);
 	Log::Printf(_L("CDnsSocket[%u]::ActivateSocketL([%S#%d])"), this, &tmp, aBind.Port());
 #endif
+	LOG(Log::Printf(_L("CDnsSocket::ActivateSocketL with address bind")));
 	iWriter->SetBind(aBind);
 	ActivateSocketL();
 	}
 /**
 	//
 	CDnsSocketWriter *writer = iWriter->iNext;
 	iWriter->iNext = NULL;
 	iWriter->DeactivateSocket(aReason);
+	LOG(Log::Printf(_L("CDnsSocket::DeactivateSocket Deativatuing other writers")));
 	while (writer)
 		{
 		CDnsSocketWriter *tmp = writer;
 		writer = tmp->iNext;
-		tmp->DeactivateSocket(aReason);
+		LOG(Log::Printf(_L("CDnsSocket::DeactivateSocket calling deactivate socket for writer")));
+		TBool allowedToDelete = tmp->DeactivateSocket(aReason);
+		if (allowedToDelete)
+			{
 		delete tmp;
+			}
+		else
+			{
+			tmp->SetDeferredDelete();
+			}
 		}
 	// Oops... Should not close if re-activated ---FIX!
 	if (iListening)
 		{
 		iListening = 0;
 //		the default if parameter is omitted. The queue
 //		method will assign random id automatically.
 //	@li >= 0,
 //		16 bits of this value is used as id.
 */
-void CDnsSocket::Queue(TDnsRequest &aRequest, const TInt aId)
+void CDnsSocket::Queue(TDnsRequest &aRequest,  CDnsSocketWriter * aWriter, const TInt aId)
 	{
-	iWriter->Queue(aRequest, aId);
+if(aWriter == NULL)
+{
+// use default
+iWriter->Queue(aRequest, aId);
+}
+else
+{
+aWriter->Queue(aRequest, aId);
+}
 	}
 // Queue a request for sending with a specific socket
 //
-TInt CDnsSocket::Queue(TDnsRequest &aRequest, const RSocket &aSocket, const TInt aId)
+// Though the DNS socket writer instance was passed as part of this function, but not being used as this
-	{
+// function matches the socket to find the appropriate writer instance
-	for (CDnsSocketWriter *writer = iWriter; writer != NULL; writer = writer->iNext)
+TInt CDnsSocket::Queue(TDnsRequest &aRequest, const RSocket &aSocket,  CDnsSocketWriter */* aWriter*/, const TInt aId)
+	{
+for (CDnsSocketWriter *writer = iWriter; writer != NULL; writer = writer->iNext)
 		{
 		if (&aSocket == &writer->Socket())
 			{
 			// Found it!
 			writer->Queue(aRequest, aId);
 			return KErrNone;
 			}
 		}
 	return KErrNotFound;
 	}
 /**
 // @param aTTL of the connection (= -1, the default, requests the system default). This is
 // only effective if the connection is created.
 //
 // @return KErrNone, if queued successfully, or error code if failed.
 */
-TInt CDnsSocket::Queue(TDnsRequest &aRequest, const TInetAddr &aServer, const TInt aId,  const TInt aTTL)
+TInt CDnsSocket::Queue(TDnsRequest &aRequest, const TInetAddr &aServer,  CDnsSocketWriter * /*aWriter*/, const TInt aId,  const TInt aTTL)
 	{
 	//
 	// Locate or create connected Socket reader/writer instance
 	//
 	CDnsSocketWriter *writer = iWriter->iNext;
 // should happen). This preserves the old id of the request.
 //
 // If a request is not currently queued, this does an implicit
 // Queue. (a new id is generated).
 //
-// Exceptionally, the request assigns new ID when an incomplete query name
-// is iterated to apply multiple domain suffices on
-// the interface being used for sending requests
-//
 // @param aRequest	the request to be resent.
-// @param aRetryWithSuffix	flag set to identify retry requests
-//							on incomplete query names. Defaulted to FALSE
 */
-void CDnsSocket::ReSend(TDnsRequest &aRequest, TBool aRetryWithSuffix)
+void CDnsSocket::ReSend(TDnsRequest &aRequest, CDnsSocketWriter * aWriter)
 	{
-	Queue(aRequest, (!aRetryWithSuffix && aRequest.IsQueued()) ? aRequest.Id() : -1);
+	Queue(aRequest, aWriter, aRequest.IsQueued() ? aRequest.Id() : -1);
 	}
 /**
 // Add and activate a new secondary writer/reader unit.
 //

branch	RCL_3
changeset 75	c1029e558ef5
parent 58	8d540f55e491