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