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