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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
preftran.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：52k
源码类别：

Symbian

开发平台：

Visual C++

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