nspsrvc.c

WinCE5.0部分核心源码

		} else if (0 == memcmp(pSvcClassId, &IANAGuid, sizeof(GUID))) {
			Flags |= IANA_LOOKUP;
			ControlFlags &= ~LUP_RETURN_ADDR;
		} else if (0 == memcmp(pSvcClassId, &Ipv6Guid, sizeof(GUID))) {
			Flags |= V6_LOOKUP;
		}
		
		fNameLookup = (0 == memcmp(pSvcClassId, &HostnameGuid, sizeof(GUID)))
						|| IS_SVCID_TCP(pSvcClassId)
						|| IS_SVCID_UDP(pSvcClassId)
			|| (0 == memcmp(pSvcClassId, &InetHostName, sizeof(GUID)))
			|| (0 == memcmp(pSvcClassId, &Ipv6Guid, sizeof(GUID)))
			|| (0 == memcmp(pSvcClassId, &AtmaGuid, sizeof(GUID)));

		if (! (pwszSvcName = pRestrict->lpszServiceInstanceName) ||
			! (*pwszSvcName)) {

			if (fNameLookup) {
				Flags |= LOCAL_LOOKUP;
				pwszSvcName = TEXT("");
			} else if ( (REVERSE_LOOKUP & Flags) && pRestrict->lpcsaBuffer &&
				(1 == pRestrict->dwNumberOfCsAddrs)) {

				pSAddr = (SOCKADDR_IN *)pRestrict->lpcsaBuffer->
												RemoteAddr.lpSockaddr;
				if (MyInetNtoaW(pwszSockAddr, pSAddr->sin_addr))
					pwszSvcName = pwszTemp;
				else {
					Err = WSAEINVAL;
					// break out somehow?
				}
			} else {
				Err = WSAEINVAL;
				// break out somehow??
			}
		} else if (fNameLookup) {
			// check for special names
			if (DnsNameCompare_W(pwszSvcName, TEXT("localhost")) ||
				DnsNameCompare_W(pwszSvcName, TEXT("loopback")))
				Flags |= LOCAL_LOOKUP | LOOP_LOOKUP;
			



		}

		if (! Err) {
			// compare protocols to return
			if (cProtocols = pRestrict->dwNumberOfProtocols) {
				pAfProtocols = pRestrict->lpafpProtocols;
				while (cProtocols-- && pAfProtocols) {
					AddrFamily = pAfProtocols->iAddressFamily;
					if (AF_UNSPEC == AddrFamily) {
						Protocols = 0x3;
						break;
					} else if (AF_INET==AddrFamily || AF_INET6==AddrFamily) {
						if (! (Prot = pRestrict->lpafpProtocols->iProtocol)) {
							Protocols = 0x3;
							break;
						} else if (IPPROTO_UDP == Prot) {
							Protocols |= 0x1;
						} else if (IPPROTO_TCP == Prot) {
							Protocols |= 0x2;
						}
						// otherwise we don't do anything just in case someone
						// adds a new protocol we don't recognize
					}
					pAfProtocols++;
				}
			} else {
				Protocols = 0x3;
			}
			// get the server and protocols if there is a string
			
			if (Protocols) {
				// ...

				// if everything ok get a handle
				// don't add 1 here b/c pQuery already has an array of WCHAR[1]
				cSvcName = (wcslen(pwszSvcName)) * sizeof(WCHAR);
				if (pQuery = LocalAlloc(LPTR, sizeof(*pQuery) + cSvcName)) {
					pQuery->cRefs = 1;
					pQuery->Flags = Flags;
					pQuery->ControlFlags = ControlFlags;
					memcpy(&pQuery->Id, pSvcClassId, sizeof(GUID));
					wcscpy(pQuery->pwszSvcName, pwszSvcName);
					
					// set other fields
					EnterCriticalSection(&v_NspmCS);
					pQuery->pNext = v_pQueryList;
					v_pQueryList = pQuery;
					LeaveCriticalSection(&v_NspmCS);
					*phLookup = (HANDLE)pQuery;

				} else
					Err = WSA_NOT_ENOUGH_MEMORY;

			} else
				Err = WSANO_DATA;
		}

		LocalFree(pwszTemp);

	}

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

	return Err;

}	// NSPLookupServiceBegin()

