smplfsys.cpp

linux下的一款播放器

				StatBuffer.st_mtime,
				StatBuffer.st_mode);
    return HXR_OK;
}

/************************************************************************
 *  Method:
 *	IHXFileObject::Advise
 *  Purpose:
 *	To pass information to the File Object
 */
STDMETHODIMP CSimpleFileObject::Advise(ULONG32 ulInfo)
{
    MLOG_GEN(NULL, "CSimpleFileObject::Advise(%s) this=0x%08x\n",
             (ulInfo == HX_FILEADVISE_RANDOMACCESS ? "HX_FILEADVISE_RANDOMACCESS" :
                (ulInfo == HX_FILEADVISE_SYNCACCESS ? "HX_FILEADVISE_SYNCACCESS" :
                   (ulInfo == HX_FILEADVISE_ASYNCACCESS ? "HX_FILEADVISE_ASYNCACCESS" :
                      (ulInfo == HX_FILEADVISE_RANDOMACCESSONLY ? "HX_FILEADVISE_RANDOMACCESSONLY" :
                         (ulInfo == HX_FILEADVISE_ANYACCESS ? "HX_FILEADVISE_ANYACCESS" : "Unknown"))))),
             this);
    HX_RESULT retVal = HXR_FAIL;

#ifndef _MACINTOSH
    if (ulInfo == HX_FILEADVISE_SYNCACCESS)
    {
	m_bAsyncAccess = FALSE;
	retVal = HXR_OK;
    }
    else if (ulInfo == HX_FILEADVISE_ASYNCACCESS)
    {
	m_bAsyncAccess = TRUE;
	retVal = HXR_OK;
    }
#if defined(HELIX_FEATURE_PROGDOWN)
    else if (ulInfo == HX_FILEADVISE_RANDOMACCESS)
    {
        retVal = HXR_OK;
        if (m_pProgDownMon && m_bProgDownEnabled)
        {
            // Has this file ever been progressive?
            if (m_pProgDownMon->HasBeenProgressive())
            {
                // It has been in the past, but
                // is it currently progressive?
                if (m_pProgDownMon->IsProgressive())
                {
                    // Set the linear return value
                    retVal = HXR_ADVISE_PREFER_LINEAR;
                }
            }
            else
            {
                // Manually monitor the file size. This
                // will trigger HasBeenProgressive() to 
                // be true if the file is progressive
                m_pProgDownMon->MonitorFileSize();
                // Are we now progressive?
                if (m_pProgDownMon->HasBeenProgressive())
                {
                    // Set the linear return value
                    retVal = HXR_ADVISE_PREFER_LINEAR;
                    // Begin the monitoring of the file size
                    m_pProgDownMon->BeginSizeMonitoring();
                }
            }
        }
    }
#endif /* #if defined(HELIX_FEATURE_PROGDOWN) */
#endif	// _MACINTOSH

    MLOG_GEN(NULL, "\treturn %s\n",
             (retVal == HXR_OK ? "HXR_OK" :
                (retVal == HXR_FAIL ? "HXR_FAIL" :
                   (retVal == HXR_ADVISE_PREFER_LINEAR ? "HXR_ADVISE_PREFER_LINEAR" :
                      "Unknown"))));

    return retVal;
}

/************************************************************************
 *	Method:
 *	    IHXFileObject::GetFileObjectFromPool
 *	Purpose:
 *      To get another FileObject from the same pool.
 */
STDMETHODIMP CSimpleFileObject::GetFileObjectFromPool (
    IHXGetFileFromSamePoolResponse* response
)
{
    HX_RESULT lReturnVal = HXR_FAILED;
    CSimpleFileObject* pFileObject = 0;
    CHXString new_path;
    CHXString strFileName;
    CHXString strURL;
    IUnknown* pUnknown = 0;

    char* pNewPath    = 0;
    char* pSeparator  = 0;

    UpdateFileNameMember();
    if(!m_pFilename)
    {
	pNewPath = new char[strlen(m_base_path) + 1];
	strcpy(pNewPath, m_base_path); /* Flawfinder: ignore */
    }
    else
    {
	strURL = m_pFilename;

	// Make a nice local file name from the URL!
	GetFullPathname(strURL, &strFileName);

	pNewPath = new char[strlen(strFileName) + 1];
	strcpy(pNewPath, (const char*)strFileName); /* Flawfinder: ignore */

	pSeparator = ::strrchr(pNewPath, OS_SEPARATOR_CHAR);
	if(pSeparator)
	{
	    /* Separator will be added in seturl */
	    *pSeparator = 0;
	}
	else
	{
	    // started w/filename. no separator implies no path
	    pNewPath[0] = 0;
	}
    }
    new_path = pNewPath;
    if (pNewPath)
    {
	delete [] pNewPath;
	pNewPath = 0;
    }

    pFileObject = new CSimpleFileObject(new_path,
					m_pFileSystem,
					m_pContext,
					m_ulMaxIterationLevel);

    if (!pFileObject)
    {
	return HXR_OUTOFMEMORY;
    }

    lReturnVal = pFileObject->QueryInterface(IID_IUnknown,
					     (void**)&pUnknown);

    response->FileObjectReady(lReturnVal == HXR_OK ?
			      HXR_OK : HXR_FAILED,
			      pUnknown);
    if(pUnknown)
    {
	pUnknown->Release();
	pUnknown = NULL;
    }

    return lReturnVal;
}

