rnr.c

WinCE5.0部分核心源码

		CTEFreeLock(&v_DllCS, 0);
	}
	if (Err)
		cNs = SOCKET_ERROR;

	if (SOCKET_ERROR != cNs) {
		if (pLookup = LocalAlloc(LPTR, sizeof(*pLookup))) {
			if (cNs && (cLoaded = LoadNsProviders(pNs, cNs, pLookup))) {
				// GetServiceClassInfo here? NT has some code to do it,
				// but it is not compiled--it is if 0'ed out

				if(SOCKET_ERROR == CallNsProviders(pLookup, pRestrictions, 
					NULL, dwControlFlags,essOperation,fWSSetServiceCaller))
					Err = GetLastError();
					
				if (Err || fWSSetServiceCaller) {
					// oh, oh we failed. (or we're a SetService, which won't 
					// require the pointer later anyway)
					// probably should delete the Lookup stuff here
					FreeNsLookup(pLookup);
				} else {
					__try {
						*phLookup = (HANDLE)pLookup;
					}
					__except (EXCEPTION_EXECUTE_HANDLER) {
						Err = WSAEFAULT;
					}

					if (Err) {
						FreeNsLookup(pLookup);
					} else {
						CTEInitLock(&pLookup->Lock);
						pLookup->cRefs = 1;

						// insert in list
						CTEGetLock(&s_NsLookupsLock, 0);
						pLookup->pNext = s_pNsLookups;
						s_pNsLookups = pLookup;
						CTEFreeLock(&s_NsLookupsLock, 0);
					}
				}
			} else {
				FreeNsLookup(pLookup);
				Err = WSASERVICE_NOT_FOUND;
			}
		} else
			Err = WSA_NOT_ENOUGH_MEMORY;
	}

	if (pNs)
		LocalFree(pNs);

	if (Err) {
		SetLastError(Err);
		Err = SOCKET_ERROR;
	}
	
	return Err;
	
}


INT WSAAPI WSASetService(
	LPWSAQUERYSET lpqsRegInfo, 
	WSAESETSERVICEOP essOperation, 
	DWORD dwControlFlags
	) {
	return WSASetOrLookupBeginService(lpqsRegInfo,essOperation,dwControlFlags,NULL,TRUE);
}

INT WSAAPI WSALookupServiceBegin (
	IN	LPWSAQUERYSETW	pRestrictions,
	IN	DWORD			dwControlFlags,
	OUT	LPHANDLE		phLookup) {
	return WSASetOrLookupBeginService(pRestrictions,0,dwControlFlags,phLookup,FALSE);
}

// Find the lookup and remove from global list or add ref
NsLookup *FindNsLookup(HANDLE hLookup, uint fDelete) {
	NsLookup	**ppLookup, *pLookup;

	CTEGetLock(&s_NsLookupsLock, 0);
	ppLookup = &s_pNsLookups;
	while (pLookup = *ppLookup) {
		if ((HANDLE)pLookup == hLookup) {
			if (fDelete) {
				*ppLookup = pLookup->pNext;
			} else {
				CTEGetLock(&pLookup->Lock, 0);
				pLookup->cRefs++;
				CTEFreeLock(&pLookup->Lock, 0);
			}
			
			break;
		}
		ppLookup = &pLookup->pNext;
	}
	CTEFreeLock(&s_NsLookupsLock, 0);
	
	return pLookup;

}	// FindNsLookup()


void DerefLookup(NsLookup *pLookup) {
	LookupProvList	*pNsProvList;

	CTEGetLock(&pLookup->Lock, 0);
	ASSERT(0 < pLookup->cRefs);
	if (0 == --pLookup->cRefs) {
		// ok time to cleanup
		pNsProvList = pLookup->pNsProvList;
	} else
		pNsProvList = NULL;
		
	CTEFreeLock(&pLookup->Lock, 0);

	if (pNsProvList) {
		// we only set this if our ref count has reached 0

		CTEDeleteLock(&pLookup->Lock);
		
		FreeNsLookup(pLookup);
	}	// if (pNsProvList)

}	// DerefLookup()


void FreeLookups() {
	NsLookup	*pLookup;

	CTEGetLock(&s_NsLookupsLock, 0);
	while (pLookup = s_pNsLookups) {
		s_pNsLookups = pLookup->pNext;
		CTEFreeLock(&s_NsLookupsLock, 0);
		DerefLookup(pLookup);
		CTEGetLock(&s_NsLookupsLock, 0);
	}
	CTEFreeLock(&s_NsLookupsLock, 0);

}	// FreeLookups()


