/* BEGIN_ICS_COPYRIGHT4 ****************************************

Copyright (c) 2015, Intel Corporation

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,

      this list of conditions and the following disclaimer.

    * 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.

    * Neither the name of Intel Corporation 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 OWNER 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.

** END_ICS_COPYRIGHT4   ****************************************/

// Public header file

#include "ib_cm.h"

// Private header file

#include "cm_private.h"

//////////////////////////////////////////////////////////////////////////

// Listen

//

// Prepare CEP for Listening and put on ListenMap

//

//

// INPUTS:

//

//

//

// OUTPUTS:

//

//	None.

//

// RETURNS:

//

//	FSUCCESS.

//

// IRQL:

//

//	This routine is called at IRQL_PASSIVE_LEVEL.

//	Called with ListLock held, which protects lists and all CEPs

//

FSTATUS

Listen(

	IN CM_CEP_OBJECT*			pCEP,

	IN CM_LISTEN_INFO*			pListenInfo,

	IN PFN_CM_CALLBACK			pfnListenCB,

	IN void*					Context

	)

{

	_DBG_ENTER_LVL(_DBG_LVL_FUNC_TRACE, Listen);

	// If we are binding to a specific port, we need the CaGUID of the port

	// so that during CmRemoveDevice(), we can cancel this listen

	pCEP->LocalEndPoint.CaGUID = pListenInfo->CaGUID;

	ASSERT(! pCEP->bPeer);

	// Bind address is based on SID with secondary optional

	// Local/Remote GID/LID and the Private Data Discriminator

	// (set via CmModifyCEP)

	// Hence more than one CEP could use the same SID, provided they have unique

	// combinations of values for the other fields.  Values of 0

	// represent wildcarding the given field (SID can't be wildcarded)

	pCEP->SID = pListenInfo->ListenAddr.EndPt.SID;

	pCEP->PrimaryPath.LocalLID = pListenInfo->ListenAddr.Port.LID;

	pCEP->PrimaryPath.LocalGID = pListenInfo->ListenAddr.Port.GID;

	pCEP->PrimaryPath.RemoteLID = pListenInfo->RemoteAddr.Port.LID;

	pCEP->PrimaryPath.RemoteGID = pListenInfo->RemoteAddr.Port.GID;

	pCEP->LocalEndPoint.QPN = pCEP->LocalEndPoint.EECN = 0;

	pCEP->RemoteEndPoint.QPN = pCEP->RemoteEndPoint.EECN = 0;

	// add to ListenMap and make sure bound address is unique

	if (! CM_MapTryInsert(&gCM->ListenMap, (uintn)pCEP, &pCEP->MapEntry, "LISTEN_LIST", pCEP))

	{

		_DBG_WARNING(("<cep 0x%p> Address in use!!!\n", _DBG_PTR(pCEP)));

		// clear out CEP fields

		MemoryClear(&pCEP->LocalEndPoint, sizeof(pCEP->LocalEndPoint));

		MemoryClear(&pCEP->RemoteEndPoint, sizeof(pCEP->RemoteEndPoint));

		MemoryClear(&pCEP->PrimaryPath, sizeof(pCEP->PrimaryPath));

		pCEP->LocalEndPoint.CaGUID = 0;

		pCEP->SID = 0;

		_DBG_LEAVE_LVL(_DBG_LVL_FUNC_TRACE);

		return FCM_ADDR_INUSE;

	}

	// LocalCommID for listening CEP is used only for debugging purposes

	AssignLocalCommID(pCEP);

	pCEP->TransactionID = 0;	// not used, will use TID of remote client

	_DBG_INFO(("<cep 0x%p> Comm ID set at <lcid 0x%x>.\n",

			_DBG_PTR(pCEP), pCEP->LocalCommID));

	pCEP->Mode = CM_MODE_PASSIVE;

	pCEP->LocalCMTimeout = 0;

	pCEP->RemoteCMTimeout = 0;

	pCEP->MaxCMRetries = 0;

	pCEP->EventFlags = 0;

	pCEP->RetryCount = 0;

	//pCEP->pWaitEvent = NULL;

	DListInit(&pCEP->PendingList);

	if (pCEP->pDgrmElement)

	{

		// Return the datagram since listen objects do not use it

		_DBG_INFO(("<cep 0x%p> Releasing the dgrm <dgrm 0x%p>.\n", 

						_DBG_PTR(pCEP), _DBG_PTR(pCEP->pDgrmElement)));

		CmDgrmRelease(pCEP->pDgrmElement);

	}

	// Save user callback info

	pCEP->pfnUserCallback = pfnListenCB;

	pCEP->UserContext = Context;

	CepSetState(pCEP, CMS_LISTEN);

	_DBG_INFO(("<cep 0x%p> *** Listening on <sid 0x%"PRIx64" lid 0x%x gid 0x%"PRIx64":0x%"PRIx64">.***\n",

				_DBG_PTR(pCEP), pListenInfo->ListenAddr.EndPt.SID,

				pListenInfo->ListenAddr.Port.LID,

				pCEP->PrimaryPath.LocalGID.Type.Global.SubnetPrefix,

				pCEP->PrimaryPath.LocalGID.Type.Global.InterfaceID));

	_DBG_LEAVE_LVL(_DBG_LVL_FUNC_TRACE);

	// At this point, we are listening for incoming connections on this obj.

	return FPENDING;

} // Listen()

