vos/source/socket.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: socket.cxx,v $
  10  * $Revision: 1.18 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <stdio.h>
  32
  33 #include <rtl/memory.h>
  34 #include <osl/time.h>
  35 #include <vos/socket.hxx>
  36 #include <vos/diagnose.hxx>
  37 //#include <osl/tools.h>
  38
  39 using namespace vos;
  40
  41
  42 VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OSocketAddr, vos),
  43                         VOS_NAMESPACE(OSocketAddr, vos),
  44                         VOS_NAMESPACE(OObject, vos), 0);
  45
  46
  47 /*****************************************************************************/
  48 // OSocketAddr()
  49 /*****************************************************************************/
  50 OSocketAddr::OSocketAddr()
  51 {
  52     m_SockAddr= 0;
  53 }
  54
  55 /*****************************************************************************/
  56 // OSocketAddr()
  57 /*****************************************************************************/
  58 OSocketAddr::OSocketAddr(oslSocketAddr Addr)
  59 {
  60     m_SockAddr= Addr;
  61 }
  62
  63 /*****************************************************************************/
  64 // OSocketAddr()
  65 /*****************************************************************************/
  66 OSocketAddr::OSocketAddr(const OSocketAddr& Addr) :
  67 ISocketAddr(), OObject()
  68 {
  69     m_SockAddr= osl_copySocketAddr((oslSocketAddr)Addr);
  70 }
  71
  72 /*****************************************************************************/
  73 // ~OSocketAddr()
  74 /*****************************************************************************/
  75 OSocketAddr::~OSocketAddr()
  76 {
  77     osl_destroySocketAddr(m_SockAddr);
  78 }
  79
  80
  81 /*****************************************************************************/
  82 // getFamily()
  83 /*****************************************************************************/
  84 OSocketAddr::TAddrFamily OSocketAddr::getFamily() const
  85 {
  86     return (TAddrFamily)osl_getFamilyOfSocketAddr(m_SockAddr);
  87 }
  88
  89 /*****************************************************************************/
  90 // operator oslSocketAddr ()
  91 /*****************************************************************************/
  92 OSocketAddr::operator oslSocketAddr() const
  93 {
  94     return m_SockAddr;
  95 }
  96
  97 /*****************************************************************************/
  98 // getHostname()
  99 /*****************************************************************************/
 100 OSocketAddr::TResult OSocketAddr::getHostname(rtl::OUString& rBuffer ) const
 101 {
 102     return (TResult)osl_getHostnameOfSocketAddr(m_SockAddr, &rBuffer.pData );
 103 }
 104
 105 /*****************************************************************************/
 106 // getLocalHostname()
 107 /*****************************************************************************/
 108 OSocketAddr::TResult OSocketAddr::getLocalHostname( rtl::OUString& pBuffer )
 109 {
 110     return (TResult)osl_getLocalHostname( &pBuffer.pData );
 111 }
 112
 113 /*****************************************************************************/
 114 // resolveHostname()
 115 /*****************************************************************************/
 116 oslSocketAddr OSocketAddr::resolveHostname(const rtl::OUString& ustrHostname)
 117 {
 118     return osl_resolveHostname( ustrHostname.pData );
 119 }
 120
 121 /*****************************************************************************/
 122 // operator= (oslSocketAddr Addr)
 123 /*****************************************************************************/
 124 void OSocketAddr::operator= (oslSocketAddr Addr)
 125 {
 126     if(m_SockAddr) {
 127         osl_destroySocketAddr(m_SockAddr);
 128     }
 129
 130     m_SockAddr= Addr;
 131 }
 132
 133 /*****************************************************************************/
 134 // operator== (oslSocketAddr Addr)
 135 /*****************************************************************************/
 136 sal_Bool OSocketAddr::operator== (oslSocketAddr Addr)
 137 {
 138     return (osl_isEqualSocketAddr(m_SockAddr, Addr));
 139 }
 140
 141 /*****************************************************************************/
 142 // operator=(const OSocketAddr& Addr)
 143 /*****************************************************************************/
 144 OSocketAddr& OSocketAddr::operator=(const OSocketAddr& Addr)
 145 {
 146     if(m_SockAddr) {
 147         osl_destroySocketAddr(m_SockAddr);
 148     }
 149
 150     m_SockAddr= osl_copySocketAddr((oslSocketAddr)Addr);
 151
 152     return *this;
 153 }
 154
 155
 156 VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OInetSocketAddr, vos),
 157                         VOS_NAMESPACE(OInetSocketAddr, vos),
 158                         VOS_NAMESPACE(OSocketAddr, vos), 0);
 159
 160
 161
 162 /*****************************************************************************/
 163 // OInetSocketAddr
 164 // creates arbitrary inet-address (INADDR_ANY)
 165 /*****************************************************************************/
 166 OInetSocketAddr::OInetSocketAddr()
 167 {
 168     m_SockAddr= osl_createEmptySocketAddr(osl_Socket_FamilyInet);
 169 }
 170
 171 /*****************************************************************************/
 172 // OInetSocketAddr
 173 // uses the given oslSocketAddr as its own
 174 /*****************************************************************************/
 175 OInetSocketAddr::OInetSocketAddr(oslSocketAddr Addr) :
 176     OSocketAddr(Addr)
 177 {
 178     VOS_ASSERT(osl_getFamilyOfSocketAddr(Addr) == osl_Socket_FamilyInet);
 179 }
 180
 181 /*****************************************************************************/
 182 // OInetSocketAddr
 183 // Create a socket address either from a dotted decimal address
 184 //(e.g. 141.99.128.50) or a hostname (e.g. www.stardiv.de).
 185 /*****************************************************************************/
 186 OInetSocketAddr::OInetSocketAddr(const rtl::OUString& ustrAddrOrHostname, sal_Int32 Port)
 187 {
 188     // first try as dotted address.
 189     m_SockAddr= osl_createInetSocketAddr(ustrAddrOrHostname.pData, Port);
 190
 191     // create failed, maybe it's an hostname
 192     if(m_SockAddr == 0)
 193     {
 194         m_SockAddr= osl_resolveHostname(ustrAddrOrHostname.pData);
 195
 196         // host found?
 197         if(m_SockAddr)
 198         {
 199             // set port will fail if addrtype is not osl_Socket_FamilyInet
 200             VOS_VERIFY(osl_setInetPortOfSocketAddr(m_SockAddr, Port));
 201         }
 202     }
 203 }
 204
 205 /*****************************************************************************/
 206 // OInetSocketAddr(const OInetSocketAddr&)
 207 /*****************************************************************************/
 208 OInetSocketAddr::OInetSocketAddr(const OInetSocketAddr& sa) :
 209     OSocketAddr(sa)
 210 {
 211     VOS_ASSERT(getFamily() == TFamily_Inet);
 212 }
 213
 214 /*****************************************************************************/
 215 // OInetSocketAddr(const OSocketAddr&)
 216 /*****************************************************************************/
 217 OInetSocketAddr::OInetSocketAddr(const OSocketAddr& sa) :
 218     OSocketAddr(sa)
 219 {
 220     VOS_ASSERT(sa.getFamily() == TFamily_Inet);
 221 }
 222
 223 /*****************************************************************************/
 224 // ~OInetSocketAddr
 225 /*****************************************************************************/
 226 OInetSocketAddr::~OInetSocketAddr()
 227 {
 228 }
 229
 230 /*****************************************************************************/
 231 // operator= (oslSocketAddr Addr)
 232 /*****************************************************************************/
 233 void OInetSocketAddr::operator= (oslSocketAddr Addr)
 234 {
 235     VOS_PRECOND(osl_getFamilyOfSocketAddr(Addr) == osl_Socket_FamilyInet,
 236                 "oslSocketAddr not of type osl_Socket_FamilyInet!");
 237
 238     OSocketAddr::operator=(Addr);
 239 }
 240
 241 /*****************************************************************************/
 242 // operator== (oslSocketAddr Addr)
 243 /*****************************************************************************/
 244 sal_Bool OInetSocketAddr::operator== (oslSocketAddr Addr)
 245 {
 246     return (osl_isEqualSocketAddr(m_SockAddr, Addr));
 247 }
 248
 249 /*****************************************************************************/
 250 // operator=(const OInetSocketAddr& Addr)
 251 /*****************************************************************************/
 252 OInetSocketAddr& OInetSocketAddr::operator=(const OInetSocketAddr& Addr)
 253 {
 254     VOS_ASSERT(Addr.getFamily() == TFamily_Inet);
 255
 256     OSocketAddr::operator=(Addr);
 257
 258     return *this;
 259 }
 260
 261 /*****************************************************************************/
 262 // operator=(const OSocketAddr& Addr)
 263 /*****************************************************************************/
 264 OInetSocketAddr& OInetSocketAddr::operator=(const OSocketAddr& Addr)
 265 {
 266     VOS_ASSERT(Addr.getFamily() == TFamily_Inet);
 267
 268     OSocketAddr::operator=(Addr);
 269
 270     return *this;
 271 }
 272
 273 /*****************************************************************************/
 274 // getServicePort()
 275 /*****************************************************************************/
 276 sal_Int32 OInetSocketAddr::getServicePort(const rtl::OUString& ustrServiceName,
 277                                     const rtl::OUString& ustrProtocolName)
 278 {
 279     return osl_getServicePort(ustrServiceName.pData, ustrProtocolName.pData);
 280 }
 281
 282
 283 /*****************************************************************************/
 284 // getPort()
 285 /*****************************************************************************/
 286 sal_Int32 OInetSocketAddr::getPort () const
 287 {
 288     return osl_getInetPortOfSocketAddr(m_SockAddr);
 289 }
 290
 291
 292 /*****************************************************************************/
 293 // setPort()
 294 /*****************************************************************************/
 295 sal_Bool OInetSocketAddr::setPort (sal_Int32 Port)
 296 {
 297     return osl_setInetPortOfSocketAddr(m_SockAddr, Port);
 298 }
 299
 300
 301 /*****************************************************************************/
 302 // getDottedAddr()
 303 /*****************************************************************************/
 304 OSocketAddr::TResult OInetSocketAddr::getDottedAddr( rtl::OUString& pBuffer ) const
 305 {
 306     return (TResult)osl_getDottedInetAddrOfSocketAddr(m_SockAddr, &pBuffer.pData );
 307 }
 308
 309 /*****************************************************************************/
 310 // setAddr()
 311 /*****************************************************************************/
 312 sal_Bool OInetSocketAddr::setAddr(const rtl::OUString& ustrAddrOrHostname)
 313 {
 314     sal_Int32 Port = 0;
 315
 316     if(m_SockAddr) {
 317
 318         // retrieve old port
 319         Port= getPort();
 320
 321         // free old address
 322         osl_destroySocketAddr(m_SockAddr);
 323         m_SockAddr= 0;
 324     }
 325
 326     // first try as dotted address.
 327     m_SockAddr= osl_createInetSocketAddr(ustrAddrOrHostname.pData, Port);
 328
 329     // create failed, maybe it's an hostname
 330     if(m_SockAddr == 0)
 331     {
 332
 333         m_SockAddr= osl_resolveHostname( ustrAddrOrHostname.pData );
 334
 335         // host found?
 336         if(m_SockAddr==0)
 337         {
 338             return sal_False;
 339         }
 340
 341         // set port will fail if addrtype is not osl_Socket_FamilyInet
 342         VOS_VERIFY(osl_setInetPortOfSocketAddr(m_SockAddr, Port));
 343
 344     }
 345
 346     return sal_True;
 347 }
 348
 349 ///////////////////////////////////////////////////////////////////////////////
 350 // OIpxSocketAddr
 351
 352 VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OIpxSocketAddr, vos),
 353                         VOS_NAMESPACE(OIpxSocketAddr, vos),
 354                         VOS_NAMESPACE(OSocketAddr, vos), 0);
 355
 356
 357 /*****************************************************************************/
 358 // OIpxSocketAddr()
 359 /*****************************************************************************/
 360 OIpxSocketAddr::OIpxSocketAddr()
 361 {
 362     m_SockAddr= osl_createEmptySocketAddr(osl_Socket_FamilyIpx);
 363 }
 364
 365 /*****************************************************************************/
 366 // OIpxSocketAddr(oslSocketAddr)
 367 /*****************************************************************************/
 368 OIpxSocketAddr::OIpxSocketAddr(oslSocketAddr Addr) :
 369     OSocketAddr(Addr)
 370 {
 371     VOS_ASSERT(osl_getFamilyOfSocketAddr(Addr) == osl_Socket_FamilyIpx);
 372 }
 373
 374 /*****************************************************************************/
 375 // OIpxSocketAddr()
 376 /*****************************************************************************/
 377 OIpxSocketAddr::OIpxSocketAddr(const rtl::OUString&,
 378                                const rtl::OUString&,
 379                                sal_uInt32 )
 380 {
 381     // jbu : functionality removed from vos
 382 }
 383
 384 /*****************************************************************************/
 385 // OIpxSocketAddr(OIpxSocketAddr&)
 386 /*****************************************************************************/
 387 OIpxSocketAddr::OIpxSocketAddr(const OIpxSocketAddr& sa) :
 388     OSocketAddr(sa)
 389 {
 390     VOS_ASSERT(sa.getFamily() == TFamily_Ipx);
 391 }
 392
 393
 394 /*****************************************************************************/
 395 // OIpxSocketAddr(OSocketAddr&)
 396 /*****************************************************************************/
 397 OIpxSocketAddr::OIpxSocketAddr(const OSocketAddr& sa) :
 398     OSocketAddr(sa)
 399 {
 400     VOS_ASSERT(sa.getFamily() == TFamily_Ipx);
 401 }
 402
 403 /*****************************************************************************/
 404 // ~OIpxSocketAddr()
 405 /*****************************************************************************/
 406 OIpxSocketAddr::~OIpxSocketAddr()
 407 {
 408 }
 409
 410
 411 /*****************************************************************************/
 412 // operator=()
 413 /*****************************************************************************/
 414 void OIpxSocketAddr::operator= (oslSocketAddr Addr)
 415 {
 416     VOS_PRECOND(osl_getFamilyOfSocketAddr(Addr) == osl_Socket_FamilyIpx,
 417             "oslSocketAddr not of type osl_Socket_FamilyIpx!");
 418
 419     OSocketAddr::operator=(Addr);
 420 }
 421
 422 /*****************************************************************************/
 423 // operator== (oslSocketAddr Addr)
 424 /*****************************************************************************/
 425 sal_Bool OIpxSocketAddr::operator== (oslSocketAddr Addr)
 426 {
 427     return (osl_isEqualSocketAddr(m_SockAddr, Addr));
 428 }
 429
 430 /*****************************************************************************/
 431 // operator=(const OIpxSocketAddr& Addr)
 432 /*****************************************************************************/
 433 OIpxSocketAddr& OIpxSocketAddr::operator=(const OIpxSocketAddr& Addr)
 434 {
 435     VOS_ASSERT(Addr.getFamily() == TFamily_Ipx);
 436
 437     OSocketAddr::operator=(Addr);
 438
 439     return *this;
 440 }
 441
 442 /*****************************************************************************/
 443 // operator=(const OSocketAddr& Addr)
 444 /*****************************************************************************/
 445 OIpxSocketAddr& OIpxSocketAddr::operator=(const OSocketAddr& Addr)
 446 {
 447     VOS_ASSERT(Addr.getFamily() == TFamily_Ipx);
 448
 449     OSocketAddr::operator=(Addr);
 450
 451     return *this;
 452 }
 453
 454 /*****************************************************************************/
 455 // getNetNumber()
 456 /*****************************************************************************/
 457 OSocketAddr::TResult OIpxSocketAddr::getNetNumber(TIpxNetNumber&) const
 458 {
 459     // jbu : functionality removed from vos
 460     return (TResult)0;
 461 }
 462
 463 /*****************************************************************************/
 464 // getNodeNumber()
 465 /*****************************************************************************/
 466 OSocketAddr::TResult OIpxSocketAddr::getNodeNumber(TIpxNodeNumber& ) const
 467 {
 468     // jbu : functionality removed from vos
 469     return (TResult)0;
 470 }
 471
 472 /*****************************************************************************/
 473 // getSocketNumber()
 474 /*****************************************************************************/
 475 sal_uInt32 OIpxSocketAddr::getSocketNumber() const
 476 {
 477 //      return osl_getIpxSocketNumber(m_SockAddr);
 478     return (TResult)0;
 479 }
 480
 481
 482 /*****************************************************************************/
 483 // getAddressString()
 484 /*****************************************************************************/
 485 //void OIpxSocketAddr::getAddressString(sal_Char* Buffer, sal_uInt32 Len) const
 486 void OIpxSocketAddr::getAddressString( rtl::OUString& ) const
 487 {
 488     // jbu : functionality removed from vos
 489 }
 490
 491
 492 ///////////////////////////////////////////////////////////////////////////////
 493 // Socket
 494
 495
 496 VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OSocket, vos),
 497                         VOS_NAMESPACE(OSocket, vos),
 498                         VOS_NAMESPACE(OObject, vos), 0);
 499
 500 /*****************************************************************************/
 501 // OSocket()
 502 /*****************************************************************************/
 503 OSocket::OSocket()
 504 {
 505     m_pRecvTimeout = 0;
 506     m_pSendTimeout = 0;
 507
 508     m_pSockRef= 0;
 509 }
 510
 511
 512 /*****************************************************************************/
 513 // OSocket()
 514 /*****************************************************************************/
 515 OSocket::OSocket(TSocketType Type,
 516                  TAddrFamily Family,
 517                  TProtocol   Protocol)
 518 {
 519     m_pRecvTimeout = 0;
 520     m_pSendTimeout = 0;
 521
 522     m_pSockRef=
 523         new SockRef(osl_createSocket((oslAddrFamily)Family,
 524                                      (oslSocketType)Type,
 525                                      (oslProtocol)Protocol));
 526
 527     VOS_POSTCOND(m_pSockRef != 0, "OSocket(): new failed.\n");
 528     VOS_POSTCOND((*m_pSockRef)(), "OSocket(): creation of socket failed!\n");
 529 }
 530
 531 /*****************************************************************************/
 532 // OSocket()
 533 /*****************************************************************************/
 534 OSocket::OSocket(const OSocket& sock) :
 535 ISocketTypes(), OReference(), OObject()
 536 {
 537     m_pRecvTimeout = 0;
 538     m_pSendTimeout = 0;
 539     m_pSockRef=0;
 540
 541     VOS_ASSERT(sock.m_pSockRef != 0);
 542
 543     if ( sock.m_pSockRef !=0 )
 544     {
 545         m_pSockRef= sock.m_pSockRef;
 546
 547         setRecvTimeout(sock.m_pRecvTimeout);
 548         setSendTimeout(sock.m_pSendTimeout);
 549
 550         m_pSockRef->acquire();
 551     }
 552 }
 553
 554 /*****************************************************************************/
 555 // OSocket()
 556 /*****************************************************************************/
 557 OSocket::OSocket(oslSocket Socket)
 558 {
 559     m_pRecvTimeout = 0;
 560     m_pSendTimeout = 0;
 561
 562     m_pSockRef = new SockRef(Socket);
 563 }
 564
 565
 566 /*****************************************************************************/
 567 // ~OSocket()
 568 /*****************************************************************************/
 569 OSocket::~OSocket()
 570 {
 571     close();
 572
 573     delete m_pRecvTimeout;
 574     delete m_pSendTimeout;
 575 }
 576
 577
 578 /*****************************************************************************/
 579 // create
 580 /*****************************************************************************/
 581 sal_Bool OSocket::create(TSocketType Type,
 582                         TAddrFamily Family,
 583                         TProtocol   Protocol)
 584 {
 585     // if this was a valid socket, decrease reference
 586     if ((m_pSockRef) && (m_pSockRef->release() == 0))
 587     {
 588         osl_releaseSocket((*m_pSockRef)());
 589         delete m_pSockRef;
 590         m_pSockRef= 0;
 591     }
 592
 593     m_pSockRef=
 594         new SockRef(osl_createSocket((oslAddrFamily)Family,
 595                                      (oslSocketType)Type,
 596                                      (oslProtocol)Protocol));
 597
 598     VOS_POSTCOND(m_pSockRef != 0, "OSocket(): new failed.\n");
 599
 600     return (*m_pSockRef)() != 0;
 601 }
 602
 603 /*****************************************************************************/
 604 // operator=
 605 /*****************************************************************************/
 606 OSocket& OSocket::operator= (const OSocket& sock)
 607 {
 608     VOS_PRECOND(sock.m_pSockRef != 0, "OSocket::operator=: tried to assign an empty/invalid socket\n");
 609
 610     if (m_pSockRef == sock.m_pSockRef)
 611         return *this;
 612
 613     // if this was a valid socket, decrease reference
 614     if ((m_pSockRef) && (m_pSockRef->release() == 0))
 615     {
 616         osl_releaseSocket((*m_pSockRef)());
 617         delete m_pSockRef;
 618         m_pSockRef= 0;
 619     }
 620
 621     m_pSockRef= sock.m_pSockRef;
 622
 623     setRecvTimeout(sock.m_pRecvTimeout);
 624     setSendTimeout(sock.m_pSendTimeout);
 625
 626     m_pSockRef->acquire();
 627
 628     return *this;
 629 }
 630
 631 /*****************************************************************************/
 632 // operator oslSocket()
 633 /*****************************************************************************/
 634 OSocket::operator oslSocket() const
 635 {
 636     VOS_ASSERT(m_pSockRef);
 637     return (*m_pSockRef)();
 638 }
 639
 640 /*****************************************************************************/
 641 // isValid()
 642 /*****************************************************************************/
 643 sal_Bool OSocket::isValid() const
 644 {
 645     return m_pSockRef != 0 && (*m_pSockRef)() != 0;
 646 }
 647
 648
 649 /*****************************************************************************/
 650 // close
 651 /*****************************************************************************/
 652 void OSocket::close()
 653 {
 654     if (m_pSockRef && (*m_pSockRef)() && (m_pSockRef->release() == 0))
 655     {
 656         osl_releaseSocket((*m_pSockRef)());
 657         delete m_pSockRef;
 658     }
 659
 660     m_pSockRef= 0;
 661 }
 662
 663 /*****************************************************************************/
 664 // getLocalAddr
 665 /*****************************************************************************/
 666 void OSocket::getLocalAddr(OSocketAddr& sa) const
 667 {
 668     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
 669
 670     if ( m_pSockRef && (*m_pSockRef)() )
 671     {
 672         sa= osl_getLocalAddrOfSocket((*m_pSockRef)());
 673     }
 674 }
 675
 676 /*****************************************************************************/
 677 // getLocalPort
 678 /*****************************************************************************/
 679 sal_Int32 OSocket::getLocalPort() const
 680 {
 681     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
 682
 683     sal_Int32 Port= OSL_INVALID_PORT;
 684
 685     if ( m_pSockRef && (*m_pSockRef)() )
 686     {
 687         oslSocketAddr Addr= osl_getLocalAddrOfSocket((*m_pSockRef)());
 688
 689         if(Addr)
 690         {
 691             Port= osl_getInetPortOfSocketAddr(Addr);
 692             osl_destroySocketAddr(Addr);
 693         }
 694     }
 695
 696     return Port;
 697 }
 698
 699 /*****************************************************************************/
 700 // getLocalHost
 701 /*****************************************************************************/
 702 OSocket::TResult OSocket::getLocalHost( rtl::OUString& pBuffer) const
 703 {
 704     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
 705
 706     if ( m_pSockRef && (*m_pSockRef)() )
 707     {
 708         oslSocketAddr Addr= osl_getLocalAddrOfSocket((*m_pSockRef)());
 709
 710         if(Addr)
 711         {
 712 //              TResult Result= (TResult)osl_getHostnameOfSocketAddr(Addr,
 713 //                                                                                                              pBuffer, BufferSize);
 714             TResult Result= (TResult)osl_getHostnameOfSocketAddr(Addr,
 715                                                              &pBuffer.pData );
 716
 717             osl_destroySocketAddr(Addr);
 718
 719             return Result;
 720         }
 721     }
 722
 723     return TResult_Error;
 724 }
 725
 726 /*****************************************************************************/
 727 // getPeerAddr
 728 /*****************************************************************************/
 729 void OSocket::getPeerAddr(OSocketAddr& sa) const
 730 {
 731     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
 732
 733     if ( m_pSockRef && (*m_pSockRef)() )
 734     {
 735         sa= osl_getPeerAddrOfSocket((*m_pSockRef)());
 736     }
 737 }
 738
 739 /*****************************************************************************/
 740 // getPeerPort
 741 /*****************************************************************************/
 742 sal_Int32 OSocket::getPeerPort() const
 743 {
 744     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
 745
 746     sal_Int32 Port= OSL_INVALID_PORT;
 747
 748     if ( m_pSockRef && (*m_pSockRef)() )
 749     {
 750         oslSocketAddr Addr= osl_getPeerAddrOfSocket((*m_pSockRef)());
 751
 752         if(Addr)
 753         {
 754             Port= osl_getInetPortOfSocketAddr(Addr);
 755             osl_destroySocketAddr(Addr);
 756         }
 757     }
 758
 759     return Port;
 760 }
 761
 762 /*****************************************************************************/
 763 // getPeerHost
 764 /*****************************************************************************/
 765 OSocket::TResult OSocket::getPeerHost( rtl::OUString& pBuffer ) const
 766 {
 767     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
 768
 769     if ( m_pSockRef && (*m_pSockRef)() )
 770     {
 771         oslSocketAddr Addr= osl_getPeerAddrOfSocket((*m_pSockRef)());
 772
 773         if(Addr)
 774         {
 775 //                  TResult Result= (TResult)osl_getHostnameOfSocketAddr(Addr,
 776 //                                                                                                              pBuffer, BufferSize);
 777             TResult Result= (TResult)osl_getHostnameOfSocketAddr(Addr,
 778                                                              &pBuffer.pData );
 779
 780             osl_destroySocketAddr(Addr);
 781
 782             return Result;
 783         }
 784     }
 785
 786     return TResult_Error;
 787 }
 788
 789 /*****************************************************************************/
 790 // bind
 791 /*****************************************************************************/
 792 sal_Bool OSocket::bind(const OSocketAddr& Addr)
 793 {
 794     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
 795
 796     if ( m_pSockRef && (*m_pSockRef)() )
 797     {
 798         return osl_bindAddrToSocket((*m_pSockRef)(), (oslSocketAddr)Addr);
 799     }
 800
 801     return sal_False;
 802 }
 803
 804
 805 /*****************************************************************************/
 806 // setSendTimeout
 807 /*****************************************************************************/
 808 void OSocket::setSendTimeout(const TimeValue* pTimeout)
 809 {
 810     delete m_pSendTimeout;
 811
 812     if (pTimeout)
 813         m_pSendTimeout = new TimeValue(*pTimeout);
 814     else
 815         m_pSendTimeout = 0;
 816 }
 817
 818 /*****************************************************************************/
 819 // setRecvTimeout
 820 /*****************************************************************************/
 821 void OSocket::setRecvTimeout(const TimeValue* pTimeout)
 822 {
 823     delete m_pRecvTimeout;
 824
 825     if (pTimeout)
 826         m_pRecvTimeout = new TimeValue(*pTimeout);
 827     else
 828         m_pRecvTimeout = 0;
 829 }
 830
 831 /*****************************************************************************/
 832 // isRecvReady
 833 /*****************************************************************************/
 834 sal_Bool OSocket::isRecvReady(const TimeValue* pTimeout) const
 835 {
 836     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
 837
 838     if ( m_pSockRef && (*m_pSockRef)() )
 839     {
 840         return osl_isReceiveReady((*m_pSockRef)(), pTimeout);
 841     }
 842
 843     return sal_False;
 844 }
 845
 846 /*****************************************************************************/
 847 // isSendReady
 848 /*****************************************************************************/
 849 sal_Bool OSocket::isSendReady(const TimeValue* pTimeout) const
 850 {
 851     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
 852
 853     if ( m_pSockRef && (*m_pSockRef)() )
 854     {
 855         return osl_isSendReady((*m_pSockRef)(), pTimeout);
 856     }
 857
 858     return sal_False;
 859 }
 860
 861 /*****************************************************************************/
 862 // isExceptionPending
 863 /*****************************************************************************/
 864 sal_Bool OSocket::isExceptionPending(const TimeValue* pTimeout) const
 865 {
 866     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
 867
 868     if ( m_pSockRef && (*m_pSockRef)() )
 869     {
 870         return osl_isExceptionPending((*m_pSockRef)(), pTimeout);
 871     }
 872
 873     return sal_False;
 874 }
 875
 876
 877 /*****************************************************************************/
 878 // getOption
 879 /*****************************************************************************/
 880 sal_Int32 OSocket::getOption(TSocketOption Option,
 881                               void* pBuffer,
 882                            sal_uInt32 BufferLen,
 883                            TSocketOptionLevel Level) const
 884 {
 885     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
 886
 887     if ( m_pSockRef && (*m_pSockRef)() )
 888     {
 889         return osl_getSocketOption((*m_pSockRef)(),
 890                                    (oslSocketOptionLevel)Level,
 891                                    (oslSocketOption)Option,
 892                                    pBuffer,
 893                                    BufferLen);
 894     }
 895
 896     return sal_False;
 897 }
 898
 899 /*****************************************************************************/
 900 // setOption
 901 /*****************************************************************************/
 902 sal_Bool OSocket::setOption(TSocketOption Option,
 903                            void* pBuffer,
 904                            sal_uInt32 BufferLen,
 905                            TSocketOptionLevel Level) const
 906 {
 907     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
 908
 909     if ( m_pSockRef && (*m_pSockRef)() )
 910     {
 911         return osl_setSocketOption((*m_pSockRef)(),
 912                                    (oslSocketOptionLevel)Level,
 913                                    (oslSocketOption)Option,
 914                                    pBuffer,
 915                                    BufferLen);
 916     }
 917
 918     return sal_False;
 919 }
 920
 921
 922 /*****************************************************************************/
 923 // enableNonBlockingMode
 924 /*****************************************************************************/
 925 sal_Bool OSocket::enableNonBlockingMode(sal_Bool On)
 926 {
 927     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
 928
 929     if ( m_pSockRef && (*m_pSockRef)() )
 930     {
 931         return osl_enableNonBlockingMode((*m_pSockRef)(), On);
 932     }
 933
 934     return sal_False;
 935 }
 936
 937 /*****************************************************************************/
 938 // isNonBlockingMode
 939 /*****************************************************************************/
 940 sal_Bool OSocket::isNonBlockingMode() const
 941 {
 942     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
 943
 944     if ( m_pSockRef && (*m_pSockRef)() )
 945     {
 946         return osl_isNonBlockingMode((*m_pSockRef)());
 947     }
 948
 949     return sal_False;
 950 }
 951
 952 /*****************************************************************************/
 953 // getType
 954 /*****************************************************************************/
 955 OSocket::TSocketType OSocket::getType() const
 956 {
 957     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
 958
 959     if ( m_pSockRef && (*m_pSockRef)() )
 960     {
 961         return (TSocketType)osl_getSocketType((*m_pSockRef)());
 962     }
 963
 964     return TType_Invalid;
 965 }
 966
 967 /*****************************************************************************/
 968 // clearError
 969 /*****************************************************************************/
 970 sal_Int32 OSocket::clearError() const
 971 {
 972     sal_Int32 err = 0;
 973
 974     getOption(TOption_Error, &err, sizeof(err));
 975
 976     return err;
 977 }
 978
 979 /*****************************************************************************/
 980 // setDebug
 981 /*****************************************************************************/
 982 sal_Int32 OSocket::setDebug(sal_Int32 opt) const
 983 {
 984     sal_Int32 old= 0;
 985
 986     getOption(TOption_Debug, &old, sizeof(old));
 987
 988     if (opt != -1)
 989         setOption(TOption_Debug, &opt, sizeof(opt));
 990
 991     return old;
 992 }
 993
 994 /*****************************************************************************/
 995 // setReuseAddr
 996 /*****************************************************************************/
 997 sal_Int32 OSocket::setReuseAddr(sal_Int32 opt) const
 998 {
 999     sal_Int32 old = 0;
1000
1001     getOption(TOption_ReuseAddr, &old, sizeof(old));
1002
1003     if (opt != -1)
1004         setOption(TOption_ReuseAddr, &opt, sizeof(opt));
1005
1006     return (old);
1007 }
1008
1009 /*****************************************************************************/
1010 // setKeepAlive
1011 /*****************************************************************************/
1012 sal_Int32 OSocket::setKeepAlive(sal_Int32 opt) const
1013 {
1014     sal_Int32 old = 0;
1015
1016     getOption(TOption_KeepAlive, &old, sizeof(old));
1017
1018     if (opt != -1)
1019         setOption(TOption_KeepAlive, &opt, sizeof(opt));
1020
1021     return (old);
1022 }
1023
1024 /*****************************************************************************/
1025 // setDontRoute
1026 /*****************************************************************************/
1027 sal_Int32 OSocket::setDontRoute(sal_Int32 opt) const
1028 {
1029     sal_Int32 old = 0;
1030
1031     getOption(TOption_DontRoute, &old, sizeof(old));
1032
1033     if (opt != -1)
1034         setOption(TOption_DontRoute, &opt, sizeof(opt));
1035
1036     return (old);
1037 }
1038
1039 /*****************************************************************************/
1040 // setBroadcast
1041 /*****************************************************************************/
1042 sal_Int32 OSocket::setBroadcast(sal_Int32 opt) const
1043 {
1044     sal_Int32 old = 0;
1045
1046     getOption(TOption_Broadcast, &old, sizeof(old));
1047
1048     if (opt != -1)
1049         setOption(TOption_Broadcast, &opt, sizeof(opt));
1050
1051     return (old);
1052 }
1053
1054 /*****************************************************************************/
1055 // setOobinline
1056 /*****************************************************************************/
1057 sal_Int32 OSocket::setOobinline(sal_Int32 opt) const
1058 {
1059     sal_Int32 old = 0;
1060
1061     getOption(TOption_OOBinLine, &old, sizeof(old));
1062
1063     if (opt != -1)
1064         setOption(TOption_OOBinLine, &opt, sizeof(opt));
1065
1066     return (old);
1067 }
1068
1069 /*****************************************************************************/
1070 // setLinger
1071 /*****************************************************************************/
1072 sal_Int32 OSocket::setLinger(sal_Int32 time) const
1073 {
1074     /* local decl. of linger-struct */
1075     struct SockLinger
1076     {
1077         sal_Int32 m_onoff;    // option on/off
1078         sal_Int32 m_linger;   // linger time
1079     };
1080
1081
1082     SockLinger  old = { 0, 0 };
1083
1084     getOption(TOption_Linger, &old, sizeof(old));
1085
1086     if (time > 0) // enable linger with wait-times > 0
1087     {
1088         SockLinger nw = { 1, time };
1089         setOption(TOption_Linger, &nw, sizeof(nw));
1090     }
1091     else if (time == 0) // disable linger with wait-time == 0
1092     {
1093         SockLinger nw = { 0, old.m_linger };
1094         setOption(TOption_Linger, &nw, sizeof(nw));
1095     }
1096
1097     // returns 0 if linger was off, else the linger-time
1098     return (old.m_onoff ? old.m_linger : 0);
1099 }
1100
1101 /*****************************************************************************/
1102 // setSendBufSize
1103 /*****************************************************************************/
1104 sal_Int32 OSocket::setSendBufSize(sal_Int32 sz) const
1105 {
1106     sal_Int32 old = 0;
1107
1108     getOption(TOption_SndBuf, &old, sizeof(old));
1109
1110     if (sz >= 0)
1111         setOption(TOption_SndBuf, &sz, sizeof(sz));
1112
1113     return (old);
1114 }
1115
1116 /*****************************************************************************/
1117 // setRecvBufSize
1118 /*****************************************************************************/
1119 sal_Int32 OSocket::setRecvBufSize(sal_Int32 sz) const
1120 {
1121     sal_Int32 old = 0;
1122
1123     getOption(TOption_RcvBuf, &old, sizeof(old));
1124
1125     if (sz >= 0)
1126         setOption(TOption_RcvBuf, &sz, sizeof(sz));
1127
1128     return (old);
1129 }
1130
1131 /*****************************************************************************/
1132 // setTcpNoDelay
1133 /*****************************************************************************/
1134 sal_Int32 OSocket::setTcpNoDelay(sal_Int32 sz) const
1135 {
1136     sal_Int32 old = 0;
1137
1138     getOption(TOption_TcpNoDelay, &old, sizeof(old), TLevel_Tcp);
1139
1140     if (sz >= 0)
1141         setOption(TOption_TcpNoDelay, &sz, sizeof(sz), TLevel_Tcp);
1142
1143     return (old);
1144 }
1145
1146 /*****************************************************************************/
1147 // getError
1148 /*****************************************************************************/
1149 //void OSocket::getError(sal_Char* pBuffer, sal_uInt32 nSize) const
1150 void OSocket::getError( rtl::OUString& pBuffer ) const
1151 {
1152     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
1153
1154     if (m_pSockRef && (*m_pSockRef)())
1155         osl_getLastSocketErrorDescription((*m_pSockRef)(), &pBuffer.pData );
1156     else
1157         osl_getLastSocketErrorDescription(NULL, &pBuffer.pData );
1158 }
1159
1160 /*****************************************************************************/
1161 // getError
1162 /*****************************************************************************/
1163 OSocket::TSocketError OSocket::getError() const
1164 {
1165     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
1166
1167     if (m_pSockRef && (*m_pSockRef)())
1168         return (TSocketError)osl_getLastSocketError((*m_pSockRef)());
1169     else
1170         return (TSocketError)osl_getLastSocketError(NULL);
1171 }
1172
1173
1174
1175 VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OAcceptorSocket, vos),
1176                         VOS_NAMESPACE(OAcceptorSocket, vos),
1177                         VOS_NAMESPACE(OSocket, vos), 0);
1178
1179
1180 /*****************************************************************************/
1181 // OAcceptorSocket
1182 /*****************************************************************************/
1183 OAcceptorSocket::OAcceptorSocket(TAddrFamily Family,
1184                                  TProtocol   Protocol,
1185                                  TSocketType Type) :
1186     OSocket(Type, Family, Protocol)
1187 {
1188 }
1189
1190 /*****************************************************************************/
1191 // OAcceptorSocket
1192 /*****************************************************************************/
1193 OAcceptorSocket::OAcceptorSocket(const OAcceptorSocket& sock) :
1194     OSocket(sock)
1195 {
1196 }
1197
1198 /*****************************************************************************/
1199 // ~OAcceptorSocket
1200 /*****************************************************************************/
1201 OAcceptorSocket::~OAcceptorSocket()
1202 {
1203     if (m_pSockRef && (*m_pSockRef)() && (m_pSockRef->release() == 0))
1204     {
1205         /* mfe: prepare for forthcoming api change */
1206         osl_closeSocket((*m_pSockRef)());
1207         osl_releaseSocket((*m_pSockRef)());
1208         delete m_pSockRef;
1209         m_pSockRef = 0;
1210     }
1211 }
1212
1213 /*****************************************************************************/
1214 // close
1215 /*****************************************************************************/
1216 void OAcceptorSocket::close()
1217 {
1218     if (m_pSockRef && (*m_pSockRef)() && (m_pSockRef->release() == 0))
1219     {
1220         osl_closeSocket((*m_pSockRef)());
1221     }
1222
1223     m_pSockRef= 0;
1224 }
1225
1226 /*****************************************************************************/
1227 // listen
1228 /*****************************************************************************/
1229 sal_Bool OAcceptorSocket::listen(sal_Int32 MaxPendingConnections)
1230 {
1231     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
1232
1233     if ( m_pSockRef && (*m_pSockRef)() )
1234     {
1235         return osl_listenOnSocket((*m_pSockRef)(), MaxPendingConnections);
1236     }
1237
1238     return sal_False;
1239 }
1240
1241
1242 /*****************************************************************************/
1243 // acceptConnection
1244 /*****************************************************************************/
1245 OSocket::TResult OAcceptorSocket::acceptConnection(OStreamSocket& connection)
1246 {
1247     if (m_pRecvTimeout && ! isRecvReady(m_pRecvTimeout))
1248         return TResult_TimedOut;
1249
1250     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
1251     OStreamSocket aSocket;
1252
1253     if ( m_pSockRef && (*m_pSockRef)() )
1254     {
1255         aSocket = osl_acceptConnectionOnSocket((*m_pSockRef)(), 0);
1256     }
1257
1258     if( aSocket.isValid() )
1259     {
1260         connection = aSocket;
1261         return TResult_Ok;
1262     }
1263     else
1264     {
1265         return TResult_Error;
1266     }
1267
1268 }
1269
1270 /*****************************************************************************/
1271 // acceptConnection
1272 /*****************************************************************************/
1273 OSocket::TResult OAcceptorSocket::acceptConnection(OStreamSocket& connection,
1274                                                    OSocketAddr& sa)
1275 {
1276     oslSocketAddr PeerAddr = 0;
1277     oslSocket     Socket = 0;
1278
1279     if (m_pRecvTimeout && ! isRecvReady(m_pRecvTimeout))
1280         return TResult_TimedOut;
1281
1282     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
1283
1284     if ( m_pSockRef && (*m_pSockRef)() )
1285     {
1286         Socket= osl_acceptConnectionOnSocket((*m_pSockRef)(), &PeerAddr);
1287     }
1288
1289     if (Socket)
1290     {
1291         sa= PeerAddr;
1292         connection= Socket;
1293         return TResult_Ok;
1294     }
1295     else
1296     {
1297         return TResult_Error;
1298     }
1299 }
1300
1301
1302 VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OStreamSocket, vos),
1303                         VOS_NAMESPACE(OStreamSocket, vos),
1304                         VOS_NAMESPACE(OSocket, vos), 0);
1305
1306
1307
1308 /*****************************************************************************/
1309 // OStreamSocket
1310 /*****************************************************************************/
1311 OStreamSocket::OStreamSocket()
1312 {
1313 }
1314
1315 /*****************************************************************************/
1316 // OStreamSocket
1317 /*****************************************************************************/
1318 OStreamSocket::OStreamSocket(TAddrFamily Family,
1319                              TProtocol   Protocol,
1320                              TSocketType Type) :
1321     OSocket(Type, Family, Protocol)
1322 {
1323 }
1324
1325
1326 /*****************************************************************************/
1327 // OStreamSocket
1328 /*****************************************************************************/
1329 OStreamSocket::OStreamSocket(oslSocket Socket) :
1330     OSocket(Socket)
1331 {
1332 }
1333
1334 /*****************************************************************************/
1335 // OStreamSocket
1336 // copy constructor
1337 /*****************************************************************************/
1338 OStreamSocket::OStreamSocket(const OStreamSocket& sock) :
1339     OSocket(sock), IStream()
1340 {
1341 }
1342
1343 /*****************************************************************************/
1344 // OStreamSocket
1345 // copy constructor
1346 /*****************************************************************************/
1347 OStreamSocket::OStreamSocket(const OSocket& sock) :
1348     OSocket(sock)
1349 {
1350 }
1351
1352 /*****************************************************************************/
1353 // ~OStreamSocket
1354 /*****************************************************************************/
1355 OStreamSocket::~OStreamSocket()
1356 {
1357 }
1358
1359 /*****************************************************************************/
1360 // close
1361 /*****************************************************************************/
1362 void OStreamSocket::close()
1363 {
1364     if (m_pSockRef && (*m_pSockRef)() && (m_pSockRef->release() == 0))
1365     {
1366         shutdown();
1367         osl_releaseSocket((*m_pSockRef)());
1368         delete m_pSockRef;
1369     }
1370
1371     m_pSockRef= 0;
1372 }
1373
1374
1375 /*****************************************************************************/
1376 // operator=(oslSocket)
1377 /*****************************************************************************/
1378 OStreamSocket& OStreamSocket::operator=(oslSocket Socket)
1379 {
1380     OSocket::operator=(Socket);
1381
1382     return *this;
1383 }
1384
1385 /*****************************************************************************/
1386 // operator=
1387 /*****************************************************************************/
1388 OStreamSocket& OStreamSocket::operator= (const OSocket& sock)
1389 {
1390     OSocket::operator=(sock);
1391
1392     return *this;
1393 }
1394
1395 /*****************************************************************************/
1396 // operator=
1397 /*****************************************************************************/
1398 OStreamSocket& OStreamSocket::operator= (const OStreamSocket& sock)
1399 {
1400     OSocket::operator=(sock);
1401
1402     return *this;
1403 }
1404
1405 /*****************************************************************************/
1406 // read
1407 /*****************************************************************************/
1408 sal_Int32 OStreamSocket::read(void* pBuffer, sal_uInt32 n) const
1409 {
1410     sal_uInt8 *Ptr = (sal_uInt8  *)pBuffer;
1411
1412     if (m_pRecvTimeout && ! isRecvReady(m_pRecvTimeout))
1413         return 0;
1414
1415     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
1416
1417     if ( ! ( m_pSockRef && (*m_pSockRef)() ) )
1418     {
1419         return -1;
1420     }
1421
1422     /* loop until all desired bytes were read or an error occured */
1423     sal_uInt32 BytesRead= 0;
1424     sal_uInt32 BytesToRead= n;
1425     while (BytesToRead > 0)
1426     {
1427         sal_Int32 RetVal;
1428         RetVal= osl_receiveSocket((*m_pSockRef)(),
1429                                    Ptr,
1430                                    BytesToRead,
1431                                    osl_Socket_MsgNormal);
1432
1433         /* error occured? */
1434         if(RetVal <= 0)
1435         {
1436             break;
1437         }
1438
1439         BytesToRead -= RetVal;
1440         BytesRead += RetVal;
1441         Ptr += RetVal;
1442
1443         /* wait for next available data or timeout */
1444         if ( BytesToRead > 0 && m_pRecvTimeout && ! isRecvReady(m_pRecvTimeout))
1445             break;
1446
1447     }
1448
1449     return BytesRead;
1450 }
1451
1452 /*****************************************************************************/
1453 // write
1454 /*****************************************************************************/
1455 sal_Int32 OStreamSocket::write(const void* pBuffer, sal_uInt32 n)
1456 {
1457     sal_uInt8 *Ptr = (sal_uInt8 *)pBuffer;
1458
1459     if (m_pSendTimeout && ! isSendReady(m_pSendTimeout))
1460         return 0;
1461
1462     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
1463
1464     if ( ! ( m_pSockRef && (*m_pSockRef)() ) )
1465     {
1466         return -1;
1467     }
1468
1469     /* loop until all desired bytes were send or an error occured */
1470     sal_uInt32 BytesSend= 0;
1471     sal_uInt32 BytesToSend= n;
1472     while (BytesToSend > 0)
1473     {
1474         sal_Int32 RetVal;
1475
1476         RetVal= osl_sendSocket((*m_pSockRef)(),
1477                                 Ptr,
1478                                 BytesToSend,
1479                                 osl_Socket_MsgNormal);
1480
1481         /* error occured? */
1482         if(RetVal <= 0)
1483         {
1484             break;
1485         }
1486
1487         BytesToSend -= RetVal;
1488         BytesSend += RetVal;
1489         Ptr += RetVal;
1490
1491         /* wait till new data is available or timeout occures */
1492         if ( BytesToSend > 0 && m_pSendTimeout && ! isSendReady(m_pSendTimeout))
1493             break;
1494     }
1495
1496     return BytesSend;
1497 }
1498
1499 sal_Bool OStreamSocket::isEof() const
1500 {
1501     return isValid();
1502     // BHO not enough
1503 }
1504
1505 /*****************************************************************************/
1506 // recv
1507 /*****************************************************************************/
1508 sal_Int32 OStreamSocket::recv(void* pBuffer,
1509                             sal_uInt32 BytesToRead,
1510                             TSocketMsgFlag Flag)
1511 {
1512     if (m_pRecvTimeout && ! isRecvReady(m_pRecvTimeout))
1513         return 0;
1514
1515     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
1516
1517     if ( ! ( m_pSockRef && (*m_pSockRef)() ) )
1518     {
1519         return -1;
1520     }
1521
1522     return osl_receiveSocket((*m_pSockRef)(),
1523                              pBuffer,
1524                              BytesToRead,
1525                              (oslSocketMsgFlag)Flag);
1526 }
1527
1528 /*****************************************************************************/
1529 // send
1530 /*****************************************************************************/
1531 sal_Int32 OStreamSocket::send(const void* pBuffer,
1532                             sal_uInt32 BytesToSend,
1533                             TSocketMsgFlag Flag)
1534 {
1535     if (m_pSendTimeout && ! isSendReady(m_pSendTimeout))
1536         return 0;
1537
1538     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
1539
1540     if ( ! ( m_pSockRef && (*m_pSockRef)() ) )
1541     {
1542         return -1;
1543     }
1544
1545     return osl_sendSocket((*m_pSockRef)(),
1546                           pBuffer,
1547                           BytesToSend,
1548                           (oslSocketMsgFlag)Flag);
1549 }
1550
1551 /*****************************************************************************/
1552 // shutdown
1553 /*****************************************************************************/
1554 sal_Bool OStreamSocket::shutdown(TSocketDirection Direction)
1555 {
1556     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
1557
1558     if ( m_pSockRef && (*m_pSockRef)() )
1559     {
1560         return osl_shutdownSocket((*m_pSockRef)(), (oslSocketDirection)Direction);
1561     }
1562
1563     return sal_False;
1564 }
1565
1566
1567
1568 VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OConnectorSocket, vos),
1569                         VOS_NAMESPACE(OConnectorSocket, vos),
1570                         VOS_NAMESPACE(OStreamSocket, vos), 0);
1571
1572
1573
1574 /*****************************************************************************/
1575 // OConnectorSocket
1576 /*****************************************************************************/
1577 OConnectorSocket::OConnectorSocket(TAddrFamily Family,
1578                                    TProtocol   Protocol,
1579                                    TSocketType Type) :
1580     OStreamSocket(Family, Protocol, Type)
1581 {
1582 }
1583
1584 /*****************************************************************************/
1585 // OConnectorSocket
1586 /*****************************************************************************/
1587 OConnectorSocket::OConnectorSocket(const OConnectorSocket& sock) :
1588     OStreamSocket(sock)
1589 {
1590 }
1591
1592 /*****************************************************************************/
1593 // ~OConnectorSocket
1594 /*****************************************************************************/
1595 OConnectorSocket::~OConnectorSocket()
1596 {
1597 }
1598
1599 /*****************************************************************************/
1600 // connect
1601 /*****************************************************************************/
1602 OSocket::TResult OConnectorSocket::connect(const OSocketAddr& Addr,
1603                                            const TimeValue* pTimeout)
1604 {
1605
1606     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
1607
1608     if ( m_pSockRef && (*m_pSockRef)() )
1609     {
1610         return (TResult)osl_connectSocketTo((*m_pSockRef)(),
1611                                             (oslSocketAddr)Addr,
1612                                             pTimeout);
1613     }
1614
1615     return TResult_Error;
1616 }
1617
1618
1619 VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(ODatagramSocket, vos),
1620                         VOS_NAMESPACE(ODatagramSocket, vos),
1621                         VOS_NAMESPACE(OSocket, vos), 0);
1622
1623
1624 /*****************************************************************************/
1625 // ODatagramSocket
1626 /*****************************************************************************/
1627 ODatagramSocket::ODatagramSocket(TAddrFamily Family,
1628                                  TProtocol   Protocol,
1629                                  TSocketType Type) :
1630     OSocket(Type, Family, Protocol)
1631 {
1632 }
1633
1634 /*****************************************************************************/
1635 // ODatagramSocket
1636 /*****************************************************************************/
1637 ODatagramSocket::ODatagramSocket(const ODatagramSocket& sock) :
1638     OSocket(sock)
1639 {
1640 }
1641
1642 /*****************************************************************************/
1643 // ~ODatagramSocket
1644 /*****************************************************************************/
1645 ODatagramSocket::~ODatagramSocket()
1646 {
1647 }
1648
1649
1650 /*****************************************************************************/
1651 // recvFrom
1652 /*****************************************************************************/
1653 sal_Int32 ODatagramSocket::recvFrom(void* pBuffer,
1654                                   sal_uInt32 BufferSize,
1655                                     OSocketAddr* pSenderAddr,
1656                                     TSocketMsgFlag Flag)
1657 {
1658
1659     if (m_pRecvTimeout && ! isRecvReady(m_pRecvTimeout))
1660         return 0;
1661
1662     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
1663
1664     if ( ! ( m_pSockRef && (*m_pSockRef)() ) )
1665     {
1666         return -1;
1667     }
1668
1669     sal_Int32 BytesRead;
1670
1671     if(pSenderAddr)
1672     {
1673         // we are interested in the senders address
1674         oslSocketAddr SenderAddr= osl_createEmptySocketAddr(osl_Socket_FamilyInet);
1675
1676         BytesRead=
1677             osl_receiveFromSocket((*m_pSockRef)(),
1678                                    SenderAddr,
1679                                    pBuffer,
1680                                    BufferSize,
1681                                    (oslSocketMsgFlag)Flag);
1682
1683         *pSenderAddr= SenderAddr;
1684     }
1685     else
1686     {
1687         // we don't want to know the senders address
1688
1689         BytesRead=
1690             osl_receiveFromSocket((*m_pSockRef)(),
1691                                    0,
1692                                    pBuffer,
1693                                    BufferSize,
1694                                    (oslSocketMsgFlag)Flag);
1695     }
1696
1697     return BytesRead;
1698 }
1699
1700
1701 /*****************************************************************************/
1702 // sendTo
1703 /*****************************************************************************/
1704 sal_Int32 ODatagramSocket::sendTo(const OSocketAddr& ReceiverAddr,
1705                                 const void* pBuffer,
1706                                 sal_uInt32 BufferSize,
1707                                 TSocketMsgFlag Flag)
1708 {
1709     if (m_pSendTimeout && ! isSendReady(m_pSendTimeout))
1710         return 0;
1711
1712     VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
1713
1714     if ( ( m_pSockRef && (*m_pSockRef)() ) )
1715     {
1716
1717         return osl_sendToSocket((*m_pSockRef)(),
1718                                 (oslSocketAddr)ReceiverAddr,
1719                                 pBuffer,
1720                                 BufferSize,
1721                                 (oslSocketMsgFlag)Flag);
1722     }
1723
1724     return -1;
1725 }
1726