sal/osl/unx/socket.cxx

   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
  20 #include <sal/config.h>
  21
  22 #include <utility>
  23
  24 #include "system.hxx"
  25
  26 #include <osl/socket.h>
  27 #include <osl/mutex.h>
  28 #include <osl/signal.h>
  29
  30 #include <rtl/alloc.h>
  31 #include <rtl/byteseq.h>
  32 #include <rtl/ustring.hxx>
  33 #include <assert.h>
  34 #include <sal/types.h>
  35 #include <sal/log.hxx>
  36
  37 #include "sockimpl.hxx"
  38 #include "unixerrnostring.hxx"
  39 #include <oslsocket.hxx>
  40
  41 #include <poll.h>
  42
  43 /* defines for shutdown */
  44 #define SD_RECEIVE 0
  45 #define SD_SEND 1
  46 #define SD_BOTH 2
  47
  48 /*
  49     oslSocketAddr is a pointer to a Berkeley struct sockaddr.
  50     I refrained from using sockaddr_in because of possible further
  51     extensions of this socket-interface (IP-NG?).
  52     The intention was to hide all Berkeley data-structures from
  53     direct access past the osl-interface.
  54
  55     The current implementation is internet (IP) centered. All
  56     the constructor-functions (osl_create...) take parameters
  57     that will probably make sense only in the IP-environment
  58     (e.g. because of using the dotted-address-format).
  59
  60     If the interface will be extended to host other protocol-
  61     families, I expect no externally visible changes in the
  62     existing functions. You'll probably need only new
  63     constructor-functions who take the different address
  64     formats into consideration (maybe a long dotted address
  65     or whatever).
  66 */
  67
  68 /* _Note_ that I rely on the fact that oslSocketAddr and struct sockaddr */
  69 /* are the same! I don't like it very much but see no other easy way to  */
  70 /* conceal the struct sockaddr from the eyes of the user. */
  71
  72 #define OSL_INVALID_SOCKET      -1
  73 #define OSL_SOCKET_ERROR        -1
  74
  75 /* Buffer size for getnameinfo */
  76 #define MAX_HOSTBUFFER_SIZE 2048
  77
  78 const unsigned long FamilyMap[]= {
  79     AF_INET,                    /* osl_Socket_FamilyInet    */
  80     AF_IPX,                     /* osl_Socket_FamilyIpx     */
  81     0                           /* osl_Socket_FamilyInvalid */
  82 };
  83
  84 static oslAddrFamily osl_AddrFamilyFromNative(sal_uInt32 nativeType)
  85 {
  86     oslAddrFamily i= oslAddrFamily(0);
  87
  88     while(i != osl_Socket_FamilyInvalid)
  89     {
  90         if(FamilyMap[i] == nativeType)
  91             return i;
  92         i = static_cast<oslAddrFamily>( i + 1 );
  93     }
  94
  95     return i;
  96 }
  97
  98 #define FAMILY_FROM_NATIVE(y) osl_AddrFamilyFromNative(y)
  99 #define FAMILY_TO_NATIVE(x) static_cast<short>(FamilyMap[x])
 100
 101 const sal_uInt32 ProtocolMap[]= {
 102     0,                          /* osl_Socket_ProtocolIp      */
 103     NSPROTO_IPX,                /* osl_Socket_ProtocolIpx     */
 104     NSPROTO_SPX,                /* osl_Socket_ProtocolSpx     */
 105     NSPROTO_SPXII,              /* osl_Socket_ProtocolSpxII   */
 106     0                           /* osl_Socket_ProtocolInvalid */
 107 };
 108
 109 #define PROTOCOL_TO_NATIVE(x)   ProtocolMap[x]
 110
 111 const sal_uInt32 TypeMap[]= {
 112     SOCK_STREAM,                /* osl_Socket_TypeStream    */
 113     SOCK_DGRAM,                 /* osl_Socket_TypeDgram     */
 114     SOCK_RAW,                   /* osl_Socket_TypeRaw       */
 115     SOCK_RDM,                   /* osl_Socket_TypeRdm       */
 116     SOCK_SEQPACKET,             /* osl_Socket_TypeSeqPacket */
 117     0                           /* osl_Socket_TypeInvalid   */
 118 };
 119
 120 static oslSocketType osl_SocketTypeFromNative(sal_uInt32 nativeType)
 121 {
 122     oslSocketType i= oslSocketType(0);
 123
 124     while(i != osl_Socket_TypeInvalid)
 125     {
 126         if(TypeMap[i] == nativeType)
 127             return i;
 128         i = static_cast<oslSocketType>(i + 1);
 129     }
 130
 131     return i;
 132 }
 133
 134 #define TYPE_TO_NATIVE(x)       TypeMap[x]
 135 #define TYPE_FROM_NATIVE(y)     osl_SocketTypeFromNative(y)
 136
 137 const sal_uInt32 OptionMap[]= {
 138     SO_DEBUG,                   /* osl_Socket_OptionDebug       */
 139     SO_ACCEPTCONN,              /* osl_Socket_OptionAcceptConn  */
 140     SO_REUSEADDR,               /* osl_Socket_OptionReuseAddr   */
 141     SO_KEEPALIVE,               /* osl_Socket_OptionKeepAlive   */
 142     SO_DONTROUTE,               /* osl_Socket_OptionDontRoute   */
 143     SO_BROADCAST,               /* osl_Socket_OptionBroadcast   */
 144     SO_USELOOPBACK,             /* osl_Socket_OptionUseLoopback */
 145     SO_LINGER,                  /* osl_Socket_OptionLinger      */
 146     SO_OOBINLINE,               /* osl_Socket_OptionOOBinLine   */
 147     SO_SNDBUF,                  /* osl_Socket_OptionSndBuf      */
 148     SO_RCVBUF,                  /* osl_Socket_OptionRcvBuf      */
 149     SO_SNDLOWAT,                /* osl_Socket_OptionSndLowat    */
 150     SO_RCVLOWAT,                /* osl_Socket_OptionRcvLowat    */
 151     SO_SNDTIMEO,                /* osl_Socket_OptionSndTimeo    */
 152     SO_RCVTIMEO,                /* osl_Socket_OptionRcvTimeo    */
 153     SO_ERROR,                   /* osl_Socket_OptionError       */
 154     SO_TYPE,                    /* osl_Socket_OptionType        */
 155     TCP_NODELAY,                /* osl_Socket_OptionTcpNoDelay  */
 156     0                           /* osl_Socket_OptionInvalid     */
 157 };
 158
 159 #define OPTION_TO_NATIVE(x)     OptionMap[x]
 160
 161 const sal_uInt32 OptionLevelMap[]= {
 162     SOL_SOCKET,                 /* osl_Socket_LevelSocket  */
 163     IPPROTO_TCP,                /* osl_Socket_LevelTcp     */
 164     0                           /* osl_Socket_LevelInvalid */
 165 };
 166
 167 #define OPTION_LEVEL_TO_NATIVE(x)       OptionLevelMap[x]
 168
 169 const sal_uInt32 SocketMsgFlagMap[]= {
 170     0,                          /* osl_Socket_MsgNormal    */
 171     MSG_OOB,                    /* osl_Socket_MsgOOB       */
 172     MSG_PEEK,                   /* osl_Socket_MsgPeek      */
 173     MSG_DONTROUTE,              /* osl_Socket_MsgDontRoute */
 174     MSG_MAXIOVLEN,              /* osl_Socket_MsgMaxIOVLen */
 175     0                           /* osl_Socket_MsgInvalid   */
 176 };
 177
 178 #define MSG_FLAG_TO_NATIVE(x)       SocketMsgFlagMap[x]
 179
 180 const sal_uInt32 SocketDirection[]= {
 181     SD_RECEIVE,                 /* osl_Socket_DirRead      */
 182     SD_SEND,                    /* osl_Socket_DirWrite     */
 183     SD_BOTH,                    /* osl_Socket_DirReadWrite */
 184     0                           /* osl_Socket_DirInvalid   */
 185 };
 186
 187 #define DIRECTION_TO_NATIVE(x)      SocketDirection[x]
 188
 189 const struct
 190 {
 191     int            errcode;
 192     oslSocketError error;
 193 } SocketError[]= {
 194     { 0,               osl_Socket_E_None              }, /* no error */
 195     { ENOTSOCK,        osl_Socket_E_NotSocket         }, /* Socket operation on non-socket */
 196     { EDESTADDRREQ,    osl_Socket_E_DestAddrReq       }, /* Destination address required */
 197     { EMSGSIZE,        osl_Socket_E_MsgSize           }, /* Message too long */
 198     { EPROTOTYPE,      osl_Socket_E_Prototype         }, /* Protocol wrong type for socket */
 199     { ENOPROTOOPT,     osl_Socket_E_NoProtocol        }, /* Protocol not available */
 200     { EPROTONOSUPPORT, osl_Socket_E_ProtocolNoSupport }, /* Protocol not supported */
 201 #ifdef ESOCKTNOSUPPORT
 202     { ESOCKTNOSUPPORT, osl_Socket_E_TypeNoSupport     }, /* Socket type not supported */
 203 #endif
 204     { EOPNOTSUPP,      osl_Socket_E_OpNotSupport      }, /* Operation not supported on socket */
 205     { EPFNOSUPPORT,    osl_Socket_E_PfNoSupport       }, /* Protocol family not supported */
 206     { EAFNOSUPPORT,    osl_Socket_E_AfNoSupport       }, /* Address family not supported by
 207                                                             protocol family */
 208     { EADDRINUSE,      osl_Socket_E_AddrInUse         }, /* Address already in use */
 209     { EADDRNOTAVAIL,   osl_Socket_E_AddrNotAvail      }, /* Can't assign requested address */
 210     { ENETDOWN,        osl_Socket_E_NetDown           }, /* Network is down */
 211     { ENETUNREACH,     osl_Socket_E_NetUnreachable    }, /* Network is unreachable */
 212     { ENETRESET,       osl_Socket_E_NetReset          }, /* Network dropped connection because
 213                                                             of reset */
 214     { ECONNABORTED,    osl_Socket_E_ConnAborted       }, /* Software caused connection abort */
 215     { ECONNRESET,      osl_Socket_E_ConnReset         }, /* Connection reset by peer */
 216     { ENOBUFS,         osl_Socket_E_NoBufferSpace     }, /* No buffer space available */
 217     { EISCONN,         osl_Socket_E_IsConnected       }, /* Socket is already connected */
 218     { ENOTCONN,        osl_Socket_E_NotConnected      }, /* Socket is not connected */
 219     { ESHUTDOWN,       osl_Socket_E_Shutdown          }, /* Can't send after socket shutdown */
 220 #ifdef ETOOMANYREFS
 221     { ETOOMANYREFS,    osl_Socket_E_TooManyRefs       }, /* Too many references: can't splice */
 222 #endif
 223     { ETIMEDOUT,       osl_Socket_E_TimedOut          }, /* Connection timed out */
 224     { ECONNREFUSED,    osl_Socket_E_ConnRefused       }, /* Connection refused */
 225     { EHOSTDOWN,       osl_Socket_E_HostDown          }, /* Host is down */
 226     { EHOSTUNREACH,    osl_Socket_E_HostUnreachable   }, /* No route to host */
 227     { EWOULDBLOCK,     osl_Socket_E_WouldBlock        }, /* call would block on non-blocking socket */
 228     { EALREADY,        osl_Socket_E_Already           }, /* operation already in progress */
 229     { EINPROGRESS,     osl_Socket_E_InProgress        }, /* operation now in progress */
 230     { EAGAIN,          osl_Socket_E_WouldBlock        }, /* same as EWOULDBLOCK */
 231     { -1,              osl_Socket_E_InvalidError      }
 232 };
 233
 234 static oslSocketError osl_SocketErrorFromNative(int nativeType)
 235 {
 236     int i = 0;
 237
 238     while ((SocketError[i].error != osl_Socket_E_InvalidError) &&
 239            (SocketError[i].errcode != nativeType)) i++;
 240
 241     return SocketError[i].error;
 242 }
 243
 244 #define ERROR_FROM_NATIVE(y)    osl_SocketErrorFromNative(y)
 245
 246 static oslSocketAddr osl_psz_createInetSocketAddr (
 247     const char* pszDottedAddr, sal_Int32 Port);
 248
 249 static oslHostAddr osl_psz_createHostAddr (
 250     const char *pszHostname, const oslSocketAddr Addr);
 251
 252 static oslHostAddr osl_psz_createHostAddrByName (
 253     const char *pszHostname);
 254
 255 static const char* osl_psz_getHostnameOfHostAddr (
 256     const oslHostAddr Addr);
 257
 258 static oslSocketAddr osl_psz_resolveHostname (
 259     const char* pszHostname);
 260
 261 static sal_Int32 osl_psz_getServicePort (
 262     const char* pszServicename, const char* pszProtocol);
 263
 264 static void osl_psz_getLastSocketErrorDescription (
 265     oslSocket Socket, char* pBuffer, sal_uInt32 BufferSize);
 266
 267 namespace {
 268
 269 int convertToMs(TimeValue const * value) {
 270     return value->Seconds * 1000 + value->Nanosec / 1000000; //TODO: overflow
 271 }
 272
 273 }
 274
 275 static oslSocket createSocketImpl()
 276 {
 277     oslSocket pSocket;
 278
 279     pSocket = static_cast<oslSocket>(calloc(1, sizeof(struct oslSocketImpl)));
 280
 281     pSocket->m_Socket = OSL_INVALID_SOCKET;
 282     pSocket->m_nLastError = 0;
 283     pSocket->m_nRefCount = 1;
 284
 285 #if defined(CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT)
 286     pSocket->m_bIsAccepting = false;
 287 #endif
 288
 289     return pSocket;
 290 }
 291
 292 static void destroySocketImpl(oslSocket Socket)
 293 {
 294     if ( Socket != nullptr)
 295         free(Socket);
 296 }
 297
 298 static oslSocketAddr createSocketAddr()
 299 {
 300     oslSocketAddr pAddr = static_cast<oslSocketAddr>(rtl_allocateZeroMemory( sizeof( struct oslSocketAddrImpl )));
 301     return pAddr;
 302 }
 303
 304 static oslSocketAddr createSocketAddrWithFamily(
 305     oslAddrFamily family, sal_Int32 port, sal_uInt32 nAddr )
 306 {
 307     oslSocketAddr pAddr;
 308
 309     SAL_WARN_IF( family != osl_Socket_FamilyInet, "sal.osl", "creating socket for non-IP address family" );
 310
 311     pAddr = createSocketAddr();
 312     switch( family )
 313     {
 314     case osl_Socket_FamilyInet:
 315     {
 316         struct sockaddr_in* pInetAddr= reinterpret_cast<sockaddr_in*>(&pAddr->m_sockaddr);
 317
 318         pInetAddr->sin_family = FAMILY_TO_NATIVE(osl_Socket_FamilyInet);
 319         pInetAddr->sin_addr.s_addr = nAddr;
 320         pInetAddr->sin_port = static_cast<sal_uInt16>(port&0xffff);
 321         break;
 322        }
 323     default:
 324         pAddr->m_sockaddr.sa_family = FAMILY_TO_NATIVE(family);
 325     }
 326     return pAddr;
 327 }
 328
 329 static oslSocketAddr createSocketAddrFromSystem( struct sockaddr *pSystemSockAddr )
 330 {
 331     oslSocketAddr pAddr = createSocketAddr();
 332     memcpy( &(pAddr->m_sockaddr), pSystemSockAddr, sizeof( struct sockaddr ) );
 333     return pAddr;
 334 }
 335
 336 static void destroySocketAddr( oslSocketAddr addr )
 337 {
 338     free( addr );
 339 }
 340
 341 oslSocketAddr SAL_CALL osl_createEmptySocketAddr(oslAddrFamily Family)
 342 {
 343     oslSocketAddr pAddr = nullptr;
 344
 345     /* is it an internet-Addr? */
 346     if (Family == osl_Socket_FamilyInet)
 347     {
 348         pAddr = createSocketAddrWithFamily(Family, 0 , htonl(INADDR_ANY) );
 349     }
 350     else
 351     {
 352         pAddr = createSocketAddrWithFamily( Family , 0 , 0 );
 353     }
 354
 355     return pAddr;
 356 }
 357
 358 oslSocketAddr SAL_CALL osl_copySocketAddr(oslSocketAddr Addr)
 359 {
 360     oslSocketAddr pCopy = nullptr;
 361     if (Addr)
 362     {
 363         pCopy = createSocketAddr();
 364
 365         if (pCopy)
 366             memcpy(&(pCopy->m_sockaddr),&(Addr->m_sockaddr), sizeof(struct sockaddr));
 367     }
 368     return pCopy;
 369 }
 370
 371 sal_Bool SAL_CALL osl_isEqualSocketAddr (
 372     oslSocketAddr Addr1,
 373     oslSocketAddr Addr2)
 374 {
 375     struct sockaddr* pAddr1 = nullptr;
 376     struct sockaddr* pAddr2 = nullptr;
 377
 378     assert(Addr1 && Addr2);
 379     pAddr1 = &(Addr1->m_sockaddr);
 380     pAddr2 = &(Addr2->m_sockaddr);
 381
 382     if (pAddr1 == pAddr2)
 383     {
 384         return true;
 385     }
 386
 387     if (pAddr1->sa_family == pAddr2->sa_family)
 388     {
 389         switch (pAddr1->sa_family)
 390         {
 391             case AF_INET:
 392             {
 393                 struct sockaddr_in* pInetAddr1= reinterpret_cast<sockaddr_in*>(pAddr1);
 394                 struct sockaddr_in* pInetAddr2= reinterpret_cast<sockaddr_in*>(pAddr2);
 395
 396                 if ((pInetAddr1->sin_family == pInetAddr2->sin_family) &&
 397                     (pInetAddr1->sin_addr.s_addr == pInetAddr2->sin_addr.s_addr) &&
 398                     (pInetAddr1->sin_port == pInetAddr2->sin_port))
 399                     return true;
 400                 [[fallthrough]];
 401             }
 402
 403             default:
 404             {
 405                 return (memcmp(pAddr1, pAddr2, sizeof(struct sockaddr)) == 0);
 406             }
 407         }
 408     }
 409
 410     return false;
 411 }
 412
 413 oslSocketAddr SAL_CALL osl_createInetBroadcastAddr (
 414     rtl_uString *strDottedAddr,
 415     sal_Int32    Port)
 416 {
 417     sal_uInt32    nAddr = OSL_INADDR_NONE;
 418     oslSocketAddr pAddr;
 419
 420     if (strDottedAddr && strDottedAddr->length)
 421     {
 422         /* Dotted host address for limited broadcast */
 423         rtl_String *pDottedAddr = nullptr;
 424
 425         rtl_uString2String (
 426             &pDottedAddr, strDottedAddr->buffer, strDottedAddr->length,
 427             RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);
 428
 429         in_addr buf;
 430         if (inet_pton (AF_INET, pDottedAddr->buffer, &buf) == 1) {
 431             nAddr = buf.s_addr;
 432         }
 433         rtl_string_release (pDottedAddr);
 434     }
 435
 436     if (nAddr != OSL_INADDR_NONE)
 437     {
 438         /* Limited broadcast */
 439         nAddr = ntohl(nAddr);
 440         if (IN_CLASSA(nAddr))
 441         {
 442             nAddr &= IN_CLASSA_NET;
 443             nAddr |= IN_CLASSA_HOST;
 444         }
 445         else if (IN_CLASSB(nAddr))
 446         {
 447             nAddr &= IN_CLASSB_NET;
 448             nAddr |= IN_CLASSB_HOST;
 449         }
 450         else if (IN_CLASSC(nAddr))
 451         {
 452             nAddr &= IN_CLASSC_NET;
 453             nAddr |= IN_CLASSC_HOST;
 454         }
 455         else
 456         {
 457             /* No broadcast in class D */
 458             return nullptr;
 459         }
 460         nAddr = htonl(nAddr);
 461     }
 462
 463     pAddr = createSocketAddrWithFamily( osl_Socket_FamilyInet, htons(Port), nAddr );
 464     return pAddr;
 465 }
 466
 467 oslSocketAddr SAL_CALL osl_createInetSocketAddr (
 468     rtl_uString *ustrDottedAddr,
 469     sal_Int32    Port)
 470 {
 471     rtl_String* strDottedAddr=nullptr;
 472     oslSocketAddr Addr;
 473     char* pszDottedAddr=nullptr;
 474
 475     if ( ustrDottedAddr != nullptr )
 476     {
 477         rtl_uString2String( &strDottedAddr,
 478                             rtl_uString_getStr(ustrDottedAddr),
 479                             rtl_uString_getLength(ustrDottedAddr),
 480                             RTL_TEXTENCODING_UTF8,
 481                             OUSTRING_TO_OSTRING_CVTFLAGS);
 482         pszDottedAddr = rtl_string_getStr(strDottedAddr);
 483     }
 484
 485     Addr = pszDottedAddr ? osl_psz_createInetSocketAddr(pszDottedAddr, Port) : nullptr;
 486
 487     if ( strDottedAddr != nullptr )
 488     {
 489         rtl_string_release(strDottedAddr);
 490     }
 491
 492     return Addr;
 493 }
 494
 495 oslSocketAddr osl_psz_createInetSocketAddr (
 496     const char* pszDottedAddr,
 497     sal_Int32       Port)
 498 {
 499     oslSocketAddr pAddr = nullptr;
 500     in_addr buf;
 501     if(inet_pton(AF_INET, pszDottedAddr, &buf) == 1)
 502     {
 503         /* valid dotted addr */
 504         pAddr = createSocketAddrWithFamily( osl_Socket_FamilyInet, htons(Port) , buf.s_addr );
 505     }
 506     return pAddr;
 507 }
 508
 509 oslSocketResult SAL_CALL osl_setAddrOfSocketAddr( oslSocketAddr pAddr, sal_Sequence *pByteSeq )
 510 {
 511     oslSocketResult res = osl_Socket_Error;
 512
 513     SAL_WARN_IF( !pAddr, "sal.osl", "setting address of undefined socket address" );
 514     SAL_WARN_IF( !pByteSeq, "sal.osl", "setting undefined address for socket address" );
 515
 516     if( pAddr && pByteSeq )
 517     {
 518         struct sockaddr_in * pSystemInetAddr;
 519
 520         assert( pAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE( osl_Socket_FamilyInet ) );
 521         assert( pByteSeq->nElements == 4 );
 522
 523         pSystemInetAddr = reinterpret_cast<sockaddr_in *>(&pAddr->m_sockaddr);
 524         memcpy( &(pSystemInetAddr->sin_addr) , pByteSeq->elements , 4 );
 525         res = osl_Socket_Ok;
 526     }
 527     return res;
 528 }
 529
 530 oslSocketResult SAL_CALL osl_getAddrOfSocketAddr( oslSocketAddr pAddr, sal_Sequence **ppByteSeq )
 531 {
 532     oslSocketResult res = osl_Socket_Error;
 533
 534     SAL_WARN_IF( !pAddr, "sal.osl", "getting address of undefined socket address" );
 535     SAL_WARN_IF( !ppByteSeq, "sal.osl", "getting address to undefined address pointer" );
 536
 537     if( pAddr && ppByteSeq )
 538     {
 539         struct sockaddr_in * pSystemInetAddr = reinterpret_cast<sockaddr_in *>(&pAddr->m_sockaddr);
 540         rtl_byte_sequence_constructFromArray( ppByteSeq, reinterpret_cast<sal_Int8 *>(&pSystemInetAddr->sin_addr), 4);
 541         res = osl_Socket_Ok;
 542     }
 543     return res;
 544 }
 545
 546 /** try to figure out a full-qualified hostname, by adding the current domain
 547     as given by the domainname program to the given hostname.
 548     This function MUST NOT call gethostbyname since pHostName already points
 549     to data returned by gethostname and would be garbled: use gethostname_r
 550     instead!
 551  */
 552
 553 namespace {
 554
 555 struct oslAddrInfo
 556 {
 557     addrinfo* pAddrInfoList = nullptr;
 558     int nError;
 559
 560     oslAddrInfo(const char* name, bool isInet = false)
 561     {
 562         addrinfo aHints;
 563         memset(&aHints, 0, sizeof(addrinfo));
 564         if (isInet)
 565             aHints.ai_family = AF_INET;
 566         aHints.ai_flags = AI_CANONNAME;
 567
 568         nError = getaddrinfo(name, nullptr, &aHints, &pAddrInfoList);
 569     }
 570
 571     ~oslAddrInfo()
 572     {
 573         if (nError == 0)
 574             freeaddrinfo(pAddrInfoList);
 575     }
 576
 577     const char* getHostName() const
 578     {
 579         assert(pAddrInfoList);
 580         return pAddrInfoList->ai_canonname;
 581     }
 582 };
 583
 584 }
 585 static bool isFullQualifiedDomainName (const char *pHostName)
 586 {
 587     /* a FQDN (aka 'hostname.domain.top_level_domain' )
 588      * is a name which contains a dot '.' in it ( would
 589      * match as well for 'hostname.' but is good enough
 590      * for now )*/
 591     return strchr( pHostName, int('.') ) != nullptr;
 592 }
 593
 594 static char* getFullQualifiedDomainName (const char *pHostName)
 595 {
 596     char  *pFullQualifiedName = nullptr;
 597
 598     if (isFullQualifiedDomainName(pHostName))
 599     {
 600         pFullQualifiedName = strdup(pHostName);
 601     }
 602     else
 603     {
 604         oslAddrInfo aAddrInfo(pHostName);
 605         if (aAddrInfo.nError == 0)
 606             pFullQualifiedName = strdup(aAddrInfo.getHostName());
 607     }
 608
 609     return pFullQualifiedName;
 610 }
 611
 612 struct oslHostAddrImpl
 613 {
 614     char        *pHostName;
 615     oslSocketAddr   pSockAddr;
 616 };
 617
 618 static oslHostAddr addrinfoToHostAddr (const addrinfo* ai)
 619 {
 620     if (!ai || !ai->ai_canonname || !ai->ai_addr)
 621         return nullptr;
 622
 623     char* cn = getFullQualifiedDomainName(ai->ai_canonname);
 624     SAL_WARN_IF( !cn, "sal.osl", "couldn't get full qualified domain name" );
 625     if (cn == nullptr)
 626         return nullptr;
 627
 628     oslSocketAddr pSockAddr = createSocketAddr();
 629     SAL_WARN_IF( !pSockAddr, "sal.osl", "insufficient memory" );
 630     if (pSockAddr == nullptr)
 631     {
 632         free(cn);
 633         return nullptr;
 634     }
 635
 636     if (ai->ai_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
 637     {
 638         memcpy (
 639             &(pSockAddr->m_sockaddr),
 640             ai->ai_addr,
 641             ai->ai_addrlen);
 642     }
 643     else
 644     {
 645         /* unknown address family */
 646         /* future extensions for new families might be implemented here */
 647
 648         SAL_WARN( "sal.osl", "unknown address family" );
 649
 650         destroySocketAddr( pSockAddr );
 651         free (cn);
 652         return nullptr;
 653     }
 654
 655     oslHostAddr pAddr = static_cast<oslHostAddr>(malloc(sizeof(struct oslHostAddrImpl)));
 656     SAL_WARN_IF( !pAddr, "sal.osl", "allocation error" );
 657     if (pAddr == nullptr)
 658     {
 659         destroySocketAddr( pSockAddr );
 660         free (cn);
 661         return nullptr;
 662     }
 663
 664     pAddr->pHostName= cn;
 665     pAddr->pSockAddr= pSockAddr;
 666
 667     return pAddr;
 668 }
 669
 670 oslHostAddr SAL_CALL osl_createHostAddr (
 671     rtl_uString        *ustrHostname,
 672     const oslSocketAddr Addr)
 673 {
 674     oslHostAddr HostAddr;
 675     rtl_String* strHostname=nullptr;
 676     char* pszHostName=nullptr;
 677
 678     if ( ustrHostname != nullptr )
 679     {
 680         rtl_uString2String( &strHostname,
 681                             rtl_uString_getStr(ustrHostname),
 682                             rtl_uString_getLength(ustrHostname),
 683                             RTL_TEXTENCODING_UTF8,
 684                             OUSTRING_TO_OSTRING_CVTFLAGS );
 685         pszHostName = rtl_string_getStr(strHostname);
 686     }
 687
 688     HostAddr = osl_psz_createHostAddr(pszHostName,Addr);
 689
 690     if ( strHostname != nullptr )
 691     {
 692         rtl_string_release(strHostname);
 693     }
 694
 695     return HostAddr;
 696 }
 697
 698 oslHostAddr osl_psz_createHostAddr (
 699     const char     *pszHostname,
 700     const oslSocketAddr pAddr)
 701 {
 702     oslHostAddr pHostAddr;
 703     char            *cn;
 704
 705     SAL_WARN_IF( !pszHostname, "sal.osl", "undefined hostname" );
 706     SAL_WARN_IF( !pAddr, "sal.osl", "undefined address" );
 707     if ((pszHostname == nullptr) || (pAddr == nullptr))
 708         return nullptr;
 709
 710     cn = strdup(pszHostname);
 711     SAL_WARN_IF( !cn, "sal.osl", "insufficient memory" );
 712     if (cn == nullptr)
 713         return nullptr;
 714
 715     pHostAddr= static_cast<oslHostAddr>(malloc(sizeof(struct oslHostAddrImpl)));
 716     SAL_WARN_IF( !pHostAddr, "sal.osl", "allocation error" );
 717     if (pHostAddr == nullptr)
 718     {
 719         free (cn);
 720         return nullptr;
 721     }
 722
 723     pHostAddr->pHostName= cn;
 724     pHostAddr->pSockAddr= osl_copySocketAddr( pAddr );
 725
 726     return pHostAddr;
 727 }
 728
 729 oslHostAddr SAL_CALL osl_createHostAddrByName(rtl_uString *ustrHostname)
 730 {
 731     oslHostAddr HostAddr;
 732     rtl_String* strHostname=nullptr;
 733     char* pszHostName=nullptr;
 734
 735     if ( ustrHostname != nullptr )
 736     {
 737         rtl_uString2String( &strHostname,
 738                             rtl_uString_getStr(ustrHostname),
 739                             rtl_uString_getLength(ustrHostname),
 740                             RTL_TEXTENCODING_UTF8,
 741                             OUSTRING_TO_OSTRING_CVTFLAGS );
 742         pszHostName=rtl_string_getStr(strHostname);
 743     }
 744
 745     HostAddr = osl_psz_createHostAddrByName(pszHostName);
 746
 747     if ( strHostname != nullptr )
 748     {
 749         rtl_string_release(strHostname);
 750     }
 751
 752     return HostAddr;
 753 }
 754
 755 oslHostAddr osl_psz_createHostAddrByName (const char *pszHostname)
 756 {
 757     oslAddrInfo aAddrInfo(pszHostname, /* isInet */ true);
 758
 759     return addrinfoToHostAddr (aAddrInfo.pAddrInfoList);
 760 }
 761
 762 oslHostAddr SAL_CALL osl_createHostAddrByAddr (const oslSocketAddr pAddr)
 763 {
 764     SAL_WARN_IF( !pAddr, "sal.osl", "undefined address" );
 765
 766     if (pAddr == nullptr)
 767         return nullptr;
 768
 769     if (pAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
 770     {
 771         const struct sockaddr_in *sin = reinterpret_cast<sockaddr_in *>(&pAddr->m_sockaddr);
 772         if (sin->sin_addr.s_addr == htonl(INADDR_ANY))
 773             return nullptr;
 774
 775         char host[MAX_HOSTBUFFER_SIZE];
 776         int res = getnameinfo(&pAddr->m_sockaddr, sizeof(struct sockaddr_in),
 777                               host, sizeof(host), nullptr, 0, NI_NAMEREQD);
 778         if (res != 0)
 779             return nullptr;
 780
 781         char *cn = getFullQualifiedDomainName(host);
 782         SAL_WARN_IF( !cn, "sal.osl", "couldn't get full qualified domain name" );
 783         if (cn == nullptr)
 784             return nullptr;
 785
 786         oslSocketAddr pSockAddr = createSocketAddr();
 787         SAL_WARN_IF( !pSockAddr, "sal.osl", "insufficient memory" );
 788         if (pSockAddr == nullptr)
 789         {
 790             free(cn);
 791             return nullptr;
 792         }
 793
 794         memcpy(&pSockAddr->m_sockaddr, &pAddr->m_sockaddr, sizeof(pAddr->m_sockaddr));
 795
 796         oslHostAddr pHostAddr = static_cast<oslHostAddr>(malloc(sizeof(struct oslHostAddrImpl)));
 797         SAL_WARN_IF( !pAddr, "sal.osl", "allocation error" );
 798         if (pHostAddr == nullptr)
 799         {
 800             destroySocketAddr(pSockAddr);
 801             free(cn);
 802             return nullptr;
 803         }
 804
 805         pHostAddr->pHostName = cn;
 806         pHostAddr->pSockAddr = pSockAddr;
 807
 808         return pHostAddr;
 809     }
 810
 811     return nullptr;
 812 }
 813
 814 oslHostAddr SAL_CALL osl_copyHostAddr (const oslHostAddr pAddr)
 815 {
 816     SAL_WARN_IF( !pAddr, "sal.osl", "undefined address" );
 817
 818     if (pAddr)
 819         return osl_psz_createHostAddr (pAddr->pHostName, pAddr->pSockAddr);
 820     return nullptr;
 821 }
 822
 823 void SAL_CALL osl_getHostnameOfHostAddr (
 824     const oslHostAddr   Addr,
 825     rtl_uString       **ustrHostname)
 826 {
 827     const char* pHostname = osl_psz_getHostnameOfHostAddr(Addr);
 828
 829     rtl_uString_newFromAscii (ustrHostname, pHostname);
 830 }
 831
 832 const char* osl_psz_getHostnameOfHostAddr (const oslHostAddr pAddr)
 833 {
 834     if (pAddr)
 835         return pAddr->pHostName;
 836     return nullptr;
 837 }
 838
 839 oslSocketAddr SAL_CALL osl_getSocketAddrOfHostAddr (const oslHostAddr pAddr)
 840 {
 841     SAL_WARN_IF( !pAddr, "sal.osl", "undefined address" );
 842
 843     if (pAddr)
 844         return pAddr->pSockAddr;
 845     return nullptr;
 846 }
 847
 848 void SAL_CALL osl_destroyHostAddr (oslHostAddr pAddr)
 849 {
 850     if (pAddr)
 851     {
 852         if (pAddr->pHostName)
 853             free (pAddr->pHostName);
 854         if (pAddr->pSockAddr)
 855             osl_destroySocketAddr (pAddr->pSockAddr);
 856         free (pAddr);
 857     }
 858 }
 859
 860 namespace
 861 {
 862 oslSocketResult lcl_getLocalHostname(rtl_uString **ustrLocalHostname, bool bUseFQDN)
 863 {
 864     static auto const init = [bUseFQDN]() -> std::pair<oslSocketResult, OUString> {
 865             char LocalHostname[256] = "";
 866
 867 #ifdef SYSV
 868             struct utsname uts;
 869
 870             if (uname(&uts) < 0)
 871                 return {osl_Socket_Error, OUString()};
 872
 873             if ((strlen(uts.nodename) + 1) > nBufLen)
 874                 return {osl_Socket_Error, OUString()};
 875
 876             strncpy(LocalHostname, uts.nodename, sizeof( LocalHostname ));
 877 #else  /* BSD compatible */
 878             if (gethostname(LocalHostname, sizeof(LocalHostname)-1) != 0)
 879                 return {osl_Socket_Error, OUString()};
 880 #endif /* SYSV */
 881             LocalHostname[sizeof(LocalHostname)-1] = 0;
 882
 883             /* check if we have an FQDN */
 884             if (bUseFQDN && strchr(LocalHostname, '.') == nullptr)
 885             {
 886                 oslHostAddr Addr;
 887
 888                 /* no, determine it via dns */
 889                 Addr = osl_psz_createHostAddrByName(LocalHostname);
 890
 891                 const char *pStr;
 892                 if ((pStr = osl_psz_getHostnameOfHostAddr(Addr)) != nullptr)
 893                 {
 894                     strncpy(LocalHostname, pStr, sizeof( LocalHostname ));
 895                     LocalHostname[sizeof(LocalHostname)-1] = 0;
 896                 }
 897                 osl_destroyHostAddr(Addr);
 898             }
 899
 900             if (LocalHostname[0] != '\0')
 901             {
 902                 return {osl_Socket_Ok, OUString::createFromAscii(LocalHostname)};
 903             }
 904
 905             return {osl_Socket_Error, OUString()};
 906         }();
 907
 908     rtl_uString_assign(ustrLocalHostname,init.second.pData);
 909
 910     return init.first;
 911 }
 912 }
 913
 914 oslSocketResult SAL_CALL osl_getLocalHostname(rtl_uString **ustrLocalHostname)
 915 {
 916     return lcl_getLocalHostname(ustrLocalHostname, false);
 917 }
 918
 919 oslSocketResult osl_getLocalHostnameFQDN(rtl_uString **ustrLocalHostname)
 920 {
 921     return lcl_getLocalHostname(ustrLocalHostname, true);
 922 }
 923
 924 oslSocketAddr SAL_CALL osl_resolveHostname(rtl_uString *ustrHostname)
 925 {
 926     oslSocketAddr Addr;
 927     rtl_String* strHostname=nullptr;
 928     char* pszHostName=nullptr;
 929
 930     if ( ustrHostname != nullptr )
 931     {
 932         rtl_uString2String( &strHostname,
 933                             rtl_uString_getStr(ustrHostname),
 934                             rtl_uString_getLength(ustrHostname),
 935                             RTL_TEXTENCODING_UTF8,
 936                             OUSTRING_TO_OSTRING_CVTFLAGS );
 937         pszHostName = rtl_string_getStr(strHostname);
 938     }
 939
 940     Addr = osl_psz_resolveHostname(pszHostName);
 941
 942     if ( strHostname != nullptr )
 943     {
 944         rtl_string_release(strHostname);
 945     }
 946
 947     return Addr;
 948 }
 949
 950 oslSocketAddr osl_psz_resolveHostname(const char* pszHostname)
 951 {
 952     struct oslHostAddrImpl *pAddr = osl_psz_createHostAddrByName(pszHostname);
 953
 954     if (pAddr)
 955     {
 956         oslSocketAddr SockAddr = osl_copySocketAddr(pAddr->pSockAddr);
 957
 958         osl_destroyHostAddr(pAddr);
 959
 960         return SockAddr;
 961     }
 962
 963     return nullptr;
 964 }
 965
 966 sal_Int32 SAL_CALL osl_getServicePort(rtl_uString *ustrServicename, rtl_uString *ustrProtocol)
 967 {
 968     sal_Int32 nPort;
 969     rtl_String* strServicename=nullptr;
 970     rtl_String* strProtocol=nullptr;
 971     char* pszServiceName=nullptr;
 972     char* pszProtocol=nullptr;
 973
 974     if ( ustrServicename != nullptr )
 975     {
 976         rtl_uString2String( &strServicename,
 977                             rtl_uString_getStr(ustrServicename),
 978                             rtl_uString_getLength(ustrServicename),
 979                             RTL_TEXTENCODING_UTF8,
 980                             OUSTRING_TO_OSTRING_CVTFLAGS );
 981         pszServiceName = rtl_string_getStr(strServicename);
 982     }
 983
 984     if ( ustrProtocol != nullptr )
 985     {
 986         rtl_uString2String( &strProtocol,
 987                             rtl_uString_getStr(ustrProtocol),
 988                             rtl_uString_getLength(ustrProtocol),
 989                             RTL_TEXTENCODING_UTF8,
 990                             OUSTRING_TO_OSTRING_CVTFLAGS );
 991         pszProtocol = rtl_string_getStr(strProtocol);
 992     }
 993
 994     nPort = osl_psz_getServicePort(pszServiceName,pszProtocol);
 995
 996     if ( strServicename != nullptr )
 997     {
 998         rtl_string_release(strServicename);
 999     }
1000
1001     if ( strProtocol != nullptr )
1002     {
1003         rtl_string_release(strProtocol);
1004     }
1005
1006     return nPort;
1007 }
1008
1009 sal_Int32 osl_psz_getServicePort(const char* pszServicename,
1010                         const char* pszProtocol)
1011 {
1012     struct servent* ps;
1013
1014     ps= getservbyname(pszServicename, pszProtocol);
1015
1016     if (ps != nullptr)
1017         return ntohs(ps->s_port);
1018
1019     return OSL_INVALID_PORT;
1020 }
1021
1022 void SAL_CALL osl_destroySocketAddr(oslSocketAddr pAddr)
1023 {
1024     destroySocketAddr( pAddr );
1025 }
1026
1027 oslAddrFamily SAL_CALL osl_getFamilyOfSocketAddr(oslSocketAddr pAddr)
1028 {
1029     SAL_WARN_IF( !pAddr, "sal.osl", "undefined address" );
1030
1031     if (pAddr)
1032         return FAMILY_FROM_NATIVE(pAddr->m_sockaddr.sa_family);
1033     return osl_Socket_FamilyInvalid;
1034 }
1035
1036 sal_Int32 SAL_CALL osl_getInetPortOfSocketAddr(oslSocketAddr pAddr)
1037 {
1038     SAL_WARN_IF( !pAddr, "sal.osl", "undefined address" );
1039
1040     if( pAddr )
1041     {
1042         struct sockaddr_in* pSystemInetAddr= reinterpret_cast<sockaddr_in*>(&pAddr->m_sockaddr);
1043
1044         if ( pSystemInetAddr->sin_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
1045             return ntohs(pSystemInetAddr->sin_port);
1046     }
1047     return OSL_INVALID_PORT;
1048 }
1049
1050 sal_Bool SAL_CALL osl_setInetPortOfSocketAddr(oslSocketAddr pAddr, sal_Int32 Port)
1051 {
1052     SAL_WARN_IF( !pAddr, "sal.osl", "undefined address" );
1053
1054     if( pAddr )
1055     {
1056         struct sockaddr_in* pSystemInetAddr= reinterpret_cast<sockaddr_in*>(&pAddr->m_sockaddr);
1057         if ( pSystemInetAddr->sin_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
1058         {
1059             pSystemInetAddr->sin_port= htons(static_cast<short>(Port));
1060             return true;
1061         }
1062     }
1063
1064     /* this is not a inet-addr => can't set port */
1065     return false;
1066 }
1067
1068 oslSocketResult SAL_CALL osl_getHostnameOfSocketAddr(oslSocketAddr Addr, rtl_uString **ustrHostname)
1069 {
1070     oslHostAddr pHostAddr= osl_createHostAddrByAddr(Addr);
1071
1072     if (!pHostAddr)
1073     {
1074         return osl_Socket_Error;
1075     }
1076
1077     rtl_uString_newFromAscii(ustrHostname,pHostAddr->pHostName);
1078
1079     osl_destroyHostAddr(pHostAddr);
1080
1081     return osl_Socket_Ok;
1082 }
1083
1084 oslSocketResult SAL_CALL osl_getDottedInetAddrOfSocketAddr(oslSocketAddr Addr, rtl_uString **ustrDottedInetAddr)
1085 {
1086     if( !Addr )
1087     {
1088         return osl_Socket_Error;
1089     }
1090
1091     struct sockaddr_in* pSystemInetAddr = reinterpret_cast<sockaddr_in *>(&Addr->m_sockaddr);
1092
1093     if (pSystemInetAddr->sin_family != FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
1094     {
1095         return osl_Socket_Error;
1096     }
1097
1098     char buf[INET_ADDRSTRLEN];
1099     auto const text = inet_ntop(AF_INET, &pSystemInetAddr->sin_addr, buf, INET_ADDRSTRLEN);
1100     assert(text != nullptr);
1101     rtl_uString_newFromAscii(ustrDottedInetAddr,text);
1102
1103     return osl_Socket_Ok;
1104
1105 }
1106
1107 oslSocket SAL_CALL osl_createSocket(
1108     oslAddrFamily Family,
1109     oslSocketType Type,
1110     oslProtocol Protocol)
1111 {
1112     oslSocket pSocket;
1113
1114     /* alloc memory */
1115     pSocket= createSocketImpl();
1116
1117     /* create socket */
1118     pSocket->m_Socket= socket(FAMILY_TO_NATIVE(Family),
1119                                 TYPE_TO_NATIVE(Type),
1120                                 PROTOCOL_TO_NATIVE(Protocol));
1121
1122     /* creation failed => free memory */
1123     if(pSocket->m_Socket == OSL_INVALID_SOCKET)
1124     {
1125         int nErrno = errno;
1126         SAL_WARN( "sal.osl", "socket creation failed: " << UnixErrnoString(nErrno) );
1127
1128         destroySocketImpl(pSocket);
1129         pSocket= nullptr;
1130     }
1131     else
1132     {
1133         sal_Int32 nFlags=0;
1134         /* set close-on-exec flag */
1135         if ((nFlags = fcntl(pSocket->m_Socket, F_GETFD, 0)) != -1)
1136         {
1137             nFlags |= FD_CLOEXEC;
1138             if (fcntl(pSocket->m_Socket, F_SETFD, nFlags) == -1)
1139             {
1140                 pSocket->m_nLastError=errno;
1141                 int nErrno = errno;
1142                 SAL_WARN( "sal.osl", "failed changing socket flags: " << UnixErrnoString(nErrno) );
1143             }
1144         }
1145         else
1146         {
1147             pSocket->m_nLastError=errno;
1148         }
1149     }
1150
1151     return pSocket;
1152 }
1153
1154 void SAL_CALL osl_acquireSocket(oslSocket pSocket)
1155 {
1156     osl_atomic_increment(&(pSocket->m_nRefCount));
1157 }
1158
1159 void SAL_CALL osl_releaseSocket(oslSocket pSocket)
1160 {
1161     if (pSocket && osl_atomic_decrement(&(pSocket->m_nRefCount)) == 0)
1162     {
1163 #if defined(CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT)
1164         if (pSocket->m_bIsAccepting)
1165         {
1166             SAL_WARN( "sal.osl", "attempt to destroy socket while accepting" );
1167             return;
1168         }
1169 #endif /* CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT */
1170         osl_closeSocket(pSocket);
1171         destroySocketImpl(pSocket);
1172     }
1173 }
1174
1175 void SAL_CALL osl_closeSocket(oslSocket pSocket)
1176 {
1177     /* socket already invalid */
1178     if (!pSocket)
1179         return;
1180
1181     pSocket->m_nLastError=0;
1182     sal_Int32 nFD = pSocket->m_Socket;
1183
1184     if (nFD == OSL_INVALID_SOCKET)
1185         return;
1186
1187     pSocket->m_Socket = OSL_INVALID_SOCKET;
1188
1189     sal_Int32 nRet=0;
1190 #if defined(CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT)
1191     pSocket->m_bIsInShutdown = true;
1192
1193     if (pSocket->m_bIsAccepting)
1194     {
1195         union {
1196             struct sockaddr aSockAddr;
1197             struct sockaddr_in aSockAddrIn;
1198         } s;
1199         socklen_t nSockLen = sizeof(s.aSockAddr);
1200
1201         nRet = getsockname(nFD, &s.aSockAddr, &nSockLen);
1202         if (nRet < 0)
1203         {
1204             int nErrno = errno;
1205             SAL_WARN( "sal.osl", "getsockname call failed: " << UnixErrnoString(nErrno) );
1206         }
1207
1208         if (s.aSockAddr.sa_family == AF_INET)
1209         {
1210             if (s.aSockAddrIn.sin_addr.s_addr == htonl(INADDR_ANY))
1211             {
1212                 s.aSockAddrIn.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
1213             }
1214
1215             int nConnFD = socket(AF_INET, SOCK_STREAM, 0);
1216             if (nConnFD < 0)
1217             {
1218                 int nErrno = errno;
1219                 SAL_WARN( "sal.osl", "socket call failed: " << UnixErrnoString(nErrno) );
1220             }
1221             else
1222             {
1223                 nRet = connect(nConnFD, &s.aSockAddr, sizeof(s.aSockAddr));
1224                 if (nRet < 0)
1225                 {
1226                     int nErrno = errno;
1227                     SAL_WARN( "sal.osl", "connect call failed: " << UnixErrnoString(nErrno) );
1228                 }
1229                 close(nConnFD);
1230             }
1231         }
1232         pSocket->m_bIsAccepting = false;
1233     }
1234 #endif /* CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT */
1235
1236     nRet=close(nFD);
1237     if (nRet != 0)
1238     {
1239         pSocket->m_nLastError=errno;
1240         int nErrno = errno;
1241         SAL_WARN( "sal.osl", "closeSocket close failed: " << UnixErrnoString(nErrno) );
1242     }
1243
1244     pSocket->m_Socket = OSL_INVALID_SOCKET;
1245 }
1246
1247 /* Note from function creator: I rely on the fact that oslSocketAddr and struct sockaddr
1248    are the same! I don't like it very much but see no other easy way to conceal
1249    the struct sockaddr from the eyes of the user. */
1250 oslSocketAddr SAL_CALL osl_getLocalAddrOfSocket(oslSocket pSocket)
1251 {
1252     socklen_t AddrLen;
1253     struct sockaddr Addr;
1254     oslSocketAddr  pAddr;
1255
1256     if (pSocket == nullptr) /* ENOTSOCK */
1257         return nullptr;
1258
1259     AddrLen= sizeof(struct sockaddr);
1260
1261     if (getsockname(pSocket->m_Socket, &Addr, &AddrLen) == OSL_SOCKET_ERROR)
1262         return nullptr;
1263
1264     pAddr = createSocketAddrFromSystem( &Addr );
1265     return pAddr;
1266 }
1267
1268 oslSocketAddr SAL_CALL osl_getPeerAddrOfSocket(oslSocket pSocket)
1269 {
1270     socklen_t AddrLen;
1271     struct sockaddr Addr;
1272
1273     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1274     if ( pSocket == nullptr )
1275     {
1276         return nullptr;
1277     }
1278
1279     pSocket->m_nLastError=0;
1280     AddrLen= sizeof(struct sockaddr);
1281
1282     if(getpeername(pSocket->m_Socket, &Addr, &AddrLen) == OSL_SOCKET_ERROR)
1283     {
1284         pSocket->m_nLastError=errno;
1285         return nullptr;
1286     }
1287     return createSocketAddrFromSystem( &Addr );
1288 }
1289
1290 sal_Bool SAL_CALL osl_bindAddrToSocket(oslSocket pSocket,
1291                              oslSocketAddr pAddr)
1292 {
1293     int nRet;
1294
1295     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1296     SAL_WARN_IF( !pAddr, "sal.osl", "undefined address" );
1297     if ( pSocket == nullptr || pAddr == nullptr )
1298     {
1299         return false;
1300     }
1301
1302     pSocket->m_nLastError=0;
1303
1304     nRet = bind(pSocket->m_Socket, &(pAddr->m_sockaddr), sizeof(struct sockaddr));
1305
1306     if ( nRet == OSL_SOCKET_ERROR)
1307     {
1308         pSocket->m_nLastError=errno;
1309         return false;
1310     }
1311
1312     return true;
1313 }
1314
1315 sal_Bool SAL_CALL osl_listenOnSocket(oslSocket pSocket,
1316                            sal_Int32 MaxPendingConnections)
1317 {
1318     int nRet;
1319
1320     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1321     if ( pSocket == nullptr )
1322     {
1323         return false;
1324     }
1325
1326     pSocket->m_nLastError=0;
1327
1328     nRet = listen(pSocket->m_Socket,
1329                   MaxPendingConnections == -1 ?
1330                   SOMAXCONN :
1331                   MaxPendingConnections);
1332     if ( nRet == OSL_SOCKET_ERROR)
1333     {
1334         pSocket->m_nLastError=errno;
1335         return false;
1336     }
1337
1338     return true;
1339 }
1340
1341 oslSocketResult SAL_CALL osl_connectSocketTo(oslSocket pSocket,
1342                                     oslSocketAddr pAddr,
1343                                     const TimeValue* pTimeout)
1344 {
1345     int      ReadyHandles;
1346
1347     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1348
1349     if ( pSocket == nullptr )
1350     {
1351         return osl_Socket_Error;
1352     }
1353
1354     pSocket->m_nLastError=0;
1355
1356     if (osl_isNonBlockingMode(pSocket))
1357     {
1358         if (connect(pSocket->m_Socket,
1359                     &(pAddr->m_sockaddr),
1360                     sizeof(struct sockaddr)) != OSL_SOCKET_ERROR)
1361             return osl_Socket_Ok;
1362
1363         if (errno == EWOULDBLOCK || errno == EINPROGRESS)
1364         {
1365             pSocket->m_nLastError=EINPROGRESS;
1366             return osl_Socket_InProgress;
1367         }
1368
1369         pSocket->m_nLastError=errno;
1370         int nErrno = errno;
1371         SAL_WARN( "sal.osl", "connection failed: " << UnixErrnoString(nErrno) );
1372         return osl_Socket_Error;
1373     }
1374
1375     /* set socket temporarily to non-blocking */
1376     if( !osl_enableNonBlockingMode(pSocket, true) )
1377         SAL_WARN( "sal.osl", "failed to enable non-blocking mode" );
1378
1379     /* initiate connect */
1380     if(connect(pSocket->m_Socket,
1381                &(pAddr->m_sockaddr),
1382                sizeof(struct sockaddr)) != OSL_SOCKET_ERROR)
1383     {
1384        /* immediate connection */
1385         osl_enableNonBlockingMode(pSocket, false);
1386
1387         return osl_Socket_Ok;
1388     }
1389
1390     /* really an error or just delayed? */
1391     if (errno != EINPROGRESS)
1392     {
1393         pSocket->m_nLastError=errno;
1394         int nErrno = errno;
1395         SAL_WARN( "sal.osl", "connection failed: " << UnixErrnoString(nErrno) );
1396
1397         osl_enableNonBlockingMode(pSocket, false);
1398         return osl_Socket_Error;
1399     }
1400
1401     /* prepare poll set for socket  */
1402     pollfd Set = {pSocket->m_Socket, POLLPRI | POLLOUT, 0};
1403
1404     /* poll */
1405     ReadyHandles= poll(&Set, 1,
1406                          pTimeout ? convertToMs(pTimeout) : -1);
1407
1408     if (ReadyHandles > 0)  /* connected */
1409     {
1410         if ( (Set.revents & POLLOUT) != 0 )
1411         {
1412             int nErrorCode = 0;
1413             socklen_t nErrorSize = sizeof( nErrorCode );
1414
1415             int nSockOpt;
1416
1417             nSockOpt = getsockopt ( pSocket->m_Socket, SOL_SOCKET, SO_ERROR,
1418                                     &nErrorCode, &nErrorSize );
1419             if ( (nSockOpt == 0) && (nErrorCode == 0))
1420             {
1421                 osl_enableNonBlockingMode(pSocket, false);
1422                 return osl_Socket_Ok;
1423             }
1424             else
1425             {
1426                 pSocket->m_nLastError = (nSockOpt == 0) ? nErrorCode : errno;
1427                 return osl_Socket_Error;
1428             }
1429         }
1430         else
1431         {
1432             return osl_Socket_Error;
1433         }
1434     }
1435     else if (ReadyHandles < 0)  /* error */
1436     {
1437         if (errno == EBADF) /* most probably interrupted by close() */
1438         {
1439             /* do not access pSockImpl because it is about to be or */
1440             /* already destroyed */
1441             return osl_Socket_Interrupted;
1442         }
1443         pSocket->m_nLastError=errno;
1444         return osl_Socket_Error;
1445     }
1446     else    /* timeout */
1447     {
1448         pSocket->m_nLastError=errno;
1449         return osl_Socket_TimedOut;
1450     }
1451 }
1452
1453 oslSocket SAL_CALL osl_acceptConnectionOnSocket(oslSocket pSocket,
1454                         oslSocketAddr* ppAddr)
1455 {
1456     struct sockaddr Addr;
1457     int Connection, Flags;
1458     oslSocket pConnectionSockImpl;
1459
1460     socklen_t AddrLen = sizeof(struct sockaddr);
1461     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1462     if ( pSocket == nullptr )
1463     {
1464         return nullptr;
1465     }
1466
1467     pSocket->m_nLastError=0;
1468 #if defined(CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT)
1469     pSocket->m_bIsAccepting = true;
1470 #endif /* CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT */
1471
1472     if( ppAddr && *ppAddr )
1473     {
1474         osl_destroySocketAddr( *ppAddr );
1475         *ppAddr = nullptr;
1476     }
1477
1478     /* prevent Linux EINTR behaviour */
1479     do
1480     {
1481         Connection = accept(pSocket->m_Socket, &Addr, &AddrLen);
1482     } while (Connection == -1 && errno == EINTR);
1483
1484     /* accept failed? */
1485     if( Connection == OSL_SOCKET_ERROR )
1486     {
1487         pSocket->m_nLastError=errno;
1488         int nErrno = errno;
1489         SAL_WARN( "sal.osl", "accept connection failed: " << UnixErrnoString(nErrno) );
1490
1491 #if defined(CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT)
1492         pSocket->m_bIsAccepting = false;
1493 #endif /* CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT */
1494         return nullptr;
1495     }
1496
1497     assert(AddrLen == sizeof(struct sockaddr));
1498
1499 #if defined(CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT)
1500     if ( pSocket->m_bIsInShutdown )
1501     {
1502         close(Connection);
1503         SAL_WARN( "sal.osl", "close while accept" );
1504         return nullptr;
1505     }
1506 #endif /* CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT */
1507
1508     if(ppAddr)
1509     {
1510         *ppAddr= createSocketAddrFromSystem(&Addr);
1511     }
1512
1513     /* alloc memory */
1514     pConnectionSockImpl= createSocketImpl();
1515
1516     /* set close-on-exec flag */
1517     if ((Flags = fcntl(Connection, F_GETFD, 0)) != -1)
1518     {
1519         Flags |= FD_CLOEXEC;
1520         if (fcntl(Connection, F_SETFD, Flags) == -1)
1521         {
1522             pSocket->m_nLastError=errno;
1523             int nErrno = errno;
1524             SAL_WARN( "sal.osl", "fcntl failed: " << UnixErrnoString(nErrno) );
1525         }
1526
1527     }
1528
1529     pConnectionSockImpl->m_Socket           = Connection;
1530     pConnectionSockImpl->m_nLastError       = 0;
1531 #if defined(CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT)
1532     pConnectionSockImpl->m_bIsAccepting     = false;
1533
1534     pSocket->m_bIsAccepting = false;
1535 #endif /* CLOSESOCKET_DOESNT_WAKE_UP_ACCEPT */
1536     return pConnectionSockImpl;
1537 }
1538
1539 sal_Int32 SAL_CALL osl_receiveSocket(oslSocket pSocket,
1540                           void* pBuffer,
1541                           sal_uInt32 BytesToRead,
1542                           oslSocketMsgFlag Flag)
1543 {
1544     int nRead;
1545
1546     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1547     if ( pSocket == nullptr )
1548     {
1549         return -1;
1550     }
1551
1552     pSocket->m_nLastError=0;
1553
1554     do
1555     {
1556         nRead =  recv(pSocket->m_Socket,
1557                       pBuffer,
1558                       BytesToRead,
1559                       MSG_FLAG_TO_NATIVE(Flag));
1560     } while ( nRead < 0 && errno == EINTR );
1561
1562     if ( nRead < 0 )
1563     {
1564         pSocket->m_nLastError=errno;
1565         int nErrno = errno;
1566         SAL_WARN( "sal.osl", "receive socket [" << nRead << "] failed: " << UnixErrnoString(nErrno) );
1567     }
1568     else if ( nRead == 0 )
1569     {
1570         SAL_WARN( "sal.osl", "receive socket [" << nRead << "] failed: EOL" );
1571     }
1572
1573     return nRead;
1574 }
1575
1576 sal_Int32 SAL_CALL osl_receiveFromSocket(oslSocket pSocket,
1577                               oslSocketAddr pSenderAddr,
1578                               void* pBuffer,
1579                               sal_uInt32 BufferSize,
1580                               oslSocketMsgFlag Flag)
1581 {
1582     int nRead;
1583     struct sockaddr *pSystemSockAddr = nullptr;
1584     socklen_t AddrLen = 0;
1585     if( pSenderAddr )
1586     {
1587         AddrLen = sizeof( struct sockaddr );
1588         pSystemSockAddr = &(pSenderAddr->m_sockaddr);
1589     }
1590
1591     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1592     if ( pSocket == nullptr )
1593     {
1594         return -1;
1595     }
1596
1597     pSocket->m_nLastError=0;
1598
1599     nRead = recvfrom(pSocket->m_Socket,
1600                      pBuffer,
1601                      BufferSize,
1602                      MSG_FLAG_TO_NATIVE(Flag),
1603                      pSystemSockAddr,
1604                      &AddrLen);
1605
1606     if ( nRead < 0 )
1607     {
1608         pSocket->m_nLastError=errno;
1609         int nErrno = errno;
1610         SAL_WARN( "sal.osl", "receive socket [" << nRead << "] failed: " << UnixErrnoString(nErrno) );
1611     }
1612     else if ( nRead == 0 )
1613     {
1614         SAL_WARN( "sal.osl", "receive socket [" << nRead << "] failed: EOL" );
1615     }
1616
1617     return nRead;
1618 }
1619
1620 sal_Int32 SAL_CALL osl_sendSocket(oslSocket pSocket,
1621                        const void* pBuffer,
1622                        sal_uInt32 BytesToSend,
1623                        oslSocketMsgFlag Flag)
1624 {
1625     int nWritten;
1626
1627     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1628     if ( pSocket == nullptr )
1629     {
1630         return -1;
1631     }
1632
1633     pSocket->m_nLastError=0;
1634
1635     do
1636     {
1637         nWritten = send(pSocket->m_Socket,
1638                         pBuffer,
1639                         BytesToSend,
1640                         MSG_FLAG_TO_NATIVE(Flag));
1641     } while ( nWritten < 0 && errno == EINTR );
1642
1643     if ( nWritten < 0 )
1644     {
1645         pSocket->m_nLastError=errno;
1646         int nErrno = errno;
1647         SAL_WARN( "sal.osl", "send socket [" << nWritten << "] failed: " << UnixErrnoString(nErrno) );
1648     }
1649     else if ( nWritten == 0 )
1650     {
1651         SAL_WARN( "sal.osl", "send socket [" << nWritten << "] failed: EOL" );
1652     }
1653
1654     return nWritten;
1655 }
1656
1657 sal_Int32 SAL_CALL osl_sendToSocket(oslSocket pSocket,
1658                          oslSocketAddr ReceiverAddr,
1659                          const void* pBuffer,
1660                          sal_uInt32 BytesToSend,
1661                          oslSocketMsgFlag Flag)
1662 {
1663     int nWritten;
1664
1665     struct sockaddr *pSystemSockAddr = nullptr;
1666     int AddrLen = 0;
1667     if( ReceiverAddr )
1668     {
1669         pSystemSockAddr = &(ReceiverAddr->m_sockaddr);
1670         AddrLen = sizeof( struct sockaddr );
1671     }
1672
1673     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1674     if ( pSocket == nullptr )
1675     {
1676         return -1;
1677     }
1678
1679     pSocket->m_nLastError=0;
1680
1681     /* ReceiverAddr might be 0 when used on a connected socket. */
1682     /* Then sendto should behave like send. */
1683
1684     nWritten = sendto(pSocket->m_Socket,
1685                       pBuffer,
1686                       BytesToSend,
1687                       MSG_FLAG_TO_NATIVE(Flag),
1688                       pSystemSockAddr,
1689                       AddrLen);
1690
1691     if ( nWritten < 0 )
1692     {
1693         pSocket->m_nLastError=errno;
1694         int nErrno = errno;
1695         SAL_WARN( "sal.osl", "send socket [" << nWritten << "] failed: " << UnixErrnoString(nErrno) );
1696     }
1697     else if ( nWritten == 0 )
1698     {
1699         SAL_WARN( "sal.osl", "send socket [" << nWritten << "] failed: EOL" );
1700     }
1701
1702     return nWritten;
1703 }
1704
1705 sal_Int32 SAL_CALL osl_readSocket (
1706     oslSocket pSocket, void *pBuffer, sal_Int32 n )
1707 {
1708     sal_uInt8 * Ptr = static_cast<sal_uInt8 *>(pBuffer);
1709     sal_uInt32 BytesRead= 0;
1710     sal_uInt32 BytesToRead= n;
1711
1712     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1713
1714     /* loop until all desired bytes were read or an error occurred */
1715     while (BytesToRead > 0)
1716     {
1717         sal_Int32 RetVal;
1718         RetVal= osl_receiveSocket(pSocket,
1719                                    Ptr,
1720                                    BytesToRead,
1721                                    osl_Socket_MsgNormal);
1722
1723         /* error occurred? */
1724         if(RetVal <= 0)
1725         {
1726             break;
1727         }
1728
1729         BytesToRead -= RetVal;
1730         BytesRead += RetVal;
1731         Ptr += RetVal;
1732     }
1733
1734     return BytesRead;
1735 }
1736
1737 sal_Int32 SAL_CALL osl_writeSocket(
1738     oslSocket pSocket, const void *pBuffer, sal_Int32 n )
1739 {
1740     /* loop until all desired bytes were send or an error occurred */
1741     sal_uInt32 BytesSend= 0;
1742     sal_uInt32 BytesToSend= n;
1743     sal_uInt8 const *Ptr = static_cast<sal_uInt8 const *>(pBuffer);
1744
1745     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1746
1747     while (BytesToSend > 0)
1748     {
1749         sal_Int32 RetVal;
1750
1751         RetVal= osl_sendSocket( pSocket,Ptr,BytesToSend,osl_Socket_MsgNormal);
1752
1753         /* error occurred? */
1754         if(RetVal <= 0)
1755         {
1756             break;
1757         }
1758
1759         BytesToSend -= RetVal;
1760         BytesSend += RetVal;
1761         Ptr += RetVal;
1762
1763     }
1764     return BytesSend;
1765 }
1766
1767 static bool socket_poll (
1768     oslSocket        pSocket,
1769     const TimeValue* pTimeout,
1770     short            nEvent)
1771 {
1772     struct pollfd fds;
1773     int           timeout;
1774     int           result;
1775
1776     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1777     if (pSocket == nullptr)
1778       return false; /* EINVAL */
1779
1780     pSocket->m_nLastError = 0;
1781
1782     fds.fd      = pSocket->m_Socket;
1783     fds.events  = nEvent;
1784     fds.revents = 0;
1785
1786     timeout = -1;
1787     if (pTimeout)
1788     {
1789         timeout  = convertToMs(pTimeout);
1790     }
1791
1792     result = poll (&fds, 1, timeout);
1793     if (result < 0)
1794     {
1795         pSocket->m_nLastError = errno;
1796         int nErrno = errno;
1797         SAL_WARN( "sal.osl", "poll failed: " << UnixErrnoString(nErrno) );
1798         return false;
1799     }
1800     if (result == 0)
1801     {
1802         /* Timeout */
1803         return false;
1804     }
1805
1806     return ((fds.revents & nEvent) == nEvent);
1807 }
1808
1809 sal_Bool SAL_CALL osl_isReceiveReady (
1810     oslSocket pSocket, const TimeValue* pTimeout)
1811 {
1812     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1813     if (pSocket == nullptr)
1814     {
1815         /* ENOTSOCK */
1816         return false;
1817     }
1818
1819     return socket_poll (pSocket, pTimeout, POLLIN);
1820 }
1821
1822 sal_Bool SAL_CALL osl_isSendReady (
1823     oslSocket pSocket, const TimeValue* pTimeout)
1824 {
1825     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1826     if (pSocket == nullptr)
1827     {
1828         /* ENOTSOCK */
1829         return false;
1830     }
1831
1832     return socket_poll (pSocket, pTimeout, POLLOUT);
1833 }
1834
1835 sal_Bool SAL_CALL osl_isExceptionPending (
1836     oslSocket pSocket, const TimeValue* pTimeout)
1837 {
1838     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1839     if (pSocket == nullptr)
1840     {
1841         /* ENOTSOCK */
1842         return false;
1843     }
1844
1845     return socket_poll (pSocket, pTimeout, POLLPRI);
1846 }
1847
1848 sal_Bool SAL_CALL osl_shutdownSocket(oslSocket pSocket,
1849                            oslSocketDirection Direction)
1850 {
1851     int nRet;
1852
1853     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1854     if ( pSocket == nullptr )
1855     {
1856         return false;
1857     }
1858
1859     pSocket->m_nLastError=0;
1860
1861     nRet=shutdown(pSocket->m_Socket, DIRECTION_TO_NATIVE(Direction));
1862     if (nRet != 0 )
1863     {
1864         pSocket->m_nLastError=errno;
1865         int nErrno = errno;
1866         SAL_WARN( "sal.osl", "shutdown failed: " << UnixErrnoString(nErrno) );
1867     }
1868     return (nRet==0);
1869 }
1870
1871 sal_Int32 SAL_CALL osl_getSocketOption(oslSocket pSocket,
1872                             oslSocketOptionLevel    Level,
1873                             oslSocketOption         Option,
1874                             void*                   pBuffer,
1875                             sal_uInt32                  BufferLen)
1876 {
1877     socklen_t nOptLen = static_cast<socklen_t>(BufferLen);
1878
1879     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1880     if ( pSocket == nullptr )
1881     {
1882         return -1;
1883     }
1884
1885     pSocket->m_nLastError=0;
1886
1887     if(getsockopt(pSocket->m_Socket,
1888                   OPTION_LEVEL_TO_NATIVE(Level),
1889                   OPTION_TO_NATIVE(Option),
1890                   pBuffer,
1891                   &nOptLen) == -1)
1892     {
1893         pSocket->m_nLastError=errno;
1894         return -1;
1895     }
1896
1897     return nOptLen;
1898 }
1899
1900 sal_Bool SAL_CALL osl_setSocketOption(oslSocket pSocket,
1901                             oslSocketOptionLevel    Level,
1902                             oslSocketOption         Option,
1903                             void*                   pBuffer,
1904                             sal_uInt32                  BufferLen)
1905 {
1906     int nRet;
1907
1908     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1909     if ( pSocket == nullptr )
1910     {
1911         return false;
1912     }
1913
1914     pSocket->m_nLastError=0;
1915
1916     nRet = setsockopt(pSocket->m_Socket,
1917                       OPTION_LEVEL_TO_NATIVE(Level),
1918                       OPTION_TO_NATIVE(Option),
1919                       pBuffer,
1920                       BufferLen);
1921
1922     if ( nRet < 0 )
1923     {
1924         pSocket->m_nLastError=errno;
1925         return false;
1926     }
1927
1928     return true;
1929 }
1930
1931 sal_Bool SAL_CALL osl_enableNonBlockingMode(oslSocket pSocket,
1932                                   sal_Bool On)
1933 {
1934     int flags;
1935     int nRet;
1936
1937     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1938     if ( pSocket == nullptr )
1939     {
1940         return false;
1941     }
1942
1943     pSocket->m_nLastError=0;
1944
1945     flags = fcntl(pSocket->m_Socket, F_GETFL, 0);
1946
1947     if (On)
1948         flags |= O_NONBLOCK;
1949     else
1950         flags &= ~(O_NONBLOCK);
1951
1952     nRet = fcntl(pSocket->m_Socket, F_SETFL, flags);
1953
1954     if  ( nRet < 0 )
1955     {
1956         pSocket->m_nLastError=errno;
1957         return false;
1958     }
1959
1960     return true;
1961 }
1962
1963 sal_Bool SAL_CALL osl_isNonBlockingMode(oslSocket pSocket)
1964 {
1965     int flags;
1966
1967     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1968     if ( pSocket == nullptr )
1969     {
1970         return false;
1971     }
1972
1973     pSocket->m_nLastError=0;
1974
1975     flags = fcntl(pSocket->m_Socket, F_GETFL, 0);
1976
1977     if (flags == -1 || !(flags & O_NONBLOCK))
1978         return false;
1979
1980     return true;
1981 }
1982
1983 oslSocketType SAL_CALL osl_getSocketType(oslSocket pSocket)
1984 {
1985     int Type=0;
1986     socklen_t TypeSize= sizeof(Type);
1987
1988     SAL_WARN_IF( !pSocket, "sal.osl", "undefined socket" );
1989     if ( pSocket == nullptr )
1990     {
1991         return osl_Socket_TypeInvalid;
1992     }
1993
1994     pSocket->m_nLastError=0;
1995
1996     if(getsockopt(pSocket->m_Socket,
1997                   OPTION_LEVEL_TO_NATIVE(osl_Socket_LevelSocket),
1998                   OPTION_TO_NATIVE(osl_Socket_OptionType),
1999                   &Type,
2000                   &TypeSize) == -1)
2001     {
2002         /* error */
2003         pSocket->m_nLastError=errno;
2004         return osl_Socket_TypeInvalid;
2005     }
2006
2007     return TYPE_FROM_NATIVE(Type);
2008
2009 }
2010
2011 void SAL_CALL osl_getLastSocketErrorDescription(oslSocket Socket, rtl_uString **ustrError)
2012 {
2013     char pszError[1024];
2014
2015     pszError[0] = '\0';
2016
2017     osl_psz_getLastSocketErrorDescription(Socket,pszError,sizeof(pszError));
2018
2019     rtl_uString_newFromAscii(ustrError,pszError);
2020 }
2021
2022 void osl_psz_getLastSocketErrorDescription(oslSocket pSocket, char* pBuffer, sal_uInt32 BufferSize)
2023 {
2024     /* make sure pBuffer will be a zero-terminated string even when strncpy has to cut */
2025     pBuffer[BufferSize-1]= '\0';
2026
2027     if ( pSocket == nullptr )
2028     {
2029         strncpy(pBuffer, strerror(EINVAL), BufferSize-1);
2030         return;
2031     }
2032
2033     strncpy(pBuffer, strerror(pSocket->m_nLastError), BufferSize-1);
2034 }
2035
2036 oslSocketError SAL_CALL osl_getLastSocketError(oslSocket pSocket)
2037 {
2038     if ( pSocket == nullptr )
2039     {
2040         return ERROR_FROM_NATIVE(EINVAL);
2041     }
2042
2043     return ERROR_FROM_NATIVE(pSocket->m_nLastError);
2044 }
2045
2046 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */