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): 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) {
 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         return (*this) = sock.getHandle();
 246     }
 247
 248
 249     inline bool Socket::operator==( const Socket& rSocket ) const
 250     {
 251         return m_handle == rSocket.getHandle();
 252     }
 253
 254
 255     inline bool Socket::operator==( const oslSocket socketHandle ) const
 256     {
 257         return m_handle == socketHandle;
 258     }
 259
 260
 261     inline void Socket::shutdown( oslSocketDirection Direction )
 262     {
 263         osl_shutdownSocket( m_handle , Direction );
 264     }
 265
 266
 267     inline void Socket::close()
 268     {
 269         osl_closeSocket( m_handle );
 270     }
 271
 272
 273     inline void Socket::getLocalAddr( SocketAddr & addr) const
 274     {
 275         addr.assign( osl_getLocalAddrOfSocket( m_handle ) , SAL_NO_COPY );
 276     }
 277
 278
 279     inline sal_Int32 Socket::getLocalPort() const
 280     {
 281         SocketAddr addr( NULL );
 282         getLocalAddr( addr );
 283         return addr.getPort();
 284     }
 285
 286
 287     inline ::rtl::OUString Socket::getLocalHost() const
 288     {
 289         SocketAddr addr( NULL );
 290         getLocalAddr( addr );
 291         return addr.getHostname();
 292     }
 293
 294
 295     inline void Socket::getPeerAddr( SocketAddr &addr ) const
 296     {
 297         addr.assign( osl_getPeerAddrOfSocket( m_handle ), SAL_NO_COPY );
 298     }
 299
 300
 301     inline sal_Int32 Socket::getPeerPort() const
 302     {
 303         SocketAddr addr( NULL );
 304         getPeerAddr( addr );
 305         return addr.getPort();
 306     }
 307
 308
 309     inline ::rtl::OUString Socket::getPeerHost() const
 310     {
 311         SocketAddr addr( NULL );
 312         getPeerAddr( addr );
 313         return addr.getHostname();
 314     }
 315
 316
 317     inline bool Socket::bind(const SocketAddr& LocalInterface)
 318     {
 319         return osl_bindAddrToSocket( m_handle , LocalInterface.getHandle() );
 320     }
 321
 322
 323     inline bool Socket::isRecvReady(const TimeValue *pTimeout ) const
 324     {
 325         return osl_isReceiveReady( m_handle , pTimeout );
 326     }
 327
 328
 329     inline bool Socket::isSendReady(const TimeValue *pTimeout ) const
 330     {
 331         return osl_isSendReady( m_handle, pTimeout );
 332     }
 333
 334
 335     inline bool Socket::isExceptionPending(const TimeValue *pTimeout ) const
 336     {
 337         return osl_isExceptionPending( m_handle, pTimeout );
 338     }
 339
 340
 341     inline oslSocketType Socket::getType() const
 342     {
 343         return osl_getSocketType( m_handle );
 344     }
 345
 346
 347     inline sal_Int32  Socket::getOption(
 348         oslSocketOption Option,
 349         void* pBuffer,
 350         sal_uInt32 BufferLen,
 351         oslSocketOptionLevel Level) const
 352     {
 353         return osl_getSocketOption( m_handle, Level, Option, pBuffer , BufferLen );
 354     }
 355
 356
 357     inline bool Socket::setOption(  oslSocketOption Option,
 358                                         void* pBuffer,
 359                                         sal_uInt32 BufferLen,
 360                                         oslSocketOptionLevel Level ) const
 361     {
 362         return osl_setSocketOption( m_handle, Level, Option , pBuffer, BufferLen );
 363     }
 364
 365
 366     inline bool Socket::setOption( oslSocketOption option, sal_Int32 nValue  )
 367     {
 368         return setOption( option, &nValue, sizeof( nValue ) );
 369     }
 370
 371
 372     inline sal_Int32 Socket::getOption( oslSocketOption option ) const
 373     {
 374         sal_Int32 n;
 375         getOption( option, &n, sizeof( n ) );
 376         return n;
 377     }
 378
 379
 380     inline bool Socket::enableNonBlockingMode( bool bNonBlockingMode)
 381     {
 382         return osl_enableNonBlockingMode( m_handle , bNonBlockingMode );
 383     }
 384
 385
 386     inline bool Socket::isNonBlockingMode() const
 387     {
 388         return osl_isNonBlockingMode( m_handle );
 389     }
 390
 391
 392     inline void SAL_CALL Socket::clearError() const
 393     {
 394         sal_Int32 err = 0;
 395         getOption(osl_Socket_OptionError, &err, sizeof(err));
 396     }
 397
 398
 399     inline oslSocketError Socket::getError() const
 400     {
 401         return osl_getLastSocketError( m_handle );
 402     }
 403
 404
 405     inline ::rtl::OUString Socket::getErrorAsString( ) const
 406     {
 407         ::rtl::OUString error;
 408         osl_getLastSocketErrorDescription( m_handle, &(error.pData) );
 409         return error;
 410     }
 411
 412
 413     inline oslSocket Socket::getHandle() const
 414     {
 415         return m_handle;
 416     }
 417
 418
 419     inline StreamSocket::StreamSocket(oslAddrFamily Family,
 420                                       oslProtocol Protocol,
 421                                       oslSocketType Type )
 422         : Socket( Type, Family, Protocol )
 423     {}
 424
 425
 426     inline StreamSocket::StreamSocket( oslSocket socketHandle, __sal_NoAcquire noacquire )
 427         : Socket( socketHandle, noacquire )
 428     {}
 429
 430
 431     inline StreamSocket::StreamSocket( oslSocket socketHandle )
 432         : Socket( socketHandle )
 433     {}
 434
 435
 436     inline StreamSocket::StreamSocket( const StreamSocket & socket )
 437         : Socket( socket )
 438     {}
 439
 440
 441     inline sal_Int32 StreamSocket::read(void* pBuffer, sal_uInt32 n)
 442     {
 443         return osl_readSocket( m_handle, pBuffer, n );
 444     }
 445
 446
 447     inline sal_Int32 StreamSocket::write(const void* pBuffer, sal_uInt32 n)
 448     {
 449         return osl_writeSocket( m_handle, pBuffer, n );
 450     }
 451
 452
 453     inline sal_Int32 StreamSocket::recv(void* pBuffer,
 454                                         sal_uInt32 BytesToRead,
 455                                         oslSocketMsgFlag Flag)
 456     {
 457         return osl_receiveSocket( m_handle, pBuffer,BytesToRead, Flag );
 458     }
 459
 460
 461     inline sal_Int32 StreamSocket::send(const void* pBuffer,
 462                                         sal_uInt32 BytesToSend,
 463                                         oslSocketMsgFlag Flag)
 464     {
 465         return osl_sendSocket( m_handle, pBuffer, BytesToSend, Flag );
 466     }
 467
 468
 469       inline ConnectorSocket::ConnectorSocket(oslAddrFamily Family,
 470                                             oslProtocol Protocol,
 471                                             oslSocketType   Type)
 472         : StreamSocket( Family, Protocol ,Type )
 473     {}
 474
 475
 476     inline oslSocketResult ConnectorSocket::connect( const SocketAddr& TargetHost,
 477                                                      const TimeValue* pTimeout )
 478     {
 479         return osl_connectSocketTo( m_handle , TargetHost.getHandle(), pTimeout );
 480     }
 481
 482
 483     inline AcceptorSocket::AcceptorSocket(oslAddrFamily Family ,
 484                                           oslProtocol   Protocol ,
 485                                           oslSocketType Type )
 486         : Socket( Type, Family, Protocol )
 487     {}
 488
 489
 490     inline bool AcceptorSocket::listen(sal_Int32 MaxPendingConnections)
 491     {
 492         return osl_listenOnSocket( m_handle, MaxPendingConnections );
 493     }
 494
 495
 496     inline oslSocketResult AcceptorSocket::acceptConnection( StreamSocket& Connection)
 497     {
 498         oslSocket o = osl_acceptConnectionOnSocket( m_handle, NULL );
 499         oslSocketResult status = osl_Socket_Ok;
 500         if( o )
 501         {
 502             Connection = StreamSocket( o , SAL_NO_ACQUIRE );
 503         }
 504         else
 505         {
 506             Connection = StreamSocket();
 507             status = osl_Socket_Error;
 508         }
 509         return status;
 510     }
 511
 512
 513     inline oslSocketResult AcceptorSocket::acceptConnection(
 514         StreamSocket&   Connection, SocketAddr & PeerAddr)
 515     {
 516         // TODO change in/OUT parameter
 517         oslSocket o = osl_acceptConnectionOnSocket(
 518             m_handle, reinterpret_cast<oslSocketAddr *>(&PeerAddr));
 519         oslSocketResult status = osl_Socket_Ok;
 520         if( o )
 521         {
 522             Connection = StreamSocket( o , SAL_NO_ACQUIRE );
 523         }
 524         else
 525         {
 526             Connection = StreamSocket();
 527             status = osl_Socket_Error;
 528         }
 529         return status;
 530     }
 531
 532
 533     inline DatagramSocket::DatagramSocket(oslAddrFamily Family,
 534                                           oslProtocol   Protocol,
 535                                           oslSocketType Type)
 536         : Socket( Type, Family, Protocol )
 537     {}
 538
 539
 540     inline sal_Int32 DatagramSocket::recvFrom(void*  pBuffer,
 541                                               sal_uInt32 BufferSize,
 542                                               SocketAddr* pSenderAddr,
 543                                               oslSocketMsgFlag Flag )
 544     {
 545         sal_Int32 nByteRead;
 546         if( pSenderAddr )
 547         {
 548             // TODO : correct the out-parameter pSenderAddr outparameter
 549             nByteRead = osl_receiveFromSocket( m_handle, pSenderAddr->getHandle() , pBuffer,
 550                                                  BufferSize, Flag);
 551         }
 552         else
 553         {
 554             nByteRead = osl_receiveFromSocket( m_handle, NULL , pBuffer , BufferSize ,  Flag );
 555         }
 556         return nByteRead;
 557     }
 558
 559
 560     inline sal_Int32  DatagramSocket::sendTo( const SocketAddr& ReceiverAddr,
 561                                               const void* pBuffer,
 562                                               sal_uInt32 BufferSize,
 563                                               oslSocketMsgFlag Flag )
 564     {
 565         return osl_sendToSocket( m_handle, ReceiverAddr.getHandle(), pBuffer, BufferSize, Flag );
 566     }
 567 }
 568 #endif
 569
 570 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */