/** * * @brief Get Proxyserver info * * @param[out] ProxyServer * @param[in] ProxyServerLen * @param[out] ProxyServerLenReq * * @return HTTPReturnCode */ HTTPReturnCode HTTPStackHelper::GetProxyServer ( char* ProxyServer, size_t ProxyServerLen, size_t &ProxyServerLenReq ) { HTTPReturnCode rsltCode = HTTP_FAILURE; ProxyServerLenReq = 0; if (m_ProxyServerName) { size_t servLen = std_strlen(m_ProxyServerName); if (servLen > 0) { size_t reqProxyStrLen = servLen + 7; //(7 characters assuming max port 65535,":","\0" ) char *localProxyStr = (char *)QTV_Malloc((reqProxyStrLen) * sizeof(char)); if (localProxyStr) { size_t offset = 0; offset += std_strlprintf(localProxyStr+offset,reqProxyStrLen-offset, "%s:%d", m_ProxyServerName,m_ProxyServerPort); size_t actualProxyStrLen = std_strlen(localProxyStr); if (actualProxyStrLen > 0) { if (ProxyServer != NULL && ProxyServerLen > 0 ) { if (ProxyServerLen > actualProxyStrLen) { std_strlcpy(ProxyServer,localProxyStr,ProxyServerLen); ProxyServerLenReq = actualProxyStrLen ; rsltCode = HTTP_SUCCESS; } else if (ProxyServerLen <= actualProxyStrLen ) { ProxyServerLenReq = actualProxyStrLen+1 ; rsltCode = HTTP_BADPARAM; } } else if(ProxyServer == NULL && ProxyServerLen == 0) { ProxyServerLenReq = actualProxyStrLen ; rsltCode = HTTP_SUCCESS; } } QTV_Free(localProxyStr); localProxyStr = NULL; } } } return rsltCode; }
HTTPReturnCode HTTPStackHelper::GetContentType(uint32 requestId, char *contentType, size_t contentTypeLen, size_t *contentTypeLenReq) { HTTPReturnCode result = HTTP_FAILURE; if (NULL == m_HTTPState) { QTV_MSG_PRIO(QTVDIAG_HTTP_STACK, QTVDIAG_PRIO_ERROR, "HTTPStackHelper::GetContentType : m_HTTPState is NULL"); } else { GetContentTypeArgument arg(contentType, contentTypeLen, contentTypeLenReq); const char *respContentType = m_HTTPStateInfo.GetContentType(requestId); if (NULL == contentType) { if(NULL != respContentType) { *contentTypeLenReq = std_strlen(respContentType) + 1; result = HTTP_SUCCESS; } } else { if (NULL != respContentType) { std_strlcpy(contentType, respContentType, contentTypeLen); result = HTTP_SUCCESS; } } } return result; }
/** * Initializes the Diag Interface * * @return 0 value on success else failure */ int MM_Debug_Initialize() { int index; int res=1; //! Lock the function using static Mutex res = pthread_mutex_lock(&mOSALMutex); if (0 != res) { LOGE("Mutex Lock failed in Init, %d", res); } /* Below counter will help to check whether mask is already updated or not. It is not required to execute same config file multiple times. */ if (nMMOSALDebugRefCnt == 0) { char MMOSALDebugConfig[MMOSAL_CONFIG_BUFFER_SIZE]; MM_HANDLE nMMOSALDebugConfigFile = NULL; size_t pnBytesRead = 0; /* Default bit mask. Error and Fatal are enabled. 0 0 1 1 1 1 1 1 <- bit mask D F E H M L (Debug, Fatal, Error, High, Medium, Low) 0 0 0 1 1 1 0 0 default priority*/ for(index=0;index<MAP_SIZE;index++) { ssidMaskMap[index]=24; } MMOSALDebugConfig[0] = '\0'; /* * To keep the config file path location backward compatible with other domains like * WFD, first attempt is to read from MMOSAL_LOGMASK_CONFIG_FILE (path loc is /data/) * If file open or read permission issues in above location then read from * MMOSAL_LOGMASK_CONFIG_FILE_MEDIASERVER (path loc is /data/misc/media) which is * the partition location that media server process should use. */ res = MM_File_Create(MMOSAL_LOGMASK_CONFIG_FILE, MM_FILE_CREATE_R, &nMMOSALDebugConfigFile); if (res == 0) { res = MM_File_Read(nMMOSALDebugConfigFile, MMOSALDebugConfig, (size_t)MMOSAL_CONFIG_BUFFER_SIZE,(ssize_t *) &pnBytesRead); MM_File_Release(nMMOSALDebugConfigFile); } if(res != 0) { LOGE("Open or read fail on /data/mmosal_logmask.cfg. Possible permission denied issue. Looking for /data/misc/media/mmosal_logmask.cfg"); res = MM_File_Create(MMOSAL_LOGMASK_CONFIG_FILE_MEDIASERVER, MM_FILE_CREATE_R, &nMMOSALDebugConfigFile); if (res == 0) { res = MM_File_Read(nMMOSALDebugConfigFile, MMOSALDebugConfig, (size_t)MMOSAL_CONFIG_BUFFER_SIZE,(ssize_t *) &pnBytesRead); MM_File_Release(nMMOSALDebugConfigFile); } } if (res == 0 && pnBytesRead > 0) { MMOSALDebugConfig[pnBytesRead] = '\0'; } if (std_strlen(MMOSALDebugConfig) > 0) { char sPattern[32]; int nLogMask = 0; char* pLogMask = NULL; (void)std_strlprintf(sPattern, sizeof(sPattern), "LOGMASK = %d", MSG_SSID_APPS_ALL); pLogMask = std_strstr(MMOSALDebugConfig, sPattern); if (pLogMask) { int index; nLogMask = atoi(pLogMask + std_strlen(sPattern)+1); for(index=0;index<MAP_SIZE;index++) { ssidMaskMap[index]=nLogMask; } } (void)std_strlprintf(sPattern, sizeof(sPattern), "LOGMASK = "); pLogMask = std_strstr(MMOSALDebugConfig, sPattern); if (pLogMask) { int nSysID=0; do { pLogMask = pLogMask + std_strlen(sPattern); nSysID=atoi(pLogMask)-MSG_SSID_APPS; nLogMask = atoi(pLogMask+5); if (nSysID < MAP_SIZE) { ssidMaskMap[nSysID]=nLogMask; pLogMask = std_strstr(pLogMask, sPattern); } } while (pLogMask!='\0'); } } } nMMOSALDebugRefCnt++; res = pthread_mutex_unlock(&mOSALMutex); if (0 != res) { LOGE("Mutex UnLock failed in Init, %d", res); } return 0; }
/** * @brief * Update data structures related to event id passed.for QOE data. * * @param pHTTPSourceMMIHelper * @param eventID * * @return None */ void HTTPSourceMMIExtensionEventHandler::HTTPQOEEventManager:: UpdateQOEData(HTTPSourceMMIHelper *pHTTPSourceMMIHelper, const uint32 eventID) { if(m_bQOENotify) { QTV_MSG_PRIO1(QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_LOW, "HTTPSourceMMIExtensionEventHandler::HTTPQOEEventManager::UpdateQOEData eventID = %u",eventID); char* pVideoURL = NULL; uint32 nBandwidth = 0; uint32 nBufCount = 0; size_t nURLSize = 0; size_t nIPAddrSize = 0; size_t nStopPhraseSize = 0; bool bUpdateRequired = false; uint64 currMSeconds = 0; (void)MM_Time_GetCurrentTimeInMilliSecsFromEpoch(&currMSeconds); switch(eventID) { case QOMX_HTTP_IndexParamQOEPlay: if(!dataPlay) { dataPlay = (QOMX_QOE_DATA_PLAY *)QTV_Malloc(sizeof(QOMX_QOE_DATA_PLAY)); } if(dataPlay) { memset(dataPlay,0,sizeof(QOMX_QOE_DATA_PLAY)); dataPlay->size = (OMX_U32)sizeof(QOMX_QOE_DATA_PLAY); dataPlay->timeOfDay = currMSeconds; } break; case QOMX_HTTP_IndexParamQOESwitch: { if(pHTTPSourceMMIHelper) { pHTTPSourceMMIHelper->GetQOEData(nBandwidth,nBufCount,NULL,nURLSize,NULL,nIPAddrSize,NULL,nStopPhraseSize); } if(!dataSwitch) { dataSwitch = (QOMX_QOE_DATA_SWITCH *)QTV_Malloc(sizeof(QOMX_QOE_DATA_SWITCH)); } if(dataSwitch) { memset(dataSwitch,0,sizeof(QOMX_QOE_DATA_SWITCH)); dataSwitch->bandwidth = nBandwidth; dataSwitch->reBufCount = nBufCount; dataSwitch->timeOfDay = currMSeconds; } } break; case QOMX_HTTP_IndexParamQOEPeriodic: { char* pIPAddress = NULL; if(pHTTPSourceMMIHelper) { pHTTPSourceMMIHelper->GetQOEData(nBandwidth,nBufCount,pVideoURL,nURLSize,pIPAddress,nIPAddrSize,NULL,nStopPhraseSize); if(pVideoURL == NULL && nURLSize) { pVideoURL = (char*)QTV_Malloc(nURLSize+1); if(pVideoURL) { bUpdateRequired = true; } } if(pIPAddress == NULL && nIPAddrSize) { pIPAddress = (char*)QTV_Malloc(nIPAddrSize+1); if(pIPAddress) { bUpdateRequired = true; } } if(bUpdateRequired) { pHTTPSourceMMIHelper->GetQOEData(nBandwidth,nBufCount,pVideoURL,nURLSize,pIPAddress,nIPAddrSize,NULL,nStopPhraseSize); bUpdateRequired = false; } } size_t nSize = sizeof(QOMX_QOE_DATA_PERIODIC)+nURLSize+1+nIPAddrSize+1; if(dataPeriodic) { QTV_Free(dataPeriodic); } dataPeriodic = (QOMX_QOE_DATA_PERIODIC *)QTV_Malloc(nSize); if(dataPeriodic) { memset(dataPeriodic,0,nSize); dataPeriodic->size = (uint32)nSize; dataPeriodic->bandwidth = nBandwidth; dataPeriodic->timeOfDay = currMSeconds; dataPeriodic->nInfoPeriodicLen = (OMX_U32)(nURLSize+1+nIPAddrSize+1); if(pIPAddress) { std_memmove(dataPeriodic->infoPeriodic,pIPAddress,std_strlen(pIPAddress)+1); dataPeriodic->nIpAddressLen = (OMX_U32)std_strlen(pIPAddress)+1; } if(pVideoURL) { std_memmove(dataPeriodic->infoPeriodic+dataPeriodic->nIpAddressLen,pVideoURL,std_strlen(pVideoURL)+1); dataPeriodic->nVideoURLLen = (OMX_U32)std_strlen(pVideoURL)+1; } } if(pIPAddress) { QTV_Free(pIPAddress); pIPAddress = NULL; } } break; case QOMX_HTTP_IndexParamQOEStop: { char* pStopPhrase = NULL; if(pHTTPSourceMMIHelper) { pHTTPSourceMMIHelper->GetQOEData(nBandwidth,nBufCount,pVideoURL,nURLSize,NULL,nIPAddrSize,pStopPhrase,nStopPhraseSize); if(pVideoURL == NULL && nURLSize) { pVideoURL = (char*)QTV_Malloc(nURLSize+1); if(pVideoURL) { bUpdateRequired = true; } } if(pStopPhrase == NULL && nStopPhraseSize) { pStopPhrase = (char*)QTV_Malloc(nStopPhraseSize+1); if(pStopPhrase) { bUpdateRequired = true; } } if(bUpdateRequired) { pHTTPSourceMMIHelper->GetQOEData(nBandwidth,nBufCount,pVideoURL,nURLSize,NULL,nIPAddrSize,pStopPhrase,nStopPhraseSize); bUpdateRequired = false; } } size_t nSize = sizeof(QOMX_QOE_DATA_STOP)+nURLSize+1+nStopPhraseSize+1; if(dataStop) { QTV_Free(dataStop); } dataStop = (QOMX_QOE_DATA_STOP *)QTV_Malloc(nSize); if(dataStop) { memset(dataStop,0,nSize); dataStop->size = (OMX_U32)nSize; dataStop->bandwidth = (OMX_U32)nBandwidth; dataStop->reBufCount = nBufCount; dataStop->timeOfDay = currMSeconds; dataStop->nInfoStopLen = (OMX_U32)(nURLSize+1+nStopPhraseSize+1); if(pStopPhrase) { std_memmove(dataStop->infoStop,pStopPhrase,std_strlen(pStopPhrase)+1); dataStop->nStopPhraseLen = (OMX_U32)(std_strlen(pStopPhrase)+1); } if(pVideoURL) { std_memmove(dataStop->infoStop+dataStop->nStopPhraseLen,pVideoURL,std_strlen(pVideoURL)+1); dataStop->nVideoURLLen = (OMX_U32)(std_strlen(pVideoURL)+1); } } if(pStopPhrase) { QTV_Free(pStopPhrase); pStopPhrase = NULL; } } break; default: break; } if(pVideoURL) { QTV_Free(pVideoURL); pVideoURL = NULL; } } }
/** @brief IDLE state handler. * * @param[in] pHttpResolver - Reference to HTTPResolver * @return * HTTPDL_WAITING - Successfully posted GET request to the HTTP stack * HTTPDL_ERROR_ABORT - Error */ HTTPDownloadStatus HTTPResolver::IdleStateHandler::Execute ( HTTPResolver* pHttpResolver ) { QTV_MSG_PRIO( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_LOW, "HTTPResolver::IdleStateHandler::Execute()" ); HTTPDownloadStatus status = HTTPCommon::HTTPDL_ERROR_ABORT; HTTPResolver* pSelf = static_cast<HTTPResolver *> (pHttpResolver); //Validity check if (pSelf) { HTTPSessionInfo& sessionInfo = pSelf->m_sessionInfo; URL url = sessionInfo.GetURL(); char* pLaunchURL = pSelf->m_pLaunchURL; HTTPMethodType methodType = HTTP_GET; //Prepare launch URL if (HTTPCommon::ParseURL(url, HTTP_DEFAULT_PORT, pLaunchURL) && pLaunchURL) { pSelf->m_pLaunchURL = pLaunchURL; HTTPStackInterface& HTTPStack = pSelf->m_pHTTPStack; if(HTTPStack.CreateRequest(pSelf->m_nRequestID) == HTTP_SUCCESS ) { //Add HTTP headers char hostName[HTTP_MAX_HOSTNAME_LEN] = {0}; if (url.GetHost(hostName, sizeof(hostName)) == URL::URL_OK) { (void)HTTPStack.SetHeader(pSelf->m_nRequestID, "Host", (int)std_strlen("Host"), hostName, (int)std_strlen(hostName)); } char range[HTTP_MAX_RANGE_LEN] = {0}; if (pSelf->m_nMaxRequestSize >= 0) { (void)std_strlprintf(range, sizeof(range), "bytes=%d-%d", 0, (int)pSelf->m_nMaxRequestSize); } else { (void)std_strlprintf(range, sizeof(range), "bytes=%d-", 0); } (void)HTTPStack.SetHeader(pSelf->m_nRequestID, "Range", (int)std_strlen("Range"), range, (int)std_strlen(range)); const char* pUserAgent = sessionInfo.GetUserAgent(); if (pUserAgent) { (void)HTTPStack.SetHeader(pSelf->m_nRequestID, "User-Agent", (int)std_strlen("User-Agent"), pUserAgent, (int)std_strlen(pUserAgent)); } //Add any OEM headers HTTPCommon::AddIPStreamProtocolHeaders(sessionInfo, HTTPStack, methodType, pSelf->m_nRequestID); //Send HTTP GET request QTV_MSG_SPRINTF_PRIO_2( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_HIGH, "HTTPResolver::IdleStateHandler: Posting GET %s for %s", range, pLaunchURL ); HTTPReturnCode result = HTTPStack.SendRequest(pSelf->m_nRequestID, methodType, pLaunchURL, (int)std_strlen(pLaunchURL)); if (result == HTTP_SUCCESS) { //HTTP GET request successfully composed and posted to the HTTP stack, //move to WAIT_FOR_DATA status = HTTPCommon::HTTPDL_WAITING; pSelf->SetStateHandler(&pSelf->m_WaitForDataStateHandler); QTV_MSG_PRIO( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_MEDIUM, "HTTPResolver::IdleStateHandler: HTTP GET request successfully " "composed and posted to HTTP stack - moving to WAIT_FOR_DATA" ); } else { QTV_MSG_PRIO1( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_ERROR, "HTTPResolver::IdleStateHandler: Posting HTTP GET failed %d", result ); } } else { QTV_MSG_PRIO( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_ERROR, "Error Creating Request"); } }// if (HTTPCommon::ParseURL()) }// if (pSelf) return status; }
HTTPReturnCode HTTPStackHelper::NotifyEvent(uint32 requestId, HTTPStackNotifyCode notifyCode) { HTTPReturnCode rsltCode = HTTP_FAILURE; HTTPStackNotificationCbData cbData = {0,NULL,NULL,false,NULL,NULL,NULL}; cbData.m_serverCode = m_HTTPStateInfo.GetHTTPResponseCode(requestId); cbData.m_serverMessage = (char*)m_HTTPStateInfo.GetReasonPhraseStr(requestId); cbData.m_entityBody = (char*)m_HTTPStateInfo.GetEntityBody(requestId); cbData.m_method = (char *)HTTPStackCommon::GetStringForMethod(m_HTTPStateInfo.GetRequestMethod(requestId)); cbData.m_protocolHeaders = NULL; cbData.m_pHTTPStack = m_pHTTPStack; int reqLen = 0; /** * This commented code is in line with what is specified for * protocol header events. However, current decision is to send * protocol header event for authorization or porxy-authoirzation * only. If this changes then this can be uncommented and th the * code following this can be * removed. * * httpResponse.GetHeaders(NULL, 0, reqLen); * * if (reqLen > 0) *{ * int bufSize = reqLen; cbData.m_protocolHeaders = (char * * *)QTV_Malloc(bufSize * sizeof(char)); * * if (cbData.m_protocolHeaders) * { * httpResponse.GetHeaders(cbData.m_protocolHeaders,bufSize, *reqLen); * } * } * else { * QTV_MSG_PRIO1(QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_ERROR, * * "HTTPStackHelper::NotifyEvent Did not find headers for * response. ServerCode %d", cbData.m_serverCode); * } */ static const int AUTHENTICATE_KEY_LEN = (int)std_strlen(HTTPStackCommon::AUTHENTICATE_KEY); static const int PROXY_AUTHENTICATE_KEY_LEN = (int)std_strlen(HTTPStackCommon::PROXY_AUTHENTICATE_KEY); static const char *DELIM = ": "; static const int DELIM_LEN = (int)std_strlen(DELIM); static const char *TERMINATE = "\r\n\r\n"; static const int TERMINATE_LEN = (int)std_strlen(TERMINATE); m_HTTPStateInfo.GetHeaderValue(requestId, HTTPStackCommon::AUTHENTICATE_KEY, AUTHENTICATE_KEY_LEN, NULL, 0, &reqLen); if (reqLen > 0) { // response header contains "WWW-Authenticate" int reqdBufSize = AUTHENTICATE_KEY_LEN + DELIM_LEN + reqLen + TERMINATE_LEN + 1; cbData.m_protocolHeaders = (char *)QTV_Malloc(reqdBufSize * sizeof(char)); if (cbData.m_protocolHeaders) { std_strlcpy(cbData.m_protocolHeaders, HTTPStackCommon::AUTHENTICATE_KEY, reqdBufSize); std_strlcat(cbData.m_protocolHeaders, DELIM, reqdBufSize); int tmpLen = reqLen; m_HTTPStateInfo.GetHeaderValue(requestId, HTTPStackCommon::AUTHENTICATE_KEY, AUTHENTICATE_KEY_LEN, cbData.m_protocolHeaders + AUTHENTICATE_KEY_LEN + DELIM_LEN, reqLen, &tmpLen); std_strlcat(cbData.m_protocolHeaders, TERMINATE, reqdBufSize); } else { QTV_MSG_PRIO(QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_ERROR, "cbData.m_protocolHeaders for authentication is NULL"); } } else { m_HTTPStateInfo.GetHeaderValue(requestId, HTTPStackCommon::PROXY_AUTHENTICATE_KEY, PROXY_AUTHENTICATE_KEY_LEN, NULL, 0, &reqLen); if (reqLen > 0) { int reqdBufSize = PROXY_AUTHENTICATE_KEY_LEN + DELIM_LEN + reqLen + TERMINATE_LEN + 1; cbData.m_protocolHeaders = (char *)QTV_Malloc(reqdBufSize * sizeof(char)); if (cbData.m_protocolHeaders) { std_strlcpy(cbData.m_protocolHeaders, HTTPStackCommon::PROXY_AUTHENTICATE_KEY, reqdBufSize); std_strlcat(cbData.m_protocolHeaders, DELIM, reqdBufSize); int tmpLen = reqLen; m_HTTPStateInfo.GetHeaderValue(requestId, HTTPStackCommon::PROXY_AUTHENTICATE_KEY, PROXY_AUTHENTICATE_KEY_LEN, cbData.m_protocolHeaders + PROXY_AUTHENTICATE_KEY_LEN + DELIM_LEN, reqLen, &tmpLen); std_strlcat(cbData.m_protocolHeaders, TERMINATE, reqdBufSize); } else { QTV_MSG_PRIO(QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_ERROR, "cbData.m_protocolHeaders for proxy-authentication is NULL"); } } } rsltCode = m_fNotifyCallback(requestId, notifyCode,&cbData, m_pOwner); return rsltCode; }
/** @brief IDLE state handler. * * @param[in] pDownloadHelper - Reference to PlaylistDownloadHelper * @return * HTTPDL_WAITING - Successfully initiated connection and GET request posted * to the HTTP stack * HTTPDL_ERROR_ABORT - Otherwise */ HTTPDownloadStatus PlaylistDownloadHelper::IdleStateHandler::Execute ( PlaylistDownloadHelper* pDownloadHelper ) { QTV_MSG_PRIO( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_LOW, "PlaylistDownloadHelper::IdleStateHandler::Execute()" ); HTTPDownloadStatus status = HTTPCommon::HTTPDL_ERROR_ABORT; PlaylistDownloadHelper* pSelf = pDownloadHelper; //Validity check if (pSelf) { char* pLaunchURL = pSelf->m_pLaunchURL; //Fill in default port if port already not present in URL if (pSelf->ParseURL(HTTP_DEFAULT_PORT, pLaunchURL) && pLaunchURL) { HTTPMethodType methodType = HTTP_GET; status = HTTPCommon::HTTPDL_SUCCESS; pSelf->m_pLaunchURL = pLaunchURL; HTTPStackInterface& HTTPStack = *(pSelf->m_pHTTPStack); if(HTTPStack.CreateRequest(pSelf->m_nRequestID) == HTTP_SUCCESS) { URL url = pSelf->GetURL(); char hostName[HTTP_MAX_HOSTNAME_LEN] = {0}; if (url.GetHost(hostName, sizeof(hostName)) == URL::URL_OK) { (void)HTTPStack.SetHeader(pSelf->m_nRequestID, "Host", (int)std_strlen("Host"), hostName, (int)std_strlen(hostName)); } const char* pUserAgent = (pSelf->m_sessionInfo).GetUserAgent(); if (pUserAgent) { (void)HTTPStack.SetHeader(pSelf->m_nRequestID, "User-Agent", (int)std_strlen("User-Agent"), pUserAgent, (int)std_strlen(pUserAgent)); } HTTPCommon::AddIPStreamProtocolHeaders(pSelf->m_sessionInfo,HTTPStack,methodType, pSelf->m_nRequestID); //Send GET to get the playlist HTTPReturnCode result = HTTPStack.SendRequest(pSelf->m_nRequestID, methodType, pLaunchURL, (int)std_strlen(pLaunchURL)); if (result == HTTP_SUCCESS) { //HTTP GET request successfully composed and posted to the HTTP stack. //So change state to WAITING_FOR_PLAYLIST and check back later status = HTTPCommon::HTTPDL_WAITING; pSelf->SetStateHandler(&pSelf->m_WaitingForPlaylistStateHandler); QTV_MSG_PRIO( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_HIGH, "HTTP GET request to get playlist successfully composed and posted " "to HTTP stack - proceeding to WAITING_FOR_PLAYLIST" ); } else { QTV_MSG_PRIO1( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_ERROR, "Error: HTTP GET request send failed %d", result ); status = HTTPCommon::HTTPDL_ERROR_ABORT; } } else { QTV_MSG_PRIO( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_ERROR, "Error Creating Request"); } } else { QTV_MSG_PRIO( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_ERROR, "Error: ParseURL failed" ); }// if (pSelf->ParseURL(HTTP_DEFAULT_PORT, pLaunchURL) && pLaunchURL) }// if (pSelf && pSelf->GetState() == IDLE) return status; }
/** @brief Parses the input URL and fills in the default port if port already * not present. * * @param[in] pDefaultPort - Default HTTP port to use if port not present in URL * @param[out] pLaunchURL - Launch URL used to connect to server * @return * TRUE - Launch URL ready * FALSE - Otherwise */ bool PlaylistDownloadHelper::ParseURL ( const char* pDefaultPort, char*& pLaunchURL ) { bool bOk = false; URL url(GetURL()); size_t launchURLLen = url.GetUrlLength() + 1; uint32 port = 0; if (pLaunchURL) { QTV_Free(pLaunchURL); pLaunchURL = NULL; } if (url.GetPort(&port) == URL::URL_OK) { if (port) { pLaunchURL = (char*)QTV_Malloc(launchURLLen); if (pLaunchURL && url.GetUrlBuffer()) { bOk = true; (void)std_strlcpy(pLaunchURL, url.GetUrlBuffer(), launchURLLen); } } else if (pDefaultPort) { char hostName[HTTP_MAX_HOSTNAME_LEN] = {0}; //Extra space for ":9300" launchURLLen += std_strlen(pDefaultPort) + 1; pLaunchURL = (char*)QTV_Malloc(launchURLLen); if (pLaunchURL && url.GetHost(hostName, sizeof(hostName)) == URL::URL_OK) { //Write http:// size_t arg2 = std_strlen("http://") + 1; size_t dstBufLen = STD_MIN(launchURLLen, arg2); size_t numURLBytes = std_strlcpy(pLaunchURL, "http://", dstBufLen); //Write hostname arg2 = std_strlen(hostName) + 1; dstBufLen = STD_MIN(launchURLLen - numURLBytes, arg2); numURLBytes += std_strlcpy(pLaunchURL + numURLBytes, hostName, dstBufLen); //Write : arg2 = std_strlen(":") + 1; dstBufLen = STD_MIN(launchURLLen - numURLBytes, arg2); numURLBytes += std_strlcpy(pLaunchURL + numURLBytes, ":", dstBufLen); //Write default port arg2 = std_strlen(pDefaultPort) + 1; dstBufLen = STD_MIN(launchURLLen - numURLBytes, arg2); numURLBytes += std_strlcpy(pLaunchURL + numURLBytes, pDefaultPort, dstBufLen); //Write / arg2 = std_strlen("/") + 1; dstBufLen = STD_MIN(launchURLLen - numURLBytes, arg2); numURLBytes += std_strlcpy(pLaunchURL + numURLBytes, "/", dstBufLen); //Write clipname dstBufLen = launchURLLen - numURLBytes; char* pClipName = NULL; pClipName = (char*)QTV_Malloc(dstBufLen); if (pClipName) { if (url.GetClipName(pClipName, dstBufLen) == URL::URL_OK) { bOk = true; (void)std_strlcpy(pLaunchURL + numURLBytes, pClipName, dstBufLen); } QTV_Free(pClipName); } } } else { QTV_MSG_PRIO( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_ERROR, "Error: Invalid port" ); } } if(!bOk) { if(pLaunchURL) { QTV_Free(pLaunchURL); } } return bOk; }
static int cmd_list_cb(int argc, const char *argv[], void *chout_p, void *chin_p, void *arg_p, void *call_arg_p) { const FAR struct setting_t *setting_p; int i; int8_t int8; int16_t int16; int32_t int32; char buf[32]; size_t size; /* Print the header. */ std_fprintf(chout_p, FSTR("NAME TYPE SIZE VALUE\r\n")); /* Print all settings. */ setting_p = &settings[0]; while (setting_p->name_p != NULL) { /* Print the name. */ if (std_strlen(setting_p->name_p) >= sizeof(buf)) { continue; } std_strcpy(buf, setting_p->name_p); std_fprintf(chout_p, FSTR("%-20s "), buf); size = setting_p->size; switch (setting_p->type) { case setting_type_int8_t: int8 = 0; settings_read(&int8, setting_p->address, size); std_fprintf(chout_p, FSTR("int8_t 1 %d\r\n"), (int)int8); break; case setting_type_int16_t: int16 = 0; settings_read(&int16, setting_p->address, size); std_fprintf(chout_p, FSTR("int16_t 2 %d\r\n"), (int)int16); break; case setting_type_int32_t: int32 = 0; settings_read(&int32, setting_p->address, size); std_fprintf(chout_p, FSTR("int32_t 4 %ld\r\n"), (long)int32); break; case setting_type_string_t: std_fprintf(chout_p, FSTR("string %4u "), (int)size); for (i = 0; i < size; i++) { settings_read(&buf[0], setting_p->address + i, 1); if (buf[0] == '\0') { break; } std_fprintf(chout_p, FSTR("%c"), buf[0]); } std_fprintf(chout_p, FSTR("\r\n")); break; default: std_fprintf(chout_p, FSTR("bad setting type %d\r\n"), setting_p->type); } setting_p++; } return (0); }