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

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

Symbian

开发平台：

Visual C++

ot_net.cp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: ot_net.cp,v 1.3.36.1 2004/07/09 02:06:38 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 "Mac_net.h"
  52. #include "OT_net.h"
  53. #include "OT_TCP.h"
  54. #include "OT_UDP.h"
  55. #include "hxmm.h"
  56. #include "hxerrors.h"
  57. #include <string.h>
  58. #include <stdio.h>
  59. #include <stdlib.h>
  60. #include <ctype.h>
  62. #include "hxslist.h"
  64. ULONG32  OT_net::sMacAddress = 0L;
  66. Boolean  OT_net::sMacAddressValid = FALSE;
  67. Boolean  OT_net::sCheckedOT = FALSE;
  68. Boolean  OT_net::sHaveOT = FALSE;
  69. Boolean  OT_net::sMacAddressStrValid = FALSE;
  70. char  OT_net::sMacAddrStr[16];
  71. #ifdef _CARBON
  72. OTClientContextPtr OT_net::sOToutClientContext = NULL;
  73. #endif
  75. //#define _LOG_DATA 1
  77. #if defined(_DEBUG) && defined (_LOG_DATA)
  78. #define DEBUGSTR(x) DebugStr(x)
  79. #else
  80. #define DEBUGSTR(x)
  81. #endif
  83. OT_net*
  84. OT_net::new_socket(UINT16 type)
  85. {
  86. OT_net  *c = NULL;
  88. switch(type)
  89. {
  90. case HX_TCP_SOCKET:
  91. c = new OT_TCP;
  92. break;
  94. case HX_UDP_SOCKET:
  95. c = new OT_UDP;
  96. break;
  99. }
  101. return(c);
  102. }
  104. // Creator should set the socket reference to a value indicating the socket is not open
  105. OT_net::OT_net (void)
  107. : mActiveName (NULL)
  108. , mRef (0)
  109. , mDataArrived (FALSE)
  110. , mDataFlowOn (FALSE)
  111. , mClosing (FALSE)
  112. , mOtherSideHasClosed (FALSE)
  113. , mWeHaveClosed (FALSE)
  114. , mRelease (FALSE)
  115. , mStartedReceivingData (FALSE)
  116. , mAsyncError(HXR_OK)
  117. , m_lRefCount(0)
  118.      , m_pPendingCallbackListOne(NULL)
  119.      , m_pPendingCallbackListTwo(NULL)
  120.      , m_bUsingListOne(FALSE)
  121.      , m_bUsingListTwo(FALSE)
  122.      , m_bDeferredTaskPending(FALSE)
  123.      , m_bIsQuitting(FALSE)
  124. {
  125. #ifdef _USE_OT_DEFER
  126.     m_OTDeferredCookie = OTCreateDeferredTask(OT_net::DeferredTaskProc, this);
  127. #else
  128.     m_DeferredTaskStruct.dtReserved = 0;
  129.     m_DeferredTaskStruct.dtFlags = 0;
  130. #ifdef _CARBON
  131.     m_DeferredTaskStruct.dtAddr = NewDeferredTaskUPP(OT_net::DeferredTaskProc);;
  132. #else
  133.     m_DeferredTaskStruct.dtAddr = NewDeferredTaskProc(OT_net::DeferredTaskProc);;
  134. #endif
  135.     m_DeferredTaskStruct.dtParam = (long) this; 
  136.     m_DeferredTaskStruct.qType = dtQType;
  137. #endif    
  138.     
  139. }
  141. // ~OT_net should close the socket if it is open
  142. OT_net::~OT_net(void)
  143. {
  144.     m_bIsQuitting = TRUE;
  145.     
  146.     UINT32 timeout = TickCount() + 300L;
  147.     while ( m_bDeferredTaskPending && timeout - TickCount() > 0 )
  148.     {
  149. // sit-n-spin, awaiting completion of callbacks.
  150.     }
  151.     
  152. #ifdef _USE_OT_DEFER
  153.     if (m_OTDeferredCookie != 0)
  154.     {
  155.         OTDestroyDeferredTask(m_OTDeferredCookie);
  156.         m_OTDeferredCookie = 0;
  157.     }
  158. #else
  159.     if (m_DeferredTaskStruct.dtAddr != NULL)
  160.     {
  161. #ifdef _CARBON
  162. DisposeDeferredTaskUPP(m_DeferredTaskStruct.dtAddr);
  163. #else
  164. DisposeRoutineDescriptor(m_DeferredTaskStruct.dtAddr);
  165. #endif
  166. m_DeferredTaskStruct.dtAddr = NULL;
  167.     }    
  168. #endif
  170.     CleanupPendingLists();
  172.     HX_DELETE(m_pPendingCallbackListOne);
  173.     HX_DELETE(m_pPendingCallbackListTwo);
  175. if(mRef) 
  176. OTCloseProvider(mRef);
  178. mRef = 0;
  180. if (mActiveName) 
  181. delete [] mActiveName;
  182. mActiveName = nil;
  183. }
  188. void
  189. OT_net::done (void)
  190. {
  191. mLastError = HXR_OK;
  192. }
  194. #if 1
  195. /*----------------------------------------------------------------------------
  196. OTWait 
  198. Wait for an asynchronous Open Transport stream call to complete.
  200. Exit: function result = error code.
  201. ----------------------------------------------------------------------------*/
  202. HX_RESULT
  203. OT_net::OTWait (void)
  204. {
  205. Boolean cancel = FALSE;
  207. do {
  208. cancel = Mac_net::CheckForCancel();
  209. }
  210. while (!mComplete && !cancel);
  212. if(cancel)
  213. mResult = HXR_BLOCK_CANCELED;
  215. return mResult;
  216. }
  217. #else
  218. /*----------------------------------------------------------------------------
  219. OTWait 
  221. Wait for an asynchronous Open Transport stream call to complete.
  223. Exit: function result = error code.
  224. ----------------------------------------------------------------------------*/
  225. HX_RESULT
  226. OT_net::OTWait (void)
  227. {
  228. EventRecord macEvent;
  230. do {
  231. WaitNextEvent(nullEvent, &macEvent, 0L,NULL);
  232. }
  233. while (!mComplete);
  235. return mResult;
  236. }
  237. #endif
  238. /*----------------------------------------------------------------------------
  239. OTSvcWait 
  241. Wait for an asynchronous Open Transport Internet services call to complete.
  243. Entry: svcInfo = pointer to OTSvcInfo struct.
  245. Exit: function result = error code.
  246. ----------------------------------------------------------------------------*/
  248. HX_RESULT
  249. OT_net::OTSvcWait (OTSvcInfo *svcInfo)
  250. {
  251. Boolean cancel = FALSE;
  252. HX_RESULT theErr = HXR_OK;
  254. do 
  255. {
  256. cancel = Mac_net::CheckForCancel();
  257. }
  258. while (!svcInfo->complete && !cancel);
  260. if(cancel)
  261. theErr = HXR_BLOCK_CANCELED;
  262. else
  263. theErr = svcInfo->result;
  265. return theErr;
  266. }
  268. /*----------------------------------------------------------------------------
  269. NetHaveOT 
  271. Determine whether we have Open Transport.
  273. Exit: function result = true if Open Transport and Open Transport/TCP
  274. are both installed.
  275. ----------------------------------------------------------------------------*/
  277. Boolean 
  278. OT_net::NetHaveOT (void)
  279. {
  280. HX_RESULT theErr = HXR_OK;
  281. long result;
  283. if (!sCheckedOT) 
  284. {
  285. theErr = Gestalt(gestaltOpenTpt, &result);
  286. sHaveOT = theErr == HXR_OK && 
  287. (result & gestaltOpenTptPresentMask) != 0 &&
  288. (result & gestaltOpenTptTCPPresentMask) != 0;
  289. sCheckedOT = true;
  290. }
  292. return sHaveOT;
  293. }
  295. /*----------------------------------------------------------------------------
  296. MyOTInetSvcNotifyProc 
  298. Open Transport notifier proc for an Internet services provider.
  300. Entry: svcIfno = pointer to MyOTInetSvcInfo struct.
  301. code = OT event code.
  302. result = OT result.
  303. cookie = OT cookie.
  304. ----------------------------------------------------------------------------*/
  306. pascal void OT_net::SvcNotifyProc (
  308. void  *stream, 
  309. OTEventCode code,
  310. OTResult  result, 
  311. void  *cookie )
  313. {
  315. OTSvcInfo *svcInfo = (OTSvcInfo *) stream;
  317. switch (code) 
  318. {
  319. case T_OPENCOMPLETE:
  320. case T_DNRSTRINGTOADDRCOMPLETE:
  321. case T_DNRADDRTONAMECOMPLETE:
  322. svcInfo->complete = true;
  323. svcInfo->result = result; 
  324. svcInfo->cookie = cookie;
  325. break;
  326. }
  327. }
  329. /*----------------------------------------------------------------------------
  330. OpenInetServices 
  332. Open an Internet services provider.
  334. Entry: svcInfo = pointer to OTSvcInfo struct for this
  335. provider.
  337. Exit: function result = error code.
  338. ----------------------------------------------------------------------------*/
  340. HX_RESULT
  341.  OT_net::OpenInetServices (OTSvcInfo *svcInfo)
  342. {
  343. HX_RESULT theErr = HXR_OK;
  345. svcInfo->complete = false;
  346. #ifdef _CARBON
  347. theErr = OTAsyncOpenInternetServicesInContext(kDefaultInternetServicesPath, 0,
  348. (OTNotifyUPP)SvcNotifyProc, svcInfo, NULL);
  349. #else
  350. theErr = OTAsyncOpenInternetServices(kDefaultInternetServicesPath, 0, 
  351. SvcNotifyProc, svcInfo);
  352. #endif
  354. if(!theErr) theErr = OTSvcWait(svcInfo);
  355. if(!theErr) svcInfo->ref = (InetSvcRef) svcInfo->cookie;
  357. return theErr;
  358. }
  361. /*----------------------------------------------------------------------------
  362. NetGetMyAddr 
  364. Get this Mac's IP address.
  366. Exit: function result = error code.
  367. *addr = the IP address of this Mac.
  369. With Open Transport, if the Mac has more than one IP interface, the
  370. IP address of the default interface is returned.
  371. ----------------------------------------------------------------------------*/
  373. HX_RESULT OT_net::NetGetMyAddr (unsigned long *addr)
  374. {
  375. HX_RESULT theErr = HXR_OK;
  376. InetInterfaceInfo ifaceInfo;
  378. if (!sMacAddressValid) 
  379. {
  380. theErr = OTInetGetInterfaceInfo(&ifaceInfo, kDefaultInetInterface);
  381. if (theErr != HXR_OK) return (theErr);
  382. sMacAddress = ifaceInfo.fAddress;
  384. sMacAddressValid = true;
  385. }
  387. *addr = sMacAddress;
  388. return HXR_OK;
  389. }
  391. HX_RESULT OT_net::NetGetIfaceInfo(InetInterfaceInfo* ifaceInfo)
  392. {
  393.   return (OTInetGetInterfaceInfo(ifaceInfo, kDefaultInetInterface));
  394. }
  396. HX_RESULT
  397. OT_net::blocking(void)
  398. {
  400. return(HXR_OK);
  401. }
  403. HX_RESULT
  404. OT_net::nonblocking(void)
  405. {
  407. return(HXR_OK);
  408. }
  411. /*----------------------------------------------------------------------------
  412. NetGetMyAddrStr 
  414. Get this Mac's IP address as a dotted-decimal string
  416. Exit: function result = error code.
  417. name = this Mac's IP address, as a C-format string.
  418. You must allocate at least 16 bytes for this string.
  419. The returned string has max length 15.
  420. ----------------------------------------------------------------------------*/
  422. HX_RESULT OT_net::NetGetMyAddrStr (char *addrStr)
  423. {
  424. unsigned long addr;
  425. HX_RESULT theErr = HXR_OK;
  427. if (!sMacAddressStrValid) 
  428. {
  429. theErr = NetGetMyAddr(&addr);
  430. if (theErr != HXR_OK) return (theErr);
  432. sprintf(sMacAddrStr, "%ld.%ld.%ld.%ld",
  433. (addr >> 24) & 0xff,
  434. (addr >> 16) & 0xff,
  435. (addr >> 8) & 0xff,
  436.  addr & 0xff);
  438. sMacAddressStrValid = TRUE;
  439. }
  440. strcpy(addrStr, sMacAddrStr);
  441. return HXR_OK;
  442. }
  444. /*----------------------------------------------------------------------------
  445. NetNameToAddr 
  447. Translate a domain name to an IP address.
  449. Entry:  name = C-format domain name string, optionally followed by a
  450. comma, space, or colon and then the port number.
  451. defaultPort = default port number.
  453. Exit: function result = error code.
  454. *addr = IP address.
  455. *port = port number.
  456. ----------------------------------------------------------------------------*/
  458. HX_RESULT OT_net::NetNameToAddr (
  460. char *name, 
  461. unsigned short defaultPort, 
  462. unsigned long *addr, 
  463. unsigned short *port)
  465. {
  466. HX_RESULT theErr = HXR_OK;
  468. InetHostInfo hInfoOT;
  469. char domainName[256];
  470. char *p, *q;
  471. OTSvcInfo svcInfo;
  474. p = name;
  475. q = domainName;
  476. while (*p != 0 && *p != ',' && *p != ' ' && *p != ':') *q++ = *p++;
  477. *q = 0;
  478. q = p;
  479. while (*q == ' ') q++;
  480. if (*q == 0) {
  481. *port = defaultPort;
  482. } else {
  483. p++;
  484. if (!isdigit(*p)) return HXR_BIND;
  485. q = p+1;
  486. while (isdigit(*q)) q++;
  487. while (*q == ' ') q++;
  488. if (*q != 0) return HXR_BIND;
  489. *port = atoi(p);
  490. }
  492. if(conn::is_cached(domainName,addr))
  493. return HXR_OK;
  495. theErr = OTInetStringToHost(domainName, addr);
  496. if (theErr != HXR_OK) {
  497. theErr = OpenInetServices(&svcInfo);
  498. if (theErr == kEINVALErr) return HXR_BIND;
  499. if (theErr != HXR_OK) return (theErr);
  500. svcInfo.complete = false;
  501. theErr = OTInetStringToAddress(svcInfo.ref, domainName, &hInfoOT);
  502. if (theErr == HXR_OK) theErr = OTSvcWait(&svcInfo);
  503. OTCloseProvider(svcInfo.ref);
  504. if (theErr != HXR_OK) {
  505. if (theErr == kOTNoDataErr || theErr == kOTBadNameErr) theErr = HXR_BIND;
  506. return (theErr);
  507. }
  508. OTCloseProvider(svcInfo.ref);
  509. }
  511. conn::add_to_cache(domainName, *addr);
  514. if (mActiveName) 
  515. {
  516. delete [] mActiveName;
  517. mActiveName = NULL;
  518. }
  519. mActiveName = (Ptr) new char[ (::strlen (domainName) + 1)];
  520. if (HXR_OK != (theErr = ::MemError ())) return (theErr);
  521. ::strcpy (mActiveName, domainName);
  523. return HXR_OK;
  524. }
  528. /*----------------------------------------------------------------------------
  529. NetAddrToName 
  531. Translate an IP address to a domain name.
  533. Entry: addr = IP address.
  535. Exit: function result = error code.
  536. name = domain name, as a C-format string.
  537. ----------------------------------------------------------------------------*/
  539. HX_RESULT OT_net::NetAddrToName (unsigned long addr, InetDomainName name)
  540. {
  541. HX_RESULT theErr = HXR_OK;
  542. OTSvcInfo svcInfo;
  544. theErr = OpenInetServices(&svcInfo);
  545. if (theErr != HXR_OK) return (theErr);
  546. svcInfo.complete = false;
  547. theErr = OTInetAddressToName(svcInfo.ref, addr, name);
  548. if (theErr == HXR_OK) theErr = OTSvcWait(&svcInfo);
  549. OTCloseProvider(svcInfo.ref);
  550. if (theErr != HXR_OK) {
  551. if (theErr == kOTNoDataErr || theErr == kOTBadNameErr) theErr = HXR_BIND;
  552. return (theErr);
  553. }
  554. return HXR_OK;
  555. }
  558. // init_drivers() should do any network driver initialization here
  559. // params is a pointer to a platform specfic defined struct that 
  560. // contains an required initialization data
  562. HX_RESULT
  563. OT_net::init_drivers(void *params)
  564. {
  565. return(NetInit());
  566. }
  568. HX_RESULT OT_net::NetInit (void)
  569. {
  570. HX_RESULT theErr = HXR_OK;
  572. if(NetHaveOT())
  573. {
  575. #ifdef _CARBON
  576. theErr = InitOpenTransportInContext(kInitOTForApplicationMask, &sOToutClientContext);
  578. // in the embedded player case, the above call may fail
  579. // so try again with kInitOTForExtensionMask flag
  580. // sOToutClientContext has to be provided when not calling from an application
  581. if (theErr != HXR_OK)
  582. {
  583. theErr = InitOpenTransportInContext(kInitOTForExtensionMask, &sOToutClientContext);
  584. }
  585. HX_ASSERT( theErr == HXR_OK );
  586. if (theErr != HXR_OK) return HXR_OK;
  587. #else
  588. theErr = InitOpenTransport();
  589. #endif
  590. if (theErr != HXR_OK) return HX_OPEN_DRIVER_ERROR;
  591. }
  592. else
  593. theErr = -1;
  595. return(theErr);
  596. }
  598. // close_drivers() should close any network drivers used by the program
  599. // NOTE: The program MUST not make any other calls to the network drivers
  600. // until init_drivers() has been called
  602. HX_RESULT
  603. OT_net::close_drivers(void *params)
  604. {
  605. if(sHaveOT)
  606. {
  607. #ifdef _CARBON
  608. CloseOpenTransportInContext(sOToutClientContext);
  609. #else
  610. CloseOpenTransport();
  611. #endif
  612. }
  614. return(HXR_OK);
  615. }
  618. HX_RESULT
  619. OT_net::host_to_ip_str(char *host, char *ip, UINT32 ulBufLen)
  620. {
  621. HX_RESULT  theErr = HXR_OK;
  622. ULONG32  addr;
  623. UINT16 port;
  625. theErr = lookup_host(host,&addr, &port);
  627. if(!theErr) OTInetHostToString(addr,ip);
  629. if(theErr) theErr = HXR_BIND;
  631. return(theErr);
  632. }
  634. ULONG32 OT_net::AddRef()
  635. {
  636.     return InterlockedIncrement(&m_lRefCount);
  637. }
  639. ULONG32 OT_net::Release()
  640. {
  641.     if (InterlockedDecrement(&m_lRefCount) > 0)
  642.     {
  643.         return m_lRefCount;
  644.     }
  646.     delete this;
  647.     return 0;
  648. }
  651. HX_RESULT
  652. OT_net::lookup_host (
  654. char  *name, 
  655. ULONG32  *addr, 
  656. UINT16  *port,
  657. UINT16  defaultPort)
  659. {
  660. HX_RESULT theErr = HXR_OK;
  662. InetHostInfo hInfoOT;
  663. char domainName[256];
  664. char *p, *q;
  665. OTSvcInfo svcInfo;
  667. p = name;
  668. q = domainName;
  670. while (*p != 0 && *p != ',' && *p != ' ' && *p != ':') *q++ = *p++;
  672. *q = 0;
  673. q = p;
  675. while (*q == ' ') q++;
  677. if (*q == 0) 
  678. *port = defaultPort;
  679. else 
  680. {
  681. p++;
  682. if (!isdigit(*p)) return HXR_BIND;
  683. q = p+1;
  684. while (isdigit(*q)) q++;
  685. while (*q == ' ') q++;
  686. if (*q != 0) return HXR_BIND;
  687. *port = atoi(p);
  688. }
  690. // check if DNS has been cached
  691. if(conn::is_cached(domainName,addr))
  692. return HXR_OK;
  694. theErr = OTInetStringToHost(domainName, addr);
  695. if (theErr != HXR_OK) 
  696. {
  697. theErr = OpenInetServices(&svcInfo);
  698. if (theErr == kEINVALErr) return HXR_BIND;
  699. if (theErr != HXR_OK) return (theErr);
  700. svcInfo.complete = false;
  701. theErr = OTInetStringToAddress(svcInfo.ref, domainName, &hInfoOT);
  702. if (theErr == HXR_OK) theErr = OTSvcWait(&svcInfo);
  703. OTCloseProvider(svcInfo.ref);
  704. if (theErr != HXR_OK) 
  705. {
  706. if (theErr == kOTNoDataErr || theErr == kOTBadNameErr) theErr = HXR_BIND;
  707. return (theErr);
  708. }
  709. *addr = hInfoOT.addrs[0];
  710. }
  712. conn::add_to_cache(domainName, *addr);
  714. return HXR_OK;
  715. }
  718. HX_RESULT OT_net::dns_find_ip_addr(const char * host, UINT16 blocking)
  719. {
  720. if(!host)                 
  721. {
  722. mLastError = HX_INVALID_HOST;
  723. return mLastError;
  724. }
  725. //XXXCWB
  726. // if(get_sock() < 0)                 
  727. // {
  728. // mLastError = HX_NET_SOCKET_INVALID;
  729. // return mLastError;
  730. // }
  732. if (conn::is_cached((char *) host, &mHostIPAddr))
  733. {
  734. mHostIPValid = TRUE;
  735. mDNSDone = TRUE;
  736. if (mCallBack)  
  737. {
  738.     mCallBack->Func(DNS_NOTIFICATION, TRUE);
  739. }
  740. return( mLastError = HXR_OK);
  741. }
  743.         char* pTemp = strrchr(host, '.');
  744.         if (pTemp && atoi(pTemp + 1))
  745.         {   /* IP address. */
  747. struct in_addr addr;  
  748. mHostIPValid = FALSE;
  749. mHostIPAddr = 0;
  750. mDNSDone = TRUE;
  752. ::OTInetStringToHost((char*)host, &addr.s_addr); //!!!!!
  754. if ((UINT)addr.s_addr == (UINT)-1) 
  755. {
  756. mLastError = HX_INVALID_HOST;
  757. if (mCallBack)  
  758. {
  759.     mCallBack->Func(DNS_NOTIFICATION, FALSE);
  760. }
  761. return mLastError;
  762. }
  764. mHostIPValid = TRUE;
  765. mHostIPAddr = *(ULONG32 *) &addr;
  766. conn::add_to_cache((char *) host, mHostIPAddr);
  768. if (mCallBack)  
  769. {
  770.     mCallBack->Func(DNS_NOTIFICATION, TRUE);
  771. }
  772. return HXR_OK;
  773. } 
  775. if (blocking)
  776. {
  777. struct in_addr addr;  
  778.                     
  779. mHostIPValid = FALSE;
  780. mHostIPAddr = 0;
  781. mDNSDone = TRUE;
  783. InetHostInfo ihost;
  784. OTSvcInfo svcInfo;
  785. OSErr theErr = OpenInetServices(&svcInfo);
  786. if (theErr == kEINVALErr) return HXR_BIND;
  787. if (theErr != HXR_OK) return (theErr);
  788. svcInfo.complete = false;
  790. ::OTInetStringToAddress(svcInfo.ref,(char*)host,&ihost);
  791. if (theErr == HXR_OK) theErr = OTSvcWait(&svcInfo);
  792. OTCloseProvider(svcInfo.ref);
  794. if (!ihost.addrs ) 
  795. {
  796. mLastError = HX_INVALID_HOST;
  798. if (mCallBack)  
  799. {
  800.     mCallBack->Func(DNS_NOTIFICATION, FALSE);
  801. }
  803. return mLastError;
  804. }
  806. memcpy(&addr, ihost.addrs, sizeof(struct in_addr));
  808. mHostIPValid = TRUE;
  809. mHostIPAddr = *(ULONG32 *) &addr;
  810. conn::add_to_cache((char *) host, mHostIPAddr);
  812. if (mCallBack)  
  813. {
  814.     mCallBack->Func(DNS_NOTIFICATION, TRUE);
  815. }
  817. return( mLastError = HXR_OK);
  818. }
  819. else // non-blocking
  820. {
  821. mDNSDone     = TRUE;
  822. mHostIPValid = FALSE;
  823. mHostIPAddr  = 0;
  825. HX_RESULT theErr;
  826. MyOTInfo myOTInfo;
  828. ::memset(&myOTInfo, 0, sizeof(myOTInfo));
  830. myOTInfo.hostName = host;
  831. myOTInfo.complete = false;
  833. #ifdef _CARBON
  834. theErr = OTAsyncOpenInternetServicesInContext(kDefaultInternetServicesPath, 0,
  835. ::NewOTNotifyUPP(MyOTNotifyProc), &myOTInfo, NULL);
  836. #else
  837. theErr = OTAsyncOpenInternetServices(kDefaultInternetServicesPath, 0,
  838. MyOTNotifyProc, &myOTInfo);
  839. #endif
  840. if (theErr != HXR_OK)
  841. {
  842. return( mLastError = HXR_BIND);
  843. }
  845. // MyOTNotifyProc() handles asynch. functionality of this routine
  847. Boolean cancel = false;
  848. do 
  849. {
  850. cancel = Mac_net::CheckForCancel();
  851. }
  852. while (!myOTInfo.complete && !cancel);
  854. // Save the IP address
  855. Boolean bFound;
  856. if (myOTInfo.hostInfo.addrs && *myOTInfo.hostInfo.addrs)
  857. {
  858. bFound = true;
  859. mLastError = HXR_OK;
  860.  
  861. struct in_addr addr;  
  862. memcpy(&addr, myOTInfo.hostInfo.addrs, sizeof(struct in_addr));
  864. mHostIPValid = TRUE;
  865. mHostIPAddr = *(ULONG32 *) &addr;
  866. conn::add_to_cache((char *) host, mHostIPAddr);
  867. }
  868. else
  869. {
  870. bFound = false;
  871. mLastError = HX_INVALID_HOST;
  872. }
  874. ::OTRemoveNotifier(myOTInfo.inetSvcRef);
  875. ::OTCloseProvider (myOTInfo.inetSvcRef);
  877. if (mCallBack)  
  878. {
  879.     mCallBack->Func(DNS_NOTIFICATION, bFound);
  880. }
  882. return(mLastError);
  883. }
  884. return FALSE;
  885. }
  887. pascal void OT_net::MyOTNotifyProc
  888. (
  889. void*  contextPtr, 
  890. OTEventCode  code,
  891. OTResult  result, 
  892. void*  cookie
  893. )
  894. {
  895. MyOTInfo* myOTInfoPtr = (MyOTInfo *) contextPtr;
  897. switch (code) 
  898. {
  899. case T_OPENCOMPLETE:
  900. myOTInfoPtr->inetSvcRef = (InetSvcRef)cookie;
  901. ::OTInetStringToAddress(myOTInfoPtr->inetSvcRef, (char*)myOTInfoPtr->hostName, &myOTInfoPtr->hostInfo);
  902. break;
  904. case T_DNRSTRINGTOADDRCOMPLETE:
  905. case T_DNRADDRTONAMECOMPLETE:
  906. myOTInfoPtr->complete = true;
  907. break;
  908. }
  909. }
  912. BOOL OT_net::dns_ip_addr_found(BOOL * valid, ULONG32 *addr)
  913. {
  914. if (mDNSDone)
  915. {
  916. *valid = mHostIPValid;
  917. *addr  = mHostIPAddr;
  919. return TRUE;
  920. }
  921. else
  922. return FALSE;
  924. return FALSE;
  925. }
  928. /***********Common code for OT_UDP/OT_TCP*************************/
  930. pascal void OT_net::UDPTCPNotifyProc (
  932.  void *stream, 
  933.  OTEventCode code,
  934.  OTResult result, 
  935.  void *cookie )
  936.  
  937. {
  938. HXMM_INTERRUPTON();
  940. OT_net* s =  (OT_net*) stream;
  942. #ifdef _USE_OT_DEFER
  943.         if (s->m_OTDeferredCookie != 0)
  944. #else
  945. if (s->m_DeferredTaskStruct.dtAddr != NULL)
  946. #endif
  947. {
  948.     OTCallbackInfo* pOTCallbackInfo = new OTCallbackInfo(code, result, cookie); 
  949.     
  950.     s->AddToThePendingList((void*) pOTCallbackInfo);
  951.     
  952.     if (!s->m_bDeferredTaskPending)
  953.     {
  954.         if ( !s->m_bIsQuitting )
  955.         {
  956.         s->m_bDeferredTaskPending = TRUE;
  957. #ifdef _USE_OT_DEFER
  958. OTScheduleDeferredTask(s->m_OTDeferredCookie);
  959. #else
  960.         DTInstall(&s->m_DeferredTaskStruct);
  961. #endif
  962.         }
  963.     }
  964. }
  965.     
  966.     HXMM_INTERRUPTOFF();
  967. }
  969. #ifdef _USE_OT_DEFER
  970. pascal void OT_net::DeferredTaskProc(void* inParam)
  971. #else
  972. pascal void OT_net::DeferredTaskProc(long inParam)
  973. #endif
  974. {
  975.     HXMM_INTERRUPTON();
  977.     OT_net* s =  (OT_net*) inParam;
  978.     if(s)
  979.     {
  980. if ( !s->m_bIsQuitting )
  981. {
  982.     s->ProcessPendingCallbacks();
  983. }
  984.         s->m_bDeferredTaskPending = FALSE;
  985.     }
  986.     
  987.     HXMM_INTERRUPTOFF();
  988. }
  990. void OT_net::AddToThePendingList(void* pNode)
  991. {
  992.     /* Atleast one of the list MUST be free to operate on */
  993.     HX_ASSERT(!m_bUsingListOne || !m_bUsingListTwo);
  995.     if (!m_bUsingListOne)
  996.     {
  997.         if (!m_pPendingCallbackListOne)
  998.         {
  999.             m_pPendingCallbackListOne = new CHXSimpleList;
  1000.         }
  1001.         
  1002.         m_pPendingCallbackListOne->AddTail(pNode);
  1003.     }
  1004.     else if (!m_bUsingListTwo)
  1005.     {
  1006.         if (!m_pPendingCallbackListTwo)
  1007.         {
  1008.             m_pPendingCallbackListTwo = new CHXSimpleList;
  1009.         }
  1010.         
  1011.         m_pPendingCallbackListTwo->AddTail(pNode);
  1012.     }    
  1013. }
  1016. void OT_net::ProcessPendingCallbacks()
  1017. {
  1018. start:
  1019.     m_bUsingListOne = TRUE;
  1021.     while (m_pPendingCallbackListOne && 
  1022.           !m_pPendingCallbackListOne->IsEmpty())
  1023.     {
  1024. OTCallbackInfo* cmd = (OTCallbackInfo*) m_pPendingCallbackListOne->RemoveHead();
  1026. /* Send time sync for ONLY the last pending audio callback */
  1027. ProcessCmd(cmd->m_Code, cmd->m_Result, cmd->m_Cookie);
  1029.       delete cmd;
  1030.     }
  1032.     m_bUsingListOne = FALSE;
  1034.     m_bUsingListTwo = TRUE;
  1036.     while (m_pPendingCallbackListTwo && 
  1037.           !m_pPendingCallbackListTwo->IsEmpty())
  1038.     {
  1039. OTCallbackInfo* cmd = (OTCallbackInfo*) m_pPendingCallbackListTwo->RemoveHead();
  1041. /* Send time sync for ONLY the last pending audio callback */
  1042. ProcessCmd(cmd->m_Code, cmd->m_Result, cmd->m_Cookie);
  1044.      delete cmd;
  1045.     }
  1047.     m_bUsingListTwo = FALSE;
  1048.     
  1049.     /* Do we still have more pending callbacks to process? */
  1050.     if ((m_pPendingCallbackListOne && m_pPendingCallbackListOne->GetCount() > 0) ||
  1051.         (m_pPendingCallbackListTwo && m_pPendingCallbackListTwo->GetCount() > 0))
  1052.     {
  1053.         goto start;
  1054.     }    
  1055. }        
  1057. void OT_net::CleanupPendingLists()
  1058. {
  1059.     m_bUsingListOne = TRUE;
  1060.     while(m_pPendingCallbackListOne && !m_pPendingCallbackListOne->IsEmpty())
  1061.     {
  1062.         SndCommand* cmd = (SndCommand*)m_pPendingCallbackListOne->RemoveHead();
  1063.         delete cmd;
  1064.     }
  1066.     m_bUsingListOne = FALSE;
  1068.     m_bUsingListTwo = TRUE;
  1069.     while(m_pPendingCallbackListTwo && !m_pPendingCallbackListTwo->IsEmpty())
  1070.     {
  1071.         SndCommand* cmd = (SndCommand*)m_pPendingCallbackListTwo->RemoveHead();
  1072.         delete cmd;
  1073.     }
  1075.     m_bUsingListTwo = FALSE;
  1076. }
  1078. OTResult OT_net::GetFourByteOption(EndpointRef ep,
  1079.                            OTXTILevel level,
  1080.                            OTXTIName  name,
  1081.                            UInt32   *value)
  1082. {
  1083.    OTResult err;
  1084.    TOption  option;
  1085.    TOptMgmt request;
  1086.    TOptMgmt result;
  1087.    
  1088.    /* Set up the option buffer */
  1089.    option.len  = kOTFourByteOptionSize;
  1090.    option.level= level;
  1091.    option.name = name;
  1092.    option.status = 0;
  1093.    option.value[0] = 0;// Ignored because we're getting the value.
  1095.    /* Set up the request parameter for OTOptionManagement to point
  1096.     to the option buffer we just filled out */
  1098.    request.opt.buf= (UInt8 *) &option;
  1099.    request.opt.len= sizeof(option);
  1100.    request.flags= T_CURRENT;
  1102.    /* Set up the reply parameter for OTOptionManagement. */
  1103.    result.opt.buf  = (UInt8 *) &option;
  1104.    result.opt.maxlen = sizeof(option);
  1105.    
  1106.    err = OTOptionManagement(ep, &request, &result);
  1108.    if (err == noErr) {
  1109.       switch (option.status) 
  1110.       {
  1111.          case T_SUCCESS:
  1112.          case T_READONLY:
  1113.             *value = option.value[0];
  1114.             break;
  1115.          default:
  1116.             err = option.status;
  1117.             break;
  1118.       }
  1119.    }
  1120.             
  1121.    return (err);
  1122. }
  1124. OTResult OT_net::SetFourByteOption(EndpointRef ep,
  1125.                            OTXTILevel level,
  1126.                            OTXTIName  name,
  1127.                            UInt32     value)
  1128. {
  1129.    OTResult err;
  1130.    TOption  option;
  1131.    TOptMgmt request;
  1132.    TOptMgmt result;
  1133.    
  1134.    /* Set up the option buffer */
  1135.    option.len  = kOTFourByteOptionSize;
  1136.    option.level= level;
  1137.    option.name = name;
  1138.    option.status = 0;
  1139.    option.value[0] = value; // set the value here
  1141.    /* Set up the request parameter for OTOptionManagement to point
  1142.     to the option buffer we just filled out */
  1144.    request.opt.buf= (UInt8 *) &option;
  1145.    request.opt.len= sizeof(option);
  1146.    request.flags= T_NEGOTIATE;
  1148.    /* Set up the reply parameter for OTOptionManagement. */
  1149.    result.opt.buf  = (UInt8 *) &option;
  1150.    result.opt.maxlen = sizeof(option);
  1151.    
  1152.    err = OTOptionManagement(ep, &request, &result);
  1154.    if (err == noErr) {
  1155.       switch (option.status) 
  1156.       {
  1157.          case T_SUCCESS:
  1158.          case T_READONLY:
  1159.             value = option.value[0];
  1160.             break;
  1161.          default:
  1162.             err = option.status;
  1163.             break;
  1164.       }
  1165.    }
  1166.             
  1167.    return (err);
  1168. }