// IHXFileExists interface
/************************************************************************
 *	Method:
 *	    IHXFileExists::DoesExist
 *	Purpose:
 */
STDMETHODIMP CSimpleFileObject::DoesExist(const char* /*IN*/  pPath,
				IHXFileExistsResponse* /*IN*/  pFileResponse)
{
    BOOL bExists = FALSE;
    BOOL bPlusURL = FALSE;
    CHXString   strFileName;
    CHXString	strPath;
    CHXString   plusFileName;
    CHXString   plusPath;

    strPath = pPath;

    bPlusURL = HXXFile::IsPlusURL(pPath);
    if (bPlusURL)
    {
	INT32 index = strPath.ReverseFind('+');

	plusFileName = strPath.Right(strPath.GetLength() - (index+1));
	strPath = strPath.Left(index);
	index = strPath.ReverseFind('/');

	if (index >= 0)
	{
	    plusPath = strPath.Left(index+1);
	    plusPath = plusPath + plusFileName;
	}
	else
	{
	    plusPath = plusFileName;
	}

	HXXFile::GetReasonableLocalFileName(plusPath);
	GetFullPathname(plusPath, &plusFileName);
    }

    // Make a nice local file name from the URL!

    HXXFile::GetReasonableLocalFileName(strPath);
    GetFullPathname(strPath, &strFileName);

#ifdef _MACINTOSH
    CHXDataFile*	    pDataFile = 0; /* cross-platform file object */
    pDataFile = CHXDataFile::Construct();
    if (pDataFile->Open((const char*)strFileName,O_RDONLY) == HXR_OK)
    {
	if (bPlusURL)
	{
	    if (pDataFile->Open((const char*)plusFileName,O_RDONLY) == HXR_OK)
	    {
		bExists = TRUE;
	    }
	}
	else
	{
	    bExists = TRUE;
	}
    }
    delete pDataFile;
#else
    struct stat statbuf;

    m_pDataFile->Bind((const char *)strFileName);
    if (m_pDataFile->Stat(&statbuf) == 0)
    {
	if (bPlusURL)
	{
	    m_pDataFile->Bind((const char *)plusFileName);
	    if (m_pDataFile->Stat(&statbuf) == 0)
	    {
		DPRINTF(0x5d000000, ("CSFO::DoesExist() -- both r TRUE\n"));
		bExists = TRUE;
	    }
	}
	else
	{
	    DPRINTF(0x5d000000, ("CSFO::DoesExist() -- TRUE\n"));
	    bExists = TRUE;
	}
    }
    else
	DPRINTF(0x5d000000, ("CSFO::DoesExist() -- FALSE\n"));
#endif

    pFileResponse->DoesExistDone(bExists);
    return HXR_OK;
}

/************************************************************************
 *	Method:
 *	    Private interface::OpenFile
 *	Purpose:
 *	    This common method is used from Init() and GetFileObjectFromPool()
 */
