开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
preftran.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：51k
源码类别：

Symbian

开发平台：

C/C++

preftran.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #include "hxcom.h"
  37. #include "hxtypes.h"
  38. #include "hlxclib/string.h"
  39. #include "hlxclib/stdio.h"
  40. #ifdef _MACINTOSH
  41. //#include <stat.mac.h> // Not needed on Mac and doesn't exist in CW Pro 7.
  42. #else
  43. #include "hlxclib/sys/types.h"
  44. #include "hlxclib/sys/stat.h"
  45. #endif
  46. #include "hlxclib/time.h"
  47. #if defined(_AIX)
  48. #include <ctype.h>
  49. #endif
  51. #if defined(_WINDOWS)  
  52. #include <windows.h>
  53. #ifndef _WINCE
  54. #include <winsock2.h>
  55. #include <ws2tcpip.h>
  56. #endif /* _WINCE */
  57. #endif /* _WINDOWS */
  58. #include "hlxclib/sys/socket.h"
  60. #include "hxresult.h"
  61. #include "hxslist.h"
  62. #include "ihxpckts.h"
  63. #include "hxstrutl.h"
  64. #include "dbcs.h"
  65. #include "dllpath.h"
  66. #include "hxprefs.h"
  67. #include "hxprefutil.h"
  68. #include "hxthread.h"
  69. #include "netbyte.h"
  70. #include "hxpxymgr.h"
  71. #include "portaddr.h"
  72. #include "prefdefs.h"
  73. #include "hxengin.h"
  74. #include "hxnetif.h"
  75. #include "pacutil.h"
  76. #include "preftran.h"
  79. #ifdef _UNIX
  80. #include <sys/types.h>
  81. #include <sys/stat.h>
  82. #include <netinet/in.h>
  83. #include <sys/socket.h>
  84. #if defined _SOLARIS || defined _FREEBSD || defined _OPENBSD || defined _NETBSD
  85. #include <sys/sockio.h>
  86. #endif
  87. #include <net/if.h>
  88. #include <sys/ioctl.h>
  89. #endif
  91. #include "hlxclib/stdlib.h" // for i64toa
  93. #if defined (_UNIX) && !defined(_SUN) && !defined(_SCO_UW) && !defined(_HPUX) && !defined(_IRIX) && !defined(_OSF1)
  94. #include <sys/file.h>
  95. #endif /* UNIX */
  97. #define RM_PREFTRAN_CAPTION "# RealMedia Preferred Transport Filen# This is a generated file!  Do not edit.nn"
  98. #define RM_PREFTRAN_DIR_NAME "preftran/"
  99. #define RM_PREFTRAN_FILE_LOCK "PrefTranFileLock"
  101. #include "hxdir.h" /* for OS_SEPARATOR_CHAR and OS_SEPARATOR_STRING */
  104. HXPreferredTransport::HXPreferredTransport(HXPreferredTransportManager* pOwner)
  105.      : m_lRefCount(0)
  106.      , m_pOwner(pOwner)
  107.      , m_bHTTPNG(FALSE)
  108.      , m_pHost(NULL)
  109.      , m_ulHost(0)
  110.      , m_ulParentPlaybacks(0)
  111.      , m_uPlaybacks(0)
  112.      , m_uCloakPort(0)
  113.      , m_state(PTS_UNKNOWN)
  114.      , m_lastUsedTime(0)
  115.      , m_prefTransportClass(PTC_UNKNOWN)
  116.      , m_prefTransportProtocol(PTP_UNKNOWN)
  117.      , m_prefTransportType(UnknownMode)
  118.      , m_pPrefTransportSinkList(NULL)
  119. {
  120.     HX_ADDREF(m_pOwner);
  121. }
  123. HXPreferredTransport::~HXPreferredTransport()
  124. {
  125.     Close();
  126. }
  128. STDMETHODIMP
  129. HXPreferredTransport::QueryInterface(REFIID riid, void**ppvObj)
  130. {
  131.     QInterfaceList qiList[] =
  132.         {
  133.             { GET_IIDHANDLE(IID_IHXPreferredTransport), (IHXPreferredTransport*)this },
  134.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXPreferredTransport*)this },
  135.         };
  136.     
  137.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  138. }
  140. /////////////////////////////////////////////////////////////////////////
  141. //  Method:
  142. // IUnknown::AddRef
  143. //  Purpose:
  144. // Everyone usually implements this the same... feel free to use
  145. // this implementation.
  146. //
  147. STDMETHODIMP_(ULONG32) 
  148. HXPreferredTransport::AddRef()
  149. {
  150.     return InterlockedIncrement(&m_lRefCount);
  151. }
  153. /////////////////////////////////////////////////////////////////////////
  154. //  Method:
  155. // IUnknown::Release
  156. //  Purpose:
  157. // Everyone usually implements this the same... feel free to use
  158. // this implementation.
  159. //
  160. STDMETHODIMP_(ULONG32) 
  161. HXPreferredTransport::Release()
  162. {
  163.     if (InterlockedDecrement(&m_lRefCount) > 0)
  164.     {
  165.         return m_lRefCount;
  166.     }
  168.     delete this;
  169.     return 0;
  170. }
  172. /*
  173.  * IHXPreferredTransport methods
  174.  */
  175. STDMETHODIMP
  176. HXPreferredTransport::GetTransport (REF(TransportMode) /* OUT */   prefTransportType,
  177.     REF(UINT16) /* OUT */   ulCloakPort)
  178. {
  179.     HX_RESULT rc = HXR_OK;
  181.     prefTransportType = UnknownMode;
  182.     ulCloakPort = 0;
  184.     switch (m_state)
  185.     {
  186.     case PTS_CREATE:
  187. m_state = PTS_PENDING;
  188. prefTransportType = m_prefTransportType;
  189. ulCloakPort = m_uCloakPort;
  190. break;
  191.     case PTS_PENDING:
  192. rc = HXR_WOULD_BLOCK;
  193. break;
  194.     case PTS_READY:
  195. prefTransportType = m_prefTransportType;
  196. ulCloakPort = m_uCloakPort;
  197. break;
  198.     default:
  199. break;
  200.     }
  202.     return rc;
  203. }
  204.     
  205. STDMETHODIMP
  206. HXPreferredTransport::SetTransport(TransportMode   /* IN  */   prefTransportType,
  207.     UINT16     /* IN  */   ulCloakPort)
  208. {
  209.     HX_RESULT rc = HXR_OK;
  210.     BOOL bSave = FALSE;
  211.     UINT32 ulTransportMask = 0;
  213.     HX_ASSERT(UnknownMode != prefTransportType);
  215.     // we will mask UDP to Multicast if Multicast is selected given
  216.     // the fact the server will always try UDP along with Multicast request
  217.     if (UDPMode == prefTransportType && m_pOwner)
  218.     {
  219. if (PTP_RTSP == m_prefTransportProtocol)
  220. {
  221.     ulTransportMask = m_pOwner->m_ulRTSPTransportMask;
  222. }
  223. else
  224. {
  225.     ulTransportMask = m_pOwner->m_ulPNMTransportMask;
  226.      }
  228. if (ulTransportMask & ATTEMPT_MULTICAST)
  229. {
  230.     prefTransportType = MulticastMode;
  231. }
  232.     }
  234.     m_state = PTS_READY;
  235.     m_uCloakPort = ulCloakPort;
  236.     m_lastUsedTime = time(NULL);
  238.     if (m_prefTransportType != prefTransportType)
  239.     {
  240. bSave = TRUE;
  241. m_uPlaybacks = 0;
  242. m_prefTransportType = prefTransportType;
  243.     }
  245.     if (m_pPrefTransportSinkList)
  246.     {
  247. CHXSimpleList::Iterator i = m_pPrefTransportSinkList->Begin();
  248. for (; i != m_pPrefTransportSinkList->End(); ++i)
  249. {
  250.     IHXPreferredTransportSink* pSink = (IHXPreferredTransportSink*)*i;
  251.     pSink->TransportSucceeded(m_prefTransportType, m_uCloakPort);
  252. }
  253.     }
  255.     if (m_pOwner)
  256.     {
  257.         m_pOwner->TransportSet(this, bSave);
  258.     }
  260.     return rc;
  261. }
  263. STDMETHODIMP
  264. HXPreferredTransport::SwitchTransport(HX_RESULT     /* IN  */   error,
  265.       REF(TransportMode)    /* INOUT */ prefTransportType)
  266. {
  267.     if (m_pOwner)
  268.     {
  269.         return m_pOwner->DownShiftTransport(error, this, prefTransportType);
  270.     }
  272.     return HXR_FAILED;
  273. }
  275. STDMETHODIMP
  276. HXPreferredTransport::RemoveTransport()
  277. {
  278.     m_state = PTS_UNKNOWN;
  279.     m_uPlaybacks = 0;
  280.     m_uCloakPort = 0;
  281.     m_prefTransportType = UnknownMode;
  282.     m_lastUsedTime = 0;
  284.     if (m_pPrefTransportSinkList)
  285.     {
  286. CHXSimpleList::Iterator i = m_pPrefTransportSinkList->Begin();
  287. for (; i != m_pPrefTransportSinkList->End(); ++i)
  288. {
  289.     IHXPreferredTransportSink* pSink = (IHXPreferredTransportSink*)*i;
  290.     pSink->TransportFailed();
  291. }
  292.     }
  294.     return HXR_OK;
  295. }
  296.     
  297. STDMETHODIMP_(BOOL)
  298. HXPreferredTransport::ValidateTransport(TransportMode    /* IN */ prefTransportType)
  299. {
  300.     if (m_pOwner)
  301.     {
  302.         return m_pOwner->ValidateTransport(this, prefTransportType);
  303.     }
  305.     return FALSE;
  306. }
  308. STDMETHODIMP_(PreferredTransportState)
  309. HXPreferredTransport::GetState()
  310. {
  311.     return m_state;
  312. }
  314. STDMETHODIMP_(PreferredTransportClass)
  315. HXPreferredTransport::GetClass()
  316. {
  317.     return m_prefTransportClass;
  318. }
  320. STDMETHODIMP
  321. HXPreferredTransport::AddTransportSink(IHXPreferredTransportSink* /* IN  */   pPrefTransportSink)
  322. {
  323.     LISTPOSITION lPosition = 0;
  325.     if (!pPrefTransportSink)
  326.     {
  327. return HXR_FAILED;
  328.     }
  330.     if (!m_pPrefTransportSinkList)
  331.     {
  332. m_pPrefTransportSinkList = new CHXSimpleList;
  333.     }
  334.     else
  335.     {
  336. lPosition = m_pPrefTransportSinkList->Find(pPrefTransportSink);
  337.     }
  339.     if (!lPosition)
  340.     {
  341. pPrefTransportSink->AddRef();
  342. m_pPrefTransportSinkList->AddTail(pPrefTransportSink);
  343.     }
  345.     return HXR_OK;
  346. }
  348. STDMETHODIMP
  349. HXPreferredTransport::RemoveTransportSink(IHXPreferredTransportSink* /* IN  */   pPrefTransportSink)
  350. {
  351.     if (!m_pPrefTransportSinkList)
  352.     {
  353. return HXR_UNEXPECTED;
  354.     }
  356.     LISTPOSITION lPosition = m_pPrefTransportSinkList->Find(pPrefTransportSink);
  357.     if (!lPosition)
  358.     {
  359. return HXR_UNEXPECTED;
  360.     }
  362.     m_pPrefTransportSinkList->RemoveAt(lPosition);
  363.     HX_RELEASE(pPrefTransportSink);
  364.     
  365.     return HXR_OK;
  366. }
  368. STDMETHODIMP_(BOOL)
  369. HXPreferredTransport::GetHTTPNG()
  370. {
  371.     return m_bHTTPNG;
  372. }
  374. STDMETHODIMP
  375. HXPreferredTransport::SetHTTPNG(BOOL bHTTPNG)
  376. {
  377.     m_bHTTPNG = bHTTPNG;
  378.     return HXR_OK;
  379. }
  381. void
  382. HXPreferredTransport::Initialize()
  383. {
  384.     TransportMode upShiftToTransport = UnknownMode;
  386.     if (!m_pOwner)
  387.     {
  388.         return;
  389.     }
  391.     if (m_lastUsedTime && PTS_READY == m_state)
  392.     {
  393. // detect whether the preferences has been changed
  394. // since its last use
  395. if (PTP_RTSP == m_prefTransportProtocol &&
  396.     m_lastUsedTime < m_pOwner->m_lastRTSPPreferencesModifiedTime)
  397. {
  398.     m_state = PTS_CREATE;
  399.     m_uPlaybacks = 0;
  400.     m_prefTransportType = m_pOwner->m_rtspTransportTypeStartWith;
  401. }
  402. else if (PTP_PNM == m_prefTransportProtocol &&
  403.          m_lastUsedTime < m_pOwner->m_lastPNMPreferencesModifiedTime)
  404. {
  405.     m_state = PTS_CREATE;
  406.     m_uPlaybacks = 0;
  407.     m_prefTransportType = m_pOwner->m_pnmTransportTypeStartWith;
  408. }
  409. else if (m_pOwner->m_ulPlaybacks != m_ulParentPlaybacks)
  410. {
  411.     m_ulParentPlaybacks = m_pOwner->m_ulPlaybacks;   
  412.     m_uPlaybacks++;
  413.     // save the playback counter for UpShift
  414.     if (PTP_RTSP == m_prefTransportProtocol &&
  415. m_prefTransportType > m_pOwner->m_rtspTransportTypeStartWith)
  416.     {
  417. m_pOwner->m_bSave = TRUE;
  418.     }
  419.     else if (PTP_PNM == m_prefTransportProtocol &&
  420.      m_prefTransportType > m_pOwner->m_pnmTransportTypeStartWith)
  421.     {
  422. m_pOwner->m_bSave = TRUE;
  423.     }
  425.     // attempt transport upshift every 3rd play
  426.     m_uPlaybacks = m_uPlaybacks % 3;
  427.     if (0 == m_uPlaybacks)
  428.     {
  429. upShiftToTransport = m_prefTransportType;
  430. m_pOwner->UpShiftTransport(this, upShiftToTransport);
  432. if (upShiftToTransport != m_prefTransportType)
  433. {
  434.     m_state = PTS_CREATE;
  435.     m_prefTransportType = upShiftToTransport;
  436. }
  437.     }
  438. }
  439.     }
  440.     // this is the first use
  441.     else
  442.     {
  443. if (PTS_CREATE == m_state)
  444. {
  445.     m_uPlaybacks = 0;
  446.     m_prefTransportType = m_pOwner->GetTransportPreferred(this);
  447. }
  448. else
  449. {
  450.     HX_ASSERT(PTS_PENDING == m_state);
  451.     m_prefTransportType = UnknownMode;
  452. }
  453.     }
  454.     
  455.     // sanity check
  456.     if (UnknownMode != m_prefTransportType)
  457.     {
  458. if (PTP_RTSP == m_prefTransportProtocol)
  459. {
  460.     HX_ASSERT(m_prefTransportType >= m_pOwner->m_rtspTransportTypeStartWith);
  461. }
  462. else if (PTP_PNM == m_prefTransportProtocol)
  463. {
  464.     HX_ASSERT(m_prefTransportType >= m_pOwner->m_pnmTransportTypeStartWith);
  465. }
  466.     }
  468.     return;
  469. }
  471. void
  472. HXPreferredTransport::Close()
  473. {
  474.     HX_DELETE(m_pHost);
  476.     if (m_pPrefTransportSinkList)
  477.     {
  478. CHXSimpleList::Iterator i = m_pPrefTransportSinkList->Begin();
  479. for (; i != m_pPrefTransportSinkList->End(); ++i)
  480. {
  481.     IHXPreferredTransportSink* pSink = (IHXPreferredTransportSink*)*i;
  482.     HX_RELEASE(pSink);
  483. }
  484. HX_DELETE(m_pPrefTransportSinkList);
  485.     }
  487.     HX_RELEASE(m_pOwner);
  488. }
  490. HXPreferredTransportManager::HXPreferredTransportManager(IUnknown* pContext)
  491.     : m_lRefCount(0)
  492.     , m_bSave(FALSE)
  493.     , m_pszFile(NULL)
  494.     , m_ulRTSPTransportMask(ATTEMPT_AUTOTRANSPORT)
  495.     , m_ulPNMTransportMask(ATTEMPT_AUTOTRANSPORT)
  496.     , m_ulLocalHost(0)
  497.     , m_ulSubnetMask(0)
  498.     , m_ulSubnet(0)
  499.     , m_ulPlaybacks(0)
  500.     , m_lastRTSPPreferencesModifiedTime(0)
  501.     , m_lastPNMPreferencesModifiedTime(0)
  502.     , m_internalTransportType(MulticastMode)
  503.     , m_externalTransportType(MulticastMode)
  504.     , m_rtspTransportTypeStartWith(MulticastMode)
  505.     , m_pnmTransportTypeStartWith(MulticastMode)
  506.     , m_pPrefHostTransportList(NULL)
  507.     , m_pPrevPrefHostTransportList(NULL)
  508.     , m_pSubnetManager(NULL)
  509.     , m_pPreferences(NULL)
  510.     , m_pProxyManager(NULL)
  511.     , m_pHXNetInterface(NULL)
  512.     , m_bInitialized(FALSE)
  513. #ifdef _WINDOWS
  514.     , m_pLock(NULL)
  515. #elif _UNIX
  516.     , m_fileID(0)
  517. #endif /* _WINDOWS */
  518. {    
  519.     if (pContext)
  520.     {
  521. m_pContext = pContext;
  522. m_pContext->AddRef();
  523.     }
  524. }
  526. HXPreferredTransportManager::~HXPreferredTransportManager()
  527. {
  528.     Close();
  529. }
  531. STDMETHODIMP
  532. HXPreferredTransportManager::QueryInterface(REFIID riid, void**ppvObj)
  533. {
  534.     QInterfaceList qiList[] =
  535.         {
  536.             { GET_IIDHANDLE(IID_IHXPreferredTransportManager), (IHXPreferredTransportManager*)this },
  537.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXPreferredTransportManager*)this },
  538.         };
  539.     
  540.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  541. }
  543. /////////////////////////////////////////////////////////////////////////
  544. //  Method:
  545. // IUnknown::AddRef
  546. //  Purpose:
  547. // Everyone usually implements this the same... feel free to use
  548. // this implementation.
  549. //
  550. STDMETHODIMP_(ULONG32) 
  551. HXPreferredTransportManager::AddRef()
  552. {
  553.     return InterlockedIncrement(&m_lRefCount);
  554. }
  556. /////////////////////////////////////////////////////////////////////////
  557. //  Method:
  558. // IUnknown::Release
  559. //  Purpose:
  560. // Everyone usually implements this the same... feel free to use
  561. // this implementation.
  562. //
  563. STDMETHODIMP_(ULONG32) 
  564. HXPreferredTransportManager::Release()
  565. {
  566.     if (InterlockedDecrement(&m_lRefCount) > 0)
  567.     {
  568.         return m_lRefCount;
  569.     }
  571.     delete this;
  572.     return 0;
  573. }
  575. HX_RESULT    
  576. HXPreferredTransportManager::_Initialize(void)
  577. {
  578.     HX_RESULT hr = HXR_OK;
  579.     HXNetInterface* pHXNI = NULL;
  580.     
  581.     if (!m_pContext)
  582.     {
  583. hr = HXR_FAILED;
  584. goto cleanup;
  585.     }
  587.     if (!m_pSubnetManager)
  588.     {
  589. m_pSubnetManager = new HXSubnetManager((IUnknown*)m_pContext);
  590.     }
  592. #if defined(HELIX_FEATURE_PROXYMGR)
  593.     if (!m_pProxyManager)
  594.     {
  595. m_pContext->QueryInterface(IID_IHXProxyManager, (void**)&m_pProxyManager);
  596. HX_ASSERT(m_pProxyManager);
  597.     }
  598. #endif /* #if defined(HELIX_FEATURE_PROXYMGR) */
  600.     CollectNetworkInfo();
  602.     PrepPrefTransport();
  604.     OpenPrefTransport();
  606.     m_bInitialized = TRUE;
  608. cleanup:
  610.     return hr;
  611. }
  613. HX_RESULT
  614. HXPreferredTransportManager::ReadPreferences(BOOL  bRTSPProtocol, UINT32& ulTransportMask)
  615. {
  616.     BOOL bAutoTransport = TRUE;
  617.     BOOL bMulticast = FALSE;
  618.     BOOL bUDP = FALSE;
  619.     BOOL bTCP = FALSE;
  620.     BOOL bHTTPCloak = FALSE; 
  622.     ulTransportMask = 0;
  624.     ReadPrefBOOL(m_pPreferences, "AutoTransport", bAutoTransport);
  626.     if (bAutoTransport)
  627.     {
  628. ulTransportMask = ATTEMPT_AUTOTRANSPORT;
  629.     }
  630.     else
  631.     {
  632.         ReadPrefBOOL(m_pPreferences, bRTSPProtocol?"AttemptRTSPvMulticast":"AttemptPNAvMulticast", bMulticast);
  633.         ReadPrefBOOL(m_pPreferences, bRTSPProtocol?"AttemptRTSPvUDP":"AttemptPNAvUDP", bUDP);
  634.         ReadPrefBOOL(m_pPreferences, bRTSPProtocol?"AttemptRTSPvTCP":"AttemptPNAvTCP", bTCP);
  635.         ReadPrefBOOL(m_pPreferences, bRTSPProtocol?"AttemptRTSPvHTTP":"AttemptPNAvHTTP", bHTTPCloak);
  637. if (bMulticast)
  638. {
  639.     ulTransportMask |= ATTEMPT_MULTICAST;
  640. }
  642. if (bUDP)
  643. {
  644.     ulTransportMask |= ATTEMPT_UDP;
  645. }
  647. if (bTCP)
  648. {
  649.     ulTransportMask |= ATTEMPT_TCP;
  650. }
  652. if (bHTTPCloak)
  653. {
  654.     ulTransportMask |= ATTEMPT_HTTPCLOAK;
  655. }
  656.     }
  658.     return HXR_OK;
  659. }
  661. void
  662. HXPreferredTransportManager::Close(void)
  663. {
  664.     if (m_bSave)
  665.     {
  666. SavePrefTransport();
  667.     }
  669.     ResetPrefTransport(m_pPrevPrefHostTransportList);
  670.     HX_DELETE(m_pPrevPrefHostTransportList);
  672.     ResetPrefTransport(m_pPrefHostTransportList);
  673.     HX_DELETE(m_pPrefHostTransportList);
  675.     HX_DELETE(m_pSubnetManager);
  677.     if (m_pHXNetInterface)
  678.     {
  679. m_pHXNetInterface->RemoveAdviseSink((IHXNetInterfacesAdviseSink*)this);
  680. HX_RELEASE(m_pHXNetInterface);
  681.     }
  683. #if defined(HELIX_FEATURE_PROXYMGR)
  684.     HX_RELEASE(m_pProxyManager);
  685. #endif /* HELIX_FEATURE_PROXYMGR */
  687.     HX_RELEASE(m_pPreferences);
  688.     HX_RELEASE(m_pContext);
  690.     HX_VECTOR_DELETE(m_pszFile);
  692.     m_bInitialized = FALSE;
  694. #ifdef _WINDOWS
  695.     HX_DELETE(m_pLock);
  696. #endif /* _WINDOWS */
  697. }
  699. void
  700. HXPreferredTransportManager::TransportSet(HXPreferredTransport* pPreferredTransport,
  701.    BOOL bSave)
  702. {
  703.     if (PTC_INTERNAL == pPreferredTransport->m_prefTransportClass)
  704.     {
  705. m_internalTransportType = pPreferredTransport->m_prefTransportType;
  706.     }
  707.     else if (PTC_EXTERNAL == pPreferredTransport->m_prefTransportClass)
  708.     {
  709. m_externalTransportType = pPreferredTransport->m_prefTransportType;
  710.     }
  711.     else
  712.     {
  713. HX_ASSERT(FALSE);
  714.     }
  716.     if (bSave)
  717.     {
  718. m_bSave = TRUE;
  719.     }
  720. }
  721.       
  722. /************************************************************************
  723.  * Method:
  724.  *     IHXPreferredTransportManager::Initialize
  725.  * Purpose:
  726.  *     Initialize the transport manager such as re-reading the preferences
  727.  */
  728. STDMETHODIMP
  729. HXPreferredTransportManager::Initialize()
  730. {
  731.     HX_RESULT rc = HXR_OK;
  732.     BOOL bPreferenceModified = FALSE;
  733.     UINT32 ulRTSPTransportMask = ATTEMPT_AUTOTRANSPORT;
  734.     UINT32 ulPNMTransportMask = ATTEMPT_AUTOTRANSPORT;
  736.     if (!m_bInitialized)
  737.     {
  738. rc = _Initialize();
  739.     }
  741.     HX_ASSERT(HXR_OK == rc);
  743.     ResetPrefTransport(m_pPrevPrefHostTransportList);
  745.     ReadPreferences(TRUE, ulRTSPTransportMask);
  746.     ReadPreferences(FALSE, ulPNMTransportMask);
  748.     if (ulRTSPTransportMask != m_ulRTSPTransportMask)
  749.     {
  750. bPreferenceModified = TRUE;
  751. m_ulRTSPTransportMask = ulRTSPTransportMask;
  752. m_lastRTSPPreferencesModifiedTime = time(NULL);
  753.     }
  755.     if (ulPNMTransportMask != m_ulPNMTransportMask)
  756.     {
  757. bPreferenceModified = TRUE;
  758. m_ulPNMTransportMask = ulPNMTransportMask;
  759. m_lastPNMPreferencesModifiedTime = time(NULL);
  760.     }
  762.     InitTransportTypeStartWith(m_ulRTSPTransportMask, m_rtspTransportTypeStartWith);
  763.     InitTransportTypeStartWith(m_ulPNMTransportMask, m_pnmTransportTypeStartWith);
  765.     // re-initialize internal/external transport type to its lowest start transport
  766.     // type when we detect the transport preference has been changed
  767.     if (bPreferenceModified)
  768.     {
  769. m_externalTransportType = m_internalTransportType = GetLowerTransport(m_rtspTransportTypeStartWith,
  770.       m_pnmTransportTypeStartWith);
  771.     }
  773.     m_pSubnetManager->Initialize();
  775. #if defined(HELIX_FEATURE_PROXYMGR)
  776.     m_pProxyManager->Initialize(m_pContext);
  777. #endif /* HELIX_FEATURE_PROXYMGR */
  779.     m_ulPlaybacks++;
  781.     return rc;
  782. }
  784. /************************************************************************
  785.  * Method:
  786.  *     IHXPreferredTransportManager::GetPrefTransport
  787.  * Purpose:
  788.  *     Get preferred host transport
  789.  */
  790. STDMETHODIMP
  791. HXPreferredTransportManager::GetPrefTransport(const char*     /* IN  */ pszHostName,
  792.       PreferredTransportProtocol    /* IN  */ prefTransportProtocol,
  793.       REF(IHXPreferredTransport*)   /* OUT */ pPrefTransport)
  794. {
  795.     HX_RESULT     rc = HXR_OK;
  796.     BOOL     bFound = FALSE;
  797.     UINT32     ulIAddress = 0;
  798.     UINT32     ulHostAddress = 0;
  799.     HXPreferredTransport*   pTransport = NULL;
  800.     PreferredTransportClass prefTransportClass = PTC_EXTERNAL;
  801.     CHXString*     pDomainHost = NULL;
  802.     CHXSimpleList::Iterator i;
  804.     pPrefTransport = NULL;
  806.     if (!m_bInitialized)
  807.     {
  808. rc = _Initialize();
  809. if (HXR_OK != rc)
  810. {
  811.     goto cleanup;
  812. }
  813.     }
  815.     if (pszHostName)
  816.     {
  817.         if(IsNumericAddr(pszHostName, strlen(pszHostName)))
  818.         {
  819.     ulIAddress = HXinet_addr(pszHostName);
  820.     ulHostAddress = DwToHost(ulIAddress);
  821.     pDomainHost = new CHXString(pszHostName);
  822.         }
  823.         else
  824.         {
  825.     pDomainHost = GetMasterDomain(pszHostName);
  826.         }
  828.         prefTransportClass = GetTransportClass(pszHostName, ulHostAddress);
  830.         if (m_pPrefHostTransportList)
  831.         {
  832.     i = m_pPrefHostTransportList->Begin();
  833.     for (; i != m_pPrefHostTransportList->End(); ++i)
  834.     {
  835.         pTransport = (HXPreferredTransport*)*i;
  837.         // based on host name for now
  838.         if (pTransport->m_pHost &&
  839.                     !pTransport->m_pHost->CompareNoCase((const char*)*pDomainHost)   &&
  840.     pTransport->m_prefTransportProtocol == prefTransportProtocol    &&
  841.     pTransport->m_prefTransportClass == prefTransportClass)
  842.         {
  843.     bFound = TRUE;
  844.     break;
  845.         }
  846.     }
  847.         }
  848.     }
  850.     if (bFound)
  851.     {
  852. // previous transport attempt is failed
  853. if (pTransport->m_state == PTS_UNKNOWN)
  854. {
  855.     pTransport->m_state = PTS_CREATE;
  856. }
  857.  
  858. pTransport->Initialize();
  859.         pPrefTransport = pTransport;
  860. pPrefTransport->AddRef();
  861.     }
  862.     else
  863.     {
  864. pTransport = new HXPreferredTransport(this);
  865. pTransport->AddRef();
  867. pTransport->m_pHost = pDomainHost;
  868. pTransport->m_ulHost = ulHostAddress;
  869. pTransport->m_prefTransportClass = prefTransportClass;
  870. pTransport->m_prefTransportProtocol = prefTransportProtocol; 
  871. pTransport->m_state = PTS_CREATE;
  873. pTransport->Initialize();
  875.         if (!m_pPrefHostTransportList)
  876.         {
  877.     m_pPrefHostTransportList = new CHXSimpleList();
  878.         }
  880. m_pPrefHostTransportList->AddTail(pTransport);
  881. rc = pTransport->QueryInterface(IID_IHXPreferredTransport, (void**)&pPrefTransport);
  882.     }
  884.     if (pTransport->m_state != PTS_READY)
  885.     {
  886. m_bSave = TRUE;
  887.     }
  889. cleanup:
  891.     return rc;
  892. }
  894. /************************************************************************
  895.  * Method:
  896.  *     IHXPreferredTransportManager::RemovePrefTransport
  897.  * Purpose:
  898.  *     Remove preferred host transport
  899.  */
  900. STDMETHODIMP
  901. HXPreferredTransportManager::RemovePrefTransport(IHXPreferredTransport*   /* IN */ pPrefTransport)
  902. {
  903.     HX_RESULT     rc = HXR_OK;
  904.     HXPreferredTransport*  pTransport = NULL;
  905.     LISTPOSITION     lPos = NULL;
  907.     if (!m_pPrefHostTransportList)
  908.     {
  909. goto cleanup;
  910.     }
  912.     lPos = m_pPrefHostTransportList->GetHeadPosition();
  913.     while (lPos && m_pPrefHostTransportList->GetCount())
  914.     {     
  915. pTransport = (HXPreferredTransport*)m_pPrefHostTransportList->GetAt(lPos);
  917. if (pTransport == pPrefTransport)
  918. {
  919.     HX_RELEASE(pTransport);
  920.     lPos = m_pPrefHostTransportList->RemoveAt(lPos);
  921. }
  922. else
  923. {
  924.     m_pPrefHostTransportList->GetNext(lPos);
  925. }
  926.     }
  928. cleanup:
  930.     return rc;
  931. }
  933. /************************************************************************
  934.  * Method:
  935.  *     IHXPreferredTransportManager::GetTransportPreference
  936.  * Purpose:
  937.  *     Get transport preference set by the user
  938.  */
  939. STDMETHODIMP
  940. HXPreferredTransportManager::GetTransportPreference(PreferredTransportProtocol /* IN  */ prefTransportProtocol,
  941.      REF(UINT32) /* OUT */ ulPreferenceMask)
  942. {
  943.     HX_RESULT rc = HXR_OK;
  945.     if (PTP_RTSP == prefTransportProtocol)
  946.     {
  947. ulPreferenceMask = m_ulRTSPTransportMask;
  948.     }
  949.     else if (PTP_PNM == prefTransportProtocol)
  950.     {
  951. ulPreferenceMask = m_ulPNMTransportMask;
  952.     }
  953.     else
  954.     {
  955. rc = HXR_FAILED;
  956.     }
  958.     return rc;
  959. }
  961. /*
  962.  * IHXNetInterfacesAdviseSink methods
  963.  */
  964. STDMETHODIMP
  965. HXPreferredTransportManager::NetInterfacesUpdated()
  966. {
  968.     HX_RESULT rc = HXR_OK;
  970.     if (m_bSave)
  971.     {
  972. SavePrefTransport();
  973.     }
  975.     ResetPrefTransport(m_pPrevPrefHostTransportList);
  976.     m_pPrevPrefHostTransportList = m_pPrefHostTransportList;
  977.     m_pPrefHostTransportList = NULL;
  979.     HX_VECTOR_DELETE(m_pszFile);
  981.     m_bInitialized = FALSE;
  983.     return rc;
  984. }
  986. HX_RESULT     
  987. HXPreferredTransportManager::CollectNetworkInfo(void)
  988. {
  989.     HX_RESULT rc = HXR_FAILED;
  990.     UINT16 i = 0;
  991.     UINT32 uNI = 0;
  992.     NIInfo* pTempNIInfo = NULL;
  993.     NIInfo* pNIInfo = NULL;
  995.     if (!m_pHXNetInterface)
  996.     {
  997. if (HXR_OK != m_pContext->QueryInterface(IID_IHXNetInterfaces, (void**)&m_pHXNetInterface))
  998. {
  999.     goto cleanup;
  1000. }
  1001. m_pHXNetInterface->AddAdviseSink((IHXNetInterfacesAdviseSink*)this);
  1002.     }
  1004.     if (m_pHXNetInterface)
  1005.     {
  1006. uNI = m_pHXNetInterface->GetNumOfNetInterfaces();
  1008. for (i = 0; i < uNI; i++)
  1009. {
  1010.     if (HXR_OK == m_pHXNetInterface->GetNetInterfaces(i, pTempNIInfo))
  1011.     {
  1012. if (pTempNIInfo && pTempNIInfo->bActive)
  1013. {     
  1014.     pNIInfo = pTempNIInfo;
  1016.     if (POINTTOPOINT == pNIInfo->type)
  1017.     {
  1018. break;
  1019.     }
  1020. }
  1021.     }
  1022. }
  1024. if (pNIInfo)
  1025. {
  1026.     m_ulLocalHost  = DwToHost(pNIInfo->ulNetAddress);
  1027.     m_ulSubnetMask = DwToHost(pNIInfo->ulNetMask);
  1028.     rc = HXR_OK;
  1029. }
  1030.     }
  1032.     HX_ASSERT(m_ulLocalHost);
  1033.     HX_ASSERT(m_ulSubnetMask);
  1035.     m_ulSubnet = m_ulLocalHost & m_ulSubnetMask;
  1037. cleanup:
  1039.     return rc;
  1040. }
  1042. HX_RESULT     
  1043. HXPreferredTransportManager::PrepPrefTransport(void)
  1044. {
  1045.     HX_RESULT   hr = HXR_OK;
  1046. #ifndef _VXWORKS
  1047.     char        buffer[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */
  1048.     const char* pszValue = NULL;
  1049.     IHXBuffer*  pBuffer = NULL;
  1050.     IHXBuffer*  pPrefBuffer = NULL;
  1051.     CHXString   strUserDataPath;
  1053.     if (!m_pPreferences &&  
  1054.         HXR_OK != m_pContext->QueryInterface(IID_IHXPreferences, (void**)&m_pPreferences))
  1055.     {
  1056.         hr = HXR_FAILED;
  1057.         goto cleanup;
  1058.     }
  1060.     if (HXR_OK == m_pPreferences->ReadPref("UserSDKDataPath", pBuffer) && pBuffer)
  1061.     {
  1062.         pszValue = (char*) pBuffer->GetBuffer();
  1063.     }
  1065.     if (!pszValue)
  1066.     {
  1067.         // construct base path
  1068. #ifdef _UNIX
  1069.         strUserDataPath = (const char*) getenv("HOME");
  1070.         strUserDataPath += OS_SEPARATOR_CHAR;
  1071.         strUserDataPath += ".helix";
  1072.         strUserDataPath += OS_SEPARATOR_CHAR;
  1073.         pszValue = (const char*) strUserDataPath;
  1074. #else
  1075.         pszValue = GetDLLAccessPath()->GetPath(DLLTYPE_COMMON);
  1076. #endif        
  1077.     }
  1079.     // determine whether preferred transport setting of this network configuration
  1080.     // has been saved
  1081. #ifdef _MAC_MACHO
  1082. sprintf(buffer, "networkconfig_%lX.txt", m_ulSubnet);
  1083. #else
  1084.     i64toa(m_ulSubnet, buffer, 16);
  1085.     strcat(buffer, ".txt"); /* Flawfinder: ignore */
  1086. #endif
  1087.    
  1088.     m_pszFile = new char[strlen(pszValue) + strlen(buffer) + 10];
  1089.     ::strcpy(m_pszFile, pszValue); /* Flawfinder: ignore */
  1090.     if (m_pszFile[::strlen(m_pszFile)-1] != OS_SEPARATOR_CHAR)
  1091.     {
  1092.         strcat(m_pszFile, OS_SEPARATOR_STRING); /* Flawfinder: ignore */
  1093.     }
  1095.     strcat(m_pszFile, buffer); /* Flawfinder: ignore */
  1097. #if !defined (__TCS__)
  1098.     // we maintain max # of preferred transport config files with
  1099.     // the least used file deleted
  1100.     m_pPreferences->ReadPref("PreferredTransportFiles", pPrefBuffer);
  1102.     ::AddFileToFileListWithCap(buffer, 0, pszValue, pPrefBuffer);
  1103.     m_pPreferences->WritePref("PreferredTransportFiles", pPrefBuffer);
  1104. #endif /* __TCS__ */
  1106.     HX_RELEASE(pPrefBuffer);
  1107.     HX_RELEASE(pBuffer);
  1109. #endif /* _VXWORKS */
  1111.   cleanup:
  1113.     return hr;
  1114. }
  1116. void
  1117. HXPreferredTransportManager::ResetPrefTransport(CHXSimpleList* pPrefHostTransportList)
  1118. {
  1119.     HXPreferredTransport*   pTransport = NULL;
  1121.     while (pPrefHostTransportList && pPrefHostTransportList->GetCount() > 0)
  1122.     {
  1123. pTransport = (HXPreferredTransport*)pPrefHostTransportList->RemoveHead();
  1124. pTransport->Close();
  1125. HX_RELEASE(pTransport);
  1126.     }
  1127. }
  1129. HX_RESULT
  1130. HXPreferredTransportManager::FileReadLine(FILE* fp, char* pLine, UINT32 ulLineBuf, UINT32* pBytesRead)
  1131. {
  1132.     HX_RESULT hr = HXR_OK;
  1133.     UINT32 i = 0;
  1134.     UINT32 ulBytesRead = 0;
  1135.     char* pTmpBuf = NULL;
  1137.     if (!fp)
  1138.     {
  1139. hr = HXR_FAILED;
  1140. goto cleanup;
  1141.     }
  1143.     if (ulLineBuf < 1) 
  1144.     {
  1145.         *pBytesRead = 0;
  1146.         goto cleanup;
  1147.     }
  1149.     ulBytesRead = fread(pLine, sizeof(char), ulLineBuf, fp);
  1150.     pTmpBuf = pLine;
  1152.     if (ulBytesRead)
  1153.     {
  1154. while (i < ulBytesRead) 
  1155. {
  1156. #ifdef _MACINTOSH
  1157.     if (pTmpBuf[i] == 10 || pTmpBuf[i] == 13)
  1158. #else
  1159.     if (pTmpBuf[i] == 10)
  1160. #endif
  1161.     {   // LF
  1162. if (pTmpBuf[i+1])
  1163. {
  1164.     pTmpBuf[i+1] = '';
  1165. }
  1167. // Back the file pointer up.
  1168. fseek(fp, (long)((i + 1) - ulBytesRead), SEEK_CUR);
  1169. *pBytesRead = i + 1;
  1170. break;
  1171.     }
  1172.     i++;
  1173. }
  1174.     }
  1175.     else
  1176.     {
  1177. hr = HXR_FAILED;
  1178.     }
  1179.     
  1180. cleanup:
  1182.     return hr;
  1183. }
  1185. HX_RESULT
  1186. HXPreferredTransportManager::FileWriteLine(FILE* fp, HXPreferredTransport* pPrefTransport)
  1187. {
  1188.     HX_RESULT rc = HXR_OK;
  1189.     UINT32 ulNetAddress = 0;
  1190.     char        buffer[36] = {0}; /* Flawfinder: ignore */
  1191.     char* value = NULL;
  1193.     /* line format is:
  1194.      *
  1195.      * hostname t class t protocol t transport t cloakport t lastRTSPmodifiedtime(internalclass) or
  1196.      *   lastPNMModifiedtime(externalclass)
  1197.      *
  1198.      * hostname     - string(null by default)
  1199.      * class     - transport class(PTC_Internal by default)
  1200.      * protocol     - protocol type(RTSP vs PNM)
  1201.      * transport    - preferred transport(UDPMode by default)
  1202.      * cloakport    - cloak port
  1203.      * time     - last used time
  1204.      * sameserverIP - cloak GET/POST w/ same serverIP
  1205.      * playbacks    - # of playbacks
  1206.      */
  1207.     if (pPrefTransport->m_pHost)
  1208.     {     
  1209. fwrite((const char*)*(pPrefTransport->m_pHost), sizeof(char), pPrefTransport->m_pHost->GetLength(), fp);
  1210.     }
  1211.     else
  1212.     {
  1213.         HX_ASSERT(FALSE);
  1214.     }
  1215.     fwrite("t", sizeof(char), 1, fp);
  1217.     itoa(pPrefTransport->m_prefTransportClass, buffer, 10);
  1218.     fwrite(buffer, sizeof(char), strlen(buffer), fp);
  1219.     fwrite("t", sizeof(char), 1, fp);
  1221.     itoa(pPrefTransport->m_prefTransportProtocol, buffer, 10);
  1222.     fwrite(buffer, sizeof(char), strlen(buffer), fp);
  1223.     fwrite("t", sizeof(char), 1, fp);
  1225.     itoa(pPrefTransport->m_prefTransportType, buffer, 10);
  1226.     fwrite(buffer, sizeof(char), strlen(buffer), fp);
  1227.     fwrite("t", sizeof(char), 1, fp);
  1229.     itoa(pPrefTransport->m_uCloakPort, buffer, 10);
  1230.     fwrite(buffer, sizeof(char), strlen(buffer), fp);
  1231.     fwrite("t", sizeof(char), 1, fp);
  1233.     snprintf(buffer, 36, "%lu", pPrefTransport->m_lastUsedTime); /* Flawfinder: ignore */
  1234.     fwrite(buffer, sizeof(char), strlen(buffer), fp);
  1235.     fwrite("t", sizeof(char), 1, fp);
  1237.     itoa(pPrefTransport->m_bHTTPNG, buffer, 10);
  1238.     fwrite(buffer, sizeof(char), strlen(buffer), fp);
  1239.     fwrite("t", sizeof(char), 1, fp);
  1241.     itoa(pPrefTransport->m_uPlaybacks, buffer, 10);
  1242.     fwrite(buffer, sizeof(char), strlen(buffer), fp);
  1244.     fwrite(LINEBREAK, sizeof(char), LINEBREAK_LEN, fp);
  1246.     return rc;
  1247. }
  1249. HX_RESULT
  1250. HXPreferredTransportManager::FileWriteClass(FILE* fp, 
  1251.      PreferredTransportClass prefTransportClass, 
  1252.      TransportMode transportType,
  1253.      PreferredTransportProtocol protocol,
  1254.      UINT32 ulTransportMask,
  1255.      time_t lastModifiedTime)
  1256. {
  1257.     HX_RESULT rc = HXR_OK;
  1258.     char        buffer[36] = {0}; /* Flawfinder: ignore */
  1260.     /* line format is:
  1261.      *
  1262.      * hostname t class t protocol t transport t cloakport t lastusedtime
  1263.      *
  1264.      * hostname     - string(null by default)
  1265.      * class     - transport class(PTC_Internal by default)
  1266.      * transport    - preferred transport of this class
  1267.      * protocol     - protocol type(RTSP vs PNM)
  1268.      * transportmask- mask for the transport preference
  1269.      * time     - last RTSP/PNM preferences' modified time
  1270.      */
  1271.     fwrite("localhost", sizeof(char), 9, fp);
  1272.     fwrite("t", sizeof(char), 1, fp);
  1274.     itoa(prefTransportClass, buffer, 10);
  1275.     fwrite(buffer, sizeof(char), strlen(buffer), fp);
  1276.     fwrite("t", sizeof(char), 1, fp);
  1278.     itoa(transportType, buffer, 10);
  1279.     fwrite(buffer, sizeof(char), strlen(buffer), fp);
  1280.     fwrite("t", sizeof(char), 1, fp);
  1282.     itoa(protocol, buffer, 10);
  1283.     fwrite(buffer, sizeof(char), strlen(buffer), fp);
  1284.     fwrite("t", sizeof(char), 1, fp);
  1286.     snprintf(buffer,36, "%lu", ulTransportMask); /* Flawfinder: ignore */
  1287.     fwrite(buffer, sizeof(char), strlen(buffer), fp);
  1288.     fwrite("t", sizeof(char), 1, fp);
  1290.     snprintf(buffer,36, "%lu", lastModifiedTime); /* Flawfinder: ignore */
  1291.     fwrite(buffer, sizeof(char), strlen(buffer), fp);
  1293.     fwrite(LINEBREAK, sizeof(char), LINEBREAK_LEN, fp);
  1295.     return rc;
  1296. }
  1298. HX_RESULT
  1299. HXPreferredTransportManager::DownShiftTransport(HX_RESULT error, 
  1300.  HXPreferredTransport* pPrefTransport,
  1301.  REF(TransportMode) prefTransportType)
  1302. {
  1303.     HX_RESULT rc = HXR_OK;
  1304.     UINT32 ulTransportMask = ATTEMPT_AUTOTRANSPORT;
  1306.     HX_ASSERT(UnknownMode != prefTransportType);
  1308.     // HTTPCloak is the last on the transport switching list
  1309.     if (HTTPCloakMode == prefTransportType)
  1310.     {
  1311. prefTransportType = UnknownMode;
  1312. goto cleanup;
  1313.     }
  1315.     if (PTP_RTSP == pPrefTransport->m_prefTransportProtocol)
  1316.     {
  1317. ulTransportMask = m_ulRTSPTransportMask;
  1318.     }
  1319.     else if (PTP_PNM == pPrefTransport->m_prefTransportProtocol)
  1320.     {
  1321. ulTransportMask = m_ulPNMTransportMask;
  1322.     }
  1323.     else
  1324.     {
  1325. HX_ASSERT(FALSE);
  1326.     }
  1328.     // switch to HTTP Cloaking directly if the following list of network
  1329.     // errors have been occured
  1330.     if (error == HXR_NET_CONNECT     ||
  1331. error == HXR_DNR     ||
  1332. error == HXR_SERVER_DISCONNECTED    ||
  1333. error == HXR_DOC_MISSING     ||
  1334. error == HXR_BAD_SERVER     ||
  1335. error == HXR_PROXY_NET_CONNECT)
  1336.     {
  1337. if (ulTransportMask & ATTEMPT_HTTPCLOAK)
  1338. {
  1339.     prefTransportType = HTTPCloakMode;
  1340. }
  1341. else
  1342. {
  1343.     prefTransportType = UnknownMode;
  1344. }
  1345.     }
  1346.     else
  1347.     {
  1348. if (prefTransportType == MulticastMode ||
  1349.     prefTransportType == UDPMode)
  1350. {
  1351.     if (ulTransportMask & ATTEMPT_TCP)
  1352.     {
  1353. prefTransportType = TCPMode;
  1354. goto cleanup;
  1355.     }
  1356.          else if (ulTransportMask & ATTEMPT_HTTPCLOAK)
  1357.     {
  1358. prefTransportType = HTTPCloakMode;
  1359. goto cleanup;
  1360.     }
  1361.     else
  1362.     {
  1363. prefTransportType = UnknownMode;
  1364. goto cleanup;
  1365.     }
  1366. }
  1367. else if (prefTransportType == TCPMode)
  1368. {  
  1369.     if (ulTransportMask & ATTEMPT_HTTPCLOAK)
  1370.     {
  1371. prefTransportType = HTTPCloakMode;
  1372. goto cleanup;
  1373.     }
  1374.     else
  1375.     {
  1376. prefTransportType = UnknownMode;
  1377. goto cleanup;
  1378.     }
  1379. }
  1380.     }
  1382. cleanup:
  1384.     return rc;
  1385. }
  1387. HX_RESULT
  1388. HXPreferredTransportManager::UpShiftTransport(HXPreferredTransport* pPrefTransport,
  1389.        REF(TransportMode) prefTransportType)
  1390. {
  1391.     HX_RESULT rc = HXR_OK;
  1392.     UINT32 ulTransportMask = ATTEMPT_AUTOTRANSPORT;
  1394.     HX_ASSERT(UnknownMode != prefTransportType);
  1396.     // MulticastMode/UDPMode is the toppest on the transport switching list
  1397.     if (MulticastMode == prefTransportType ||
  1398. UDPMode == prefTransportType)
  1399.     {
  1400. goto cleanup;
  1401.     }
  1403.     if (PTP_RTSP == pPrefTransport->m_prefTransportProtocol)
  1404.     {
  1405. ulTransportMask = m_ulRTSPTransportMask;
  1406.     }
  1407.     else if (PTP_PNM == pPrefTransport->m_prefTransportProtocol)
  1408.     {
  1409. ulTransportMask = m_ulPNMTransportMask;
  1410.     }
  1411.     else
  1412.     {
  1413. HX_ASSERT(FALSE);
  1414.     }
  1416.     if (prefTransportType == HTTPCloakMode)
  1417.     {
  1418.         if (ulTransportMask & ATTEMPT_TCP)
  1419.         {
  1420.     prefTransportType = TCPMode;
  1421.     goto cleanup;
  1422. }
  1423. // this is intentional...since we always try UDP
  1424. // when we try Multicast.
  1425. else if (ulTransportMask & ATTEMPT_MULTICAST)
  1426. {
  1427.     prefTransportType = MulticastMode;
  1428. }
  1429. else if (ulTransportMask & ATTEMPT_UDP)
  1430. {
  1431.     prefTransportType = UDPMode;
  1432. }
  1433.     }
  1434.     else if (prefTransportType == TCPMode)
  1435.     {
  1436. // this is intentional...since we always try UDP
  1437. // when we try Multicast.
  1438. if (ulTransportMask & ATTEMPT_MULTICAST)
  1439. {
  1440.     prefTransportType = MulticastMode;
  1441. }
  1442. else if (ulTransportMask & ATTEMPT_UDP)
  1443. {
  1444.     prefTransportType = UDPMode;
  1445. }
  1446.     }
  1448. cleanup:
  1450.     return rc;
  1451. }
  1453. BOOL
  1454. HXPreferredTransportManager::ValidateTransport(HXPreferredTransport* pPrefTransport,
  1455. TransportMode prefTransportType)
  1456. {
  1457.     BOOL    bResult = TRUE;
  1458.     UINT32  ulTransportMask = ATTEMPT_AUTOTRANSPORT;
  1460.     if (PTP_RTSP == pPrefTransport->m_prefTransportProtocol)
  1461.     {
  1462. ulTransportMask = m_ulRTSPTransportMask;
  1463.     }
  1464.     else if (PTP_PNM == pPrefTransport->m_prefTransportProtocol)
  1465.     {
  1466. ulTransportMask = m_ulPNMTransportMask;
  1467.     }
  1468.     else
  1469.     {
  1470. HX_ASSERT(FALSE);
  1471.     }
  1473.     switch (prefTransportType)
  1474.     {
  1475.     case MulticastMode:
  1476. bResult = (ulTransportMask & ATTEMPT_MULTICAST);
  1477. break;
  1478.     case UDPMode:
  1479. bResult = (ulTransportMask & ATTEMPT_UDP);
  1480. break;
  1481.     case TCPMode:
  1482. bResult = (ulTransportMask & ATTEMPT_TCP);
  1483. break;
  1484.     case HTTPCloakMode:
  1485. bResult = (ulTransportMask & ATTEMPT_HTTPCLOAK);
  1486. break;
  1487.     default:
  1488. bResult = FALSE;
  1489. break;
  1490.     }
  1492.     return bResult;
  1493. }
  1495. CHXString*
  1496. HXPreferredTransportManager::GetMasterDomain(const char* pszHostName)
  1497. {
  1498.     int nFields = 0;
  1499.     CHXString* pOutString = NULL;
  1500.     CHXString inString;
  1501.     CHXString outString;
  1502.     CHXString domainExt;
  1504.     inString = pszHostName;
  1505.     
  1506.     nFields = inString.CountFields('.');
  1508.     // a valid master domain contains either one or two fields
  1509.     // such as "dingdong", "realguide.com" and "rbn.com"
  1510.     if (nFields <= 2)
  1511.     {
  1512. pOutString = new CHXString(inString);
  1513.     }
  1514.     else
  1515.     {
  1516. domainExt = inString.NthField('.', nFields);
  1518. // distinguish between domestic domains and international domains
  1519. if (!domainExt.CompareNoCase("com") ||
  1520.     !domainExt.CompareNoCase("net") ||
  1521.     !domainExt.CompareNoCase("org") ||
  1522.     !domainExt.CompareNoCase("edu") ||
  1523.     !domainExt.CompareNoCase("gov") ||
  1524.     !domainExt.CompareNoCase("mil"))
  1525. {
  1526.     // save the last 2 nodes for domestic domains
  1527.     outString = inString.NthField('.', nFields - 1);
  1528.     outString += ".";
  1529.     outString += inString.NthField('.', nFields);
  1530. }
  1531. else
  1532. {
  1533.     // save the last 3 nods for international domains
  1534.     outString = inString.NthField('.', nFields - 2);
  1535.     outString += ".";
  1536.     outString += inString.NthField('.', nFields - 1);
  1537.     outString += ".";
  1538.     outString += inString.NthField('.', nFields);
  1539. }
  1541. pOutString = new CHXString(outString);
  1542.     }
  1544.     return pOutString;
  1545. }
  1547. TransportMode
  1548. HXPreferredTransportManager::GetTransportPreferred(HXPreferredTransport* pPrefTransport)
  1549. {
  1550.     TransportMode   transportMode = UnknownMode;
  1551.  
  1552.     if (PTC_INTERNAL == pPrefTransport->m_prefTransportClass)
  1553.     {
  1554. if (PTP_RTSP == pPrefTransport->m_prefTransportProtocol)
  1555. {
  1556.     transportMode = GetHigherTransport(m_rtspTransportTypeStartWith,
  1557.        m_internalTransportType);
  1558. }
  1559. else if (PTP_PNM == pPrefTransport->m_prefTransportProtocol)
  1560. {
  1561.     transportMode = GetHigherTransport(m_pnmTransportTypeStartWith,
  1562.        m_internalTransportType);
  1563. }
  1564. else
  1565. {
  1566.     HX_ASSERT(FALSE);
  1567. }
  1568.     }
  1569.     else if (PTC_EXTERNAL == pPrefTransport->m_prefTransportClass)
  1570.     {
  1571. if (PTP_RTSP == pPrefTransport->m_prefTransportProtocol)
  1572. {
  1573.     transportMode = m_rtspTransportTypeStartWith; 
  1574. //     GetHigherTransport(m_rtspTransportTypeStartWith,
  1575. //        m_externalTransportType);
  1576. }
  1577. else if (PTP_PNM == pPrefTransport->m_prefTransportProtocol)
  1578. {
  1579.     transportMode = m_pnmTransportTypeStartWith;
  1580. //     GetHigherTransport(m_pnmTransportTypeStartWith,
  1581. //        m_externalTransportType);
  1582. }
  1583. else
  1584. {
  1585.     HX_ASSERT(FALSE);
  1586. }
  1587.     }
  1588.  
  1589.     return transportMode;
  1590. }
  1592. TransportMode
  1593. HXPreferredTransportManager::GetHigherTransport(TransportMode mode1, TransportMode mode2)
  1594. {
  1595.     if (mode1 < mode2)
  1596.     {
  1597. return mode2;
  1598.     }
  1599.     else
  1600.     {
  1601. return mode1;
  1602.     }    
  1603. }
  1604.     
  1605. TransportMode
  1606. HXPreferredTransportManager::GetLowerTransport(TransportMode mode1, TransportMode mode2)
  1607. {
  1608.     if (mode1 > mode2)
  1609.     {
  1610. return mode2;
  1611.     }
  1612.     else
  1613.     {
  1614. return mode1;
  1615.     }    
  1616. }
  1618. PreferredTransportClass
  1619. HXPreferredTransportManager::GetTransportClass(const char* pszHostName, UINT32 ulHostAddress)
  1620. {
  1621.     HX_RESULT rc = HXR_OK;
  1622.     PreferredTransportClass prefTransportClass = PTC_EXTERNAL;
  1624.     // Internal server is defined as:
  1625.     // a. a media server on the same network subnet as the client, or
  1626.     // b. a media server on a network subnet that meets the "Peer Subnet" criteria 
  1627.     //    (either as an explicit entry or by meeting wildcard criteria), or
  1628.     // c. a media server that meets the "Proxy Exclude" criteria 
  1629.     //    (either as an explicit entry or by meeting wildcard criteria)
  1630.     if ((m_ulSubnetMask && m_ulSubnet && ((ulHostAddress & m_ulSubnetMask) == m_ulSubnet))  ||
  1631. m_pSubnetManager->IsSubnet(pszHostName)     
  1632. #if defined(HELIX_FEATURE_PROXYMGR)
  1633. || m_pProxyManager->IsExemptionHost((char*)pszHostName)
  1634. #endif /* HELIX_FEATURE_PROXYMGR */
  1635. )
  1636.     {
  1637. prefTransportClass = PTC_INTERNAL;
  1638.     }
  1640.     return prefTransportClass;
  1641. }
  1643. void
  1644. HXPreferredTransportManager::InitTransportTypeStartWith(UINT32 ulTransportMask, 
  1645.  TransportMode& transportStartWith)
  1646. {
  1647.     transportStartWith = UnknownMode;
  1649.     if (ulTransportMask & ATTEMPT_MULTICAST)
  1650.     {
  1651. transportStartWith = MulticastMode;
  1652.     }
  1653.     else if (ulTransportMask & ATTEMPT_UDP)
  1654.     {
  1655. transportStartWith = UDPMode;
  1656.     }
  1657.     else if (ulTransportMask & ATTEMPT_TCP)
  1658.     {
  1659. transportStartWith = TCPMode;
  1660.     }
  1661.     else if (ulTransportMask & ATTEMPT_HTTPCLOAK)
  1662.     {
  1663. transportStartWith = HTTPCloakMode;
  1664.     }
  1665.     else
  1666.     {
  1667. HX_ASSERT(FALSE);
  1668.     }
  1670.     return;
  1671. }
  1673. HX_RESULT
  1674. HXPreferredTransportManager::OpenPrefTransport(void)
  1675. {
  1676.     HX_RESULT     hr = HXR_OK;
  1677.     char*     pszHostName = NULL;
  1678.     char*     pszClass = NULL;
  1679.     char*     pszProtocol = NULL;
  1680.     char*     pszTransport = NULL; 
  1681.     char*     pszTransportMask = NULL;
  1682.     char*     pszCloakPort = NULL;
  1683.     char*     pszExpires = NULL;
  1684.     char*     pszHTTPNG = NULL;
  1685.     char*     pszPlaybacks = NULL;
  1686.     char*     pszUnknownField = NULL;
  1687.     char     buffer[LINE_BUFFER_SIZE] = {0}; /* Flawfinder: ignore */
  1688.     UINT32     ulBytesRead = 0;
  1689.     UINT32     ulIAddress = 0;
  1690.     FILE*     fp = NULL;
  1691.     HXPreferredTransport* pTransport = NULL;
  1692.     PreferredTransportClass transportClass = PTC_UNKNOWN;
  1693.  
  1694.     if (!m_pszFile)
  1695.     {
  1696. hr = HXR_FAILED;
  1697. goto cleanup;
  1698.     }
  1700. #ifdef _WINDOWS
  1701.     if (!m_pLock)
  1702.     {
  1703. #ifdef THREADS_SUPPORTED        
  1704. HXEvent::MakeEvent(m_pLock, RM_PREFTRAN_FILE_LOCK, FALSE);
  1705. #else        
  1706. HXEvent::MakeStubEvent(m_pLock, RM_PREFTRAN_FILE_LOCK, FALSE);
  1707. #endif
  1708.     }
  1709.     else
  1710.     {
  1711. m_pLock->Wait();
  1712.     }
  1713. #endif /* _WINDOWS */
  1715.     if (!(fp = fopen(m_pszFile, "r+b")))
  1716.     {
  1717. hr = HXR_FAILED;
  1718. goto cleanup;
  1719.     }
  1721. #if defined (_UNIX) && !defined(_SUN) && !defined(_SCO_UW) && !defined(_HPUX) && !defined(_IRIX) && !defined(_AIX) && !defined(_OSF1)
  1722.     m_fileID = fileno(fp);    
  1723.     flock(m_fileID, LOCK_EX);
  1724. #endif /* _UNIX */
  1726.      /* line format is:
  1727.      *
  1728.      * hostname t class t protocol t transport t cloakport t time
  1729.      *
  1730.      * hostname     - string(null by default)
  1731.      * class     - transport class(PTC_Internal by default)
  1732.      * protocol     - protocol type(RTSP vs PNM)
  1733.      * transport    - preferred transport(UDPMode by default)
  1734.      * cloakport    - cloak port
  1735.      * time     - time of last used or modified
  1736.      */
  1737.     while (HXR_OK == FileReadLine(fp, &buffer[0], LINE_BUFFER_SIZE, &ulBytesRead))
  1738.     {
  1739. if (*buffer == '#' || *buffer == CR || *buffer == LF || *buffer == 0)
  1740. {
  1741.     continue;
  1742. }
  1744. pszHostName = buffer;
  1745.     
  1746. if(!(pszClass = strchr(pszHostName, 't')))
  1747. {
  1748.     continue;
  1749. }
  1750. *pszClass++ = '';
  1751. if(*pszClass == CR || *pszClass == LF || *pszClass == 0)
  1752. {
  1753.     continue;
  1754. }
  1756. if (0 == strcasecmp(pszHostName, "localhost"))
  1757. {
  1758.     transportClass = (PreferredTransportClass)atoi(pszClass);
  1760.     if(!(pszTransport = strchr(pszClass, 't')))
  1761.     {
  1762. continue;
  1763.     }
  1764.     *pszTransport++ = '';
  1765.     if(*pszTransport == CR || *pszTransport == LF || *pszTransport == 0)
  1766.     {
  1767. continue;
  1768.     }
  1770.     if(!(pszProtocol = strchr(pszTransport, 't')))
  1771.     {
  1772. continue;
  1773.     }
  1774.     *pszProtocol++ = '';
  1775.     if(*pszProtocol == CR || *pszProtocol == LF || *pszProtocol == 0)
  1776.     {
  1777. continue;
  1778.     }
  1780.     if(!(pszTransportMask = strchr(pszProtocol, 't')))
  1781.     {
  1782. continue;
  1783.     }
  1784.     *pszTransportMask++ = '';
  1785.     if(*pszTransportMask == CR || *pszTransportMask == LF || *pszTransportMask == 0)
  1786.     {
  1787. continue;
  1788.     }
  1790.     if(!(pszExpires = strchr(pszTransportMask, 't')))
  1791.     {
  1792. continue;
  1793.     }
  1794.     *pszExpires++ = '';
  1795.     if(*pszExpires == CR || *pszExpires == LF || *pszExpires == 0)
  1796.     {
  1797. continue;
  1798.     }
  1800.     if (!(pszUnknownField = strchr(pszExpires, 't')))
  1801.     {
  1802. // remove the 'n' from the end of the entry
  1803. pszExpires = ::StripLine(pszExpires);
  1804.     }
  1805.     else
  1806.     {
  1807. *pszUnknownField++ = '';
  1808.     }
  1810.     if (PTC_INTERNAL == transportClass)
  1811.     {
  1812. m_internalTransportType = (TransportMode)atoi(pszTransport);
  1813. #ifdef _MACINTOSH
  1814. m_ulRTSPTransportMask = atoi64(pszTransportMask);
  1815. m_lastRTSPPreferencesModifiedTime = (time_t)atoi64(pszExpires);
  1816. #else
  1817. m_ulRTSPTransportMask = atol(pszTransportMask);
  1818. m_lastRTSPPreferencesModifiedTime = atol(pszExpires);
  1819. #endif
  1820.     }
  1821.     else if (PTC_EXTERNAL == transportClass)
  1822.     {
  1823. m_externalTransportType = (TransportMode)atoi(pszTransport);
  1824. #ifdef _MACINTOSH
  1825. m_ulPNMTransportMask = atoi64(pszTransportMask);
  1826. m_lastPNMPreferencesModifiedTime = (time_t)atoi64(pszExpires);
  1827. #else
  1828. m_ulPNMTransportMask = atol(pszTransportMask);
  1829. m_lastPNMPreferencesModifiedTime = atol(pszExpires);
  1830. #endif
  1831.     }
  1832.     else
  1833.     {
  1834. HX_ASSERT(FALSE);
  1835.     }
  1836. }
  1837. else
  1838. {
  1839.     if(!(pszProtocol = strchr(pszClass, 't')))
  1840.     {
  1841. continue;
  1842.     }
  1843.     *pszProtocol++ = '';
  1844.     if(*pszProtocol == CR || *pszProtocol == LF || *pszProtocol == 0)
  1845.     {
  1846. continue;
  1847.     }
  1849.     if(!(pszTransport = strchr(pszProtocol, 't')))
  1850.     {
  1851. continue;
  1852.     }
  1853.     *pszTransport++ = '';
  1854.     if(*pszTransport == CR || *pszTransport == LF || *pszTransport == 0)
  1855.     {
  1856. continue;
  1857.     }
  1859.     if(!(pszCloakPort = strchr(pszTransport, 't')))
  1860.     {
  1861. continue;
  1862.     }
  1863.     *pszCloakPort++ = '';
  1864.     if(*pszCloakPort == CR || *pszCloakPort == LF || *pszCloakPort == 0)
  1865.     {
  1866. continue;
  1867.     }
  1869.     if(!(pszExpires = strchr(pszCloakPort, 't')))
  1870.     {
  1871. continue;
  1872.     }
  1873.     *pszExpires++ = '';
  1874.     if(*pszExpires == CR || *pszExpires == LF || *pszExpires == 0)
  1875.     {
  1876. continue;
  1877.     }
  1879.     if(!(pszHTTPNG = strchr(pszExpires, 't')))
  1880.     {
  1881. continue;
  1882.     }
  1883.     *pszHTTPNG++ = '';
  1884.     if(*pszHTTPNG == CR || *pszHTTPNG == LF || *pszHTTPNG == 0)
  1885.     {
  1886. continue;
  1887.     }
  1889.     if (!(pszPlaybacks = strchr(pszHTTPNG, 't')))
  1890.     {
  1891. continue;
  1892.     }
  1893.     *pszPlaybacks++ = '';
  1894.     if(*pszPlaybacks == CR || *pszPlaybacks == LF || *pszPlaybacks == 0)
  1895.     {
  1896. continue;
  1897.     }
  1898.     
  1899.     if (!(pszUnknownField = strchr(pszPlaybacks, 't')))
  1900.     {
  1901. // remove the 'n' from the end of the entry
  1902. pszPlaybacks = ::StripLine(pszPlaybacks);
  1903.     }
  1904.     else
  1905.     {
  1906. *pszUnknownField++ = '';
  1907.     }
  1909.     // construct a new preferred transport struct
  1910.     pTransport = new HXPreferredTransport(this);
  1911.     pTransport->AddRef();
  1913.     pTransport->m_pHost = new CHXString(pszHostName);
  1914.     pTransport->m_prefTransportClass = (PreferredTransportClass)atoi(pszClass);
  1915.     pTransport->m_prefTransportProtocol = (PreferredTransportProtocol)atoi(pszProtocol);
  1916.     pTransport->m_prefTransportType = (TransportMode)atoi(pszTransport);
  1917.     pTransport->m_uCloakPort = atoi(pszCloakPort);
  1918. #ifdef _MACINTOSH
  1919.     pTransport->m_lastUsedTime = (time_t)atoi64(pszExpires);
  1920. #else
  1921.     pTransport->m_lastUsedTime = atol(pszExpires);
  1922. #endif
  1923.     pTransport->m_bHTTPNG = atoi(pszHTTPNG);
  1924.     pTransport->m_uPlaybacks = atoi(pszPlaybacks);
  1925.     pTransport->m_state = PTS_READY;
  1927.     if (!m_pPrefHostTransportList)
  1928.     {
  1929. m_pPrefHostTransportList = new CHXSimpleList();
  1930.     }
  1932.     m_pPrefHostTransportList->AddTail(pTransport);
  1933. }
  1934.     }
  1936. cleanup:
  1938. #if defined (_UNIX) && !defined(_SUN) && !defined(_SCO_UW) && !defined(_HPUX) && !defined(_IRIX) && !defined(_AIX) && !defined(_OSF1)
  1939.     flock(m_fileID, LOCK_UN);
  1940. #endif /* _UNIX */
  1942.     if (fp)
  1943.     {
  1944. fclose(fp);
  1945.     }
  1947. #ifdef _WINDOWS
  1948.     if (m_pLock)
  1949.     {
  1950. m_pLock->SignalEvent();
  1951.     }
  1952. #endif /* _WINDOWS */
  1954.     return hr;
  1955. }
  1957. HX_RESULT
  1958. HXPreferredTransportManager::SavePrefTransport(void)
  1959. {
  1960.     HX_RESULT     hr = HXR_OK;
  1961.     FILE*     fp = NULL;
  1962.     UINT32     ulTransportMask = 0;
  1963.     HXPreferredTransport*  pTransport = NULL;
  1964.     CHXSimpleList::Iterator  i;
  1966.     if (!m_pszFile)
  1967.     {
  1968. goto cleanup;
  1969.     }
  1971. #ifdef _WINDOWS
  1972.     if (!m_pLock)
  1973.     {
  1974. #ifdef THREADS_SUPPORTED        
  1975. HXEvent::MakeEvent(m_pLock, RM_PREFTRAN_FILE_LOCK, FALSE);
  1976. #else
  1977. HXEvent::MakeStubEvent(m_pLock, RM_PREFTRAN_FILE_LOCK, FALSE);
  1978. #endif        
  1979.     }
  1980.     else
  1981.     {
  1982. m_pLock->Wait();
  1983.     }
  1984. #endif /* _WINDOWS */
  1986.     if (!(fp = fopen(m_pszFile, "w")))
  1987.     {
  1988. hr = HXR_FAILED;
  1989. goto cleanup;
  1990.     }
  1992. #ifdef _UNIX
  1993.     //Make the permisions on the cookies file User read/write only.
  1994.     if( chmod( m_pszFile, S_IRUSR | S_IWUSR ) != 0 )
  1995.     {
  1996.         HX_ASSERT( "Can't change permision on cookies file." == NULL );
  1997.     }
  1998.     
  1999. #endif    
  2001. #if defined (_UNIX) && !defined(_SUN) && !defined(_SCO_UW) && !defined(_HPUX) && !defined(_IRIX) && !defined(_AIX) && !defined(_OSF1)
  2002.     m_fileID = fileno(fp);    
  2003.     flock(m_fileID, LOCK_EX);
  2004. #endif /* _UNIX */
  2006.     fwrite(RM_PREFTRAN_CAPTION, sizeof(char), strlen(RM_PREFTRAN_CAPTION), fp);
  2008.     // save preferred class information first
  2009.     FileWriteClass(fp, PTC_INTERNAL, m_internalTransportType, PTP_RTSP, m_ulRTSPTransportMask, m_lastRTSPPreferencesModifiedTime);
  2010.     FileWriteClass(fp, PTC_EXTERNAL, m_externalTransportType, PTP_PNM, m_ulPNMTransportMask, m_lastPNMPreferencesModifiedTime);
  2012.     // save preferred host information
  2013.     if (m_pPrefHostTransportList)
  2014.     {
  2015. for (i = m_pPrefHostTransportList->Begin(); i != m_pPrefHostTransportList->End(); ++i)
  2016. {
  2017.     pTransport = (HXPreferredTransport*)(*i);
  2018.     if (pTransport->m_pHost && PTS_READY == pTransport->m_state)
  2019.     {
  2020. FileWriteLine(fp, pTransport);
  2021.     }
  2022. }
  2023.     }
  2025.     m_bSave = FALSE;
  2026.     
  2027. cleanup:
  2029. #if defined (_UNIX) && !defined(_SUN) && !defined(_SCO_UW) && !defined(_HPUX) && !defined(_IRIX) && !defined(_AIX) && !defined(_OSF1)
  2030.     flock(m_fileID, LOCK_UN);
  2031. #endif /* _UNIX */
  2033.     if (fp)
  2034.     {
  2035. fclose(fp);
  2036.     }
  2038. #ifdef _WINDOWS
  2039.     if (m_pLock)
  2040.     {
  2041. m_pLock->SignalEvent();
  2042.     }
  2043. #endif /* _WINDOWS */
  2045.     return(hr);
  2046. }