// See GetConnInfo in cm_active.c for callback processing

//////////////////////////////////////////////////////////////////////////

// WaitP

//

//

// INPUTS:

//

//

//

// OUTPUTS:

//

//	None.

//

// RETURNS:

//

//	FSUCCESS or FTIMEOUT.

//

// IRQL:

//

//	This routine is called at IRQL_PASSIVE_LEVEL.

//

FSTATUS

WaitP(

	IN CM_CEP_OBJECT*			pCEP,

	OUT CM_CONN_INFO*			pConnInfo,

	uint32						Timeout_us	// TODO: Put a max limit on this in addition to infinite

	)

{

	FSTATUS Status=FSUCCESS;

	uint32 WaitTimeUs=Timeout_us;

	uint64 TimeoutUs=Timeout_us;

	uint64 StartTimeUs=GetTimeStamp();

	uint64 CurrTimeUs=0;

	uint64 TimeElapsedUs=0;

	//CMM_MSG* pMsg=&((CM_MAD*)GsiDgrmGetSendMad(pCEP->pDgrmElement))->payload;

	_DBG_ENTER_LVL(_DBG_LVL_FUNC_TRACE, WaitP);

waitagain:

	// Update the timeout

	if ((int32)WaitTimeUs != EVENT_NO_TIMEOUT)

	{

		if (CurrTimeUs >= StartTimeUs)

		{

			TimeElapsedUs = (CurrTimeUs - StartTimeUs);

		}

		else // wrap-around

		{

			TimeElapsedUs = (CurrTimeUs + ((uint64)(-1) - StartTimeUs));

		}

		if (TimeoutUs > TimeElapsedUs)

		{

			WaitTimeUs = (uint32) (TimeoutUs - TimeElapsedUs);

		}

		else

		{

			WaitTimeUs = 0;

		}

	}

	//_DBG_INFO(("<cep 0x%p> Waiting on obj... <timeout %ums lcid 0x%x %s>\n", 

	//			_DBG_PTR(pCEP), WaitTimeUs/1000, pCEP->LocalCommID,

	//			_DBG_PTR(CmGetStateString(pCEP->State))));

	Status = EventWaitOn(pCEP->pEventObj, WaitTimeUs);

	//_DBG_INFO(("<cep 0x%p> Waiting on obj... complete <%s %s>\n", 

	//			_DBG_PTR(pCEP), _DBG_PTR(FSTATUS_MSG(Status)),

	//			_DBG_PTR(CmGetStateString(pCEP->State))));

	if (Status == FTIMEOUT)

	{

		if (Timeout_us == 0)

		{

			//_DBG_INFO(("<cep 0x%p> Obj state is nonsignaled.\n", _DBG_PTR(pCEP)));

		}

		else

		{

			_DBG_WARNING(("<cep 0x%p> EventWaitOn() returns FTIMEOUT!\n", _DBG_PTR(pCEP)));

		}

		_DBG_LEAVE_LVL(_DBG_LVL_FUNC_TRACE);

		return FTIMEOUT;

	}

	ASSERT(Status == FSUCCESS);

	_DBG_INFO(("<cep 0x%p> Obj state is signaled <%s>.\n",

				_DBG_PTR(pCEP), _DBG_PTR(CmGetStateString(pCEP->State))));

	// Get mutual ex to the object

	SpinLockAcquire(&gCM->ListLock);

	Status = GetConnInfo(pCEP, pConnInfo);

	if (Status != FSUCCESS)

	{

		// Handle the case when we get signal but we already process the event

		// with the previous signal

		// eg evt1 --> signal; evt2 --> signal

		//							->wait() returned

		_DBG_WARNING(("<cep 0x%p> GetConnInfo() returns %s!\n",

						_DBG_PTR(pCEP), _DBG_PTR(FSTATUS_MSG(Status))));

		ASSERT(pConnInfo->Status == 0);

		SpinLockRelease(&gCM->ListLock);

		goto waitagain;

	}

	SpinLockRelease(&gCM->ListLock);

	_DBG_LEAVE_LVL(_DBG_LVL_FUNC_TRACE);

	return Status;

} // WaitP()

// given a CEP for which a FCM_CONNECT_REQUEST has been reported

// fetch the head of the pending list

static FSTATUS

GetPendingCEP(

	IN CM_CEP_OBJECT*			pCEP,

	OUT CM_CEP_OBJECT**			ppCEPEntry

	)

{

	CM_CEP_OBJECT* pCEPEntry = NULL;

	DLIST_ENTRY* pListEntry=NULL;

	FSTATUS		Status=FSUCCESS;

	_DBG_ENTER_LVL(_DBG_LVL_FUNC_TRACE, GetPendingCEP);

	switch (pCEP->State)

	{

	case CMS_IDLE:

		if (BitTest(pCEP->EventFlags, USRE_CANCEL))

		{

			// User cancelled the listen, but hasn't gotten callback yet

			Status = FCM_CONNECT_CANCEL;

		} else {

			Status = FERROR;

		}

		break;

	case CMS_LISTEN:

	case CMS_REQ_RCVD:	// separate out for Peer, no PendingList need then

	case CMS_MRA_REQ_SENT:	// separate out for Peer, no PendingList need then

			// could have listen get the pCEPEntry and then have common code

			// with Peer REQ_RCVD/MRA_REQ_SENT cases

		//

		// Accepting new client or peer connection 

		//

		if (pCEP->bPeer)

		{

			_DBG_INFO(("<cep 0x%p> *** Accepting peer connection ***\n", _DBG_PTR(pCEP)));

		} else {

			_DBG_INFO(("<cep 0x%p> *** Accepting client connection ***\n", _DBG_PTR(pCEP)));

		}

		if (DListIsEmpty(&pCEP->PendingList))	

		{

			// If user reject() or cancel() and then call accept()

			_DBG_WARNING(("<cep 0x%p> Pending list is empty!\n", _DBG_PTR(pCEP)));

			Status = FNOT_FOUND;

			break;

		}

		// Note: For peer-to-peer connection (bPeer == TRUE), the entry in the PENDING list 

		// is the same as the one passed in i.e. pCEP == pCEPEntry

		pListEntry = DListGetNext(&pCEP->PendingList);

		pCEPEntry = PARENT_STRUCT(pListEntry, CM_CEP_OBJECT, PendingListEntry);

		ASSERT(pCEPEntry->pParentCEP == pCEP);

		if (pCEP->bPeer)

		{

			ASSERT(pCEPEntry == pCEP);

		} else {

			ASSERT(pCEPEntry != pCEP);

		}

		// Cannot accept until the user has been notify thru wait

		/*

		if (!BitTest(pCEPEntry->EventFlags, USRE_WAIT))

		{

			_DBG_WARNING(("<cep 0x%p> Cannot accept - User must call wait() before accept()!\n",

							_DBG_PTR(pCEP)));

			// Re-signal

			EventSet(pCEP, CME_RCVD_REQ);

			Status = FUNAVAILABLE;

			break;

		}

		BitClear(pCEPEntry->EventFlags, USRE_WAIT);

		*/

		// Make sure we havent timed-out or receive a reject

		switch (pCEPEntry->State)

		{

		case CMS_REQ_RCVD:

		case CMS_MRA_REQ_SENT:

			*ppCEPEntry = pCEPEntry;

			Status = FSUCCESS;

			break;

		default:

			Status = FINVALID_STATE;

			break;

		}

		break;

	default:

		Status = FINVALID_STATE;

		break;

	} // switch()

	_DBG_LEAVE_LVL(_DBG_LVL_FUNC_TRACE);

	return Status;

} // GetPendingCEP

// process an inbound REQ for a passive CEP

FSTATUS

ProcessRequestP(

	IN CM_CEP_OBJECT*			pCEP,

	IN CM_REP_FAILOVER 			Failover,

	OUT CM_PROCESS_REQUEST_INFO *Info

	)

{

	FSTATUS Status;

	IB_CA_ATTRIBUTES *pCaAttr = NULL;

	CM_CEP_OBJECT*			pCEPEntry;

	_DBG_ENTER_LVL(_DBG_LVL_FUNC_TRACE, ProcessRequestP);

	// TBD - RD code here is not complete/accurate

	ASSERT(pCEP->Mode == CM_MODE_PASSIVE);

	Status = GetPendingCEP(pCEP, &pCEPEntry);

	if (Status != FSUCCESS)

		goto done;

	if (pCEPEntry->Type == CM_UD_TYPE)

	{

		Status = FINVALID_STATE;

		goto done;

	}

	if (Info == NULL)

	{

		Status = FINVALID_PARAMETER;

		goto done;

	}

	MemoryClear(Info, sizeof(*Info));	// just to be safe

	// Child must inherit parent's setting for now

	// Will be saved again when AcceptP

	pCEPEntry->bFailoverSupported = pCEP->bFailoverSupported;

	// get ca Attr

	pCaAttr = (IB_CA_ATTRIBUTES*)MemoryAllocate(sizeof(*pCaAttr), FALSE, CM_MEM_TAG);

	if (pCaAttr == NULL)

	{

		Status = FINSUFFICIENT_MEMORY;

		goto done;

	}

	pCaAttr->PortAttributesListSize = 0;

	pCaAttr->PortAttributesList = NULL;

	Status = iba_query_ca_by_guid(pCEPEntry->LocalEndPoint.CaGUID, pCaAttr);

	if (Status != FINSUFFICIENT_MEMORY && Status != FSUCCESS)

		goto done;

	// set up attributes to move QP to Init

	GetInitAttrFromCep(pCEPEntry, &Info->QpAttrInit);

	// update LocalResponder/Initiator/SendPSN so we are ready in case

	// application calls iba_cm_prepare_rts before doing iba_cm_accept

	// Build Reply

	pCEPEntry->LocalRecvPSN = Info->ReplyInfo.Info.Reply.StartingPSN =

															GenerateStartPSN();

	// RDMA Read is not supported for UC, leave zero

	if (pCEPEntry->Type != CM_UC_TYPE) {

		pCEPEntry->LocalResponderResources =

			Info->ReplyInfo.Info.Reply.ArbResponderResources =

							MIN(pCEPEntry->LocalResponderResources,

									pCaAttr->MaxQPResponderResources);

		pCEPEntry->LocalInitiatorDepth =

			Info->ReplyInfo.Info.Reply.ArbInitiatorDepth =

							MIN(pCEPEntry->LocalInitiatorDepth,

									pCaAttr->MaxQPInitiatorDepth);

	}

	Info->ReplyInfo.Info.Reply.TargetAckDelay = pCaAttr->LocalCaAckDelay;

	// spec implies we should say NOT_SUPPORTED even if no alternate path

	// was provided in REQ

	if (pCaAttr->PathMigrationLevel == CAPathMigNone

			|| ! pCEPEntry->bFailoverSupported)

	{

		Info->ReplyInfo.Info.Reply.FailoverAccepted = CM_REP_FO_NOT_SUPPORTED;

	} else {

		Info->ReplyInfo.Info.Reply.FailoverAccepted = Failover;

	}

	// end to end credits and RNR not allowed for UC

	if (pCEPEntry->Type != CM_UC_TYPE) {

		// our CA supports RC credits

		Info->ReplyInfo.Info.Reply.EndToEndFlowControl = TRUE;

		Info->ReplyInfo.Info.Reply.RnRRetryCount =

									pCEPEntry->LocalRnrRetryCount; // 1st guess

		// caller must set approprite RnrRetryCount, this is just

		// a wild guess, caller can set higher or lower

	}

	// set up attributes to move QP to RTR

	GetRtrAttrFromCep(pCEPEntry,

			(Info->ReplyInfo.Info.Reply.FailoverAccepted == CM_REP_FO_ACCEPTED),

			&Info->QpAttrRtr);

done:

	if (pCaAttr)

		MemoryDeallocate(pCaAttr);

	_DBG_LEAVE_LVL(_DBG_LVL_FUNC_TRACE);

	return Status;

}