STDMETHODIMP CSimpleFileObject::_OpenFile(ULONG32     ulFlags)
{
    HX_LOG_BLOCK( "CSimpleFileObject::_OpenFile" );

    DPRINTF(0x5d000000, ("CSFO::_OpenFile(%lu)\n", ulFlags));
    HX_RESULT lReturnVal = HXR_OK;
    IHXUserImpersonation* pUserImpersonationThis = NULL;
    CHXString strFileName;
    CHXString strURL;

    m_ulFlags = ulFlags;

    UpdateFileNameMember();
    strURL = m_pFilename;

    // Make a nice local file name from the URL!
    GetFullPathname(strURL, &strFileName);

    if (m_pUnknownUserContext)
    {
	m_pUnknownUserContext->QueryInterface(IID_IHXUserImpersonation,
	    (void**)&pUserImpersonationThis);
    }

    if (pUserImpersonationThis)
    {
	// see ntauth plugin
	pUserImpersonationThis->Start();
    }

    UINT16 flags = 0;

#ifdef _MACINTOSH
    // use native modes
    if (ulFlags & HX_FILE_READ)
	flags |= O_RDONLY;
    if (ulFlags & HX_FILE_WRITE)
	flags |= O_WRONLY;
    if (ulFlags & HX_FILE_BINARY)
	flags |= O_BINARY;
    if (!ulFlags)
    {
	flags = O_RDONLY | O_BINARY;
	m_ulFlags = HX_FILE_READ | HX_FILE_BINARY;
    }

    // XXXGH must do HX_FILE_REPLACE for MAC
    m_pDataFile = (CMacAsyncFile*) CMacAsyncFile::Construct();
    m_pDataFile->SetAsyncResponse(m_pAsyncFileResponse);
    BOOL bAtInterrupt = FALSE;
    if (m_pInterruptState)
    {
         bAtInterrupt = m_pInterruptState->AtInterruptTime();
    }

    m_nFd = m_pDataFile->SafeOpen((const char*)strFileName,flags, 0, bAtInterrupt);
#else
    if (ulFlags & HX_FILE_READ)
	flags |= HX_FILEFLAG_READ;
    if (ulFlags & HX_FILE_WRITE)
	flags |= HX_FILEFLAG_WRITE;
    if (ulFlags & HX_FILE_BINARY)
	flags |= HX_FILEFLAG_BINARY;
    if (!ulFlags)
    {
	flags = HX_FILEFLAG_READ | HX_FILEFLAG_BINARY;
	m_ulFlags = HX_FILE_READ | HX_FILE_BINARY;
    }
    DPRINTF(0x5d000000, ("CSFO::_OpenFile() -- flags(%u)\n", flags));

    HX_ASSERT(m_pDataFile);

    MLOG_GEN(NULL, "CSimpleFileObject::_OpenFile() this=0x%08x tick=%lu filename=%s\n",
             this, HX_GET_BETTERTICKCOUNT(), (const char*) strFileName);
    m_pDataFile->Bind((const char *)strFileName);
    if (HXR_OK == m_pDataFile->Open((UINT16)m_ulFlags))
    {
	m_nFd = m_pDataFile->GetFd();
	DPRINTF(0x5d000000, ("CSFO::_OpenFile() "
		"-- fd(%d), filename(%s)\n", m_nFd,
		((const char *)strFileName) ? (const char *)strFileName : "NULL"));
    }
    else
    {
	m_nFd = -1;
    }

#endif

    if (pUserImpersonationThis)
    {
	pUserImpersonationThis->Stop();
    }

    /* InitDone may result in close/destruction of this object.Mime mapper
     * is only interested in the mimetype. This is the sequence of events:
     * InitDone->FinishSetup->Close MimeMapper.. Release it. load right ff
     * hand over file system to the file format.
     * So by the time control returns back here, this object may already be
     * closed, resulting in m_nFd = -1
     */
    if (m_nFd != -1)
    {
	lReturnVal = HXR_OK;
    }
    else if (pUserImpersonationThis)
    {
	lReturnVal = HXR_NOT_AUTHORIZED;
    }
    else
    {
	DPRINTF(0x5d000000, ("Error: file missing\n"));
	lReturnVal = HXR_DOC_MISSING;
    }

    HX_RELEASE(pUserImpersonationThis);

    if (lReturnVal == HXR_OK)
    {
	if (!m_pDescriptorReg)
	{
	    m_pContext->QueryInterface(IID_IHXDescriptorRegistration,
						(void **)&m_pDescriptorReg);
	}

	if (m_pDescriptorReg)
	{
	    m_pDescriptorReg->RegisterDescriptors(1);
	}
    }

    return lReturnVal;
}

void
CSimpleFileObject::UpdateFileNameMember()
{
    const char* pURL;

    if (m_base_path.GetLength() > 0)
    {
       /* Running on the Server, do this without wasting CPU! */
       if (m_pRequest->GetURL(pURL) != HXR_OK)
       {
	   HX_VECTOR_DELETE(m_pFilename);
	   return;
       }

       UINT32 ulIndex = 0;
       while (pURL[ulIndex] != 0)
       {

	   // HP - allow '$' in directory/file names
	   //
	   // still need to take care of that obsolete $ sign option:
	   // rtsp://moe.cr.prognet.com/ambush.rm$1:00
	   // time after the $ is assumed to be the start time.
	   //
	   // the solution is to compare the string following the $ to
	   // a properly formed time. If the string is a time and only
	   // a time, then we know its the old-style start-time option
	   // otherwise, '$' is part of the directory/file name and we
	   // will keep it.
	   if (pURL[ulIndex] == '$')
	   {
	       const char* pszOption = &pURL[ulIndex + 1];
	       if (::TimeParse(pszOption))
	       {
		   goto strip_and_duplicate;
	       }
	   }
	   else
	   {

#if !defined(_MACINTOSH) && !defined(_MAC_UNIX)	// ? # and + are legal in Mac file names and shouldn't be stripped (yes, we're seeing a file name, not a URL here)

	       switch (pURL[ulIndex])
	       {


	       case '?':
	       case '#':
	       case '+':
		   goto strip_and_duplicate;
	       default:
		   break;
	       }
#endif
	   }
	   ulIndex++;
       }
       HX_VECTOR_DELETE(m_pFilename);

#if defined(_MACINTOSH) || defined(_MAC_UNIX)
       m_pFilename = new_string(pURL); // on Mac, new_path_string mangles legal filenames which have / or \ in them
#else
       m_pFilename = new_path_string(pURL);
#endif

       return;

strip_and_duplicate:
       HX_VECTOR_DELETE(m_pFilename);

#if defined(_MACINTOSH) || defined(_MAC_UNIX)
       m_pFilename = new_string(pURL); // on Mac, new_path_string mangles legal filenames which have / or \ in them
#else
       m_pFilename = new_path_string(pURL);
#endif

       m_