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

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

Symbian

开发平台：

C/C++

ot_net.cp：源码内容
  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 "Mac_net.h"
  38. #include "OT_net.h"
  39. #include "OT_TCP.h"
  40. #include "OT_UDP.h"
  41. #include "hxmm.h"
  42. #include "hxerrors.h"
  43. #include <string.h>
  44. #include <stdio.h>
  45. #include <stdlib.h>
  46. #include <ctype.h>
  48. #include "hxslist.h"
  50. ULONG32  OT_net::sMacAddress = 0L;
  52. Boolean  OT_net::sMacAddressValid = FALSE;
  53. Boolean  OT_net::sCheckedOT = FALSE;
  54. Boolean  OT_net::sHaveOT = FALSE;
  55. Boolean  OT_net::sMacAddressStrValid = FALSE;
  56. char  OT_net::sMacAddrStr[16];
  57. #ifdef _CARBON
  58. OTClientContextPtr OT_net::sOToutClientContext = NULL;
  59. #endif
  61. //#define _LOG_DATA 1
  63. #if defined(_DEBUG) && defined (_LOG_DATA)
  64. #define DEBUGSTR(x) DebugStr(x)
  65. #else
  66. #define DEBUGSTR(x)
  67. #endif
  69. OT_net*
  70. OT_net::new_socket(UINT16 type)
  71. {
  72. OT_net  *c = NULL;
  74. switch(type)
  75. {
  76. case HX_TCP_SOCKET:
  77. c = new OT_TCP;
  78. break;
  80. case HX_UDP_SOCKET:
  81. c = new OT_UDP;
  82. break;
  85. }
  87. return(c);
  88. }
  90. // Creator should set the socket reference to a value indicating the socket is not open
  91. OT_net::OT_net (void)
  93. : mActiveName (NULL)
  94. , mRef (0)
  95. , mDataArrived (FALSE)
  96. , mDataFlowOn (FALSE)
  97. , mClosing (FALSE)
  98. , mOtherSideHasClosed (FALSE)
  99. , mWeHaveClosed (FALSE)
  100. , mRelease (FALSE)
  101. , mStartedReceivingData (FALSE)
  102. , mAsyncError(HXR_OK)
  103. , m_lRefCount(0)
  104.      , m_pPendingCallbackListOne(NULL)
  105.      , m_pPendingCallbackListTwo(NULL)
  106.      , m_bUsingListOne(FALSE)
  107.      , m_bUsingListTwo(FALSE)
  108.      , m_bDeferredTaskPending(FALSE)
  109.      , m_bIsQuitting(FALSE)
  110. {
  111. #ifdef _USE_OT_DEFER
  112.     m_OTDeferredCookie = OTCreateDeferredTask(OT_net::DeferredTaskProc, this);
  113. #else
  114.     m_DeferredTaskStruct.dtReserved = 0;
  115.     m_DeferredTaskStruct.dtFlags = 0;
  116. #ifdef _CARBON
  117.     m_DeferredTaskStruct.dtAddr = NewDeferredTaskUPP(OT_net::DeferredTaskProc);;
  118. #else
  119.     m_DeferredTaskStruct.dtAddr = NewDeferredTaskProc(OT_net::DeferredTaskProc);;
  120. #endif
  121.     m_DeferredTaskStruct.dtParam = (long) this; 
  122.     m_DeferredTaskStruct.qType = dtQType;
  123. #endif    
  124.     
  125. }
  127. // ~OT_net should close the socket if it is open
  128. OT_net::~OT_net(void)
  129. {
  130.     m_bIsQuitting = TRUE;
  131.     
  132.     UINT32 timeout = TickCount() + 300L;
  133.     while ( m_bDeferredTaskPending && timeout - TickCount() > 0 )
  134.     {
  135. // sit-n-spin, awaiting completion of callbacks.
  136.     }
  137.     
  138. #ifdef _USE_OT_DEFER
  139.     if (m_OTDeferredCookie != 0)
  140.     {
  141.         OTDestroyDeferredTask(m_OTDeferredCookie);
  142.         m_OTDeferredCookie = 0;
  143.     }
  144. #else
  145.     if (m_DeferredTaskStruct.dtAddr != NULL)
  146.     {
  147. #ifdef _CARBON
  148. DisposeDeferredTaskUPP(m_DeferredTaskStruct.dtAddr);
  149. #else
  150. DisposeRoutineDescriptor(m_DeferredTaskStruct.dtAddr);
  151. #endif
  152. m_DeferredTaskStruct.dtAddr = NULL;
  153.     }    
  154. #endif
  156.     CleanupPendingLists();
  158.     HX_DELETE(m_pPendingCallbackListOne);
  159.     HX_DELETE(m_pPendingCallbackListTwo);
  161. if(mRef) 
  162. OTCloseProvider(mRef);
  164. mRef = 0;
  166. if (mActiveName) 
  167. delete [] mActiveName;
  168. mActiveName = nil;
  169. }
  174. void
  175. OT_net::done (void)
  176. {
  177. mLastError = HXR_OK;
  178. }
  180. #if 1
  181. /*----------------------------------------------------------------------------
  182. OTWait 
  184. Wait for an asynchronous Open Transport stream call to complete.
  186. Exit: function result = error code.
  187. ----------------------------------------------------------------------------*/
  188. HX_RESULT
  189. OT_net::OTWait (void)
  190. {
  191. Boolean cancel = FALSE;
  193. do {
  194. cancel = Mac_net::CheckForCancel();
  195. }
  196. while (!mComplete && !cancel);
  198. if(cancel)
  199. mResult = HXR_BLOCK_CANCELED;
  201. return mResult;
  202. }
  203. #else
  204. /*----------------------------------------------------------------------------
  205. OTWait 
  207. Wait for an asynchronous Open Transport stream call to complete.
  209. Exit: function result = error code.
  210. ----------------------------------------------------------------------------*/
  211. HX_RESULT
  212. OT_net::OTWait (void)
  213. {
  214. EventRecord macEvent;
  216. do {
  217. WaitNextEvent(nullEvent, &macEvent, 0L,NULL);
  218. }
  219. while (!mComplete);
  221. return mResult;
  222. }
  223. #endif
  224. /*----------------------------------------------------------------------------
  225. OTSvcWait 
  227. Wait for an asynchronous Open Transport Internet services call to complete.
  229. Entry: svcInfo = pointer to OTSvcInfo struct.
  231. Exit: function result = error code.
  232. ----------------------------------------------------------------------------*/
  234. HX_RESULT
  235. OT_net::OTSvcWait (OTSvcInfo *svcInfo)
  236. {
  237. Boolean cancel = FALSE;
  238. HX_RESULT theErr = HXR_OK;
  240. do 
  241. {
  242. cancel = Mac_net::CheckForCancel();
  243. }
  244. while (!svcInfo->complete && !cancel);
  246. if(cancel)
  247. theErr = HXR_BLOCK_CANCELED;
  248. else
  249. theErr = svcInfo->result;
  251. return theErr;
  252. }
  254. /*----------------------------------------------------------------------------
  255. NetHaveOT 
  257. Determine whether we have Open Transport.
  259. Exit: function result = true if Open Transport and Open Transport/TCP
  260. are both installed.
  261. ----------------------------------------------------------------------------*/
  263. Boolean 
  264. OT_net::NetHaveOT (void)
  265. {
  266. HX_RESULT theErr = HXR_OK;
  267. long result;
  269. if (!sCheckedOT) 
  270. {
  271. theErr = Gestalt(gestaltOpenTpt, &result);
  272. sHaveOT = theErr == HXR_OK && 
  273. (result & gestaltOpenTptPresentMask) != 0 &&
  274. (result & gestaltOpenTptTCPPresentMask) != 0;
  275. sCheckedOT = true;
  276. }
  278. return sHaveOT;
  279. }
  281. /*----------------------------------------------------------------------------
  282. MyOTInetSvcNotifyProc 
  284. Open Transport notifier proc for an Internet services provider.
  286. Entry: svcIfno = pointer to MyOTInetSvcInfo struct.
  287. code = OT event code.
  288. result = OT result.
  289. cookie = OT cookie.
  290. ----------------------------------------------------------------------------*/
  292. pascal void OT_net::SvcNotifyProc (
  294. void  *stream, 
  295. OTEventCode code,
  296. OTResult  result, 
  297. void  *cookie )
  299. {
  301. OTSvcInfo *svcInfo = (OTSvcInfo *) stream;
  303. switch (code) 
  304. {
  305. case T_OPENCOMPLETE:
  306. case T_DNRSTRINGTOADDRCOMPLETE:
  307. case T_DNRADDRTONAMECOMPLETE:
  308. svcInfo->complete = true;
  309. svcInfo->result = result; 
  310. svcInfo->cookie = cookie;
  311. break;
  312. }
  313. }
  315. /*----------------------------------------------------------------------------
  316. OpenInetServices 
  318. Open an Internet services provider.
  320. Entry: svcInfo = pointer to OTSvcInfo struct for this
  321. provider.
  323. Exit: function result = error code.
  324. ----------------------------------------------------------------------------*/
  326. HX_RESULT
  327.  OT_net::OpenInetServices (OTSvcInfo *svcInfo)
  328. {
  329. HX_RESULT theErr = HXR_OK;
  331. svcInfo->complete = false;
  332. #ifdef _CARBON
  333. theErr = OTAsyncOpenInternetServicesInContext(kDefaultInternetServicesPath, 0,
  334. (OTNotifyUPP)SvcNotifyProc, svcInfo, NULL);
  335. #else
  336. theErr = OTAsyncOpenInternetServices(kDefaultInternetServicesPath, 0, 
  337. SvcNotifyProc, svcInfo);
  338. #endif
  340. if(!theErr) theErr = OTSvcWait(svcInfo);
  341. if(!theErr) svcInfo->ref = (InetSvcRef) svcInfo->cookie;
  343. return theErr;
  344. }
  347. /*----------------------------------------------------------------------------
  348. NetGetMyAddr 
  350. Get this Mac's IP address.
  352. Exit: function result = error code.
  353. *addr = the IP address of this Mac.
  355. With Open Transport, if the Mac has more than one IP interface, the
  356. IP address of the default interface is returned.
  357. ----------------------------------------------------------------------------*/
  359. HX_RESULT OT_net::NetGetMyAddr (unsigned long *addr)
  360. {
  361. HX_RESULT theErr = HXR_OK;
  362. InetInterfaceInfo ifaceInfo;
  364. if (!sMacAddressValid) 
  365. {
  366. theErr = OTInetGetInterfaceInfo(&ifaceInfo, kDefaultInetInterface);
  367. if (theErr != HXR_OK) return (theErr);
  368. sMacAddress = ifaceInfo.fAddress;
  370. sMacAddressValid = true;
  371. }
  373. *addr = sMacAddress;
  374. return HXR_OK;
  375. }
  377. HX_RESULT OT_net::NetGetIfaceInfo(InetInterfaceInfo* ifaceInfo)
  378. {
  379.   return (OTInetGetInterfaceInfo(ifaceInfo, kDefaultInetInterface));
  380. }
  382. HX_RESULT
  383. OT_net::blocking(void)
  384. {
  386. return(HXR_OK);
  387. }
  389. HX_RESULT
  390. OT_net::nonblocking(void)
  391. {
  393. return(HXR_OK);
  394. }
  397. /*----------------------------------------------------------------------------
  398. NetGetMyAddrStr 
  400. Get this Mac's IP address as a dotted-decimal string
  402. Exit: function result = error code.
  403. name = this Mac's IP address, as a C-format string.
  404. You must allocate at least 16 bytes for this string.
  405. The returned string has max length 15.
  406. ----------------------------------------------------------------------------*/
  408. HX_RESULT OT_net::NetGetMyAddrStr (char *addrStr)
  409. {
  410. unsigned long addr;
  411. HX_RESULT theErr = HXR_OK;
  413. if (!sMacAddressStrValid) 
  414. {
  415. theErr = NetGetMyAddr(&addr);
  416. if (theErr != HXR_OK) return (theErr);
  418. sprintf(sMacAddrStr, "%ld.%ld.%ld.%ld",
  419. (addr >> 24) & 0xff,
  420. (addr >> 16) & 0xff,
  421. (addr >> 8) & 0xff,
  422.  addr & 0xff);
  424. sMacAddressStrValid = TRUE;
  425. }
  426. strcpy(addrStr, sMacAddrStr);
  427. return HXR_OK;
  428. }
  430. /*----------------------------------------------------------------------------
  431. NetNameToAddr 
  433. Translate a domain name to an IP address.
  435. Entry:  name = C-format domain name string, optionally followed by a
  436. comma, space, or colon and then the port number.
  437. defaultPort = default port number.
  439. Exit: function result = error code.
  440. *addr = IP address.
  441. *port = port number.
  442. ----------------------------------------------------------------------------*/
  444. HX_RESULT OT_net::NetNameToAddr (
  446. char *name, 
  447. unsigned short defaultPort, 
  448. unsigned long *addr, 
  449. unsigned short *port)
  451. {
  452. HX_RESULT theErr = HXR_OK;
  454. InetHostInfo hInfoOT;
  455. char domainName[256];
  456. char *p, *q;
  457. OTSvcInfo svcInfo;
  460. p = name;
  461. q = domainName;
  462. while (*p != 0 && *p != ',' && *p != ' ' && *p != ':') *q++ = *p++;
  463. *q = 0;
  464. q = p;
  465. while (*q == ' ') q++;
  466. if (*q == 0) {
  467. *port = defaultPort;
  468. } else {
  469. p++;
  470. if (!isdigit(*p)) return HXR_BIND;
  471. q = p+1;
  472. while (isdigit(*q)) q++;
  473. while (*q == ' ') q++;
  474. if (*q != 0) return HXR_BIND;
  475. *port = atoi(p);
  476. }
  478. if(conn::is_cached(domainName,addr))
  479. return HXR_OK;
  481. theErr = OTInetStringToHost(domainName, addr);
  482. if (theErr != HXR_OK) {
  483. theErr = OpenInetServices(&svcInfo);
  484. if (theErr == kEINVALErr) return HXR_BIND;
  485. if (theErr != HXR_OK) return (theErr);
  486. svcInfo.complete = false;
  487. theErr = OTInetStringToAddress(svcInfo.ref, domainName, &hInfoOT);
  488. if (theErr == HXR_OK) theErr = OTSvcWait(&svcInfo);
  489. OTCloseProvider(svcInfo.ref);
  490. if (theErr != HXR_OK) {
  491. if (theErr == kOTNoDataErr || theErr == kOTBadNameErr) theErr = HXR_BIND;
  492. return (theErr);
  493. }
  494. OTCloseProvider(svcInfo.ref);
  495. }
  497. conn::add_to_cache(domainName, *addr);
  500. if (mActiveName) 
  501. {
  502. delete [] mActiveName;
  503. mActiveName = NULL;
  504. }
  505. mActiveName = (Ptr) new char[ (::strlen (domainName) + 1)];
  506. if (HXR_OK != (theErr = ::MemError ())) return (theErr);
  507. ::strcpy (mActiveName, domainName);
  509. return HXR_OK;
  510. }
  514. /*----------------------------------------------------------------------------
  515. NetAddrToName 
  517. Translate an IP address to a domain name.
  519. Entry: addr = IP address.
  521. Exit: function result = error code.
  522. name = domain name, as a C-format string.
  523. ----------------------------------------------------------------------------*/
  525. HX_RESULT OT_net::NetAddrToName (unsigned long addr, InetDomainName name)
  526. {
  527. HX_RESULT theErr = HXR_OK;
  528. OTSvcInfo svcInfo;
  530. theErr = OpenInetServices(&svcInfo);
  531. if (theErr != HXR_OK) return (theErr);
  532. svcInfo.complete = false;
  533. theErr = OTInetAddressToName(svcInfo.ref, addr, name);
  534. if (theErr == HXR_OK) theErr = OTSvcWait(&svcInfo);
  535. OTCloseProvider(svcInfo.ref);
  536. if (theErr != HXR_OK) {
  537. if (theErr == kOTNoDataErr || theErr == kOTBadNameErr) theErr = HXR_BIND;
  538. return (theErr);
  539. }
  540. return HXR_OK;
  541. }
  544. // init_drivers() should do any network driver initialization here
  545. // params is a pointer to a platform specfic defined struct that 
  546. // contains an required initialization data
  548. HX_RESULT
  549. OT_net::init_drivers(void *params)
  550. {
  551. return(NetInit());
  552. }
  554. HX_RESULT OT_net::NetInit (void)
  555. {
  556. HX_RESULT theErr = HXR_OK;
  558. if(NetHaveOT())
  559. {
  561. #ifdef _CARBON
  562. theErr = InitOpenTransportInContext(kInitOTForApplicationMask, &sOToutClientContext);
  564. // in the embedded player case, the above call may fail
  565. // so try again with kInitOTForExtensionMask flag
  566. // sOToutClientContext has to be provided when not calling from an application
  567. if (theErr != HXR_OK)
  568. {
  569. theErr = InitOpenTransportInContext(kInitOTForExtensionMask, &sOToutClientContext);
  570. }
  571. HX_ASSERT( theErr == HXR_OK );
  572. if (theErr != HXR_OK) return HXR_OK;
  573. #else
  574. theErr = InitOpenTransport();
  575. #endif
  576. if (theErr != HXR_OK) return HX_OPEN_DRIVER_ERROR;
  577. }
  578. else
  579. theErr = -1;
  581. return(theErr);
  582. }
  584. // close_drivers() should close any network drivers used by the program
  585. // NOTE: The program MUST not make any other calls to the network drivers
  586. // until init_drivers() has been called
  588. HX_RESULT
  589. OT_net::close_drivers(void *params)
  590. {
  591. if(sHaveOT)
  592. {
  593. #ifdef _CARBON
  594. CloseOpenTransportInContext(sOToutClientContext);
  595. #else
  596. CloseOpenTransport();
  597. #endif
  598. }
  600. return(HXR_OK);
  601. }
  604. HX_RESULT
  605. OT_net::host_to_ip_str(char *host, char *ip, UINT32 ulBufLen)
  606. {
  607. HX_RESULT  theErr = HXR_OK;
  608. ULONG32  addr;
  609. UINT16 port;
  611. theErr = lookup_host(host,&addr, &port);
  613. if(!theErr) OTInetHostToString(addr,ip);
  615. if(theErr) theErr = HXR_BIND;
  617. return(theErr);
  618. }
  620. ULONG32 OT_net::AddRef()
  621. {
  622.     return InterlockedIncrement(&m_lRefCount);
  623. }
  625. ULONG32 OT_net::Release()
  626. {
  627.     if (InterlockedDecrement(&m_lRefCount) > 0)
  628.     {
  629.         return m_lRefCount;
  630.     }
  632.     delete this;
  633.     return 0;
  634. }
  637. HX_RESULT
  638. OT_net::lookup_host (
  640. char  *name, 
  641. ULONG32  *addr, 
  642. UINT16  *port,
  643. UINT16  defaultPort)
  645. {
  646. HX_RESULT theErr = HXR_OK;
  648. InetHostInfo hInfoOT;
  649. char domainName[256];
  650. char *p, *q;
  651. OTSvcInfo svcInfo;
  653. p = name;
  654. q = domainName;
  656. while (*p != 0 && *p != ',' && *p != ' ' && *p != ':') *q++ = *p++;
  658. *q = 0;
  659. q = p;
  661. while (*q == ' ') q++;
  663. if (*q == 0) 
  664. *port = defaultPort;
  665. else 
  666. {
  667. p++;
  668. if (!isdigit(*p)) return HXR_BIND;
  669. q = p+1;
  670. while (isdigit(*q)) q++;
  671. while (*q == ' ') q++;
  672. if (*q != 0) return HXR_BIND;
  673. *port = atoi(p);
  674. }
  676. // check if DNS has been cached
  677. if(conn::is_cached(domainName,addr))
  678. return HXR_OK;
  680. theErr = OTInetStringToHost(domainName, addr);
  681. if (theErr != HXR_OK) 
  682. {
  683. theErr = OpenInetServices(&svcInfo);
  684. if (theErr == kEINVALErr) return HXR_BIND;
  685. if (theErr != HXR_OK) return (theErr);
  686. svcInfo.complete = false;
  687. theErr = OTInetStringToAddress(svcInfo.ref, domainName, &hInfoOT);
  688. if (theErr == HXR_OK) theErr = OTSvcWait(&svcInfo);
  689. OTCloseProvider(svcInfo.ref);
  690. if (theErr != HXR_OK) 
  691. {
  692. if (theErr == kOTNoDataErr || theErr == kOTBadNameErr) theErr = HXR_BIND;
  693. return (theErr);
  694. }
  695. *addr = hInfoOT.addrs[0];
  696. }
  698. conn::add_to_cache(domainName, *addr);
  700. return HXR_OK;
  701. }
  704. HX_RESULT OT_net::dns_find_ip_addr(const char * host, UINT16 blocking)
  705. {
  706. if(!host)                 
  707. {
  708. mLastError = HX_INVALID_HOST;
  709. return mLastError;
  710. }
  711. //XXXCWB
  712. // if(get_sock() < 0)                 
  713. // {
  714. // mLastError = HX_NET_SOCKET_INVALID;
  715. // return mLastError;
  716. // }
  718. if (conn::is_cached((char *) host, &mHostIPAddr))
  719. {
  720. mHostIPValid = TRUE;
  721. mDNSDone = TRUE;
  722. if (mCallBack)  
  723. {
  724.     mCallBack->Func(DNS_NOTIFICATION, TRUE);
  725. }
  726. return( mLastError = HXR_OK);
  727. }
  729.         char* pTemp = strrchr(host, '.');
  730.         if (pTemp && atoi(pTemp + 1))
  731.         {   /* IP address. */
  733. struct in_addr addr;  
  734. mHostIPValid = FALSE;
  735. mHostIPAddr = 0;
  736. mDNSDone = TRUE;
  738. ::OTInetStringToHost((char*)host, &addr.s_addr); //!!!!!
  740. if ((UINT)addr.s_addr == (UINT)-1) 
  741. {
  742. mLastError = HX_INVALID_HOST;
  743. if (mCallBack)  
  744. {
  745.     mCallBack->Func(DNS_NOTIFICATION, FALSE);
  746. }
  747. return mLastError;
  748. }
  750. mHostIPValid = TRUE;
  751. mHostIPAddr = *(ULONG32 *) &addr;
  752. conn::add_to_cache((char *) host, mHostIPAddr);
  754. if (mCallBack)  
  755. {
  756.     mCallBack->Func(DNS_NOTIFICATION, TRUE);
  757. }
  758. return HXR_OK;
  759. } 
  761. if (blocking)
  762. {
  763. struct in_addr addr;  
  764.                     
  765. mHostIPValid = FALSE;
  766. mHostIPAddr = 0;
  767. mDNSDone = TRUE;
  769. InetHostInfo ihost;
  770. OTSvcInfo svcInfo;
  771. OSErr theErr = OpenInetServices(&svcInfo);
  772. if (theErr == kEINVALErr) return HXR_BIND;
  773. if (theErr != HXR_OK) return (theErr);
  774. svcInfo.complete = false;
  776. ::OTInetStringToAddress(svcInfo.ref,(char*)host,&ihost);
  777. if (theErr == HXR_OK) theErr = OTSvcWait(&svcInfo);
  778. OTCloseProvider(svcInfo.ref);
  780. if (!ihost.addrs ) 
  781. {
  782. mLastError = HX_INVALID_HOST;
  784. if (mCallBack)  
  785. {
  786.     mCallBack->Func(DNS_NOTIFICATION, FALSE);
  787. }
  789. return mLastError;
  790. }
  792. memcpy(&addr, ihost.addrs, sizeof(struct in_addr));
  794. mHostIPValid = TRUE;
  795. mHostIPAddr = *(ULONG32 *) &addr;
  796. conn::add_to_cache((char *) host, mHostIPAddr);
  798. if (mCallBack)  
  799. {
  800.     mCallBack->Func(DNS_NOTIFICATION, TRUE);
  801. }
  803. return( mLastError = HXR_OK);
  804. }
  805. else // non-blocking
  806. {
  807. mDNSDone     = TRUE;
  808. mHostIPValid = FALSE;
  809. mHostIPAddr  = 0;
  811. HX_RESULT theErr;
  812. MyOTInfo myOTInfo;
  814. ::memset(&myOTInfo, 0, sizeof(myOTInfo));
  816. myOTInfo.hostName = host;
  817. myOTInfo.complete = false;
  819. #ifdef _CARBON
  820. theErr = OTAsyncOpenInternetServicesInContext(kDefaultInternetServicesPath, 0,
  821. ::NewOTNotifyUPP(MyOTNotifyProc), &myOTInfo, NULL);
  822. #else
  823. theErr = OTAsyncOpenInternetServices(kDefaultInternetServicesPath, 0,
  824. MyOTNotifyProc, &myOTInfo);
  825. #endif
  826. if (theErr != HXR_OK)
  827. {
  828. return( mLastError = HXR_BIND);
  829. }
  831. // MyOTNotifyProc() handles asynch. functionality of this routine
  833. Boolean cancel = false;
  834. do 
  835. {
  836. cancel = Mac_net::CheckForCancel();
  837. }
  838. while (!myOTInfo.complete && !cancel);
  840. // Save the IP address
  841. Boolean bFound;
  842. if (myOTInfo.hostInfo.addrs && *myOTInfo.hostInfo.addrs)
  843. {
  844. bFound = true;
  845. mLastError = HXR_OK;
  846.  
  847. struct in_addr addr;  
  848. memcpy(&addr, myOTInfo.hostInfo.addrs, sizeof(struct in_addr));
  850. mHostIPValid = TRUE;
  851. mHostIPAddr = *(ULONG32 *) &addr;
  852. conn::add_to_cache((char *) host, mHostIPAddr);
  853. }
  854. else
  855. {
  856. bFound = false;
  857. mLastError = HX_INVALID_HOST;
  858. }
  860. ::OTRemoveNotifier(myOTInfo.inetSvcRef);
  861. ::OTCloseProvider (myOTInfo.inetSvcRef);
  863. if (mCallBack)  
  864. {
  865.     mCallBack->Func(DNS_NOTIFICATION, bFound);
  866. }
  868. return(mLastError);
  869. }
  870. return FALSE;
  871. }
  873. pascal void OT_net::MyOTNotifyProc
  874. (
  875. void*  contextPtr, 
  876. OTEventCode  code,
  877. OTResult  result, 
  878. void*  cookie
  879. )
  880. {
  881. MyOTInfo* myOTInfoPtr = (MyOTInfo *) contextPtr;
  883. switch (code) 
  884. {
  885. case T_OPENCOMPLETE:
  886. myOTInfoPtr->inetSvcRef = (InetSvcRef)cookie;
  887. ::OTInetStringToAddress(myOTInfoPtr->inetSvcRef, (char*)myOTInfoPtr->hostName, &myOTInfoPtr->hostInfo);
  888. break;
  890. case T_DNRSTRINGTOADDRCOMPLETE:
  891. case T_DNRADDRTONAMECOMPLETE:
  892. myOTInfoPtr->complete = true;
  893. break;
  894. }
  895. }
  898. BOOL OT_net::dns_ip_addr_found(BOOL * valid, ULONG32 *addr)
  899. {
  900. if (mDNSDone)
  901. {
  902. *valid = mHostIPValid;
  903. *addr  = mHostIPAddr;
  905. return TRUE;
  906. }
  907. else
  908. return FALSE;
  910. return FALSE;
  911. }
  914. /***********Common code for OT_UDP/OT_TCP*************************/
  916. pascal void OT_net::UDPTCPNotifyProc (
  918.  void *stream, 
  919.  OTEventCode code,
  920.  OTResult result, 
  921.  void *cookie )
  922.  
  923. {
  924. HXMM_INTERRUPTON();
  926. OT_net* s =  (OT_net*) stream;
  928. #ifdef _USE_OT_DEFER
  929.         if (s->m_OTDeferredCookie != 0)
  930. #else
  931. if (s->m_DeferredTaskStruct.dtAddr != NULL)
  932. #endif
  933. {
  934.     OTCallbackInfo* pOTCallbackInfo = new OTCallbackInfo(code, result, cookie); 
  935.     
  936.     s->AddToThePendingList((void*) pOTCallbackInfo);
  937.     
  938.     if (!s->m_bDeferredTaskPending)
  939.     {
  940.         if ( !s->m_bIsQuitting )
  941.         {
  942.         s->m_bDeferredTaskPending = TRUE;
  943. #ifdef _USE_OT_DEFER
  944. OTScheduleDeferredTask(s->m_OTDeferredCookie);
  945. #else
  946.         DTInstall(&s->m_DeferredTaskStruct);
  947. #endif
  948.         }
  949.     }
  950. }
  951.     
  952.     HXMM_INTERRUPTOFF();
  953. }
  955. #ifdef _USE_OT_DEFER
  956. pascal void OT_net::DeferredTaskProc(void* inParam)
  957. #else
  958. pascal void OT_net::DeferredTaskProc(long inParam)
  959. #endif
  960. {
  961.     HXMM_INTERRUPTON();
  963.     OT_net* s =  (OT_net*) inParam;
  964.     if(s)
  965.     {
  966. if ( !s->m_bIsQuitting )
  967. {
  968.     s->ProcessPendingCallbacks();
  969. }
  970.         s->m_bDeferredTaskPending = FALSE;
  971.     }
  972.     
  973.     HXMM_INTERRUPTOFF();
  974. }
  976. void OT_net::AddToThePendingList(void* pNode)
  977. {
  978.     /* Atleast one of the list MUST be free to operate on */
  979.     HX_ASSERT(!m_bUsingListOne || !m_bUsingListTwo);
  981.     if (!m_bUsingListOne)
  982.     {
  983.         if (!m_pPendingCallbackListOne)
  984.         {
  985.             m_pPendingCallbackListOne = new CHXSimpleList;
  986.         }
  987.         
  988.         m_pPendingCallbackListOne->AddTail(pNode);
  989.     }
  990.     else if (!m_bUsingListTwo)
  991.     {
  992.         if (!m_pPendingCallbackListTwo)
  993.         {
  994.             m_pPendingCallbackListTwo = new CHXSimpleList;
  995.         }
  996.         
  997.         m_pPendingCallbackListTwo->AddTail(pNode);
  998.     }    
  999. }
  1002. void OT_net::ProcessPendingCallbacks()
  1003. {
  1004. start:
  1005.     m_bUsingListOne = TRUE;
  1007.     while (m_pPendingCallbackListOne && 
  1008.           !m_pPendingCallbackListOne->IsEmpty())
  1009.     {
  1010. OTCallbackInfo* cmd = (OTCallbackInfo*) m_pPendingCallbackListOne->RemoveHead();
  1012. /* Send time sync for ONLY the last pending audio callback */
  1013. ProcessCmd(cmd->m_Code, cmd->m_Result, cmd->m_Cookie);
  1015.       delete cmd;
  1016.     }
  1018.     m_bUsingListOne = FALSE;
  1020.     m_bUsingListTwo = TRUE;
  1022.     while (m_pPendingCallbackListTwo && 
  1023.           !m_pPendingCallbackListTwo->IsEmpty())
  1024.     {
  1025. OTCallbackInfo* cmd = (OTCallbackInfo*) m_pPendingCallbackListTwo->RemoveHead();
  1027. /* Send time sync for ONLY the last pending audio callback */
  1028. ProcessCmd(cmd->m_Code, cmd->m_Result, cmd->m_Cookie);
  1030.      delete cmd;
  1031.     }
  1033.     m_bUsingListTwo = FALSE;
  1034.     
  1035.     /* Do we still have more pending callbacks to process? */
  1036.     if ((m_pPendingCallbackListOne && m_pPendingCallbackListOne->GetCount() > 0) ||
  1037.         (m_pPendingCallbackListTwo && m_pPendingCallbackListTwo->GetCount() > 0))
  1038.     {
  1039.         goto start;
  1040.     }    
  1041. }        
  1043. void OT_net::CleanupPendingLists()
  1044. {
  1045.     m_bUsingListOne = TRUE;
  1046.     while(m_pPendingCallbackListOne && !m_pPendingCallbackListOne->IsEmpty())
  1047.     {
  1048.         SndCommand* cmd = (SndCommand*)m_pPendingCallbackListOne->RemoveHead();
  1049.         delete cmd;
  1050.     }
  1052.     m_bUsingListOne = FALSE;
  1054.     m_bUsingListTwo = TRUE;
  1055.     while(m_pPendingCallbackListTwo && !m_pPendingCallbackListTwo->IsEmpty())
  1056.     {
  1057.         SndCommand* cmd = (SndCommand*)m_pPendingCallbackListTwo->RemoveHead();
  1058.         delete cmd;
  1059.     }
  1061.     m_bUsingListTwo = FALSE;
  1062. }
  1064. OTResult OT_net::GetFourByteOption(EndpointRef ep,
  1065.                            OTXTILevel level,
  1066.                            OTXTIName  name,
  1067.                            UInt32   *value)
  1068. {
  1069.    OTResult err;
  1070.    TOption  option;
  1071.    TOptMgmt request;
  1072.    TOptMgmt result;
  1073.    
  1074.    /* Set up the option buffer */
  1075.    option.len  = kOTFourByteOptionSize;
  1076.    option.level= level;
  1077.    option.name = name;
  1078.    option.status = 0;
  1079.    option.value[0] = 0;// Ignored because we're getting the value.
  1081.    /* Set up the request parameter for OTOptionManagement to point
  1082.     to the option buffer we just filled out */
  1084.    request.opt.buf= (UInt8 *) &option;
  1085.    request.opt.len= sizeof(option);
  1086.    request.flags= T_CURRENT;
  1088.    /* Set up the reply parameter for OTOptionManagement. */
  1089.    result.opt.buf  = (UInt8 *) &option;
  1090.    result.opt.maxlen = sizeof(option);
  1091.    
  1092.    err = OTOptionManagement(ep, &request, &result);
  1094.    if (err == noErr) {
  1095.       switch (option.status) 
  1096.       {
  1097.          case T_SUCCESS:
  1098.          case T_READONLY:
  1099.             *value = option.value[0];
  1100.             break;
  1101.          default:
  1102.             err = option.status;
  1103.             break;
  1104.       }
  1105.    }
  1106.             
  1107.    return (err);
  1108. }
  1110. OTResult OT_net::SetFourByteOption(EndpointRef ep,
  1111.                            OTXTILevel level,
  1112.                            OTXTIName  name,
  1113.                            UInt32     value)
  1114. {
  1115.    OTResult err;
  1116.    TOption  option;
  1117.    TOptMgmt request;
  1118.    TOptMgmt result;
  1119.    
  1120.    /* Set up the option buffer */
  1121.    option.len  = kOTFourByteOptionSize;
  1122.    option.level= level;
  1123.    option.name = name;
  1124.    option.status = 0;
  1125.    option.value[0] = value; // set the value here
  1127.    /* Set up the request parameter for OTOptionManagement to point
  1128.     to the option buffer we just filled out */
  1130.    request.opt.buf= (UInt8 *) &option;
  1131.    request.opt.len= sizeof(option);
  1132.    request.flags= T_NEGOTIATE;
  1134.    /* Set up the reply parameter for OTOptionManagement. */
  1135.    result.opt.buf  = (UInt8 *) &option;
  1136.    result.opt.maxlen = sizeof(option);
  1137.    
  1138.    err = OTOptionManagement(ep, &request, &result);
  1140.    if (err == noErr) {
  1141.       switch (option.status) 
  1142.       {
  1143.          case T_SUCCESS:
  1144.          case T_READONLY:
  1145.             value = option.value[0];
  1146.             break;
  1147.          default:
  1148.             err = option.status;
  1149.             break;
  1150.       }
  1151.    }
  1152.             
  1153.    return (err);
  1154. }