//////////////////////////////////////////////////////////////////////////

// AcceptP_Async

//

//

// INPUTS:

//

//

//

// OUTPUTS:

//

//	None.

//

// RETURNS:

//

//	FSUCCESS - The function has completed successfully. For server, this indicates the initialization.

//		>FCM_CONNECT_ESTABLISHED

//		>FCM_CONNECT_REJECT

//		>FCM_CONNECT_TIMEOUT

//		>FCM_CONNECT_CANCEL

//

//	FINVALID_STATE - The endpoint is not in the valid state for this call

//	FERROR	- Unable to send the reply ack packet

//	FTIMEOUT - The timeout interval expires

//

//

// IRQL:

//

//	This routine is called at IRQL_PASSIVE_LEVEL.

//

FSTATUS

AcceptP_Async(

	IN CM_CEP_OBJECT*			pCEP,

	IN const CM_CONN_INFO*		pSendConnInfo,		// Send REP

	IN EVENT_HANDLE				hEvent,

	IN EVENT_HANDLE				hWaitEvent,

	IN PFN_CM_CALLBACK			pfnCallback,

	IN void*					Context,

	IN boolean					willWait,

	OUT CM_CEP_OBJECT**			ppCEP

	)

{

	CM_CEP_OBJECT* pCEPEntry = NULL;

	FSTATUS		Status=FSUCCESS;

	uint32		rep_timeout_ms=0;

	uint64		elapsed_us=0;

	uint8		timewait;

	_DBG_ENTER_LVL(_DBG_LVL_FUNC_TRACE, AcceptP_Async);

	if (ppCEP)

	{

		*ppCEP = NULL;

	}

	// Check QPN/EECN has been supplied

	if (! pSendConnInfo || (pSendConnInfo->Info.Reply.QPN == 0

							&& pSendConnInfo->Info.Reply.EECN == 0))

	{

		Status = FINVALID_PARAMETER;

		goto done;

	}

	SpinLockAcquire(&gCM->ListLock);

	Status = GetPendingCEP(pCEP, &pCEPEntry);

	if (Status != FSUCCESS)

		goto unlock;

	//BitClear(pCEPEntry->EventFlags, CME_REQ_RCVD);

	elapsed_us = CmGetElapsedTime(pCEPEntry);

	// Update the turnaround time

	gCM->turnaround_time_us = UpdateTurnaroundTime(gCM->turnaround_time_us, elapsed_us);

	_DBG_INFO(("Update turnaround time <tat %"PRIu64"us>.\n", gCM->turnaround_time_us));

	// check RDMA Read parameters have not been incorrectly increased

	if (pCEPEntry->LocalInitiatorDepth <

							pSendConnInfo->Info.Reply.ArbInitiatorDepth

		|| pCEPEntry->LocalResponderResources <

							pSendConnInfo->Info.Reply.ArbResponderResources)

	{

		Status = FINVALID_PARAMETER;

		goto unlock;

	}

	if (pCEPEntry->bPeer)

	{

		// API design decision, must use same EndPoint in CmAccept

		// as did in original PeerConnect.  We enforce this

		// (as opposed to blindly replacing Reply or CEP info)

		// to catch applications which end up with 2 QPs for the CEP

		if (pCEPEntry->LocalEndPoint.QPN != pSendConnInfo->Info.Reply.QPN

			|| pCEPEntry->LocalEndPoint.EECN != pSendConnInfo->Info.Reply.EECN)

		{

			Status = FINVALID_PARAMETER;

			goto unlock;

		}

	} else {

		// Save the relevent user reply info to this object

		pCEPEntry->LocalEndPoint.QPN = pSendConnInfo->Info.Reply.QPN;

		pCEPEntry->LocalEndPoint.EECN = pSendConnInfo->Info.Reply.EECN;

		if (! CM_MapTryInsert(&gCM->LocalEndPointMap, (uintn)pCEPEntry,

				&pCEPEntry->LocalEndPointMapEntry, "LOCAL_END_POINT_LIST", pCEPEntry))

		{

			Status = FCM_ADDR_INUSE;

			pCEPEntry->LocalEndPoint.QPN = 0;

			pCEPEntry->LocalEndPoint.EECN = 0;

			goto unlock;

		}

		// Save the disconnect callback

		pCEPEntry->pfnUserCallback = pfnCallback;

		pCEPEntry->UserContext = Context;

		pCEPEntry->bAsyncAccept = pCEP->bAsyncAccept;

		pCEPEntry->bTimewaitCallback = pCEP->bTimewaitCallback;

		pCEPEntry->bFailoverSupported = pCEP->bFailoverSupported;

		pCEPEntry->turnaround_time_us = pCEP->turnaround_time_us;

		// Use this user-specified event obj instead of the one we created internally

		if (hEvent)

		{

			OS_WAIT_OBJ_HANDLE hCEPEventObj = (OS_WAIT_OBJ_HANDLE)pCEPEntry->pEventObj;

			boolean            RemoveReference = FALSE;

			if (hCEPEventObj)

			{

 				if (pCEPEntry->bPrivateEvent)

				{

					EventDealloc(pCEPEntry->pEventObj);

				}

				else

				{

					RemoveReference = TRUE;

				}

			}

			pCEPEntry->bPrivateEvent = 0;

			pCEPEntry->pEventObj = (EVENT*)hEvent;

			OsWaitObjAddRef((OS_WAIT_OBJ_HANDLE)pCEPEntry->pEventObj);

			if (RemoveReference)

			{

				OsWaitObjRemoveRef(hCEPEventObj);

			}

		}

		if (hWaitEvent)

		{

			pCEPEntry->pWaitEvent = (EVENT*)hWaitEvent;

		}

	}

	if (pCEP->AlternatePath.LocalLID != 0)

	{

		if (pSendConnInfo->Info.Reply.FailoverAccepted != CM_REP_FO_ACCEPTED)

		{

			MemoryClear(&pCEP->AlternatePath, sizeof(pCEP->AlternatePath));

		}

		pCEPEntry->bFailoverSupported &= IsFailoverSupported(

							pSendConnInfo->Info.Reply.FailoverAccepted);

	}

	// save arbitrated RDMA Read parameters

	pCEPEntry->LocalInitiatorDepth =

							pSendConnInfo->Info.Reply.ArbInitiatorDepth;

	pCEPEntry->LocalResponderResources =

							pSendConnInfo->Info.Reply.ArbResponderResources;

	if (pSendConnInfo->Info.Reply.TargetAckDelay > pCEP->TargetAckDelay)

	{

		pCEP->TargetAckDelay = pSendConnInfo->Info.Reply.TargetAckDelay;

	}

	pCEP->LocalRecvPSN = pSendConnInfo->Info.Reply.StartingPSN;

	// update timewait 

	// some applications don't set TargetAckDelay properly

	// and to be safe we want our timewait to be no less than remote end

	// so be conservative and only increase it, the computation below

	// due to the round up of PktLifeTime, essentially always

	// adds TargetAckDelay to the timewait

	timewait = TimeoutTimeToMult(

						(TimeoutMultToTimeInUsec(pCEPEntry->PktLifeTime)<<1)

							+ TimeoutMultToTimeInUsec(pCEP->TargetAckDelay));

	if (pCEPEntry->Timewait < timewait)

		pCEPEntry->Timewait = timewait;

	FormatREP((CM_MAD*)GsiDgrmGetSendMad(pCEPEntry->pDgrmElement),

				&pSendConnInfo->Info.Reply,

				pCEPEntry->TransactionID,

				pCEPEntry->LocalCommID,

				pCEPEntry->RemoteCommID,

				pCEPEntry->LocalEndPoint.CaGUID);

	_DBG_INFO(("<cep 0x%p> REP's dgrm address field <portguid 0x%"PRIx64", dlid 0x%x, slm %d, pathbits %d, rate %d>\n",

				_DBG_PTR(pCEPEntry), 

				pCEPEntry->pDgrmElement->PortGuid,

				pCEPEntry->pDgrmElement->RemoteLID,

				pCEPEntry->pDgrmElement->ServiceLevel,

				pCEPEntry->pDgrmElement->PathBits,

				pCEPEntry->pDgrmElement->StaticRate));

	// Send out the REP

	Status = CmDgrmSend(pCEPEntry->pDgrmElement);

	if (FSUCCESS != Status)

	{

		// fall through and let timer retry the send later

		_DBG_WARN(("<cep 0x%p> DgrmSend() failed for REP!!! <%s>\n",

					_DBG_PTR(pCEP), _DBG_PTR(FSTATUS_MSG(Status))));

		Status = FSUCCESS;

	} else {

		AtomicIncrementVoid(&gCM->Sent.Rep);

	}

	_DBG_INFO(("<cep 0x%p> REP sent <lcid 0x%x rcid 0x%x slid 0x%x dlid 0x%x>.\n", 

				_DBG_PTR(pCEPEntry), pCEPEntry->LocalCommID, pCEPEntry->RemoteCommID,

				pCEPEntry->PrimaryPath.LocalLID, pCEPEntry->PrimaryPath.RemoteLID));

	CepRemoveFromPendingList(pCEPEntry);

	CepSetState(pCEPEntry, CMS_REP_SENT);

	// For peer connection, leave the entry in the LISTEN list

	// Start timer to timeout the REP i.e. wait for the RTU msg to arrive

	pCEPEntry->RetryCount = 0;

	rep_timeout_ms = TimeoutMultToTimeInMs(pCEPEntry->LocalCMTimeout);

	CmTimerStart(pCEPEntry, rep_timeout_ms, REP_TIMER);

	if (willWait)

	{

		// caller will be doing a WaitP

		// prevent a callback until caller WaitP completes

		AtomicIncrementVoid(&pCEPEntry->CallbackRefCnt);

		AtomicIncrementVoid(&gCM->TotalCallbackRefCnt);

	}

	// If another connection is pending for this server endpoint, 

	// we must set it again to wake up the Wait()

	if (pCEP->PendingCount)

	{

		SetNotification(pCEP, CME_RCVD_REQ);//EventSet(pCEP, CME_RCVD_REQ);

	}

	// Return the new CEP object to the user

	if (ppCEP)

	{

		*ppCEP = pCEPEntry;

	}

	Status = FPENDING;

unlock:

	SpinLockRelease(&gCM->ListLock);

done:

	_DBG_LEAVE_LVL(_DBG_LVL_FUNC_TRACE);

	return Status;

} // AcceptP_Asynch()

