include/osl/socket.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19 #ifndef INCLUDED_OSL_SOCKET_HXX
  20 #define INCLUDED_OSL_SOCKET_HXX
  21
  22 #include "osl/socket_decl.hxx"
  23
  24 namespace osl
  25 {
  26
  27     inline SocketAddr::SocketAddr()
  28         : m_handle( osl_createEmptySocketAddr( osl_Socket_FamilyInet ) )
  29     {}
  30
  31
  32     inline SocketAddr::SocketAddr(const SocketAddr& Addr)
  33         : m_handle( osl_copySocketAddr( Addr.m_handle ) )
  34     {
  35     }
  36
  37 #if defined LIBO_INTERNAL_ONLY
  38     SocketAddr::SocketAddr(SocketAddr && other) noexcept : m_handle(other.m_handle) {
  39         other.m_handle = nullptr;
  40     }
  41 #endif
  42
  43     inline SocketAddr::SocketAddr(oslSocketAddr Addr)
  44         : m_handle( osl_copySocketAddr( Addr ) )
  45     {
  46     }
  47
  48
  49     inline SocketAddr::SocketAddr(oslSocketAddr Addr, __osl_socket_NoCopy )
  50         : m_handle( Addr )
  51     {
  52     }
  53
  54
  55     inline SocketAddr::SocketAddr( const ::rtl::OUString& strAddrOrHostName, sal_Int32 nPort)
  56         : m_handle( osl_createInetSocketAddr( strAddrOrHostName.pData, nPort ) )
  57     {
  58         if(! m_handle )
  59         {
  60             m_handle = osl_resolveHostname(strAddrOrHostName.pData);
  61
  62             // host found?
  63             if(m_handle)
  64             {
  65                 osl_setInetPortOfSocketAddr(m_handle, nPort);
  66             }
  67             else
  68             {
  69                 osl_destroySocketAddr( m_handle );
  70                 m_handle = NULL;
  71             }
  72         }
  73     }
  74
  75
  76     inline SocketAddr::~SocketAddr()
  77     {
  78         if( m_handle )
  79             osl_destroySocketAddr( m_handle );
  80     }
  81
  82
  83     inline ::rtl::OUString SocketAddr::getHostname( oslSocketResult *pResult ) const
  84     {
  85         ::rtl::OUString hostname;
  86         oslSocketResult result = osl_getHostnameOfSocketAddr( m_handle, &(hostname.pData) );
  87         if( pResult )
  88             *pResult = result;
  89         return hostname;
  90     }
  91
  92
  93     inline sal_Int32 SAL_CALL SocketAddr::getPort() const
  94     {
  95         return osl_getInetPortOfSocketAddr(m_handle);
  96     }
  97
  98
  99     inline bool SAL_CALL SocketAddr::setPort( sal_Int32 nPort )
 100     {
 101         return osl_setInetPortOfSocketAddr(m_handle, nPort );
 102     }
 103
 104     inline bool SAL_CALL SocketAddr::setHostname( const ::rtl::OUString &sDottedIpOrHostname )
 105     {
 106         *this = SocketAddr( sDottedIpOrHostname , getPort() );
 107         return is();
 108     }
 109
 110
 111     inline bool SAL_CALL SocketAddr::setAddr( const ::rtl::ByteSequence & address )
 112     {
 113         return osl_setAddrOfSocketAddr( m_handle, address.getHandle() )
 114             == osl_Socket_Ok;
 115     }
 116
 117     inline ::rtl::ByteSequence SAL_CALL SocketAddr::getAddr( oslSocketResult *pResult ) const
 118     {
 119         ::rtl::ByteSequence sequence;
 120         oslSocketResult result = osl_getAddrOfSocketAddr( m_handle, reinterpret_cast<sal_Sequence **>(&sequence) );
 121         if( pResult )
 122             *pResult = result;
 123         return sequence;
 124     }
 125
 126
 127     inline SocketAddr & SAL_CALL SocketAddr::operator= (oslSocketAddr Addr)
 128     {
 129         oslSocketAddr pNewAddr = osl_copySocketAddr( Addr );
 130         if( m_handle )
 131             osl_destroySocketAddr( m_handle );
 132         m_handle = pNewAddr;
 133         return *this;
 134     }
 135
 136
 137     inline SocketAddr & SAL_CALL SocketAddr::operator= (const SocketAddr& Addr)
 138     {
 139         *this = Addr.getHandle();
 140         return *this;
 141     }
 142
 143 #if defined LIBO_INTERNAL_ONLY
 144     SocketAddr & SocketAddr::operator =(SocketAddr && other) noexcept {
 145         if (m_handle != nullptr) {
 146             osl_destroySocketAddr(m_handle);
 147         }
 148         m_handle = other.m_handle;
 149         other.m_handle = nullptr;
 150         return *this;
 151     }
 152 #endif
 153
 154     inline SocketAddr & SAL_CALL SocketAddr::assign( oslSocketAddr Addr, __osl_socket_NoCopy )
 155     {
 156         if( m_handle )
 157             osl_destroySocketAddr( m_handle );
 158         m_handle = Addr;
 159         return *this;
 160     }
 161
 162
 163     inline bool SAL_CALL SocketAddr::operator== (oslSocketAddr Addr) const
 164     {
 165         return osl_isEqualSocketAddr( m_handle, Addr );
 166     }
 167
 168     inline oslSocketAddr SocketAddr::getHandle() const
 169     {
 170         return m_handle;
 171     }
 172
 173
 174     inline bool SocketAddr::is() const
 175     {
 176         return m_handle != NULL;
 177     }
 178
 179     inline ::rtl::OUString SAL_CALL SocketAddr::getLocalHostname( oslSocketResult *pResult )
 180     {
 181         ::rtl::OUString hostname;
 182         oslSocketResult result = osl_getLocalHostname( &(hostname.pData) );
 183         if(pResult )
 184             *pResult = result;
 185         return hostname;
 186     }
 187
 188     inline void SAL_CALL SocketAddr::resolveHostname(
 189         const ::rtl::OUString & strHostName, SocketAddr &Addr)
 190     {
 191         Addr = SocketAddr( osl_resolveHostname( strHostName.pData ) , SAL_NO_COPY );
 192     }
 193
 194     inline sal_Int32 SAL_CALL SocketAddr::getServicePort(
 195             const ::rtl::OUString& strServiceName,
 196             const ::rtl::OUString & strProtocolName )
 197     {
 198         return osl_getServicePort( strServiceName.pData, strProtocolName.pData );
 199     }
 200
 201
 202     inline Socket::Socket(oslSocketType Type,
 203                           oslAddrFamily Family,
 204                           oslProtocol   Protocol)
 205         : m_handle( osl_createSocket(Family, Type, Protocol) )
 206     {}
 207
 208
 209     inline Socket::Socket( oslSocket socketHandle, __sal_NoAcquire )
 210         : m_handle( socketHandle )
 211     {}
 212
 213
 214     inline Socket::Socket( oslSocket socketHandle )
 215         : m_handle( socketHandle )
 216     {
 217         osl_acquireSocket( m_handle );
 218     }
 219
 220
 221     inline Socket::Socket( const Socket & socket )
 222         : m_handle( socket.getHandle() )
 223     {
 224         osl_acquireSocket( m_handle );
 225     }
 226
 227
 228     inline Socket::~Socket()
 229     {
 230         osl_releaseSocket( m_handle );
 231     }
 232
 233
 234     inline Socket& Socket::operator= ( oslSocket socketHandle)
 235     {
 236         osl_acquireSocket( socketHandle );
 237         osl_releaseSocket( m_handle );
 238         m_handle = socketHandle;
 239         return *this;
 240     }
 241
 242
 243     inline Socket&  Socket::operator= (const Socket& sock)
 244     {
 245         *this = sock.getHandle();
 246         return *this;
 247     }
 248
 249
 250     inline bool Socket::operator==( const Socket& rSocket ) const
 251     {
 252         return m_handle == rSocket.getHandle();
 253     }
 254
 255
 256     inline bool Socket::operator==( const oslSocket socketHandle ) const
 257     {
 258         return m_handle == socketHandle;
 259     }
 260
 261
 262     inline void Socket::shutdown( oslSocketDirection Direction )
 263     {
 264         osl_shutdownSocket( m_handle , Direction );
 265     }
 266
 267
 268     inline void Socket::close()
 269     {
 270         osl_closeSocket( m_handle );
 271     }
 272
 273
 274     inline void Socket::getLocalAddr( SocketAddr & addr) const
 275     {
 276         addr.assign( osl_getLocalAddrOfSocket( m_handle ) , SAL_NO_COPY );
 277     }
 278
 279
 280     inline sal_Int32 Socket::getLocalPort() const
 281     {
 282         SocketAddr addr( NULL );
 283         getLocalAddr( addr );
 284         return addr.getPort();
 285     }
 286
 287
 288     inline ::rtl::OUString Socket::getLocalHost() const
 289     {
 290         SocketAddr addr( NULL );
 291         getLocalAddr( addr );
 292         return addr.getHostname();
 293     }
 294
 295
 296     inline void Socket::getPeerAddr( SocketAddr &addr ) const
 297     {
 298         addr.assign( osl_getPeerAddrOfSocket( m_handle ), SAL_NO_COPY );
 299     }
 300
 301
 302     inline sal_Int32 Socket::getPeerPort() const
 303     {
 304         SocketAddr addr( NULL );
 305         getPeerAddr( addr );
 306         return addr.getPort();
 307     }
 308
 309
 310     inline ::rtl::OUString Socket::getPeerHost() const
 311     {
 312         SocketAddr addr( NULL );
 313         getPeerAddr( addr );
 314         return addr.getHostname();
 315     }
 316
 317
 318     inline bool Socket::bind(const SocketAddr& LocalInterface)
 319     {
 320         return osl_bindAddrToSocket( m_handle , LocalInterface.getHandle() );
 321     }
 322
 323
 324     inline bool Socket::isRecvReady(const TimeValue *pTimeout ) const
 325     {
 326         return osl_isReceiveReady( m_handle , pTimeout );
 327     }
 328
 329
 330     inline bool Socket::isSendReady(const TimeValue *pTimeout ) const
 331     {
 332         return osl_isSendReady( m_handle, pTimeout );
 333     }
 334
 335
 336     inline bool Socket::isExceptionPending(const TimeValue *pTimeout ) const
 337     {
 338         return osl_isExceptionPending( m_handle, pTimeout );
 339     }
 340
 341
 342     inline oslSocketType Socket::getType() const
 343     {
 344         return osl_getSocketType( m_handle );
 345     }
 346
 347
 348     inline sal_Int32  Socket::getOption(
 349         oslSocketOption Option,
 350         void* pBuffer,
 351         sal_uInt32 BufferLen,
 352         oslSocketOptionLevel Level) const
 353     {
 354         return osl_getSocketOption( m_handle, Level, Option, pBuffer , BufferLen );
 355     }
 356
 357
 358     inline bool Socket::setOption(  oslSocketOption Option,
 359                                         void* pBuffer,
 360                                         sal_uInt32 BufferLen,
 361                                         oslSocketOptionLevel Level ) const
 362     {
 363         return osl_setSocketOption( m_handle, Level, Option , pBuffer, BufferLen );
 364     }
 365
 366
 367     inline bool Socket::setOption( oslSocketOption option, sal_Int32 nValue  )
 368     {
 369         return setOption( option, &nValue, sizeof( nValue ) );
 370     }
 371
 372
 373     inline sal_Int32 Socket::getOption( oslSocketOption option ) const
 374     {
 375         sal_Int32 n;
 376         getOption( option, &n, sizeof( n ) );
 377         return n;
 378     }
 379
 380
 381     inline bool Socket::enableNonBlockingMode( bool bNonBlockingMode)
 382     {
 383         return osl_enableNonBlockingMode( m_handle , bNonBlockingMode );
 384     }
 385
 386
 387     inline bool Socket::isNonBlockingMode() const
 388     {
 389         return osl_isNonBlockingMode( m_handle );
 390     }
 391
 392
 393     inline void SAL_CALL Socket::clearError() const
 394     {
 395         sal_Int32 err = 0;
 396         getOption(osl_Socket_OptionError, &err, sizeof(err));
 397     }
 398
 399
 400     inline oslSocketError Socket::getError() const
 401     {
 402         return osl_getLastSocketError( m_handle );
 403     }
 404
 405
 406     inline ::rtl::OUString Socket::getErrorAsString( ) const
 407     {
 408         ::rtl::OUString error;
 409         osl_getLastSocketErrorDescription( m_handle, &(error.pData) );
 410         return error;
 411     }
 412
 413
 414     inline oslSocket Socket::getHandle() const
 415     {
 416         return m_handle;
 417     }
 418
 419
 420     inline StreamSocket::StreamSocket(oslAddrFamily Family,
 421                                       oslProtocol Protocol,
 422                                       oslSocketType Type )
 423         : Socket( Type, Family, Protocol )
 424     {}
 425
 426
 427     inline StreamSocket::StreamSocket( oslSocket socketHandle, __sal_NoAcquire noacquire )
 428         : Socket( socketHandle, noacquire )
 429     {}
 430
 431
 432     inline StreamSocket::StreamSocket( oslSocket socketHandle )
 433         : Socket( socketHandle )
 434     {}
 435
 436
 437     inline sal_Int32 StreamSocket::read(void* pBuffer, sal_uInt32 n)
 438     {
 439         return osl_readSocket( m_handle, pBuffer, n );
 440     }
 441
 442
 443     inline sal_Int32 StreamSocket::write(const void* pBuffer, sal_uInt32 n)
 444     {
 445         return osl_writeSocket( m_handle, pBuffer, n );
 446     }
 447
 448
 449     inline sal_Int32 StreamSocket::recv(void* pBuffer,
 450                                         sal_uInt32 BytesToRead,
 451                                         oslSocketMsgFlag Flag)
 452     {
 453         return osl_receiveSocket( m_handle, pBuffer,BytesToRead, Flag );
 454     }
 455
 456
 457     inline sal_Int32 StreamSocket::send(const void* pBuffer,
 458                                         sal_uInt32 BytesToSend,
 459                                         oslSocketMsgFlag Flag)
 460     {
 461         return osl_sendSocket( m_handle, pBuffer, BytesToSend, Flag );
 462     }
 463
 464
 465       inline ConnectorSocket::ConnectorSocket(oslAddrFamily Family,
 466                                             oslProtocol Protocol,
 467                                             oslSocketType   Type)
 468         : StreamSocket( Family, Protocol ,Type )
 469     {}
 470
 471
 472     inline oslSocketResult ConnectorSocket::connect( const SocketAddr& TargetHost,
 473                                                      const TimeValue* pTimeout )
 474     {
 475         return osl_connectSocketTo( m_handle , TargetHost.getHandle(), pTimeout );
 476     }
 477
 478
 479     inline AcceptorSocket::AcceptorSocket(oslAddrFamily Family ,
 480                                           oslProtocol   Protocol ,
 481                                           oslSocketType Type )
 482         : Socket( Type, Family, Protocol )
 483     {}
 484
 485
 486     inline bool AcceptorSocket::listen(sal_Int32 MaxPendingConnections)
 487     {
 488         return osl_listenOnSocket( m_handle, MaxPendingConnections );
 489     }
 490
 491
 492     inline oslSocketResult AcceptorSocket::acceptConnection( StreamSocket& Connection)
 493     {
 494         oslSocket o = osl_acceptConnectionOnSocket( m_handle, NULL );
 495         oslSocketResult status = osl_Socket_Ok;
 496         if( o )
 497         {
 498             Connection = StreamSocket( o , SAL_NO_ACQUIRE );
 499         }
 500         else
 501         {
 502             Connection = StreamSocket();
 503             status = osl_Socket_Error;
 504         }
 505         return status;
 506     }
 507
 508
 509     inline oslSocketResult AcceptorSocket::acceptConnection(
 510         StreamSocket&   Connection, SocketAddr & PeerAddr)
 511     {
 512         // TODO change in/OUT parameter
 513         oslSocket o = osl_acceptConnectionOnSocket(
 514             m_handle, reinterpret_cast<oslSocketAddr *>(&PeerAddr));
 515         oslSocketResult status = osl_Socket_Ok;
 516         if( o )
 517         {
 518             Connection = StreamSocket( o , SAL_NO_ACQUIRE );
 519         }
 520         else
 521         {
 522             Connection = StreamSocket();
 523             status = osl_Socket_Error;
 524         }
 525         return status;
 526     }
 527
 528
 529     inline DatagramSocket::DatagramSocket(oslAddrFamily Family,
 530                                           oslProtocol   Protocol,
 531                                           oslSocketType Type)
 532         : Socket( Type, Family, Protocol )
 533     {}
 534
 535
 536     inline sal_Int32 DatagramSocket::recvFrom(void*  pBuffer,
 537                                               sal_uInt32 BufferSize,
 538                                               SocketAddr* pSenderAddr,
 539                                               oslSocketMsgFlag Flag )
 540     {
 541         sal_Int32 nByteRead;
 542         if( pSenderAddr )
 543         {
 544             // TODO : correct the out-parameter pSenderAddr outparameter
 545             nByteRead = osl_receiveFromSocket( m_handle, pSenderAddr->getHandle() , pBuffer,
 546                                                  BufferSize, Flag);
 547         }
 548         else
 549         {
 550             nByteRead = osl_receiveFromSocket( m_handle, NULL , pBuffer , BufferSize ,  Flag );
 551         }
 552         return nByteRead;
 553     }
 554
 555
 556     inline sal_Int32  DatagramSocket::sendTo( const SocketAddr& ReceiverAddr,
 557                                               const void* pBuffer,
 558                                               sal_uInt32 BufferSize,
 559                                               oslSocketMsgFlag Flag )
 560     {
 561         return osl_sendToSocket( m_handle, ReceiverAddr.getHandle(), pBuffer, BufferSize, Flag );
 562     }
 563 }
 564 #endif
 565
 566 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */