int NameToBthAddr(char *pszRemoteName, PSOCKADDR_BTH pRemoteBthAddr) { INT iResult = CXN_SUCCESS; BOOL bContinueLookup = FALSE, bRemoteDeviceFound = FALSE; ULONG ulFlags = 0, ulPQSSize = sizeof(WSAQUERYSET); HANDLE hLookup = NULL; PWSAQUERYSET pWSAQuerySet = NULL; ZeroMemory(pRemoteBthAddr, sizeof(*pRemoteBthAddr)); pWSAQuerySet = (PWSAQUERYSET)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ulPQSSize); if (NULL == pWSAQuerySet) { iResult = STATUS_NO_MEMORY; printf("[BTClient] Unable to allocate memory for WSAQUERYSET\n"); } // // Search for the device with the correct name // printf("[BTClient] Looking for %s...\n", pszRemoteName); if (CXN_SUCCESS == iResult) { for (INT iRetryCount = 0; !bRemoteDeviceFound && (iRetryCount < CXN_MAX_INQUIRY_RETRY); iRetryCount++) { // // WSALookupService is used for both service search and device inquiry // LUP_CONTAINERS is the flag which signals that we're doing a device inquiry. // ulFlags = LUP_CONTAINERS; // // Friendly device name (if available) will be returned in lpszServiceInstanceName // ulFlags |= LUP_RETURN_NAME; // // BTH_ADDR will be returned in lpcsaBuffer member of WSAQUERYSET // ulFlags |= LUP_RETURN_ADDR; if (0 == iRetryCount) { printf("[BTClient] Inquiring device from cache...\n"); } else { // // Flush the device cache for all inquiries, except for the first inquiry // // By setting LUP_FLUSHCACHE flag, we're asking the lookup service to do // a fresh lookup instead of pulling the information from device cache. // ulFlags |= LUP_FLUSHCACHE; // // Pause for some time before all the inquiries after the first inquiry // // Remote Name requests will arrive after device inquiry has // completed. Without a window to receive IN_RANGE notifications, // we don't have a direct mechanism to determine when remote // name requests have completed. // printf("[BTClient] Unable to find device. Waiting for %d seconds before re-inquiry...\n", CXN_DELAY_NEXT_INQUIRY); Sleep(CXN_DELAY_NEXT_INQUIRY * 1000); printf("[BTClient] Inquiring device ...\n"); } // // Start the lookup service // iResult = CXN_SUCCESS; hLookup = 0; bContinueLookup = FALSE; ZeroMemory(pWSAQuerySet, ulPQSSize); pWSAQuerySet->dwNameSpace = NS_BTH; pWSAQuerySet->dwSize = sizeof(WSAQUERYSET); printf("[BTClient] before WSALookupServiceBegin\n"); iResult = WSALookupServiceBegin(pWSAQuerySet, ulFlags, &hLookup); printf("[BTClient] after WSALookupServiceBegin\n"); // // Even if we have an error, we want to continue until we // reach the CXN_MAX_INQUIRY_RETRY // if ((NO_ERROR == iResult) && (NULL != hLookup)) { bContinueLookup = TRUE; } else if (0 < iRetryCount) { printf("[BTClient] WSALookupServiceBegin() failed with error code %d, WSAGetLastError = %d\n", iResult, WSAGetLastError()); break; } while (bContinueLookup) { // // Get information about next bluetooth device // // Note you may pass the same WSAQUERYSET from LookupBegin // as long as you don't need to modify any of the pointer // members of the structure, etc. // // ZeroMemory(pWSAQuerySet, ulPQSSize); // pWSAQuerySet->dwNameSpace = NS_BTH; // pWSAQuerySet->dwSize = sizeof(WSAQUERYSET); printf("[BTClient] Before WSALookupServiceNext\n"); if (NO_ERROR == WSALookupServiceNext(hLookup, ulFlags, &ulPQSSize, pWSAQuerySet)) { // // Compare the name to see if this is the device we are looking for. // wchar_t* wcRemoteName = convertCharArrayToLPCWSTR(pszRemoteName); if ((pWSAQuerySet->lpszServiceInstanceName != NULL) && (0 == wcscmp(pWSAQuerySet->lpszServiceInstanceName, wcRemoteName))) { delete wcRemoteName; // // Found a remote bluetooth device with matching name. // Get the address of the device and exit the lookup. // wprintf(L"[BTClient] Found %s!\n", pWSAQuerySet->lpszServiceInstanceName); //printf("[BTClient] lpszServiceInstanceName addr %d\n", (pWSAQuerySet->lpszServiceInstanceName)); //printf("[BTClient] lpcsaBuffer address is %d\n", (pWSAQuerySet->lpcsaBuffer)); //printf("[BTClient]\t pResults->...->btAddr: %012X\n", ((PSOCKADDR_BTH)pWSAQuerySet->lpcsaBuffer->RemoteAddr.lpSockaddr)->btAddr); //printf("[BTClient] RemoteAddr address is %d\n", (pWSAQuerySet->lpcsaBuffer->RemoteAddr)); CopyMemory(pRemoteBthAddr, (PSOCKADDR_BTH)pWSAQuerySet->lpcsaBuffer->RemoteAddr.lpSockaddr, sizeof(*pRemoteBthAddr)); bRemoteDeviceFound = TRUE; bContinueLookup = FALSE; printf("[BTClient] Finished copy\n"); } else { wprintf(L"[BTClient] Found %s, still looking...\n", pWSAQuerySet->lpszServiceInstanceName); } } else { iResult = WSAGetLastError(); if (WSA_E_NO_MORE == iResult) { //No more data printf("[BTClient] WSA_E_NO_MORE\n"); // // No more devices found. Exit the lookup. // bContinueLookup = FALSE; } else if (WSAEFAULT == iResult) { // // The buffer for QUERYSET was insufficient. // In such case 3rd parameter "ulPQSSize" of function "WSALookupServiceNext()" receives // the required size. So we can use this parameter to reallocate memory for QUERYSET. // HeapFree(GetProcessHeap(), 0, pWSAQuerySet); pWSAQuerySet = (PWSAQUERYSET)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ulPQSSize); printf("[BTClient] Got WSAEFAULT\n"); if (NULL == pWSAQuerySet) { printf("[BTClient] Unable to allocate memory for WSAQERYSET\n"); iResult = STATUS_NO_MEMORY; bContinueLookup = FALSE; } } else { printf("[BTClient] WSALookupServiceNext() failed with error code %d\n", iResult); bContinueLookup = FALSE; } } } // // End the lookup service // WSALookupServiceEnd(hLookup); if (STATUS_NO_MEMORY == iResult) { break; } } } if (NULL != pWSAQuerySet) { HeapFree(GetProcessHeap(), 0, pWSAQuerySet); pWSAQuerySet = NULL; } if (bRemoteDeviceFound) { iResult = CXN_SUCCESS; } else { iResult = CXN_ERROR; } return iResult; }
//------------------------------------------------------------------------- // Function: PnrpResolve // // Purpose: Resolve the given name within a PNRP cloud // // Arguments: // pwzName : name to resolve in PNRP, generally the graph id // pwzCloud : name of cloud to resolve in, NULL = global cloud // pAddr : pointer to result buffer // // Returns: HRESULT // HRESULT PnrpResolve(PCWSTR pwzName, PCWSTR pwzCloud, __out SOCKADDR_IN6* pAddr) { HRESULT hr = S_OK; PNRPINFO pnrpInfo = {0}; BLOB blPnrpData = {0}; WSAQUERYSET querySet = {0}; WSAQUERYSET* pResults = NULL; WSAQUERYSET tempResultSet = {0}; HANDLE hLookup = NULL; BOOL fFound = FALSE; DWORD dwError; INT iRet; ULONG i; DWORD dwSize = 0; // // fill in the WSAQUERYSET // pnrpInfo.dwSize = sizeof(pnrpInfo); pnrpInfo.nMaxResolve = 1; pnrpInfo.dwTimeout = 30; pnrpInfo.enResolveCriteria = PNRP_RESOLVE_CRITERIA_NON_CURRENT_PROCESS_PEER_NAME; blPnrpData.cbSize = sizeof(pnrpInfo); blPnrpData.pBlobData = (BYTE*)&pnrpInfo; querySet.dwSize = sizeof(querySet); querySet.dwNameSpace = NS_PNRPNAME; querySet.lpServiceClassId = (LPGUID)&SVCID_PNRPNAME; querySet.lpszServiceInstanceName = (PWSTR) pwzName; querySet.lpszContext = (PWSTR) pwzCloud; querySet.lpBlob = &blPnrpData; // start resolve iRet = WSALookupServiceBegin( &querySet, LUP_RETURN_NAME | LUP_RETURN_ADDR | LUP_RETURN_COMMENT, &hLookup); if (iRet != 0) { hr = HRESULT_FROM_WIN32(WSAGetLastError()); } if (SUCCEEDED(hr)) { dwSize = sizeof(tempResultSet); // retrieve the required size iRet = WSALookupServiceNext(hLookup, 0, &dwSize, &tempResultSet); dwError = WSAGetLastError(); if (dwError == WSAEFAULT) { // allocate space for the results pResults = (WSAQUERYSET*)malloc(dwSize); if (pResults == NULL) { hr = HRESULT_FROM_WIN32(WSAGetLastError()); } } else { hr = HRESULT_FROM_WIN32(dwError); } } if (SUCCEEDED(hr)) { // retrieve the addresses iRet = WSALookupServiceNext(hLookup, 0, &dwSize, pResults); if (iRet != 0) { hr = HRESULT_FROM_WIN32(WSAGetLastError()); } } if (SUCCEEDED(hr)) { // return the first IPv6 address found for (i = 0; i < pResults->dwNumberOfCsAddrs; i++) { if (pResults->lpcsaBuffer[i].iProtocol == IPPROTO_TCP && pResults->lpcsaBuffer[i].RemoteAddr.iSockaddrLength == sizeof(SOCKADDR_IN6)) { CopyMemory(pAddr, pResults->lpcsaBuffer[i].RemoteAddr.lpSockaddr, sizeof(SOCKADDR_IN6)); fFound = TRUE; break; } } if (!fFound) { // unable to find an IPv6 address hr = HRESULT_FROM_WIN32(WSA_E_NO_MORE); } } if (hLookup != NULL) { WSALookupServiceEnd(hLookup); } free(pResults); return hr; }
int RhoBluetoothManager::DiscoverDevices() { LOG(INFO) + "RhoBluetoothManager::DiscoverDevices() START"; WSAQUERYSET wsaq; HANDLE hLookup; RhoDeviceList * tempDevice; union { CHAR buf[5000]; double __unused; // ensure proper alignment }; LPWSAQUERYSET pwsaResults = (LPWSAQUERYSET) buf; DWORD dwSize = sizeof(buf); BOOL bHaveName; ZeroMemory(&wsaq, sizeof(wsaq)); wsaq.dwSize = sizeof(wsaq); wsaq.dwNameSpace = NS_BTH; wsaq.lpcsaBuffer = NULL; if (ERROR_SUCCESS != WSALookupServiceBegin (&wsaq, LUP_CONTAINERS, &hLookup)) { LOG(INFO) + "RhoBluetoothManager::DiscoverDevices() return ERROR"; return WSAGetLastError(); } ZeroMemory(pwsaResults, sizeof(WSAQUERYSET)); pwsaResults->dwSize = sizeof(WSAQUERYSET); pwsaResults->dwNameSpace = NS_BTH; pwsaResults->lpBlob = NULL; if(m_pStart) { for(m_pCurrentDevice=m_pStart;m_pCurrentDevice;) { RhoDeviceList *temp=m_pCurrentDevice; m_pCurrentDevice=m_pCurrentDevice->NextDevice; free(temp); } } m_pEnd=m_pStart=NULL; m_iNumDevices=0; while (true) { if(WSALookupServiceNext (hLookup, LUP_RETURN_NAME | LUP_RETURN_ADDR, &dwSize, pwsaResults)!=ERROR_SUCCESS) break; ASSERT (pwsaResults->dwNumberOfCsAddrs == 1); //Populate the link list tempDevice=(RhoDeviceList*)malloc(sizeof(RhoDeviceList)); tempDevice->NextDevice=NULL; if(m_pStart==NULL) { m_pStart = tempDevice; m_pEnd=m_pStart; } else { m_pEnd->NextDevice =tempDevice; m_pEnd=tempDevice; } m_iNumDevices++; m_pEnd->bthAddress = ((SOCKADDR_BTH *)pwsaResults->lpcsaBuffer->RemoteAddr.lpSockaddr)->btAddr; bHaveName = pwsaResults->lpszServiceInstanceName && *(pwsaResults->lpszServiceInstanceName); //If device name is available, add to node StringCchPrintf(m_pEnd->bthName, ARRAYSIZE(m_pEnd->bthName),L"%s",bHaveName ? pwsaResults->lpszServiceInstanceName : L""); { char name[1024]; WideCharToMultiByte(CP_UTF8, 0, m_pEnd->bthName, -1, name, 1024, 0, 0); LOG(INFO) + "RhoBluetoothManager::DiscoverDevices() FOUND = "+name; } } WSALookupServiceEnd(hLookup); LOG(INFO) + "RhoBluetoothManager::DiscoverDevices() FINISH"; // LeaveCriticalSection(&criticalSection); return 0; }
static int bthPerformServiceLookup ( BluetoothServiceLookupResult *result, ULONGLONG address, GUID *guid, DWORD beginFlags, DWORD nextFlags ) { int found = 0; if (bthStartSockets()) { SOCKADDR_BTH socketAddress = { .addressFamily = AF_BTH, .btAddr = address }; char addressString[0X100]; DWORD addressLength = sizeof(addressString); if (WSAAddressToString((SOCKADDR *)&socketAddress, sizeof(socketAddress), NULL, addressString, &addressLength) != SOCKET_ERROR) { HANDLE handle; CSADDR_INFO csa[] = { { .RemoteAddr = { .lpSockaddr = (SOCKADDR *)&socketAddress, .iSockaddrLength = sizeof(socketAddress) } } }; WSAQUERYSET restrictions = { .dwNameSpace = NS_BTH, .lpszContext = addressString, .lpcsaBuffer = csa, .dwNumberOfCsAddrs = ARRAY_COUNT(csa), .lpServiceClassId = guid, .dwSize = sizeof(restrictions) }; if (WSALookupServiceBegin(&restrictions, (LUP_FLUSHCACHE | beginFlags), &handle) != SOCKET_ERROR) { DWORD resultLength = sizeof(*result); if (WSALookupServiceNext(handle, nextFlags, &resultLength, &result->querySet) != SOCKET_ERROR) { found = 1; } else { static const DWORD exceptions[] = { #ifdef WSA_E_NO_MORE WSA_E_NO_MORE, #endif /* WSA_E_NO_MORE */ #ifdef WSAENOMORE WSAENOMORE, #endif /* WSAENOMORE */ NO_ERROR }; bthSocketError("WSALookupServiceNext", exceptions); } if (WSALookupServiceEnd(handle) == SOCKET_ERROR) { bthSocketError("WSALookupServiceEnd", NULL); } } else { bthSocketError("WSALookupServiceBegin", NULL); } } else {
DWORD dwResultSize; // Fill out information for WSA query CloudInfo.dwSize = sizeof(CloudInfo); CloudInfo.Cloud.Scope = PNRP_LINK_LOCAL_SCOPE; blPnrpData.cbSize = sizeof(CloudInfo); blPnrpData.pBlobData = (LPBYTE)&CloudInfo; querySet.dwSize = sizeof(querySet); querySet.dwNameSpace = NS_PNRPCLOUD; querySet.lpServiceClassId = (LPGUID)&SVCID_PNRPCLOUD; querySet.lpBlob = &blPnrpData; iErr = WSALookupServiceBegin( &querySet, LUP_RETURN_NAME|LUP_RETURN_BLOB, &hLookup); if (iErr != 0) { hr = HRESULT_FROM_WIN32(WSAGetLastError()); } if (SUCCEEDED(hr)) { dwResultSize = sizeof(tempResultSet); // Get size of results iErr = WSALookupServiceNext(hLookup, 0, &dwResultSize, &tempResultSet); if (iErr != 0)
// ============================================================================= // BTDeviceIsNear // ============================================================================= bool BTDeviceIsNear() { //Initialising winsock WSADATA data; int result; result = WSAStartup(MAKEWORD(2, 2), &data); if (result != 0){ MsgBox("An error occured while initialising winsock, closing...."); return false; } //Initialising query for device WSAQUERYSET queryset; memset(&queryset, 0, sizeof(WSAQUERYSET)); queryset.dwSize = sizeof(WSAQUERYSET); queryset.dwNameSpace = NS_BTH; HANDLE hLookup; result = WSALookupServiceBegin(&queryset, LUP_CONTAINERS, &hLookup); if (result != 0){ MsgBox("An error occured while initialising look for devices, closing...."); return false; } //Initialisation succeed, start looking for devices BYTE buffer[4096]; memset(buffer, 0, sizeof(buffer)); DWORD bufferLength = sizeof(buffer); WSAQUERYSET *pResults = (WSAQUERYSET*)&buffer; while (result == 0) { result = WSALookupServiceNext(hLookup, LUP_RETURN_NAME | LUP_CONTAINERS | LUP_RETURN_ADDR | LUP_FLUSHCACHE | LUP_RETURN_TYPE | LUP_RETURN_BLOB | LUP_RES_SERVICE, &bufferLength, pResults); if (result == 0) { // A device found LPTSTR deviceFoundName = pResults->lpszServiceInstanceName; PSOCKADDR_BTH sa = PSOCKADDR_BTH(pResults->lpcsaBuffer->RemoteAddr.lpSockaddr); if (sa->addressFamily != AF_BTH) { // Address family is not AF_BTH for bluetooth device discovered continue; } //the MAC address is available in sa->btAddr printf("[HookExe] Device found\n"); if ((deviceFoundName != NULL) && (0 == _wcsicmp(deviceFoundName, convertCharArrayToLPCWSTR("btdevice")))) { printf("[HookExe] Found the device!\n"); printf("[HookExe] Device name is %S\t Device addr is 0x%0x\n", deviceFoundName, sa->btAddr); if (BluetoothIsConnectable(hLookup)) { //if (pResults->dwOutputFlags == BTHNS_RESULT_DEVICE_CONNECTED) { printf("[HookExe] Device is CONNECTED!!! 0x%0x \n", pResults->dwOutputFlags); } else { printf("[HookExe] Device is NOOOOOOOT CONNECTED!!! - 0x%0x\n", pResults->dwOutputFlags); } return true; } else { printf("[HookExe] Didn't find the device...\n"); printf("[HookExe] Device name is %S\t Device addr is 0x%0x\n", deviceFoundName, sa->btAddr); } } } WSALookupServiceEnd(hLookup); return false; }
//--------------------------------------------------------------------------- // FUNCTION: void DoRnrClient (int nServiceType, char * pszServerName, DWORD dwNameSpace) // // PURPOSE: Given the service type id "nServiceType", the server instance name // "pszServerName" and the name space to query "dwNameSpace", // perform name resolution to the server and send a message to it. // If "nServiceType" is some known SAP Id such as Print Queue (3), // File Server (4), Job Server (5), Print Server (7), Archive // Server (9), Remote Bridge Server (36) or Advertising Print Server // (71), it will not send a message to the server. //--------------------------------------------------------------------------- void DoRnrClient (int nServiceType, char * pszServerName, DWORD dwNameSpace) { static GUID guid = SVCID_NETWARE ( nServiceType ); //use this as the class id WSAQUERYSET qs = {0}; AFPROTOCOLS afp[g_nMaxNumOfSocks] = {{AF_IPX, NSPROTO_IPX}, {AF_INET, IPPROTO_UDP}, {AF_INET6, IPPROTO_UDP}}; HANDLE hLookup = NULL; DWORD dwResult = 0; static char szName[100] = {'\0'}; BOOL fKnownSapId = FALSE; DWORD dwLength = 0; BYTE abyBuf[sizeof(WSAQUERYSET) + OFFSET] = {0}; // provide a sufficient large // buffer for returned query set WSAQUERYSET * pQS = (WSAQUERYSETA*) abyBuf; HRESULT hRet; if(FAILED(hRet = StringCchCopy(szName, sizeof(szName)/sizeof(szName[0]), pszServerName ))) { printf("StringCchCopy failed: 0x%x\n",hRet); return; } SecureZeroMemory (&qs, sizeof (WSAQUERYSET)); qs.dwSize = sizeof (WSAQUERYSET); qs.lpszServiceInstanceName = szName; qs.lpServiceClassId = &guid; qs.dwNameSpace = dwNameSpace; qs.dwNumberOfProtocols = g_nMaxNumOfSocks; qs.lpafpProtocols = afp; SecureZeroMemory (abyBuf, sizeof (WSAQUERYSET) + OFFSET); dwLength = sizeof(WSAQUERYSET) + OFFSET; // some well known SAP name space services if (nServiceType == 3 || nServiceType == 4 || nServiceType == 5 || nServiceType == 7 || nServiceType == 9 || nServiceType == 36 || nServiceType == 71) fKnownSapId = TRUE; if (WSALookupServiceBegin ( &qs, LUP_RETURN_ADDR | LUP_RETURN_NAME, &hLookup) == SOCKET_ERROR) { PrintError("WSALookupServiceBegin"); return; } printf ("Performing Query for service (type, name) = (%d, %s) . . .\n\n", nServiceType, pszServerName); if (strcmp(pszServerName, "*") == 0) { // enumerate all service instances for (;;) { dwResult = WSALookupServiceNext(hLookup, 0, &dwLength, pQS); if (dwResult == SOCKET_ERROR) { if (WSAGetLastError() == WSAEFAULT) { printf("WSALookupServiceNext Error: Oops, we need a larger buffer size of : %d Bytes\n", dwLength); } else { PrintError("WSALookupServiceNext"); } WSALookupServiceEnd (hLookup); return; } if (!dwResult) { for (DWORD i = 0; i < pQS->dwNumberOfCsAddrs; i++) { SOCKADDR_STORAGE *mypt = (SOCKADDR_STORAGE *) pQS->lpcsaBuffer[i].RemoteAddr.lpSockaddr; if (mypt) { // we have valid remote sockaddr char temp[DEFAULT_STRING_LEN] = {'\0'}; printf ("Name[%d]: %30s", i, pQS->lpszServiceInstanceName); GetSockAddrString (mypt, pQS->lpcsaBuffer[i].RemoteAddr.iSockaddrLength, temp, DEFAULT_STRING_LEN); printf("%40s\n", temp); if (! fKnownSapId) ClientSend(&(pQS->lpcsaBuffer[i])); } } } } } else { dwResult = WSALookupServiceNext(hLookup, 0, &dwLength, pQS); if (dwResult == SOCKET_ERROR) { if (WSAGetLastError() == WSAEFAULT) { printf("WSALookupServiceNext Error: Oops, we need a larger buffer size of : %d Bytes\n", dwLength); } else { PrintError("WSALookupServiceNext"); } WSALookupServiceEnd (hLookup); return; } if (!dwResult) { for (DWORD i = 0; i < pQS->dwNumberOfCsAddrs; i++) { SOCKADDR_STORAGE *mypt = (SOCKADDR_STORAGE *) pQS->lpcsaBuffer[i].RemoteAddr.lpSockaddr; if (mypt) { // we have valid remote sockaddr char temp[DEFAULT_STRING_LEN] = {'\0'}; printf ("Name[%d]: %30s", i, pQS->lpszServiceInstanceName); GetSockAddrString (mypt, pQS->lpcsaBuffer[i].RemoteAddr.iSockaddrLength, temp, DEFAULT_STRING_LEN); printf("%40s\n", temp); if (! fKnownSapId) ClientSend(&(pQS->lpcsaBuffer[i])); } } } WSALookupServiceEnd (hLookup); } }
// // Function: main // // Description: // Initialize Winsock and set up the WSAQUERYSET structure // for querying DNS. We use the special GUID // SVCID_INET_HOSTADDRBYNAME for name resolution and we // query on the UDP and TCP protocols. The information // is returned as a BLOB so we must specify the LUP_RETURN_BLOB // flag. Once the call to WSALookupServiceBegin/Next is // successful then decode the BLOB data into a real HOSTENT // and print the results. // int main(int argc, char **argv) { WSADATA wsd; WSAQUERYSET *qs=NULL; char buff[RNR_BUFFER_SIZE]; GUID HostnameGuid = SVCID_INET_HOSTADDRBYNAME; HANDLE hRnr; AFPROTOCOLS afproto[2] = { {AF_INET, IPPROTO_UDP}, {AF_INET, IPPROTO_TCP} }; DWORD dwLength=RNR_BUFFER_SIZE; int ret, i; LPBLOB pvRet=NULL; HOSTENT *hp=NULL; SOCKADDR_IN addr; // Check for proper usage // if (argc != 2) { printf("usage: %s hostname\n", argv[0]); return -1; } // Load Winsock // if (WSAStartup(MAKEWORD(2,2), &wsd) != 0) { printf("WSAStartup() failed: %d\n", GetLastError()); return -1; } // Initalize the WSAQUERYSET structure for the query // qs = (WSAQUERYSET *)buff; memset(qs, 0, sizeof(*qs)); qs->dwSize = sizeof(WSAQUERYSET); qs->lpszServiceInstanceName = argv[1]; // name to resolve qs->lpServiceClassId = &HostnameGuid; qs->dwNameSpace = NS_ALL; // or ND_DNS qs->dwNumberOfProtocols = 2; // TCP and UDP qs->lpafpProtocols = afproto; ret = WSALookupServiceBegin(qs, LUP_RETURN_BLOB | LUP_RETURN_NAME, &hRnr); if (ret == NO_ERROR) { // We only have to call WSALookupServiceNext once because // the BLOB HOSTENT return will contain multiple addresses // if there are mutliple IP addresses associated with the // given name // ret = WSALookupServiceNext(hRnr, 0, &dwLength, qs); if (ret != NO_ERROR) { if (WSAGetLastError() == WSASERVICE_NOT_FOUND) { printf("No such name found!\n"); WSALookupServiceEnd(hRnr); return 0; } printf("WSALookupServiceNext() failed: %d\n", WSAGetLastError()); } WSALookupServiceEnd(hRnr); } // Make sure we got something returned // if (qs->lpBlob == NULL) return -1; // // Create our own buffer to hold the blob data // hp = (HOSTENT *)LocalAlloc(LPTR, qs->lpBlob->cbSize); if (!hp) { printf("LocalAlloc() failed: %d\n", GetLastError()); return -1; } memcpy(hp, qs->lpBlob->pBlobData, qs->lpBlob->cbSize); // // Unpack the BLOB data so its meaningful // UnpackHostEnt(hp); // // Print out the addresses // for(i=0; hp->h_addr_list[i] ;i++) { memcpy(&addr.sin_addr, hp->h_addr_list[i], hp->h_length); printf("%s IP: %s\n", argv[1], inet_ntoa(addr.sin_addr)); } for(i=0; hp->h_aliases[i] ;i++) printf("Alias: %s\n", hp->h_aliases[i]); // Cleanup // LocalFree(hp); WSACleanup(); return 0; }
void bluetoothDiscovery(ConnectivityBluetooth *conn) { //BOOL bHaveName; HANDLE hScan = INVALID_HANDLE_VALUE; WSAQUERYSET wsaq; BTHNS_INQUIRYBLOB queryBlob; queryBlob.LAP = BT_ADDR_GIAC; queryBlob.num_responses = 10; queryBlob.length = 12; BLOB blob; int count = 0; BthInquiryResult *p_inqRes; union { CHAR buf[4096]; SOCKADDR_BTH __unused; }; const BluetoothAddress *addr; blob.cbSize = sizeof(queryBlob); blob.pBlobData = (BYTE *) & queryBlob; ZeroMemory(&wsaq, sizeof(wsaq)); wsaq.dwSize = sizeof(wsaq); wsaq.dwNameSpace = NS_BTH; wsaq.lpcsaBuffer = NULL; wsaq.lpBlob = &blob; addr = conn->rootInterface->getAddress<BluetoothAddress>(); if (!addr) return; CM_DBG("Doing scan on device %s - %s\n", conn->rootInterface->getName(), addr->getStr()); if (ERROR_SUCCESS != WSALookupServiceBegin(&wsaq, LUP_CONTAINERS, &hScan)) { CM_DBG("WSALookupServiceBegin failed\n"); return; } // loop the results while (!conn->shouldExit()) { DWORD dwSize = sizeof(buf); LPWSAQUERYSET pwsaResults = (LPWSAQUERYSET) buf; ZeroMemory(pwsaResults, sizeof(WSAQUERYSET)); pwsaResults->dwSize = sizeof(WSAQUERYSET); pwsaResults->dwNameSpace = NS_BTH; pwsaResults->lpBlob = NULL; unsigned char macaddr[BT_ALEN]; string name = "bluetooth device"; bool report_interface = false; InterfaceStatus_t status; if (WSALookupServiceNext(hScan, LUP_RETURN_NAME | LUP_RETURN_ADDR | LUP_RETURN_BLOB, &dwSize, pwsaResults) != ERROR_SUCCESS) { CM_DBG("Found %d Haggle devices\n", count); break; } p_inqRes = (BthInquiryResult *) pwsaResults->lpBlob->pBlobData; BT_ADDR btAddr = ((SOCKADDR_BTH *) pwsaResults->lpcsaBuffer->RemoteAddr.lpSockaddr)->btAddr; if (pwsaResults->lpszServiceInstanceName && *(pwsaResults->lpszServiceInstanceName)) { int namelen = wcslen(pwsaResults->lpszServiceInstanceName) + 1; char *tmp = new char[namelen]; wcstombs(tmp, pwsaResults->lpszServiceInstanceName, namelen); name.clear(); name = tmp; delete[] tmp; } btAddr2Mac(btAddr, macaddr); BluetoothAddress addr(macaddr); status = conn->is_known_interface(Interface::TYPE_BLUETOOTH, macaddr); if (status == INTERFACE_STATUS_HAGGLE) { report_interface = true; } else if (status == INTERFACE_STATUS_UNKNOWN) { //int ret = DetectRFCommChannel(&btAddr); int ret = findHaggleService(&btAddr); if (ret > 0) { report_interface = true; conn->report_known_interface(Interface::TYPE_BLUETOOTH, macaddr, true); } else if (ret == 0) { conn->report_known_interface(Interface::TYPE_BLUETOOTH, macaddr, false); } } if (report_interface) { CM_DBG("Found Haggle Bluetooth device [%s:%s]\n", addr.getStr(), name.c_str()); BluetoothInterface foundInterface(macaddr, name, &addr, IFFLAG_UP); conn->report_interface(&foundInterface, conn->rootInterface, new ConnectivityInterfacePolicyTTL(2)); count++; } else { CM_DBG("Bluetooth device [%s] is not a Haggle device\n", addr.getStr()); } } // cleanup WSALookupServiceEnd(hScan); return; }
/* Some code stolen from BlueCove. */ static int findHaggleService(BT_ADDR *pb) { BTHNS_RESTRICTIONBLOB queryservice; unsigned char uuid[] = HAGGLE_BLUETOOTH_SDP_UUID; BLOB blob; WSAQUERYSET queryset; SOCKADDR_BTH sa; HANDLE hLookupSearchServices; int found = 0; memset(&queryservice, 0, sizeof(queryservice)); queryservice.type = SDP_SERVICE_SEARCH_REQUEST; convertUUIDBytesToGUID((char *) uuid, &queryservice.uuids[0].u.uuid128); //UUID is full 128 bits queryservice.uuids[0].uuidType = SDP_ST_UUID128; // build BLOB pointing to service query blob.cbSize = sizeof(queryservice); blob.pBlobData = (BYTE *) & queryservice; // build query memset(&queryset, 0, sizeof(WSAQUERYSET)); queryset.dwSize = sizeof(WSAQUERYSET); queryset.dwNameSpace = NS_BTH; queryset.lpBlob = &blob; // Build address memset(&sa, 0, sizeof(sa)); sa.addressFamily = AF_BT; sa.btAddr = *pb; CSADDR_INFO csai; memset(&csai, 0, sizeof(csai)); csai.RemoteAddr.lpSockaddr = (sockaddr *) &sa; csai.RemoteAddr.iSockaddrLength = sizeof(sa); queryset.lpcsaBuffer = &csai; // begin query if (WSALookupServiceBegin(&queryset, 0, &hLookupSearchServices)) { int last_error = WSAGetLastError(); CM_DBG("WSALookupServiceBegin error [%s]", StrError(last_error)); return -1; } // fetch results int bufSize = 0x2000; void *buf = malloc(bufSize); if (buf == NULL) { WSALookupServiceEnd(hLookupSearchServices); return NULL; } memset(buf, 0, bufSize); LPWSAQUERYSET pwsaResults = (LPWSAQUERYSET) buf; pwsaResults->dwSize = sizeof(WSAQUERYSET); pwsaResults->dwNameSpace = NS_BTH; pwsaResults->lpBlob = NULL; DWORD size = bufSize; if (WSALookupServiceNext(hLookupSearchServices, LUP_RETURN_TYPE | LUP_RETURN_BLOB | LUP_RETURN_ADDR, &size, pwsaResults)) { int last_error = WSAGetLastError(); switch (last_error) { case WSANO_DATA: //HAGGLE_DBG("SDP: no data\n"); found = -1; break; case WSA_E_NO_MORE: //HAGGLE_DBG("End of SDP list\n"); break; case WSAENOTCONN: found = -1; HAGGLE_DBG("Could not connect to SDP service\n"); break; case WSASERVICE_NOT_FOUND: found = 0; HAGGLE_DBG("SDP Service not found\n"); break; default: CM_DBG("WSALookupServiceNext error [%s]\n", StrError(last_error)); found = -1; } } else { unsigned long cChannel = 0; found = 1; HAGGLE_DBG("Found Haggle service\n"); if (ERROR_SUCCESS == FindRFCOMMChannel( pwsaResults->lpBlob->pBlobData, pwsaResults->lpBlob->cbSize, &cChannel)) { HAGGLE_DBG("RFCOMM channel is %d\n", (int)cChannel); found = cChannel; } } WSALookupServiceEnd(hLookupSearchServices); free(buf); return found; }
int DNSlookup_name( const char *name, int ai_family, struct hostent **Addresses ) { char buffer[sizeof(WSAQUERYSET) + 2048]; WSAQUERYSET query; struct hostent *addr = NULL; char *bufaddr = NULL; char ** addrlist = &bufaddr; int addrcnt = 0; WSAQUERYSET *results = (WSAQUERYSET *) buffer; GUID HostnameGUID = SVCID_INET_HOSTADDRBYNAME; HANDLE handle; DWORD dwLength; int err = 0; int retcode = 0; int errcode = 0; DWORD i; /* * First we must create a query set */ memset(&query, 0, sizeof(query)); query.dwSize = sizeof(query); query.lpszServiceInstanceName = (char *)name; query.dwNameSpace = NS_DNS; query.lpServiceClassId = &HostnameGUID; err = WSALookupServiceBegin(&query, LUP_RETURN_NAME | LUP_RETURN_BLOB | LUP_RETURN_ADDR, &handle); if(err == SOCKET_ERROR) { /* * Convert the error code and return */ return (ReturnCode(WSAGetLastError())); } /* * Initially none * Change if we get something */ retcode = EAI_NONAME; dwLength = sizeof(buffer); while(err == 0) /* Drop out when error */ { memset(&buffer, 0, dwLength); err = WSALookupServiceNext( handle, 0, &dwLength, results); errcode = WSAGetLastError(); if (results->dwNumberOfCsAddrs > 0) { if (addr == NULL) { addr = (struct hostent *) malloc(sizeof(struct hostent)); memset(addr, 0, sizeof(struct hostent)); addr->h_addrtype = (short) results->lpcsaBuffer->iSocketType; addr->h_length = sizeof(struct in_addr); /* Only passing back the address */ addrlist = malloc(sizeof(char *)); *addrlist = NULL; } for (i = 0; i < results->dwNumberOfCsAddrs; i++) { AddToAddresses(addrlist, &addrcnt, &results->lpcsaBuffer[i]); } } } if (addr != NULL) { addr->h_name = (char *) name; addr->h_addr_list = addrlist; retcode = 0; *Addresses = addr; } else { #ifdef FORCE_DNSRETRY /* * We do this or the error would never be logged */ if (errcode == WSANO_DATA) msyslog(LOG_ERR, "Address not found for %s", name); #endif retcode = ReturnCode(errcode); } WSALookupServiceEnd(handle); return (retcode); }
// This just redundant!!!! // // TODO: use inquiry timeout SDP_DEFAULT_INQUIRY_SECONDS // NameToBthAddr converts a bluetooth device name to a bluetooth address, // if required by performing inquiry with remote name requests. // This function demonstrates device inquiry, with optional LUP flags. ULONG NameToBthAddr(const char * pszRemoteName, BTH_ADDR * pRemoteBtAddr) { INT iResult = 0, iRetryCount = 0; BOOL bContinueLookup = FALSE, bRemoteDeviceFound = FALSE; ULONG ulFlags = 0, ulPQSSize = sizeof(WSAQUERYSET); HANDLE hLookup = 0; PWSAQUERYSET pWSAQuerySet = NULL; if ((pszRemoteName == NULL) || (pRemoteBtAddr == NULL)) { printf("Remote name or address is NULL!\n"); goto CleanupAndExit; } if ((pWSAQuerySet = (PWSAQUERYSET)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ulPQSSize)) == NULL) { printf("!ERROR! | Unable to allocate memory for WSAQUERYSET!\n"); goto CleanupAndExit; } else printf("HeapAlloc() for WSAQUERYSET is OK!\n"); // Search for the device with the correct name for (iRetryCount = 0; !bRemoteDeviceFound && (iRetryCount < CXN_MAX_INQUIRY_RETRY); iRetryCount++) { // WSALookupServiceXXX() is used for both service search and device inquiry // LUP_CONTAINERS is the flag which signals that we're doing a device inquiry. ulFlags = LUP_CONTAINERS; // Friendly device name (if available) will be returned in lpszServiceInstanceName ulFlags |= LUP_RETURN_NAME; // BTH_ADDR will be returned in lpcsaBuffer member of WSAQUERYSET ulFlags |= LUP_RETURN_ADDR; // Similar to: // ulFlags = LUP_CONTAINERS | LUP_RETURN_NAME | LUP_RETURN_ADDR; if (iRetryCount == 0) { printf("*INFO* | Inquiring device from cache...\n"); } else { // Flush the device cache for all inquiries, except for the first inquiry // // By setting LUP_FLUSHCACHE flag, we're asking the lookup service to do // a fresh lookup instead of pulling the information from device cache. ulFlags |= LUP_FLUSHCACHE; // Pause for some time before all the inquiries after the first inquiry // // Remote Name requests will arrive after device inquiry has // completed. Without a window to receive IN_RANGE notifications, // we don't have a direct mechanism to determine when remote // name requests have completed. printf("*INFO* | Unable to find device. Waiting for %d seconds before re-inquiry...\n", CXN_DELAY_NEXT_INQUIRY); printf("I am sleeping for a while...\n"); Sleep(CXN_DELAY_NEXT_INQUIRY * 1000); printf("*INFO* | Inquiring device ...\n"); } // Start the lookup service iResult = 0; hLookup = 0; bContinueLookup = FALSE; ZeroMemory(pWSAQuerySet, ulPQSSize); pWSAQuerySet->dwNameSpace = NS_BTH; pWSAQuerySet->dwSize = sizeof(WSAQUERYSET); iResult = WSALookupServiceBegin(pWSAQuerySet, ulFlags, &hLookup); if ((iResult == NO_ERROR) && (hLookup != NULL)) { printf("WSALookupServiceBegin() is fine!\n"); bContinueLookup = TRUE; } else if (0 < iRetryCount) { printf("=CRITICAL= | WSALookupServiceBegin() failed with error code %d, Error = %d\n", iResult, WSAGetLastError()); goto CleanupAndExit; } while (bContinueLookup) { // Get information about next bluetooth device // // Note you may pass the same WSAQUERYSET from LookupBegin // as long as you don't need to modify any of the pointer // members of the structure, etc. // // ZeroMemory(pWSAQuerySet, ulPQSSize); // pWSAQuerySet->dwNameSpace = NS_BTH; // pWSAQuerySet->dwSize = sizeof(WSAQUERYSET); if (WSALookupServiceNext(hLookup, ulFlags, &ulPQSSize, pWSAQuerySet) == NO_ERROR) { printf("WSALookupServiceNext() is OK lol!\n"); if ((pWSAQuerySet->lpszServiceInstanceName != NULL)) { // Found a remote bluetooth device with matching name. // Get the address of the device and exit the lookup. printf("Again, remote name: %S\n", pWSAQuerySet->lpszServiceInstanceName); // Need to convert to the 'standard' address format printf("Local address: %012X\n", pWSAQuerySet->lpcsaBuffer->LocalAddr); printf("Remote address: %012X\n", pWSAQuerySet->lpcsaBuffer->RemoteAddr); CopyMemory(pRemoteBtAddr, &((PSOCKADDR_BTH)pWSAQuerySet->lpcsaBuffer->RemoteAddr.lpSockaddr)->btAddr, sizeof(*pRemoteBtAddr)); bRemoteDeviceFound = TRUE; bContinueLookup = FALSE; } } else { if ((iResult = WSAGetLastError()) == WSA_E_NO_MORE) //No more data { // No more devices found. Exit the lookup. printf("No more device found...\n"); bContinueLookup = FALSE; } else if (iResult == WSAEFAULT) { // The buffer for QUERYSET was insufficient. // In such case 3rd parameter "ulPQSSize" of function "WSALookupServiceNext()" receives // the required size. So we can use this parameter to reallocate memory for QUERYSET. HeapFree(GetProcessHeap(), 0, pWSAQuerySet); pWSAQuerySet = NULL; if (NULL == (pWSAQuerySet = (PWSAQUERYSET)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ulPQSSize))) { printf("!ERROR! | Unable to allocate memory for WSAQERYSET...\n"); bContinueLookup = FALSE; } else printf("HeapAlloc() for WSAQERYSET is OK!\n"); } else { printf("=CRITICAL= | WSALookupServiceNext() failed with error code %d\n", iResult); bContinueLookup = FALSE; } } } // End the lookup service WSALookupServiceEnd(hLookup); } CleanupAndExit: if (NULL != pWSAQuerySet) { HeapFree(GetProcessHeap(), 0, pWSAQuerySet); pWSAQuerySet = NULL; } if (bRemoteDeviceFound) { return(0); } else { return(1); } }