#define NAME_SIZE	168	// make this a multiple of 4

INT WSAAPI NSPLookupServiceNext(
	HANDLE			hLookup,
	DWORD			ControlFlags,
	DWORD			*pcBuf,
	LPWSAQUERYSETW	pResults) {

	int				Err = 0;
	QueryContext	*pQuery, **ppQuery;
	WSAQUERYSETW	QuerySet;
	SOCK_THREAD		*pThread;
	HOSTENT			*pHost;
	CSADDR_INFO		*pCsAddr;
	SOCKADDR		*pSAddr;
	SOCKADDR_IN		*pSAddrIn;
	SOCKADDR_IN6	*pSAddrIn6;
	char			*p;
	unsigned int	cBuf, cAddr;
	int				i, cSize, cName;
	BLOB			*pBlob;
	WCHAR			wName[NAME_SIZE];
	DWORD			IPAddr[4];
	HKEY			hKey;
	LONG			hRet;
	DWORD			Type;
	int				fLocalLookup;
	AFD_OPTIONS		AfdOptions;
	ushort			Family;

	
	if(!hLookup || !pcBuf || !pResults) {
		Err = WSAEFAULT;
	} else if ((ControlFlags & LUP_CONTAINERS) && (ControlFlags & LUP_NOCONTAINERS)) {
		Err = WSAEINVAL;
	} else if (ControlFlags & LUP_CONTAINERS) {
		Err = WSANO_DATA;
	} else {
		if (! pResults && *pcBuf) {
			// the caller lied to us!
			*pcBuf = 0;
		}
		if (*pcBuf < sizeof(WSAQUERYSETW)) {
			pResults = &QuerySet;
		}
    
		memset(pResults, 0, sizeof(WSAQUERYSETW));
		pResults->dwNameSpace = NS_DNS;
		pResults->dwSize = sizeof(WSAQUERYSETW);

		EnterCriticalSection(&v_NspmCS);
		pQuery = *_FindQuery(hLookup);
		pQuery->cRefs++;
		LeaveCriticalSection(&v_NspmCS);

		if (pQuery) {

			if (V6_LOOKUP & pQuery->Flags) {
				AfdOptions.Type = T_AAAA;
				cAddr = sizeof(SOCKADDR_IN6);
				Family = AF_INET6;
			} else {
				AfdOptions.Type = T_A;
				cAddr = sizeof(SOCKADDR_IN);
				Family = AF_INET;
			}
				

			if (DONE_LOOKUP & pQuery->Flags) {
				Err = WSA_E_NO_MORE;
			} else if (IANA_LOOKUP & pQuery->Flags) {
				ASSERT(0);
				

			} else if (REVERSE_LOOKUP & pQuery->Flags) {

				if (AF_INET6 == Family) {
					// we don't yet handle reverse queries for v6
					Err = WSANO_DATA;
					goto Done;
				} else {
					IPAddr[0] = MyInetAddrW(pQuery->pwszSvcName);
				}
				if (INADDR_NONE != IPAddr[0]) {
					if (pThread = LocalAlloc(LPTR, sizeof(*pThread))) {
						if (AFDGetHostentByAttr(pThread, NULL, 
							(BYTE *)IPAddr, &AfdOptions)) {

							pHost = &(pThread->GETHOST_host);

							p = (char *)(pResults + 1);
							cBuf = (DWORD)(pResults + 1) - (DWORD)pResults;

							ASSERT(!((DWORD)p & 0x3));

							memset(&QuerySet, 0, sizeof(QuerySet));
							// copy stuff into the query structure...
							QuerySet.dwSize = sizeof(QuerySet);

							// very silly: copy GUID from LookupServiceBegin
							if (LUP_RETURN_TYPE & pQuery->ControlFlags) {
								cSize = sizeof(GUID);
								cBuf += cSize;
								if (cBuf <= *pcBuf) {
									QuerySet.lpServiceClassId = (GUID *)p;
									memcpy(p, &pQuery->Id, cSize);
									p += cSize;

									ASSERT(!((DWORD)p & 0x3));
								}
							}
							// seems to be not set by NT
	//						QuerySet.lpVersion = NULL;
	//						QuerySet.lpszComment = NULL;
							QuerySet.dwNameSpace = NS_DNS;

							cSize = sizeof(GUID);
							cBuf += cSize;
							if (cBuf <= *pcBuf) {
								QuerySet.lpNSProviderId = (GUID *)p;
								memcpy(p, &NsId, cSize);
								p += cSize;

								ASSERT(!((DWORD)p & 0x3));
							}
	//						QuerySet.lpszContext = NULL;
	//						QuerySet.dwNumberOfProtocols = 0;
	//						QuerySet.lpafpProtocols = NULL;
	//						QuerySet.lpszQueryString = NULL;

							ASSERT(!((DWORD)p & 0x3));

							if (LUP_RETURN_ADDR & pQuery->ControlFlags) {
								// we'll only add one address for now...the one
								// that was given to us
								i = 1;
								// each pCsAddr will have two pointers to 
								// SOCKADDRS so calculate them in too...
								cSize = sizeof(*pCsAddr) + (cAddr << 1);
								cBuf += cSize;

								ASSERT(!((DWORD)cSize & 0x3));

								// if they're not all going to fit in, then don't
								// return partial info...
								if (cBuf <= *pcBuf) {
									QuerySet.dwNumberOfCsAddrs = i;
									QuerySet.lpcsaBuffer = pCsAddr = 
										(CSADDR_INFO *)p;
									p += sizeof(*pCsAddr) * i;
								
									pSAddr = (SOCKADDR *)p;

									// now copy them in...
									memset(pCsAddr, 0, sizeof(*pCsAddr));
									// copy the non-pointer info first
									
									
									pCsAddr[0].iSocketType = SOCK_STREAM;
									pCsAddr[0].iProtocol = IPPROTO_TCP;
									
									pCsAddr[0].LocalAddr.iSockaddrLength = 
										pCsAddr[0].RemoteAddr.iSockaddrLength
										= cAddr;

									pCsAddr[0].LocalAddr.lpSockaddr = pSAddr;
									memset(pSAddr, 0, cAddr);
									pSAddr->sa_family = Family;
									// local address will be blank

									p += cAddr;
									ASSERT(!((DWORD)p & 0x3));
									pSAddr = (SOCKADDR *)p;
									
									pCsAddr[0].RemoteAddr.lpSockaddr = pSAddr;
									memset(pSAddr, 0, cAddr);
									// pSAddrIn->sin_port already memset to 0
									pSAddr->sa_family = Family;
									if (Family == AF_INET) {
										pSAddrIn = (SOCKADDR_IN *)p;
										pSAddrIn->sin_addr.s_addr = IPAddr[0];
									} else {
										pSAddrIn6 = (SOCKADDR_IN6 *)p;
										memcpy(&pSAddrIn6->sin6_addr, IPAddr, 
											sizeof(struct in6_addr));
									}

									p += cAddr;
									ASSERT(!((DWORD)p & 0x3));
									
								}	// if (cBuf <= *pcBuf)
							}	// if (LUP_RETURN_ADDR & pQuery->ControlFlags
							
							// if this is an alias set this to RESULT_IS_ALIAS
	//						QuerySet.dwOutputFlags = 0;

							if (LUP_RETURN_BLOB & pQuery->ControlFlags) {
								QuerySet.lpBlob = pBlob = (BLOB *)p;
								// make sure this is a SVCID_INET_HOSTADDRBYNAME
								cSize = sizeof(BLOB);
								cBuf += cSize;
								if (cBuf <= *pcBuf) {
									p += cSize;
									ASSERT(!((DWORD)p & 0x3));
									pBlob->pBlobData = p;
								}

								Err = CopyHostentToBlob(pHost, p, *pcBuf - cBuf, 
									&cSize);
								if (! Err) {
									PointerToOffset((HOSTENT*)p);
									pBlob->cbSize = cSize;
									cSize = (cSize + 3) & ~3;
									p += cSize;
									cBuf += cSize;
								} else {
									cSize = (cSize + 3) & ~3;
									cBuf += cSize;
								}
								ASSERT(!((DWORD)p & 0x3));
							}

							if (LUP_RETURN_NAME & pQuery->ControlFlags) {

								cName = strlen(pHost->h_name) + 1;
								cSize = ((cName *2) + 3) & (~3);
								ASSERT(!((DWORD)cSize & 0x3));

								cBuf += cSize;
								if (cBuf <= *pcBuf) {
									QuerySet.lpszServiceInstanceName = (WCHAR *)p;
									MultiByteToWideChar(CP_ACP, 0, pHost->h_name, -1, (WCHAR *)p, cName);
									p += cSize;
									ASSERT(!((DWORD)p & 0x3));
								}
							}
							if (cBuf > *pcBuf) {
								Err = WSAEFAULT;
								*pcBuf = cBuf;
							} else
								memcpy(pResults, &QuerySet, sizeof(QuerySet));
							

						} else	// if (AFDGetHostentByAttr...)
							Err = GetLastError();
							
						LocalFree(pThread);
					} else
						Err = WSA_NOT_ENOUGH_MEMORY;
					

				} else {
					// what should we do here?
					ASSERT(0);
					Err = WSAEINVAL;
				}

			} else {

				if (LOCAL_LOOKUP & pQuery->Flags) {
					fLocalLookup = TRUE;

					if (! ((LUP_RETURN_NAME | LUP_RETURN_ADDR) & 
						pQuery->ControlFlags)) {
						Err = WSAEINVAL;
					} else if ( 
						! ((LUP_RETURN_NAME | LUP_RETURN_ADDR |LUP_RETURN_BLOB)
						& pQuery->ControlFlags)) {
						Err = WSAEINVAL;
					}
					if (Err)
						goto Done;

					p = (char *)(pResults + 1);
					cBuf = (DWORD)(pResults + 1) - (DWORD)pResults;

					memset(&QuerySet, 0, sizeof(QuerySet));

					// copy stuff into the query structure...
					QuerySet.dwSize = sizeof(QuerySet);

					QuerySet.dwNameSpace = NS_DNS;
					cSize = sizeof(GUID);
					cBuf += cSize;
					if (cBuf <= *pcBuf) {
						QuerySet.lpNSProviderId = (GUID *)p;
						memcpy(p, &NsId, cSize);
						p += cSize;
					}
					ASSERT(!((DWORD)p & 0x3));

					i = 0;
					if (ERROR_SUCCESS == RegOpenKeyEx (HKEY_LOCAL_MACHINE, 
												TEXT("Ident"), 0, 0, &hKey)) {
						cName = sizeof(wName);
						hRet = RegQueryValueEx(hKey, TEXT("Name"), 0, &Type,
							(char *)wName, &cName);
						RegCloseKey (hKey);
						
						if ((hRet == ERROR_SUCCESS) && (Type == REG_SZ)) {
							i++;
						}
					}
					if (! i) {
						wcscpy(wName, TEXT("WindowsCE"));
						cName = 20;
					}
					cSize = (cName + 3) & (~3);
					ASSERT(!((DWORD)cSize & 0x3));