#include "Mp_Precomp.h" #include "P2PSvc_Internal.h" #if (P2P_SUPPORT == 1) #if (P2PSVC_SUPPORT == 1) //----------------------------------------------------------------------------- // Local //----------------------------------------------------------------------------- u4Byte p2psvc_EvalSearchResultObjListLen( IN POCTET_STRING posP2PAttrs, IN OCTET_STRING osAdvSvcInfo, IN u4Byte svcInfoLen, OUT pu1Byte pnAdvSvc ) { u4Byte reqBufSize = 0; OCTET_STRING osDevName = {NULL, 0}; u4Byte totalSvcNameLen_1 = 0; u4Byte totalSvcNameLen_2 = 0; u1Byte nAdvSvc = 0; do { u4Byte idxAdvSvcInfoBuf = 0; if(RT_STATUS_SUCCESS != P2PSvc_GetDevNameFromDevInfoAttr(posP2PAttrs, &osDevName)) { break; } //RT_PRINT_DATA(COMP_P2P, DBG_LOUD, "osAdvSvcInfo:\n", osAdvSvcInfo.Octet, osAdvSvcInfo.Length); while(idxAdvSvcInfoBuf < osAdvSvcInfo.Length) { u1Byte curSvcNameLen = 0; // adv-id idxAdvSvcInfoBuf += 4; // config-method (addendm v0.43) idxAdvSvcInfoBuf += 2; // svc-name-len curSvcNameLen = (*(pu1Byte)(osAdvSvcInfo.Octet + idxAdvSvcInfoBuf)); totalSvcNameLen_2 += curSvcNameLen; idxAdvSvcInfoBuf += 1; // svc-name //RT_PRINT_STR(COMP_P2P, DBG_LOUD, "svc-name:\n", osAdvSvcInfo.Octet + i, curSvcNameLen); idxAdvSvcInfoBuf += curSvcNameLen; // TODO: shall check if the svc matches our req because hashes of other seek req may be carried in our ProbeReq so we may get more svc names then we actually want nAdvSvc++; } totalSvcNameLen_1 = osAdvSvcInfo.Length - (nAdvSvc * (4 + 2 + 1)); // minus adv-id(4), config-method(2) and svc-name-length(1) if(totalSvcNameLen_1 != totalSvcNameLen_2) { //RT_TRACE_F(COMP_P2P, DBG_WARNING, ("[WARNING] totalSvcNameLen_1(%u) != totalSvcNameLen_2(%u)\n", totalSvcNameLen_1, totalSvcNameLen_2)); //RT_PRINT_DATA(COMP_P2P, DBG_WARNING, "osAdvSvcInfo:\n", osAdvSvcInfo.Octet, osAdvSvcInfo.Length); break; } reqBufSize = 0; reqBufSize += FIELD_OFFSET(P2PSVC_OBJ_LIST, varStart); reqBufSize += (RT_OBJECT_HEADER_SIZE + 1); // search-id reqBufSize += (RT_OBJECT_HEADER_SIZE + 6); // dev-addr reqBufSize += (RT_OBJECT_HEADER_SIZE + osDevName.Length); // dev-name, no more than 32 reqBufSize += (RT_OBJECT_HEADER_SIZE + sizeof(u1Byte)); // svc count reqBufSize += (RT_OBJECT_HEADER_SIZE + sizeof(BOOLEAN)); // is SD done reqBufSize += nAdvSvc * (FIELD_OFFSET(P2PSVC_OBJ_LIST, varStart)); reqBufSize += nAdvSvc * (RT_OBJECT_HEADER_SIZE + 4); // adv-id reqBufSize += nAdvSvc * (RT_OBJECT_HEADER_SIZE + 2); // config-method (addendum v0.43) reqBufSize += (nAdvSvc * (RT_OBJECT_HEADER_SIZE)) + totalSvcNameLen_1; // svc-name if(pnAdvSvc) *pnAdvSvc = nAdvSvc; }while(FALSE); return reqBufSize; } //----------------------------------------------------------------------------- // Exported //----------------------------------------------------------------------------- VOID P2PSvc_Free_SearchResultObjList( IN PRT_LIST_ENTRY pListHead, IN pu4Byte pListCnt ) { while(RTIsListNotEmpty(pListHead)) { PVOID pEntry = NULL; PP2PSVC_SR_LIST_ENTRY pSREntry = NULL; pEntry = RTRemoveHeadListWithCnt(pListHead, pListCnt); pSREntry = (PP2PSVC_SR_LIST_ENTRY)pEntry; P2PSvc_FreeMem(pEntry, P2PSVC_SR_LIST_LEN(pSREntry)); } } BOOLEAN P2PSvc_ToProcessProbeRsp( IN PP2PSVC_INFO pP2PSvcInfo, IN u1Byte searchId, IN pu1Byte devAddr ) { RT_STATUS rtStatus = RT_STATUS_SUCCESS; PP2PSVC_SR_LIST_ENTRY pSREntryInList = NULL; BOOLEAN bAccept = FALSE; do { if(RT_STATUS_SUCCESS != (rtStatus = P2PSvc_GetSearchResult(pP2PSvcInfo, searchId, devAddr, &pSREntryInList))) { break; } if(NULL == pSREntryInList) { bAccept = TRUE; break; } else {// already have an entry in search result list u8Byte curTime = PlatformGetCurrentTime(); RT_TRACE_F(COMP_P2P, DBG_TRACE, ("curTime: %I64u, lastProbeRspTime: %I64u\n", curTime, pSREntryInList->probeRspRxTime)); // Check if we receive a bunch of probe rsp in a very short time if(curTime - pSREntryInList->probeRspRxTime < P2PSVC_LEAST_PROBE_RSP_TIME_uS) { break; } // Check if we have a outstanding SD req, if we process the probe rsp in this case, we'll send another SD req and may flood the channel if(0 != pSREntryInList->sdReqTxTime && 0 == pSREntryInList->sdRspRxTime) {// we've sent SD req but SD rsp is not yet recvd // Check if we've recv SD rsp within timeout if(P2PSVC_TIMEOUT_WAIT_SD_RSP_uS < curTime - pSREntryInList->sdReqTxTime) { // Prefast warning #pragma warning( disable:6328 ) RT_TRACE_F(COMP_P2P, DBG_LOUD, ("Timeout waiting for SD rsp, try again by accept probe rsp, sdReqTxTime: %u\n", pSREntryInList->sdReqTxTime)); RT_PRINT_ADDR(COMP_P2P, DBG_LOUD, "Target dev addr:\n", devAddr); pSREntryInList->sdReqTxTime = 0; bAccept = TRUE; break; } else {// still waiting for SD rsp break; } } // Check if we've received a SD rsp from peer and we don't want the content of this probe rsp to cover the content of SD rsp if(0 != pSREntryInList->sdRspRxTime) {// we've received a SD rsp RT_TRACE_F(COMP_P2P, DBG_TRACE, ("Drop for we got SD rsp already\n")); break; } } }while(FALSE); if(bAccept) { RT_TRACE_F(COMP_P2P, DBG_LOUD, ("Accept probe rsp\n")); } return bAccept; } // // Description: // Search the search result list with search id and devAddr as the key. // If entry found, the pointer to the entry is returned. // If not found, the pointer is set to NULL. // RT_STATUS P2PSvc_GetSearchResult( IN PP2PSVC_INFO pP2PSvcInfo, IN u1Byte searchId, IN pu1Byte devAddr, OUT PP2PSVC_SR_LIST_ENTRY *ppSREntry ) { RT_STATUS rtStatus = RT_STATUS_SUCCESS; PRT_LIST_ENTRY pEntry = NULL; if(ppSREntry) *ppSREntry = NULL; do { for(pEntry = RTGetHeadList(&pP2PSvcInfo->searchResultList); pEntry != &pP2PSvcInfo->searchResultList; pEntry = RTNextEntryList(pEntry)) { PP2PSVC_SR_LIST_ENTRY pSREntry = (PP2PSVC_SR_LIST_ENTRY)pEntry; PRT_OBJECT_HEADER pSearchIdObj = NULL; PRT_OBJECT_HEADER pDevAddrObj = NULL; // Match search id if(NULL == (pSearchIdObj = P2PSvc_GetParam(&pSREntry->srObjList, P2PSVC_OBJ_HDR_ID_DATA_SEARCH_ID, 0))) { rtStatus = RT_STATUS_INVALID_DATA; break; } if(searchId != *(pu1Byte)pSearchIdObj->Value) { continue;; } // Match dev addr if(NULL == (pDevAddrObj = P2PSvc_GetParam(&pSREntry->srObjList, P2PSVC_OBJ_HDR_ID_DATA_DEV_ADDR, 0))) { rtStatus = RT_STATUS_INVALID_DATA; break; } if(!eqMacAddr(devAddr, pDevAddrObj->Value)) { continue; } // Target found if(ppSREntry) *ppSREntry = pSREntry; break; } if(RT_STATUS_SUCCESS != rtStatus) break; }while(FALSE); return rtStatus; } BOOLEAN P2PSvc_SeekReqNeedSD( IN PP2PSVC_OBJ_LIST pSeekObjList, IN PP2PSVC_SR_LIST_ENTRY pSREntryInList, OUT PRT_OBJECT_HEADER *ppSvcInfoReqObj ) { PRT_OBJECT_HEADER pSeekSvcInfoReqObj = NULL; PRT_OBJECT_HEADER pSvcDescObjList = NULL; PRT_OBJECT_HEADER pSvcInfoObj = NULL; BOOLEAN bNeedSD = FALSE; do { //4 Check if seek req contains svc-info-req if(NULL == (pSeekSvcInfoReqObj = P2PSvc_GetParam(pSeekObjList, P2PSVC_OBJ_HDR_ID_DATA_SVC_INFO_REQ, 0))) {// shall not happen break; } if(0 == pSeekSvcInfoReqObj->Length) { PRT_OBJECT_HEADER pSeekSvcNameObj = NULL; if(NULL == (pSeekSvcNameObj = P2PSvc_GetParam(pSeekObjList, P2PSVC_OBJ_HDR_ID_DATA_SVC_NAME, 0))) {// shall not happen break; } if('*' == *((pu1Byte)pSeekSvcNameObj->Value + pSeekSvcNameObj->Length - 1)) {// ended with *, assume UTF-8 encode of * uses only a single byte bNeedSD = TRUE; break; } break; } //4 Check if we've already done SD // Get a svc desc if(NULL == (pSvcDescObjList = P2PSvc_GetParam(&pSREntryInList->srObjList, P2PSVC_OBJ_HDR_ID_DATA_SVC_DESC_LIST, 0))) { break; } // Check if the svc desc has svc-info if(NULL == (pSvcInfoObj = P2PSvc_GetParam((PP2PSVC_OBJ_LIST)pSvcDescObjList, P2PSVC_OBJ_HDR_ID_DATA_SVC_INFO, 0))) { bNeedSD = TRUE; break; } else {// already got svc-info from peer by SD break; } }while(FALSE); if(bNeedSD) { if(ppSvcInfoReqObj) *ppSvcInfoReqObj = pSeekSvcInfoReqObj; } return bNeedSD; } // // Description: // Update search result list if // 1. the input entry can be found in the list and the content is different // 2. the input entry can't be found in the list // // Return the entry in the list if no error occurs. // RT_STATUS P2PSvc_UpdateSearchResult( IN PP2PSVC_INFO pP2PSvcInfo, IN u1Byte searchId, IN pu1Byte devAddr, IN PP2PSVC_SR_LIST_ENTRY pSREntryToUpdate, OUT PBOOLEAN pbDuplicatedEntry, OUT PP2PSVC_SR_LIST_ENTRY *ppSREntryOut ) { RT_STATUS rtStatus = RT_STATUS_SUCCESS; PP2PSVC_SR_LIST_ENTRY pSREntryInList = NULL; do { if(ppSREntryOut) *ppSREntryOut = NULL; if(RT_STATUS_SUCCESS != (rtStatus = P2PSvc_GetSearchResult(pP2PSvcInfo, searchId, devAddr, &pSREntryInList))) { break; } if(pSREntryInList) {// remove the old one and insert the new to the head if(P2PSVC_OBJ_LIST_LEN(&pSREntryToUpdate->srObjList) == P2PSVC_OBJ_LIST_LEN(&pSREntryInList->srObjList) && 0 == PlatformCompareMemory(&pSREntryToUpdate->srObjList, &pSREntryInList->srObjList, P2PSVC_OBJ_LIST_LEN(&pSREntryToUpdate->srObjList))) {// has same entry in the list if(ppSREntryOut) *ppSREntryOut = pSREntryInList; if(pbDuplicatedEntry) *pbDuplicatedEntry = TRUE; } else {// different => replace the entry PRT_LIST_ENTRY pEntry = (PRT_LIST_ENTRY)pSREntryInList; PRT_LIST_ENTRY pForeEntry = RTForeEntryList(pEntry); RTRemoveEntryListWithCnt(pEntry, &pP2PSvcInfo->searchResultListCnt); P2PSvc_FreeMem(pSREntryInList, P2PSVC_SR_LIST_LEN(pSREntryInList)); pEntry = pForeEntry; RTInsertHeadListWithCnt(&pP2PSvcInfo->searchResultList, &pSREntryToUpdate->List, &pP2PSvcInfo->searchResultListCnt); RT_PRINT_DATA(COMP_P2P, DBG_LOUD, "Update SR entry:\n", pSREntryToUpdate, P2PSVC_SR_LIST_LEN(pSREntryToUpdate)); if(ppSREntryOut) *ppSREntryOut = pSREntryToUpdate; } } else {// entry not found in the search result list RTInsertHeadListWithCnt(&pP2PSvcInfo->searchResultList, &pSREntryToUpdate->List, &pP2PSvcInfo->searchResultListCnt); if(ppSREntryOut) *ppSREntryOut = pSREntryToUpdate; } }while(FALSE); return rtStatus; } // // Description: // Make search result data from ProbeRsp, memory is allocated, // svc-info is empty. // // Fixed fields including: // search-id, dev-addr, dev-name, // // Var fields describing each services advertised by the dev are: // adv-id, svc-name, (no svc-info), svc-status // // The advertised svc desc carried in advertised svc info attr contains: // adv-id, svc-name-len, svc-name // // Indicate seek result event including the following info: // 1. search-id (4) // 2. dev-addr (6) // 3. dev-name (n, n <= 32) //---------------------------- // 4. adv-id (4) // 5. config-method (2) (addendum v0.43) // 6. svc-name (n, n <= 255) // 7. svc-info (n, n <= 65535) // 8. svc-status (1) // RT_STATUS P2PSvc_MakeSearchResultDataFromProbeRsp( IN PP2PSVC_INFO pP2PSvcInfo, IN PP2PSVC_REQ_INFO_ENTRY pSeekInfoEntry, IN pu1Byte devAddr, IN POCTET_STRING posP2PAttrs, IN OCTET_STRING osAdvSvcInfo, OUT PP2PSVC_SR_LIST_ENTRY *ppSREntryOut ) { RT_STATUS rtStatus = RT_STATUS_SUCCESS; PP2PSVC_OBJ_LIST pObjList = NULL; PP2PSVC_SR_LIST_ENTRY pSREntry = NULL; u4Byte reqBufSize = 0; P2PSVC_CHECK_NULL(ppSREntryOut); P2PSVC_FUNC_IN(DBG_TRACE); do { u4Byte idxAdvSvc = 0, idxAdvSvcInfoBuf = 0; u1Byte nAdvSvc = 0; *ppSREntryOut = NULL; if(0 == (reqBufSize = p2psvc_EvalSearchResultObjListLen(posP2PAttrs, osAdvSvcInfo, 0, &nAdvSvc))) { rtStatus = RT_STATUS_INVALID_DATA; break; } reqBufSize += FIELD_OFFSET(P2PSVC_SR_LIST_ENTRY, srObjList); if(RT_STATUS_SUCCESS != (rtStatus = P2PSvc_AllocMem(pP2PSvcInfo->pAdapter, &pSREntry, reqBufSize))) { RT_TRACE_F(COMP_P2P, DBG_WARNING, ("[WARNING] Failed to allocate memory for pSREntry\n")); break; } RT_TRACE_F(COMP_P2P, DBG_LOUD, ("alloc mem for size: %u\n", reqBufSize)); PlatformFillMemory(pSREntry, reqBufSize, 0xFE); pSREntry->probeRspRxTime = 0; pSREntry->sdReqTxTime = 0; pSREntry->sdRspRxTime = 0; pSREntry->bDirty = FALSE; pObjList = &pSREntry->srObjList; P2PSVC_OBJ_LIST_INIT(pObjList, RT_OB_HDR_TYPE_DATA, P2PSVC_OBJ_HDR_ID_INDIC_SEARCH_RESULT, P2PSVC_MIN_SUPPORT_VER); //1 Note that because we have search id in the obj, the search result would belong to a specific seek req // Make required objs, nObjs is updated accordingly if(0 == P2PSvc_MakeSearchIdObj(pObjList, pSeekInfoEntry, NULL)) {rtStatus = RT_STATUS_INVALID_DATA ; break;} if(0 == P2PSvc_MakeDevAddrObj(pObjList, devAddr)) {rtStatus = RT_STATUS_INVALID_DATA ; break;} if(0 == P2PSvc_MakeDevNameObj_FromP2PAttrs(pObjList, posP2PAttrs)) {rtStatus = RT_STATUS_INVALID_DATA ; break;} if(0 == P2PSvc_MakeSvcCountObj(pObjList, nAdvSvc)) {rtStatus = RT_STATUS_INVALID_DATA ; break;} if(0 == P2PSvc_MakeIsSDDoneObj(pObjList, FALSE)) {rtStatus = RT_STATUS_INVALID_DATA ; break;} // Make svc desc obj list for each svc found for(idxAdvSvc = 0, idxAdvSvcInfoBuf = 0; idxAdvSvc < nAdvSvc; idxAdvSvc++) { PP2PSVC_OBJ_LIST pSvcDescObjList = NULL; u1Byte svcNameLen = 0; if(0 == P2PSvc_MakeSvcDescObjList(pObjList, &pSvcDescObjList)) {rtStatus = RT_STATUS_INVALID_DATA ; break;} // adv-id P2PSvc_MakeAdvIdObj(pSvcDescObjList, *((pu4Byte)(osAdvSvcInfo.Octet + idxAdvSvcInfoBuf))); idxAdvSvcInfoBuf += 4; // config-method (addendum v0.43) P2PSvc_MakeConfigMethodObj(pSvcDescObjList, *((pu2Byte)(osAdvSvcInfo.Octet + idxAdvSvcInfoBuf))); idxAdvSvcInfoBuf += 2; svcNameLen = *((pu1Byte)(osAdvSvcInfo.Octet + idxAdvSvcInfoBuf)); idxAdvSvcInfoBuf += 1; // svc-name P2PSvc_MakeSvcNameObj(pSvcDescObjList, svcNameLen, osAdvSvcInfo.Octet + idxAdvSvcInfoBuf); idxAdvSvcInfoBuf += svcNameLen; pObjList->hdr.Length += P2PSVC_OBJ_LIST_VAR_LEN(pSvcDescObjList); } if(RT_STATUS_SUCCESS != rtStatus) { break; } *ppSREntryOut = pSREntry; RT_PRINT_DATA(COMP_P2P, DBG_TRACE, "P2PSvc_MakeSearchResultDataFromProbeRsp():\n", pObjList, P2PSVC_OBJ_LIST_LEN(pObjList)); }while(FALSE); if(RT_STATUS_SUCCESS != rtStatus) { if(pSREntry) P2PSvc_FreeMem(pSREntry, reqBufSize); *ppSREntryOut = NULL; } P2PSVC_FUNC_OUT(DBG_TRACE, rtStatus); return rtStatus; } RT_STATUS P2PSvc_MakeSearchResultDataFromSDRsp( IN PP2PSVC_INFO pP2PSvcInfo, IN u1Byte searchId, IN pu1Byte devAddr, IN PP2P_SERVICE_RSP_TLV pSvcRspTlv, OUT PP2PSVC_SR_LIST_ENTRY *ppSREntryOut ) { RT_STATUS rtStatus = RT_STATUS_SUCCESS; PP2PSVC_SR_LIST_ENTRY pOldSREntry = NULL; PP2PSVC_SR_LIST_ENTRY pNewSREntry = NULL; PP2PSVC_OBJ_LIST pOldObjList = NULL; PP2PSVC_OBJ_LIST pNewObjList = NULL; u4Byte reqBufSize = 0; P2PSVC_CHECK_NULL(ppSREntryOut); P2PSVC_FUNC_IN(DBG_LOUD); do { u1Byte svcNameLen = 0; pu1Byte pSvcNameBuf = NULL; u4Byte advId = 0; u1Byte svcStatus = 0; u2Byte svcInfoLen = 0; pu1Byte pSvcInfoBuf = NULL; u1Byte nSvcInfoDesc = 0; u4Byte totalSvcNameLen = 0; u4Byte totalSvcInfoLen = 0; PRT_OBJECT_HEADER pSearchIdObj = NULL; PRT_OBJECT_HEADER pDevAddrObj = NULL; PRT_OBJECT_HEADER pDevNameObj = NULL; PRT_OBJECT_HEADER pIsSDDoneObj = NULL; u1Byte idxSvcInfoDesc = 0; while(RT_STATUS_SUCCESS == P2PSvc_ParseAnqpQueryRsp(pSvcRspTlv, nSvcInfoDesc, &svcNameLen, &pSvcNameBuf, &advId, &svcStatus, &svcInfoLen, &pSvcInfoBuf)) { totalSvcNameLen += svcNameLen; totalSvcInfoLen += svcInfoLen; nSvcInfoDesc++; } if(RT_STATUS_SUCCESS != (rtStatus = P2PSvc_GetSearchResult(pP2PSvcInfo, searchId, devAddr, &pOldSREntry))) { break; } pOldObjList = &pOldSREntry->srObjList; pSearchIdObj = P2PSvc_GetParam(pOldObjList, P2PSVC_OBJ_HDR_ID_DATA_SEARCH_ID, 0); pDevAddrObj = P2PSvc_GetParam(pOldObjList, P2PSVC_OBJ_HDR_ID_DATA_DEV_ADDR, 0); pDevNameObj = P2PSvc_GetParam(pOldObjList, P2PSVC_OBJ_HDR_ID_DATA_DEV_NAME, 0); pIsSDDoneObj = P2PSvc_GetParam(pOldObjList, P2PSVC_OBJ_HDR_ID_DATA_IS_SD_DONE, 0); if(pIsSDDoneObj && FALSE == *(PBOOLEAN)pIsSDDoneObj->Value) { *(PBOOLEAN)pIsSDDoneObj->Value = TRUE; } reqBufSize = 0; reqBufSize += FIELD_OFFSET(P2PSVC_SR_LIST_ENTRY, srObjList); reqBufSize += FIELD_OFFSET(P2PSVC_OBJ_LIST, varStart); reqBufSize += (RT_OBJECT_HEADER_SIZE + 1); // search-id reqBufSize += (RT_OBJECT_HEADER_SIZE + 6); // dev-addr reqBufSize += (RT_OBJECT_HEADER_SIZE + pDevNameObj->Length); // dev-name, no more than 32 reqBufSize += (RT_OBJECT_HEADER_SIZE + 1); // svc count reqBufSize += (RT_OBJECT_HEADER_SIZE + sizeof(BOOLEAN)); // is SD done reqBufSize += nSvcInfoDesc * (FIELD_OFFSET(P2PSVC_OBJ_LIST, varStart)); reqBufSize += nSvcInfoDesc * (RT_OBJECT_HEADER_SIZE + 4); // adv-id reqBufSize += (nSvcInfoDesc * (RT_OBJECT_HEADER_SIZE)) + totalSvcNameLen; // svc-name reqBufSize += (nSvcInfoDesc * (RT_OBJECT_HEADER_SIZE)) + totalSvcInfoLen; // svc-info reqBufSize += nSvcInfoDesc * (RT_OBJECT_HEADER_SIZE + 1); // svc-status if(RT_STATUS_SUCCESS != (rtStatus = P2PSvc_AllocMem(pP2PSvcInfo->pAdapter, &pNewSREntry, reqBufSize))) { RT_TRACE_F(COMP_P2P, DBG_WARNING, ("[WARNING] Failed to allocate memory for pSREntry\n")); break; } RT_TRACE_F(COMP_P2P, DBG_LOUD, ("alloc mem for size: %u\n", reqBufSize)); PlatformFillMemory(pNewSREntry, reqBufSize, 0xFE); pNewSREntry->probeRspRxTime = pOldSREntry->probeRspRxTime; pNewSREntry->sdReqTxTime = 0; pNewSREntry->sdRspRxTime = 0; pNewSREntry->bDirty = FALSE; pNewObjList = &pNewSREntry->srObjList; P2PSVC_OBJ_LIST_INIT(pNewObjList, RT_OB_HDR_TYPE_DATA, P2PSVC_OBJ_HDR_ID_INDIC_SEARCH_RESULT, P2PSVC_MIN_SUPPORT_VER); P2PSvc_MakeObj(pNewObjList, P2PSVC_OBJ_HDR_ID_DATA_SEARCH_ID, pSearchIdObj->Length, pSearchIdObj->Value); P2PSvc_MakeObj(pNewObjList, P2PSVC_OBJ_HDR_ID_DATA_DEV_ADDR, pDevAddrObj->Length, pDevAddrObj->Value); P2PSvc_MakeObj(pNewObjList, P2PSVC_OBJ_HDR_ID_DATA_DEV_NAME, pDevNameObj->Length, pDevNameObj->Value); P2PSvc_MakeObj(pNewObjList, P2PSVC_OBJ_HDR_ID_DATA_SVC_COUNT, sizeof(nSvcInfoDesc), &nSvcInfoDesc); if(pIsSDDoneObj != NULL) P2PSvc_MakeObj(pNewObjList, P2PSVC_OBJ_HDR_ID_DATA_IS_SD_DONE, sizeof(BOOLEAN), pIsSDDoneObj->Value); for(idxSvcInfoDesc = 0; idxSvcInfoDesc < nSvcInfoDesc; idxSvcInfoDesc++) { PP2PSVC_OBJ_LIST pSvcDescObjList = NULL; u1Byte svcNameLen = 0; if(0 == P2PSvc_MakeSvcDescObjList(pNewObjList, &pSvcDescObjList)) {rtStatus = RT_STATUS_INVALID_DATA ; break;} if(RT_STATUS_SUCCESS != (rtStatus = P2PSvc_ParseAnqpQueryRsp(pSvcRspTlv, idxSvcInfoDesc, &svcNameLen, &pSvcNameBuf, &advId, &svcStatus, &svcInfoLen, &pSvcInfoBuf))) { break; } P2PSvc_MakeObj(pSvcDescObjList, P2PSVC_OBJ_HDR_ID_DATA_ADV_ID, sizeof(advId), &advId); P2PSvc_MakeObj(pSvcDescObjList, P2PSVC_OBJ_HDR_ID_DATA_SVC_NAME, svcNameLen, pSvcNameBuf); P2PSvc_MakeObj(pSvcDescObjList, P2PSVC_OBJ_HDR_ID_DATA_SVC_INFO, svcInfoLen, pSvcInfoBuf); P2PSvc_MakeObj(pSvcDescObjList, P2PSVC_OBJ_HDR_ID_DATA_SVC_STATUS, sizeof(svcStatus), &svcStatus); pNewObjList->hdr.Length += P2PSVC_OBJ_LIST_VAR_LEN(pSvcDescObjList); } if(RT_STATUS_SUCCESS != rtStatus) { break; } *ppSREntryOut = pNewSREntry; // Free the old one RTRemoveEntryListWithCnt((PRT_LIST_ENTRY)pOldSREntry, &pP2PSvcInfo->searchResultListCnt); P2PSvc_FreeMem(pOldSREntry, P2PSVC_SR_LIST_LEN(pOldSREntry)); }while(FALSE); if(RT_STATUS_SUCCESS != rtStatus) { if(pNewSREntry) P2PSvc_FreeMem(pNewSREntry, reqBufSize); *ppSREntryOut = NULL; } P2PSVC_FUNC_OUT(DBG_LOUD, rtStatus); return rtStatus; } #endif // #if (P2PSVC_SUPPORT == 1) #endif // #if (P2P_SUPPORT == 1)