INT WSAAPI WSALookupServiceNext (
	IN     HANDLE           hLookup,
	IN     DWORD            dwControlFlags,
	IN OUT LPDWORD          lpdwBufferLength,
	OUT    LPWSAQUERYSETW   lpqsResults) {

	int				Err = 0;
	NsLookup		*pLookup;
	LookupProvList	*pLkpProv;

	CTEGetLock(&v_DllCS, 0);
	Err = Started();
	CTEFreeLock(&v_DllCS, 0);

	//
    // Verify that pointers are valid
    //

    if ( IsBadReadPtr(lpdwBufferLength, sizeof(*lpdwBufferLength) ) ||
         ( *lpdwBufferLength != 0  &&
           IsBadWritePtr(lpqsResults, *lpdwBufferLength) ) )
    {
        Err = WSAEFAULT;
    }
	
	if (Err)
		goto Exit;

	if (pLookup = FindNsLookup(hLookup, FALSE)) {
		pLkpProv = pLookup->pNsProvList; 
		Err = WSA_E_NO_MORE;
		for ( ;pLkpProv; pLkpProv = pLkpProv->pNext) {
			if (! (LOOKUP_SVC_BEGIN_FAILED & pLkpProv->Flags) &&
				! (LOOKUP_SVC_ERROR & pLkpProv->Flags)) {

				Err = pLkpProv->pNsProv->ProcTable.NSPLookupServiceNext(
					pLkpProv->hLookup, dwControlFlags, 
					lpdwBufferLength, lpqsResults);

				if (Err) {
					Err = GetLastError();
					if (WSAEFAULT == Err)
						break;
					if (WSA_E_NO_MORE != Err)
					    pLkpProv->Flags |= LOOKUP_SVC_ERROR;
				} else {
					break;
				}
			}
		}	// for (pLkpProv)
		
		DerefLookup(pLookup);

	} else
		Err = WSA_INVALID_HANDLE;
	
Exit:
	if (Err) {
		SetLastError(Err);
		Err = SOCKET_ERROR;
	}
	return Err;

}	// WSALookupServiceNext()


INT WSAAPI WSALookupServiceEnd (
	IN HANDLE  hLookup) {

	int				Err = 0;
	NsLookup		*pLookup;
	LookupProvList	*pLkpProv;

	CTEGetLock(&v_DllCS, 0);
	Err = Started();
	CTEFreeLock(&v_DllCS, 0);
	
	if (Err)
		goto Exit;

	if (pLookup = FindNsLookup(hLookup, TRUE)) {
		pLkpProv = pLookup->pNsProvList; 
		for ( ;pLkpProv; pLkpProv = pLkpProv->pNext) {
			if (! (LOOKUP_SVC_BEGIN_FAILED & pLkpProv->Flags)) {

				// there is not much to do if it fails
				pLkpProv->pNsProv->ProcTable.NSPLookupServiceEnd(
					pLkpProv->hLookup);

			}
		}	// for (pLkpProv)

		DerefLookup(pLookup);

	} else
		Err = WSA_INVALID_HANDLE;

Exit:
	if (Err) {
		SetLastError(Err);
		Err = SOCKET_ERROR;
	}
	
	return Err;

}	// WSALookupServiceEnd()


INT WSAAPI WSANSPIoctl (
	IN  HANDLE           hLookup,
	IN  DWORD            dwControlCode,
	IN  LPVOID           lpvInBuffer,
	IN  DWORD            cbInBuffer,
	OUT LPVOID           lpvOutBuffer,
	IN  DWORD            cbOutBuffer,
	OUT LPDWORD          lpcbBytesReturned,
	IN  LPWSACOMPLETION  lpCompletion) {

	NsLookup		*pLookup = NULL;
	int			ErrorCode;
    
	CTEGetLock(&v_DllCS, 0);
	ErrorCode = Started();
	CTEFreeLock(&v_DllCS, 0);
	
	if (ERROR_SUCCESS != ErrorCode) {
		goto Error;
	}

	//
	// Verify that the completion structure is readable if given.
	//
	if ((lpCompletion) && IsBadReadPtr(lpCompletion, sizeof(*lpCompletion))) {
		ErrorCode = WSAEINVAL;
		goto Error;
	}

	//
	// Verify lpcbBytesReturned.
	//
	if ((lpcbBytesReturned == NULL) ||
		IsBadWritePtr(lpcbBytesReturned, sizeof(*lpcbBytesReturned))) {
		ErrorCode = WSAEINVAL;
		goto Error;
	}

	//
	// Verify that the query handle is valid.
	//
	if (!hLookup) {
		ErrorCode = WSA_INVALID_HANDLE;
		goto Error;
	}
	
	if (pLookup = FindNsLookup(hLookup, FALSE)) {
		//
		// Make sure there is at least one and only one namespace
		// in the query that supports this operation.
		//
		unsigned int	numProviders = 0;
	  	LookupProvList	*provider, *providerIoctl = NULL;
		
		for (provider = pLookup->pNsProvList ;provider; provider = provider->pNext) {
			if (NULL != provider->pNsProv->ProcTable.NSPIoctl) {
				if(++numProviders > 1)
					break;
					
				providerIoctl = provider;
			}
		}
		
		if (numProviders > 1) {
			ErrorCode = WSAEINVAL;
			goto Error;
		}

		if (NULL == providerIoctl) {
			ErrorCode = WSAEOPNOTSUPP;
			goto Error;
		}
	
		//
		// Perform the IOCTL.
		//
		ErrorCode = providerIoctl->pNsProv->ProcTable.NSPIoctl(
										   providerIoctl->hLookup,
										   dwControlCode, lpvInBuffer, cbInBuffer,
										   lpvOutBuffer, cbOutBuffer, lpcbBytesReturned,
										   lpCompletion, NULL);
		
		DerefLookup(pLookup);
		return ErrorCode;
	} else {
		ErrorCode = WSA_INVALID_HANDLE;
	}

Error:
	if (pLookup)
		DerefLookup(pLookup);
	
	ASSERT(ERROR_SUCCESS != ErrorCode);
	SetLastError(ErrorCode);
	return SOCKET_ERROR;
	
}	// WSANSPIoctl()