//////////////////////////////////////////////////////////////////////////

// AcceptP

//

//

// INPUTS:

//

//

//

// OUTPUTS:

//

//	None.

//

// RETURNS:

//

//	FCM_CONNECT_ESTABLISHED - Connection established

//	FCM_CONNECT_REJECT		- Connection rejected

//	FCM_CONNECT_TIMEOUT		- Connection timeout

//	FCM_CONNECT_CANCEL		- Connection cancel

//

//	FINVALID_STATE			- The endpoint is not in the valid state for this call

//	FERROR					- Nothing to accept, cannot accept, or unable to send the reply packet

//	FTIMEOUT				- The timeout interval expires

//

//

// IRQL:

//

//	This routine is called at IRQL_PASSIVE_LEVEL.

//

FSTATUS

AcceptP(

	IN CM_CEP_OBJECT*			pCEP,

	IN const CM_CONN_INFO*		pSendConnInfo,		// Send REP

	OUT CM_CONN_INFO*			pRecvConnInfo,		// Rcvd RTU, REJ or TIMEOUT

	IN PFN_CM_CALLBACK			pfnCallback,

	IN void*					Context,

	OUT CM_CEP_OBJECT**			ppNewCEP

	)

{

	CM_CEP_OBJECT*	pNewCEP=NULL;

	FSTATUS		Status=FSUCCESS;

	uint32		rep_timeout_ms=0;

	boolean bPeer = pCEP->bPeer;	// save in case move Cep to Idle

	_DBG_ENTER_EXT(_DBG_LVL_FUNC_TRACE, AcceptP, == PASSIVE);

	UNUSED_VAR(rep_timeout_ms);

	if (! pRecvConnInfo && ! pCEP->bAsyncAccept)

	{

		Status = FINVALID_PARAMETER;

		goto done;

	}

	// Accept client or peer connection. Send the REP to the remote client 

	// use ppNewCEP if not-NULL so caller gets updated while in Lock in

	// AcceptP_Async

	Status = AcceptP_Async(pCEP, pSendConnInfo, NULL, NULL, pfnCallback, Context, ! pCEP->bAsyncAccept, ppNewCEP?ppNewCEP:&pNewCEP);

	if (Status != FSUCCESS && Status != FPENDING)

		goto done;

	if (ppNewCEP)

		pNewCEP = *ppNewCEP;

	if (bPeer)

	{

		ASSERT(pNewCEP == pCEP);

	}

	if (pCEP->bAsyncAccept)

	{

		// we will provide a callback when RTU or REJ arrives or timeout

		goto done;

	}

	// Wait for RTU or REJ to arrive or timeout event to occur

	// TODO: We should put a time limit here in case we dont get the timeout event ??

	Status = WaitP(pNewCEP, pRecvConnInfo, EVENT_NO_TIMEOUT);

	//rep_timeout_ms = TimeoutMultToTimeInMs(pNewCEP->LocalCMTimeout);

	//Status = WaitP(pNewCEP, pRecvConnInfo, 2*rep_timeout_ms, TRUE);

	ASSERT(Status == FSUCCESS);

	// This is the status we returned to the caller

	Status = pRecvConnInfo->Status;

	// Check the status here instead of the state since the status is what

	// we return to the caller

	if (Status == FCM_CONNECT_ESTABLISHED)

	{

		//

		// Note: Though the status is established, the pNewCEP state may not be in

		// CMS_ESTABLISHED since we may have already received a DREQ

		//

		_DBG_INFO(("<cep 0x%p> *** Connection established *** <lcid 0x%x rcid 0x%x slid 0x%x dlid 0x%x %s>.\n", 

					_DBG_PTR(pNewCEP), pNewCEP->LocalCommID, pNewCEP->RemoteCommID, 

					pNewCEP->PrimaryPath.LocalLID, pNewCEP->PrimaryPath.RemoteLID,

					_DBG_PTR(CmGetStateString(pNewCEP->State))));

	} else {

		switch (Status)

		{

		case FCM_CONNECT_CANCEL: // USRE_CANCEL

			_DBG_INFO(("<cep 0x%p> *** Connection cancelled *** <lcid 0x%x rcid 0x%x %s %s>.\n", 

					_DBG_PTR(pNewCEP), pNewCEP->LocalCommID, pNewCEP->RemoteCommID,

					_DBG_PTR(CmGetStateString(pNewCEP->State)), _DBG_PTR(FSTATUS_MSG(Status))));

			break;

		case FCM_CONNECT_REJECT: // CME_RCVD_REJ

			_DBG_INFO(("<cep 0x%p> *** Connection rejected *** <lcid 0x%x rcid 0x%x %s %s>.\n", 

					_DBG_PTR(pNewCEP), pNewCEP->LocalCommID, pNewCEP->RemoteCommID,

					_DBG_PTR(CmGetStateString(pNewCEP->State)), _DBG_PTR(FSTATUS_MSG(Status))));

			break;

		case FCM_CONNECT_TIMEOUT: // CME_TIMEOUT_REP

			_DBG_INFO(("<cep 0x%p> *** Connection timed out *** <lcid 0x%x rcid 0x%x %s %s>.\n", 

					_DBG_PTR(pNewCEP), pNewCEP->LocalCommID, pNewCEP->RemoteCommID,

					_DBG_PTR(CmGetStateString(pNewCEP->State)), _DBG_PTR(FSTATUS_MSG(Status))));

			break;

		case FCM_DISCONNECT_REQUEST:

			_DBG_INFO(("<cep 0x%p> *** Disconnecting *** <lcid 0x%x rcid 0x%x %s %s>.\n", 

					_DBG_PTR(pNewCEP), pNewCEP->LocalCommID, pNewCEP->RemoteCommID,

					_DBG_PTR(CmGetStateString(pNewCEP->State)), _DBG_PTR(FSTATUS_MSG(Status))));

			break;

		case FCM_DISCONNECTED:

			_DBG_INFO(("<cep 0x%p> *** Disconnected *** <lcid 0x%x rcid 0x%x %s %s>.\n", 

					_DBG_PTR(pNewCEP), pNewCEP->LocalCommID, pNewCEP->RemoteCommID,

					_DBG_PTR(CmGetStateString(pNewCEP->State)), _DBG_PTR(FSTATUS_MSG(Status))));

			break;

		default:

			_DBG_INFO(("<cep 0x%p> *** Connection ??? *** <lcid 0x%x rcid 0x%x %s %s>.\n", 

					_DBG_PTR(pNewCEP), pNewCEP->LocalCommID, pNewCEP->RemoteCommID,

					_DBG_PTR(CmGetStateString(pNewCEP->State)), _DBG_PTR(FSTATUS_MSG(Status))));

			ASSERT(0);

			break;