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

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

Symbian

开发平台：

Visual C++

ot_tcp.cp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: ot_tcp.cp,v 1.3.42.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 "OT_TCP.h"
  53. #include "MWDebug.h"
  54. #include "hxerrors.h"
  55. #include <string.h>
  56. #include <stdio.h>
  57. #include <stdlib.h>
  58. #include <ctype.h>
  59. #include "hxmm.h"
  61. //#define _LOG_DATA 1
  62. //#define USE_DEFERRED_IMPL 1
  64. #if defined(_DEBUG) && defined (_LOG_DATA)
  65. #define DEBUGSTR(x) DebugStr(x)
  66. #else
  67. #define DEBUGSTR(x)
  68. #endif
  70. //#include "dcon.h"
  72. OT_TCP::OT_TCP (void)
  74. : mDNSOpen (FALSE)
  75. , mSocketOpen (FALSE)
  76. , mState (TCP_STATE_CLOSED)
  77. , mDNSRef (0)
  78. , mRemoteHostName (0)
  79. , mNewConnection(NULL)
  80. , mDataReady(FALSE)
  82. { /* begin OT_TCP */
  83. //dprintf("this:%X OT_TCP::OT_TCPn", this);
  84. } /* end OT_TCP */
  86. OT_TCP::~OT_TCP (void)
  88. { /* begin ~OT_TCP */
  89. //dprintf("this:%X OT_TCP::~OT_TCPn", this);
  91. Cleanup(TRUE); 
  93. if(mRemoteHostName)
  94. {
  95. delete mRemoteHostName;
  96. mRemoteHostName = NULL;
  97. }
  100. } /* end ~OT_TCP */
  103. void
  104. OT_TCP::done(void)
  105. {
  106. //dprintf("this:%X OT_TCP::donen", this);
  107. Cleanup(TRUE);
  108. }
  113. /*----------------------------------------------------------------------------
  114. Cleanup 
  116. Cleanup a TCP stream.
  118. Exit: function result = error code.
  120. Any active connection is also aborted, if necessary, before releasing 
  121. the stream.
  123. ----------------------------------------------------------------------------*/
  125. OSErr OT_TCP::Cleanup (Boolean orderly /* = FALSE */ )
  126. {
  127. //dprintf("this:%X OT_TCP::Cleanup orderly:%sn", this, (orderly? "TRUE" : "FALSE"));
  128. OSErr theErr = HXR_OK;
  129. Boolean abort;
  131. mState = TCP_STATE_CLOSED;
  133. close_resolver();
  135. if(mRef)
  136. {
  138. abort = (!mOtherSideHasClosed || !mWeHaveClosed) && mConnectionOpen;
  140. if (abort) 
  141. {
  142. mComplete = FALSE;
  143. if (orderly && mStartedReceivingData)
  144. {
  145. mComplete = FALSE;
  146. theErr = ::OTSndOrderlyDisconnect(mRef);
  148. EventRecord macEvent;
  149. long ticks = TickCount();
  151. do 
  152. {
  153. #ifndef THREADS_SUPPORTED
  154. // xxxbobclark when threading networking is
  155. // on, this code may be executing on a non-main-
  156. // app thread. I don't even know what WNE would
  157. // do in that scenario, but that it'd be bad.
  158. WaitNextEvent(nullEvent, &macEvent, 6,NULL);
  159. #endif
  160. }
  161. while (!mComplete && ((TickCount() - ticks) < 120)); 
  162. }
  164. else
  165. theErr = ::OTSndDisconnect(mRef, nil);
  166. }
  168. ::OTRemoveNotifier(mRef); // DS 12.4.95
  169. theErr = ::OTCloseProvider(mRef);
  170. }
  172. if ( mNewConnection )
  173. {
  174. mNewConnection->done();
  175. HX_RELEASE(mNewConnection);
  176. }
  178. mRef = 0;
  180. return theErr;
  181. }
  183.  HX_RESULT
  184.  OT_TCP::connect (
  185.  
  186. const char *host, 
  187. UINT16  port,
  188. UINT16  blocking,
  189. ULONG32 ulPlatform )
  191. {
  192. //dprintf("this:%X OT_TCP::connect - host:%s port:%un", this, host, port);
  193. HX_RESULT theErr = HXR_OK;
  195. // check if socket is in a valid state
  196. if(mState != TCP_STATE_CLOSED)
  197. return HXR_SOCKET_CREATE;  // should be PN_SOCKET_STATE_ERROR
  199. if(mRemoteHostName)
  200. {
  201.  delete mRemoteHostName; 
  202.  mRemoteHostName = NULL;
  203. }
  205. // allocate a buffer to hold the host name
  206. mRemoteHostName = new char[::strlen(host) + 1];
  208. if(mRemoteHostName == NULL)
  209. theErr = HXR_OUTOFMEMORY;
  211. if(!theErr)
  212. {
  213. mConnectionOpen = FALSE;
  214. mRemotePort = port;
  215. mDataFlowOn = FALSE;
  216. mDataArrived = FALSE;
  217. mAsyncError = HXR_OK;
  219. // save a copy of the host name 
  220. ::strcpy(mRemoteHostName,host);
  222. // check if host name is already in IP format or has been cached
  223. if((::OTInetStringToHost(mRemoteHostName, &mRemoteHost) == HXR_OK) || 
  224.   (conn::is_cached(mRemoteHostName,&mRemoteHost)))
  225. {
  226. // open the socket, bind and connect to remote host
  227. mState = TCP_STATE_OPEN_SOCKET;
  228. theErr = open_socket();
  229. }
  230. else // DNR is required on host name
  231. {
  232. // do DNR,open the socket, bind and connect to remote host
  233. theErr = open_resolver();
  234. }
  235. }
  237. if(!theErr && blocking)
  238. {
  239. // wait for mConnectionOpen == TRUE or cancel
  241. }
  243. return theErr;
  244. }
  248.  HX_RESULT
  249.  OT_TCP::init (
  250.   UINT32 local_addr,
  251. UINT16  port,
  252. UINT16  blocking)
  254. {
  255. //dprintf("this:%X OT_TCP::initn", this);
  256. return (HXR_INVALID_OPERATION);
  257. }
  262. /*----------------------------------------------------------------------------
  263. write 
  265. Send data on a stream.
  267. Entry: data = pointer to data to send.
  268. len = length of data to send.
  270. Exit: function result = error code.
  271. ----------------------------------------------------------------------------*/
  273. HX_RESULT 
  274. OT_TCP::write (
  276. void *data, 
  277. UINT16 *len)
  279. {
  280. //dprintf("this:%X OT_TCP::writen", this);
  281. HX_RESULT theErr = HXR_OK;
  283. mLastError=HXR_OK;
  285. if(mAsyncError)
  286. {
  287. theErr = mAsyncError;
  288. mAsyncError = HXR_OK;
  289. return theErr;
  290. }
  292. OTResult  result;
  293. unsigned short  length, count;
  295. count = 0;
  297. if (mOtherSideHasClosed) //cz 
  298. theErr = HXR_SERVER_DISCONNECTED;
  299. else if (!mOtherSideHasClosed && !mConnectionOpen) 
  300. theErr = HXR_WOULD_BLOCK;
  302. else
  303. {
  304. #if 1
  305. if(mDataFlowOn)
  306. {
  307. // DebugStr("pDataFlowOn");
  308. *len = 0;
  309.  return(HXR_WOULD_BLOCK);
  310. }
  311. #endif
  313. length = *len;
  314. while (length > 0 && !theErr) 
  315. {
  316. result = ::OTSnd(mRef, data, length, 0);
  317. if (result >= 0) 
  318. {
  319. count += result;
  320. length -= result;
  321. } 
  323. else
  324. {
  325. #if 0
  326. Str255 s;
  327. NumToString(result,s);
  328. DebugStr(s);
  329. #endif
  330. switch(result)
  331. {
  332. case kOTFlowErr:
  333. mWriteReady = FALSE;
  334. mDataFlowOn = TRUE;
  335. theErr = HXR_WOULD_BLOCK;
  336. break;
  338. case kENOMEMErr:
  339. case kEBUSYErr:
  340. case kOTOutStateErr:
  341. case kEWOULDBLOCKErr:
  342. case kOTStateChangeErr:
  343. case kOTLookErr:
  344. mLastError = HXR_WOULD_BLOCK;
  345. theErr = HXR_WOULD_BLOCK;
  346. break;
  348. default:
  349. #if 0
  350. Str255 s;
  351. DebugStr("pOT_TCP::read");
  352. NumToString(result,s);
  353. DebugStr(s);
  354. #endif
  355. mLastError = HXR_SERVER_DISCONNECTED;
  356. theErr = HXR_SERVER_DISCONNECTED; 
  357. break;
  358. }
  360. break; // break out of the while loop
  361. }
  362. }
  364. }
  365. *len = count; // return actual number of bytes written
  367. return theErr;
  368. }
  370. /*----------------------------------------------------------------------------
  371. read 
  373. read data on a stream.
  375. Entry: data = pointer to data buffer.
  376. *len = length of data buffer.
  378. Exit: function result = error code.
  379. *len = number of bytes received.
  380. ----------------------------------------------------------------------------*/
  382. HX_RESULT
  383. OT_TCP::read (void *data, UINT16 *len)
  384. {
  385. //dprintf("this:%X OT_TCP::readn", this);
  386. //dprintf("mConnectionOpen: %sn", (mConnectionOpen ? "TRUE" : "FALSE") );
  387. //dprintf("mOtherSideHadClosed: %sn", (mOtherSideHasClosed ? "TRUE" : "FALSE")); 
  388. //dprintf("mDataArrived: %sn", (mDataArrived ? "TRUE" : "FALSE"));
  390. HX_RESULT theErr = HXR_OK;
  391. OTResult result;
  393. mLastError=HXR_OK;
  395. if(mAsyncError)
  396. {
  397. theErr = mAsyncError;
  398. mAsyncError = HXR_OK;
  399. return theErr;
  400. }
  402. if (mOtherSideHasClosed)  
  403. theErr = HXR_SERVER_DISCONNECTED;
  404. else if (!mOtherSideHasClosed && !mConnectionOpen) 
  405. theErr = HXR_WOULD_BLOCK;
  407. else
  408. {
  409. if(!mDataArrived)
  410. {
  411. *len = 0;
  412. mLastError = HXR_WOULD_BLOCK;
  413. return HXR_WOULD_BLOCK;
  414. }
  416. result = ::OTRcv(mRef, data, *len, nil);
  418. if (result >= 0) 
  419. {
  420. //dprintf("data readn");
  421. *len = result;
  422. theErr = HXR_OK;
  423. } 
  424. else
  425. {
  426. //dprintf("read errorn");
  427. switch(result)
  428. {
  429. /* take out this case after HXTCPSocket::TCPSchedulerCallbackProc
  430.    gets implemented - we're not getting data fast enough now XXXZach */
  431. case kOTNoDataErr:  
  432. *len = 0;
  433. theErr = HXR_OK;
  434. break;
  435. case kEBUSYErr:
  436. case kOTOutStateErr:
  437. case kEWOULDBLOCKErr:
  438. case kOTStateChangeErr:
  439. case kOTLookErr:
  440. *len = 0;
  441. mLastError = HXR_WOULD_BLOCK;
  442. theErr = HXR_WOULD_BLOCK;
  443. break;
  445. default:
  446. #if 0
  447. Str255 s;
  448. DebugStr("pOT_TCP::read");
  449. NumToString(result,s);
  450. DebugStr(s);
  451. #endif
  452. *len = 0;
  453. mLastError = HXR_SERVER_DISCONNECTED;
  454. theErr = HXR_SERVER_DISCONNECTED; //cz
  455. break;
  456. }
  457. }
  458. }
  460. return theErr;
  461. }
  463. HX_RESULT
  464. OT_TCP::readfrom (REF(IHXBuffer*)   pBuffer,
  465.   REF(UINT32)     ulAddress,
  466.   REF(UINT16)     ulPort)
  467. {
  468. //dprintf("this:%X OT_TCP::readfromn", this);
  469. pBuffer = NULL;
  470. ulAddress = 0;
  471. ulPort = 0;
  473. return HXR_NOTIMPL;
  474. }
  476. HX_RESULT OT_TCP::listen(ULONG32 ulLocalAddr,
  477.  UINT16 port,
  478.  UINT16 backlog, 
  479.  UINT16 blocking, 
  480.  ULONG32 ulPlatform)
  481. {
  482. //dprintf("this:%X OT_TCP::listen address:%X port:%un", this, ulLocalAddr, port);
  483. // check if socket is in a valid state
  484. if(mState != TCP_STATE_CLOSED)
  485. return HXR_UNEXPECTED;  // should be PN_SOCKET_STATE_ERROR
  487. OSErr theErr = HXR_OK;
  488. InetAddress reqAd,retAd;
  489. TBind req,ret;
  491. // Open TCP endpoint
  492. mState = TCP_STATE_OPEN_LISTEN;
  493. mComplete = false;
  494. // Note:  We are using the UDPTCPNotifyProc... Therefore we do
  495. // not get a Proccess command call at interupt time.  Normal
  496. // operation somehow gets away with it...
  497. #ifdef _CARBON
  498. theErr = ::OTAsyncOpenEndpointInContext(OTCreateConfiguration(kTCPName), 0,NULL,
  499. (OTNotifyUPP)UDPTCPNotifyProc, this, NULL);
  500. #else
  501. theErr = ::OTAsyncOpenEndpoint(OTCreateConfiguration(kTCPName), 
  502. 0,NULL, UDPTCPNotifyProc, this);
  503. #endif
  505. if ( theErr )
  506. {
  507. mLastError = theErr;
  508. theErr = HXR_SOCKET_CREATE;
  509. }
  510. // wait for open completion
  511. if(!theErr)
  512. {
  513. theErr = OTWait();
  514. if(theErr == kOTNoDataErr) theErr = HXR_OK;
  516. if(theErr || mCode != T_OPENCOMPLETE) 
  517. {
  518. theErr = theErr ? theErr : HXR_SOCKET_CREATE;
  519. mLastError = theErr;
  520. theErr = HXR_SOCKET_CREATE;
  521. }
  522. }
  524. if ( !theErr )
  525. {
  526. // get Inet address of port
  527. OTInitInetAddress(&reqAd, port, (InetHost) ulLocalAddr);
  529. // bind tcp to current address and requested port
  530. req.addr.maxlen = sizeof(struct InetAddress);
  531. req.addr.len = sizeof(struct InetAddress);
  532. req.addr.buf = (unsigned char *) &reqAd;
  533. req.qlen = 1;
  535. ret.addr.maxlen = sizeof(struct InetAddress);
  536. ret.addr.len = sizeof(struct InetAddress);
  537. ret.addr.buf = (unsigned char *) &retAd;
  539. // clear completion flag
  540. mComplete = false;
  542. mState = TCP_STATE_BIND_LISTEN;
  543. // bind provider to return structure
  544. theErr = OTBind(mRef, &req, &ret);
  545. }
  546. if(theErr)
  547. {
  548. mLastError = theErr;
  549. theErr = HXR_BIND;
  550. }
  552. // wait for bind completion
  553. if(!theErr)
  554. {
  555. theErr = OTWait();
  556. if(theErr == kOTNoDataErr) theErr = HXR_OK;
  558. if(theErr || mCode != T_BINDCOMPLETE) 
  559. {
  560. theErr = theErr ? theErr : HXR_BIND;
  561. mLastError = theErr;
  562. theErr = HXR_BIND;
  563. }
  564. }
  566. // get local port
  567. if(!theErr)
  568. {
  569. mConnectionOpen = FALSE;
  570. mRemotePort = port;
  571. mDataFlowOn = FALSE;
  572. mDataArrived = FALSE;
  573. mAsyncError = HXR_OK;
  575. mState = TCP_STATE_LISTEN;
  576. }
  577. if ( !theErr )
  578. {
  579. // check to see if we are not being called again...
  580. // calling done() on mNewConnection should be fine, because
  581. // it should be released after a connection has been accepted. 
  582. if ( mNewConnection )
  583. {
  584. mNewConnection->done();
  585. HX_RELEASE(mNewConnection);
  586. }
  587. mNewConnection = conn::actual_new_socket(HX_TCP_SOCKET);
  588. mNewConnection->AddRef();
  589. // we can wait here, because we should not be called
  590. // from deffered task time.
  591. theErr = mNewConnection->SetupEndpoint(TRUE);
  592. }
  593. return theErr;
  594. }
  596. HX_RESULT OT_TCP::resolve_address (void)
  597. {
  598. //dprintf("this:%X OT_TCP::resulve_addressn", this);
  599. mState = TCP_STATE_RESOLVE_DNS;
  600. return ::OTInetStringToAddress(mDNSRef, mRemoteHostName, &mHInfoOT);
  601. }
  603. HX_RESULT
  604. OT_TCP::open_resolver(void)
  605. {
  606. //dprintf("this:%X OT_TCP::open_resolvern", this);
  607. mState = TCP_STATE_OPEN_RESOLVER;
  608. #ifdef USE_DEFERRED_IMPL
  609. HX_RESULT theErr = ::OTAsyncOpenInternetServices(kDefaultInternetServicesPath, 0,UDPTCPNotifyProc, this);
  610. #else
  611. #ifdef _CARBON
  612. HX_RESULT theErr = ::OTAsyncOpenInternetServicesInContext(kDefaultInternetServicesPath,
  613. 0,::NewOTNotifyUPP(TCPNotifyProc), this, NULL);
  614. #else
  615. HX_RESULT theErr = ::OTAsyncOpenInternetServices(kDefaultInternetServicesPath,
  616. 0,TCPNotifyProc, this);
  617. #endif
  618. #endif
  619. if (theErr != HXR_OK) 
  620. theErr = HXR_BIND;
  622. return theErr;
  623. }
  625. void
  626. OT_TCP::close_resolver(void)
  627. {
  628. //dprintf("this:%X OT_TCP::close_resolvern", this);
  629. if(mDNSRef != 0)
  630. {
  631. ::OTRemoveNotifier(mDNSRef); // remove the DNR notification function
  632. ::OTCloseProvider(mDNSRef); // close the DNR endpoint
  633. mDNSRef = 0;
  634. }
  635. }
  638. HX_RESULT
  639. OT_TCP::open_socket(void)
  640. {
  641. //dprintf("this:%X OT_TCP::open_socketn", this);
  642. HX_RESULT theErr = HXR_OK;
  644. // Open TCP endpoint
  645. mState = TCP_STATE_OPEN_SOCKET;
  646. #ifdef USE_DEFERRED_IMPL
  647. theErr = ::OTAsyncOpenEndpoint(OTCreateConfiguration(kTCPName), 0,NULL, UDPTCPNotifyProc, this);
  648. #else
  649. #ifdef _CARBON
  650. theErr = ::OTAsyncOpenEndpointInContext(OTCreateConfiguration(kTCPName), 0,NULL,
  651. ::NewOTNotifyUPP(TCPNotifyProc), this, NULL);
  652. #else
  653. theErr = ::OTAsyncOpenEndpoint(OTCreateConfiguration(kTCPName), 0,NULL,
  654. TCPNotifyProc, this);
  655. #endif
  656. #endif
  657.  
  658. return theErr;
  659. }
  661.  HX_RESULT
  662.  OT_TCP::do_bind (void)
  663. {
  664. //dprintf("this:%X OT_TCP::do_bindn", this);
  665. HX_RESULT theErr = HXR_OK;
  667. mState = TCP_STATE_BIND_SOCKET;
  669. mBindRet.addr.maxlen = sizeof(struct InetAddress);
  670. mBindRet.addr.len = sizeof(struct InetAddress);
  671. mBindRet.addr.buf = (unsigned char *) &mAddr;
  673. // bind provider to return structure
  674. theErr = ::OTBind(mRef, nil, &mBindRet);
  676. if(theErr == kOTNoDataErr) 
  677. theErr = HXR_OK;
  679. if(theErr)
  680. theErr = HXR_BIND;
  682. return theErr;
  683. }
  685.  HX_RESULT
  686.  OT_TCP::do_connect(void)
  687. {
  688. //dprintf("this:%X OT_TCP::do_connectn", this);
  689. mState = TCP_STATE_CONNECT_SOCKET;
  691. ::memset(&mCall,0,sizeof(TCall));
  692. mCall.addr.buf = (UInt8 *)&mAddr;
  693. mCall.addr.maxlen = sizeof(InetAddress);
  694. mCall.addr.len = sizeof(InetAddress);
  696. // set up address of remote host
  697. ::OTInitInetAddress((InetAddress*)mCall.addr.buf, mRemotePort, mRemoteHost);
  699. // connect client to remote endpoint
  700. HX_RESULT theErr = ::OTConnect(mRef, &mCall, nil);
  701. if(theErr == kOTNoDataErr) 
  702. theErr = HXR_OK;
  704. if(theErr)
  705. theErr = HXR_SERVER_DISCONNECTED;
  707. return theErr;
  708. }
  710. /*----------------------------------------------------------------------------
  711. TCPNotifyProc 
  713. Open Transport notifier proc for TCP streams.
  715. Entry: s = pointer to stream.
  716. code = OT event code.
  717. result = OT result.
  718. cookie = OT cookie.
  719. ----------------------------------------------------------------------------*/
  721. pascal void OT_TCP::TCPNotifyProc (
  723.  void  *stream, 
  724.  OTEventCode  code,
  725.  OTResult  result, 
  726.  void  *cookie)
  727.  
  728. {
  729. //dprintf("this:%X OT_TCP::TCPNotifyProc cookie:%X code:%X result:%Xn", stream, cookie, code, result);
  730. HX_RESULT theErr = HXR_OK;
  732. OT_TCP* s =  (OT_TCP*) stream;
  734. HXMM_INTERRUPTON();
  735. s->ProcessCmd(code, result, cookie);
  736. HXMM_INTERRUPTOFF();
  737. return;
  738. }
  741. void OT_TCP::ProcessCmd(OTEventCode code, OTResult result, void* cookie)  
  742. {
  743. HX_RESULT theErr = HXR_OK;
  744. switch (code) 
  745. {
  746. case T_OPENCOMPLETE:
  747. {
  748. //dprintf("this:%X T_OPENCOMPLETE ", this);
  749. // check if T_OPENCOMPLETE was for DNS or socket
  750. if(mState == TCP_STATE_OPEN_RESOLVER)
  751. {
  752. //dprintf(" TCP_STATE_OPEN_RESOLVERn");
  753. theErr = result;
  754. if(!theErr)
  755. {
  756. // save DNS provider endpoint ref
  757. mDNSRef = (InetSvcRef) cookie;
  758. mDNSOpen = TRUE;
  759. theErr = resolve_address();
  760. }
  761. else
  762. theErr = HXR_BIND;
  763. }
  764. else if(mState == TCP_STATE_OPEN_SOCKET)
  765. {
  766. // DebugWrite("T_OPENCOMPLETE  TCP_STATE_OPEN_SOCKET");
  767. //dprintf(" TCP_STATE_OPEN_SOCKETn");
  769. theErr = result;
  770. if(!theErr)
  771. {
  772. // save TCP provider endpoint ref
  773. mRef = (EndpointRef) cookie;
  774. mSocketOpen = TRUE;
  775. theErr = do_bind();
  776. }
  777. else
  778. theErr = HXR_SOCKET_CREATE;
  779. }
  780. else if (mState == TCP_STATE_OPEN_LISTEN)
  781. {
  782. //dprintf(" TCP_STATE_OPEN_LISTENn");
  783. theErr = result;
  784. if ( !theErr )
  785. {
  786.     mRef = (EndpointRef) cookie;
  787.     mSocketOpen = TRUE;
  788.     mCode = code;
  789.     mComplete = true;
  790. }
  791. else
  792. theErr = HXR_SOCKET_CREATE;
  793. }
  794. else if (mState == TCP_STATE_OPEN_ACCEPT)
  795. {
  796. //dprintf(" TCP_STATE_OPEN_ACCEPTn");
  797. theErr = result;
  798. if ( !theErr )
  799. {
  800.     mRef = (EndpointRef) cookie;
  801.     mSocketOpen = TRUE;
  802.     mCode = code;
  803.     mState = TCP_STATE_READY;
  804.     mComplete = true;
  805. }
  806. else
  807. theErr = HXR_SOCKET_CREATE;
  808. }
  809. break;
  810. }
  812. case T_DNRSTRINGTOADDRCOMPLETE:
  813. case T_DNRADDRTONAMECOMPLETE:
  814. {
  816. // DebugWrite("T_DNRSTRINGTOADDRCOMPLETE");
  817. //dprintf("this:%X T_DNRSTRINGTOADDRCOMPLETEn", this);
  819. theErr = result;
  820. if(!theErr)
  821. {
  822. // extract DNS result from InetHostInfo struct
  823. mRemoteHost = mHInfoOT.addrs[0];
  825. // close the DNS endpoint
  826. // close_resolver();
  828. // open a TCP socket
  829. // next message should be T_OPEN_COMPLETE
  830. theErr = open_socket();
  831.   }
  832. else
  833. theErr = HXR_BIND;
  835. break;
  836. }
  838. case T_BINDCOMPLETE:
  839. {
  840. // DebugWrite("T_BINDCOMPLETE");
  841. //dprintf("this:%X T_BINDCOMPLETE ", this); 
  842. if ( mState == TCP_STATE_BIND_LISTEN )
  843. {
  844. //dprintf(" - Listenn");
  845. theErr = result;
  846. if ( !theErr )
  847. {
  848. mCode = code;
  849. mComplete = true;
  851. }
  852. else
  853. {
  854. theErr = HXR_BIND;
  855. }
  857. }
  858. else
  859. {
  860. //dprintf(" - Regularn");
  861. theErr = result;
  862. if(!theErr)
  863. {
  864. mComplete = true;
  866. // get inet address
  867. InetAddress *inetAddr = (InetAddress*)mBindRet.addr.buf;
  869. // save local port we are bound to
  870. mLocalPort = inetAddr->fPort;
  872. // now connect to the remote host
  873. theErr = do_connect();
  874. }
  875. else
  876. theErr = HXR_BIND;
  877. }
  879. break;
  880. }
  882. case T_CONNECT:
  883. // DebugWrite("T_CONNECT");
  884. //dprintf("this:%X T_CONNECTn", this);
  886. theErr = result;
  887. if(!theErr)
  888. theErr = ::OTRcvConnect(mRef, nil);
  890. if(!theErr)
  891. {
  892. mConnectionOpen = TRUE;
  893. mWriteReady = TRUE;
  894. mCallBack->Func(CONNECT_NOTIFICATION); //z
  895. }
  896. else
  897. theErr = HXR_SERVER_DISCONNECTED;
  899. break;
  901. case T_DISCONNECT:
  902. // DebugWrite("T_DISCONNECT");
  903. //dprintf("this:%X T_DISCONNECTn", this);
  905. /* Other side has aborted. */
  906. mCode = code;
  907. mOtherSideHasClosed = true;
  908. mComplete = true;
  909. mConnectionOpen = FALSE;
  910. mWeHaveClosed = TRUE; //cz
  911. mStartedReceivingData = FALSE;
  912. mWriteReady = FALSE;
  913. ::OTRcvDisconnect(mRef, NULL);
  914. if (mCallBack) mCallBack->Func(CONNECT_NOTIFICATION, FALSE); // rml cr zach, rahul
  915. break;
  917. case T_ORDREL:
  918. // DebugWrite("T_ORDREL");
  919. //dprintf("this:%X T_ORDRELn", this);
  921. /* Other side has closed. Close our side if necessary. */
  922. mCode = code;
  923. mOtherSideHasClosed = true;
  924. mComplete = true;
  925. mConnectionOpen = FALSE;
  926. mStartedReceivingData = FALSE;
  927. mWriteReady = FALSE;
  928. ::OTRcvOrderlyDisconnect(mRef);
  929. if (!mWeHaveClosed) 
  930. {
  931. ::OTSndOrderlyDisconnect(mRef);
  932. mWeHaveClosed = true;
  933. }
  934. if (mClosing) mRelease = true;
  935. break;
  937. case T_DATA:
  938. // DebugWrite("T_DATA");
  939. //dprintf("this:%X T_DATAn", this);
  940. mStartedReceivingData = TRUE;
  941. if (mClosing) 
  942. {
  943. /* Consume and discard response to "QUIT" comand. */
  944. do 
  945. {
  946. result = ::OTRcv(mRef, mBuf, kBufSize, nil);
  947. } while (result >= 0);
  948. }
  949. else if ( mState == TCP_STATE_ACCEPT_PENDING )
  950. {
  951. //dprintf("TCP_STAT_ACCEPT_PENDING - hold data.n");
  952. mDataReady = TRUE;
  953. }
  954. else
  955. {
  956. mDataArrived = TRUE;
  957. if(mCallBack) 
  958. // mCallBack->callback_task(HX_TCP_CALLBACK);
  959. mCallBack->Func(READ_NOTIFICATION);
  960. }
  961. break;
  963. case T_DISCONNECTCOMPLETE:
  964. case T_PASSCON:
  965. //dprintf("this:%X T_PASSCON ", this);
  966. // DebugWrite("T_DISCONNECTCOMPLETE");
  967. if ( mState == TCP_STATE_ACCEPT_PENDING )
  968. {
  969. //dprintf("TCP_STATE_ACCEPT_PENDINGn");
  970. mConnectionOpen = TRUE;
  971. mWriteReady = TRUE;
  972. mOtherSideHasClosed = false;
  973. mState = TCP_STATE_READY;
  974. if ( mDataReady )
  975. {
  976. //dprintf("Data is waiting so give notificationn");
  977. mDataArrived = TRUE;
  978. if ( mCallBack )
  979. mCallBack->Func(READ_NOTIFICATION);
  980. }
  981. }
  982. else
  983. {
  984. //dprintf("Regularn");
  985. mComplete = true;
  986. mCode = code;
  987. mResult = result;
  988. mCookie = cookie;
  989. }
  990. break;
  993. case T_GODATA:
  994. // DebugWrite("T_GODATA");
  995. //dprintf("this:%X T_GODATAn", this);
  996. mDataFlowOn = FALSE;
  997. mWriteReady = TRUE;
  998. break;
  999. case T_LISTEN:
  1000. //dprintf("this:%X T_LISTENn", this);
  1001. ::memset(&mNewAddr,0,sizeof(TCall));
  1002. mCall.addr.buf = (UInt8 *)&mNewAddr;
  1003. mCall.addr.maxlen = sizeof(InetAddress);
  1004. mCall.addr.len = sizeof(InetAddress);
  1005. //HX_ASSERT(mState == TCP_SOCKET_LISTEN);
  1006. HX_ASSERT(mNewConnection);
  1007. EndpointRef pRef;
  1008. #ifdef _CARBON
  1009. mNewConnection->GetEndpoint((void*&)pRef);
  1010. #else
  1011. mNewConnection->GetEndpoint((void*)pRef);
  1012. #endif
  1013. if ( pRef )
  1014. {
  1015.     theErr = OTListen(mRef,&mCall);
  1016.     if ( !theErr )
  1017.     {
  1018. if ( !theErr )
  1019. {
  1020.     theErr = OTAccept(mRef, pRef, &mCall);
  1021. }
  1022.     }
  1023. }
  1024. else
  1025. {
  1026. // some how we got messed up
  1027. // not much we can do... we will
  1028. // just ignor the listen request...
  1029. }
  1030. break;
  1031. case T_ACCEPTCOMPLETE:
  1032. {
  1033. //dprintf("this:%X T_ACCEPTCOMPLETEn", this);
  1034. mCallBack->Func(ACCEPT_NOTIFICATION, 
  1035. TRUE, mNewConnection);
  1036. // it is the callback's job to call done...
  1037. HX_RELEASE(mNewConnection);
  1038. mNewConnection = conn::actual_new_socket(HX_TCP_SOCKET);
  1039. mNewConnection->AddRef();
  1040. // we are in deffered task time so this will not finish
  1041. // until wait for event is called again...  therefore
  1042. // we pass in false for wait.  We will wait at the
  1043. // beginning to GetEndpoint() if it hasn't finished yet.
  1044. HX_RESULT theErr = mNewConnection->SetupEndpoint(FALSE);
  1045. }
  1046. break;
  1047. case kOTProviderIsClosed:
  1048. {
  1049. // This event is triggered by OpenTransport when the network is gone
  1050. // i.e. network cable has been unpluged
  1051. mCode = code;
  1052. mResult = result;
  1053. mOtherSideHasClosed = true;
  1054. mComplete = true;
  1055. mConnectionOpen = FALSE;
  1056. mWeHaveClosed = TRUE;
  1057. mStartedReceivingData = FALSE;
  1058. mWriteReady = FALSE;
  1059. ::OTRcvDisconnect(mRef, NULL);
  1060. if (mCallBack) mCallBack->Func(CONNECT_NOTIFICATION, FALSE);
  1061. }
  1062. break;
  1063. default:
  1064. //dprintf("this:%X Uncaugt message - %Xn", this, code);
  1065. break;
  1066. }
  1068. mAsyncError = theErr;
  1069. }
  1071. HX_RESULT OT_TCP::SetupEndpoint(BOOL bWait)
  1072. {
  1073. //dprintf("this:%X OT_TCP::SetupEndpointn", this);
  1074. // Open TCP endpoint
  1075. mState = TCP_STATE_OPEN_ACCEPT;
  1076. mComplete = false;
  1077. mConnectionOpen = FALSE;
  1078. mDataFlowOn = FALSE;
  1079. mDataArrived = FALSE;
  1080. mDataReady = FALSE;
  1081. mAsyncError = HXR_OK;
  1083. #ifdef USE_DEFERRED_IMPL
  1084. HX_RESULT theErr = ::OTAsyncOpenEndpoint(OTCreateConfiguration(kTCPName), 0,NULL, UDPTCPNotifyProc, this);
  1085. #else
  1086. #ifdef _CARBON
  1087. HX_RESULT theErr = ::OTAsyncOpenEndpointInContext(OTCreateConfiguration(kTCPName),
  1088. 0,NULL, (OTNotifyUPP)TCPNotifyProc, this, NULL);
  1089. #else
  1090. HX_RESULT theErr = ::OTAsyncOpenEndpoint(OTCreateConfiguration(kTCPName),
  1091. 0,NULL, TCPNotifyProc, this);
  1092. #endif
  1093. #endif
  1094. if ( theErr )
  1095. {
  1096. mLastError = theErr;
  1097. theErr = HXR_SOCKET_CREATE;
  1098. }
  1099. // wait for open completion.. if we were called from deffered task time
  1100. // or Interupt time we don't want to wait though...  Because the creation
  1101. // of the end point will not finish until control is passed back to the
  1102. // application.
  1103. if( bWait )
  1104. {
  1105. if ( !theErr)
  1106. {
  1107. theErr = OTWait();
  1108. if(theErr == kOTNoDataErr) theErr = HXR_OK;
  1110. if(theErr || mCode != T_OPENCOMPLETE) 
  1111. {
  1112. theErr = theErr ? theErr : HXR_SOCKET_CREATE;
  1113. mLastError = theErr;
  1114. theErr = HXR_SOCKET_CREATE;
  1115. }
  1116. }
  1117. }
  1118. return theErr;
  1119. }
  1121. HX_RESULT OT_TCP::GetEndpoint(REF(void*) pRef)
  1122. {
  1123. ////dprintf("this:%X OT_TCP::GetEndpointn", this);
  1124. HX_RESULT theErr = HXR_OK;
  1125. if ( mState == TCP_STATE_OPEN_ACCEPT )
  1126. {
  1127. theErr = OTWait();
  1128. if(theErr == kOTNoDataErr) theErr = HXR_OK;
  1129. if ( theErr || mCode != T_OPENCOMPLETE )
  1130. {
  1131. theErr = theErr ? theErr : HXR_SOCKET_CREATE;
  1132. mLastError = theErr;
  1133. return HXR_SOCKET_CREATE;
  1134. }
  1135. }
  1136. if ( mRef )
  1137. {
  1138. mState = TCP_STATE_ACCEPT_PENDING;
  1139. pRef = (void*)mRef;
  1140. return HXR_OK;
  1141. }
  1142. else
  1143. {
  1144. return HXR_NOT_INITIALIZED;
  1145. }
  1146. }