1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_sal.hxx" 26 27 #include "system.h" 28 29 #include <osl/socket.h> 30 #include <osl/diagnose.h> 31 #include <rtl/alloc.h> 32 33 #include "sockimpl.h" 34 35 extern "C" { 36 37 /* defines for shutdown */ 38 #ifdef GCC 39 # define SD_RECEIVE 0 40 # define SD_SEND 1 41 # define SD_BOTH 2 42 #endif 43 44 /* 45 oslSocketAddr is a pointer to a Berkeley struct sockaddr. 46 I refrained from using sockaddr_in because of possible further 47 extensions of this socket-interface (IP-NG?). 48 The intention was to hide all Berkeley data-structures from 49 direct access past the osl-interface. 50 51 The current implementation is internet (IP) centered. All 52 the constructor-functions (osl_create...) take parameters 53 that will probably make sense only in the IP-environment 54 (e.g. because of using the dotted-Addr-format). 55 56 If the interface will be extended to host other protocol- 57 families, I expect no externally visible changes in the 58 existing functions. You'll probably need only new 59 constructor-functions who take the different Addr 60 formats into consideration (maybe a long dotted Addr 61 or whatever). 62 */ 63 64 /* 65 _Note_ that I rely on the fact that oslSocketAddr and struct sockaddr 66 are the same! I don't like it very much but see no other easy way to 67 conceal the struct sockaddr from the eyes of the user. 68 */ 69 70 #define OSL_INVALID_SOCKET INVALID_SOCKET /* WIN32 */ 71 #define OSL_SOCKET_ERROR SOCKET_ERROR /* WIN32 */ 72 73 /*****************************************************************************/ 74 /* enum oslAddrFamily */ 75 /*****************************************************************************/ 76 77 /* map */ 78 static DWORD FamilyMap[]= { 79 AF_INET, /* osl_Socket_FamilyInet */ 80 AF_IPX, /* osl_Socket_FamilyIpx */ 81 0 /* osl_Socket_FamilyInvalid */ 82 }; 83 84 /* reverse map */ 85 static oslAddrFamily osl_AddrFamilyFromNative(DWORD nativeType) 86 { 87 oslAddrFamily i= (oslAddrFamily) 0; 88 while(i != osl_Socket_FamilyInvalid) 89 { 90 if(FamilyMap[i] == nativeType) 91 return i; 92 i = (oslAddrFamily) ( (int)i + 1); 93 } 94 return i; 95 } 96 97 /* macros */ 98 #define FAMILY_FROM_NATIVE(y) osl_AddrFamilyFromNative(y) 99 #define FAMILY_TO_NATIVE(x) (short)FamilyMap[x] 100 101 /*****************************************************************************/ 102 /* enum oslProtocol */ 103 /*****************************************************************************/ 104 105 /* map */ 106 static DWORD ProtocolMap[]= { 107 0, /* osl_Socket_FamilyInet */ 108 NSPROTO_IPX, /* osl_Socket_FamilyIpx */ 109 NSPROTO_SPX, /* osl_Socket_ProtocolSpx */ 110 NSPROTO_SPXII, /* osl_Socket_ProtocolSpx_ii */ 111 0 /* osl_Socket_ProtocolInvalid */ 112 }; 113 114 /* macros */ 115 #define PROTOCOL_FROM_NATIVE(y) osl_ProtocolFromNative(y) 116 #define PROTOCOL_TO_NATIVE(x) ProtocolMap[x] 117 118 /*****************************************************************************/ 119 /* enum oslSocketType */ 120 /*****************************************************************************/ 121 122 /* map */ 123 static DWORD TypeMap[]= { 124 SOCK_STREAM, /* osl_Socket_TypeStream */ 125 SOCK_DGRAM, /* osl_Socket_TypeDgram */ 126 SOCK_RAW, /* osl_Socket_TypeRaw */ 127 SOCK_RDM, /* osl_Socket_TypeRdm */ 128 SOCK_SEQPACKET, /* osl_Socket_TypeSeqPacket */ 129 0 /* osl_Socket_TypeInvalid */ 130 }; 131 132 /* reverse map */ 133 static oslSocketType osl_SocketTypeFromNative(DWORD nativeType) 134 { 135 oslSocketType i= (oslSocketType)0; 136 while(i != osl_Socket_TypeInvalid) 137 { 138 if(TypeMap[i] == nativeType) 139 return i; 140 i = (oslSocketType)((int)i+1); 141 } 142 return i; 143 } 144 145 /* macros */ 146 #define TYPE_TO_NATIVE(x) TypeMap[x] 147 #define TYPE_FROM_NATIVE(y) osl_SocketTypeFromNative(y) 148 149 /*****************************************************************************/ 150 /* enum oslSocketOption */ 151 /*****************************************************************************/ 152 153 /* map */ 154 static DWORD OptionMap[]= { 155 SO_DEBUG, /* osl_Socket_OptionDebug */ 156 SO_ACCEPTCONN, /* osl_Socket_OptionAcceptConn */ 157 SO_REUSEADDR, /* osl_Socket_OptionReuseAddr */ 158 SO_KEEPALIVE, /* osl_Socket_OptionKeepAlive */ 159 SO_DONTROUTE, /* osl_Socket_OptionDontRoute */ 160 SO_BROADCAST, /* osl_Socket_OptionBroadcast */ 161 SO_USELOOPBACK, /* osl_Socket_OptionUseLoopback */ 162 SO_LINGER, /* osl_Socket_OptionLinger */ 163 SO_OOBINLINE, /* osl_Socket_OptionOOBinLine */ 164 SO_SNDBUF, /* osl_Socket_OptionSndBuf */ 165 SO_RCVBUF, /* osl_Socket_OptionRcvBuf */ 166 SO_SNDLOWAT, /* osl_Socket_OptionSndLowat */ 167 SO_RCVLOWAT, /* osl_Socket_OptionRcvLowat */ 168 SO_SNDTIMEO, /* osl_Socket_OptionSndTimeo */ 169 SO_RCVTIMEO, /* osl_Socket_OptionRcvTimeo */ 170 SO_ERROR, /* osl_Socket_OptionError */ 171 SO_TYPE, /* osl_Socket_OptionType */ 172 TCP_NODELAY, /* osl_Socket_OptionTcpNoDelay */ 173 0 /* osl_Socket_OptionInvalid */ 174 }; 175 176 /* macros */ 177 #define OPTION_TO_NATIVE(x) OptionMap[x] 178 #define OPTION_FROM_NATIVE(y) osl_SocketOptionFromNative(y) 179 180 /*****************************************************************************/ 181 /* enum oslSocketOptionLevel */ 182 /*****************************************************************************/ 183 184 static DWORD OptionLevelMap[]= { 185 SOL_SOCKET, /* osl_Socket_LevelSocket */ 186 IPPROTO_TCP, /* osl_Socket_LevelTcp */ 187 0 /* osl_invalid_SocketLevel */ 188 }; 189 190 /* macros */ 191 #define OPTION_LEVEL_TO_NATIVE(x) OptionLevelMap[x] 192 #define OPTION_LEVEL_FROM_NATIVE(y) osl_SocketOptionLevelFromNative(y) 193 194 /*****************************************************************************/ 195 /* enum oslSocketMsgFlag */ 196 /*****************************************************************************/ 197 198 static DWORD SocketMsgFlagMap[]= { 199 0, /* osl_Socket_MsgNormal */ 200 MSG_OOB, /* osl_Socket_MsgOOB */ 201 MSG_PEEK, /* osl_Socket_MsgPeek */ 202 MSG_DONTROUTE, /* osl_Socket_MsgDontRoute */ 203 MSG_MAXIOVLEN /* osl_Socket_MsgMaxIOVLen */ 204 }; 205 206 /* macros */ 207 #define MSG_FLAG_TO_NATIVE(x) SocketMsgFlagMap[x] 208 #define MSG_FLAG_FROM_NATIVE(y) osl_SocketMsgFlagFromNative(y) 209 210 /*****************************************************************************/ 211 /* enum oslSocketDirection */ 212 /*****************************************************************************/ 213 214 static DWORD SocketDirection[]= { 215 SD_RECEIVE, /* osl_Socket_DirRead */ 216 SD_SEND, /* osl_Socket_DirWrite */ 217 SD_BOTH /* osl_Socket_DirReadwrite */ 218 }; 219 220 /* macros */ 221 #define DIRECTION_TO_NATIVE(x) SocketDirection[x] 222 #define DIRECTION_FROM_NATIVE(y) osl_SocketDirectionFromNative(y) 223 224 /*****************************************************************************/ 225 /* enum oslSocketError */ 226 /*****************************************************************************/ 227 228 static int SocketError[]= { 229 230 0, /* no error */ 231 WSAENOTSOCK, /* Socket operation on non-socket */ 232 WSAEDESTADDRREQ, /* Destination address required */ 233 WSAEMSGSIZE, /* Message too long */ 234 WSAEPROTOTYPE, /* Protocol wrong type for socket */ 235 WSAENOPROTOOPT, /* Protocol not available */ 236 WSAEPROTONOSUPPORT, /* Protocol not supported */ 237 WSAESOCKTNOSUPPORT, /* Socket type not supported */ 238 WSAEOPNOTSUPP, /* Operation not supported on socket */ 239 WSAEPFNOSUPPORT, /* Protocol family not supported */ 240 WSAEAFNOSUPPORT, /* Address family not supported by */ 241 /* protocol family */ 242 WSAEADDRINUSE, /* Address already in use */ 243 WSAEADDRNOTAVAIL, /* Can't assign requested address */ 244 WSAENETDOWN, /* Network is down */ 245 WSAENETUNREACH, /* Network is unreachable */ 246 WSAENETRESET, /* Network dropped connection because */ 247 /* of reset */ 248 WSAECONNABORTED, /* Software caused connection abort */ 249 WSAECONNRESET, /* Connection reset by peer */ 250 WSAENOBUFS, /* No buffer space available */ 251 WSAEISCONN, /* Socket is already connected */ 252 WSAENOTCONN, /* Socket is not connected */ 253 WSAESHUTDOWN, /* Can't send after socket shutdown */ 254 WSAETOOMANYREFS, /* Too many references: can't splice */ 255 WSAETIMEDOUT, /* Connection timed out */ 256 WSAECONNREFUSED, /* Connection refused */ 257 WSAEHOSTDOWN, /* Host is down */ 258 WSAEHOSTUNREACH, /* No route to host */ 259 WSAEWOULDBLOCK, /* call would block on non-blocking socket */ 260 WSAEALREADY, /* operation already in progress */ 261 WSAEINPROGRESS /* operation now in progress */ 262 }; 263 264 /* reverse map */ 265 static oslSocketError osl_SocketErrorFromNative(int nativeType) 266 { 267 oslSocketError i= (oslSocketError)0; 268 269 while(i != osl_Socket_E_InvalidError) 270 { 271 if(SocketError[i] == nativeType) 272 return i; 273 274 i = (oslSocketError)( (int) i + 1); 275 } 276 return i; 277 } 278 279 /* macros */ 280 #define ERROR_TO_NATIVE(x) SocketError[x] 281 #define ERROR_FROM_NATIVE(y) osl_SocketErrorFromNative(y) 282 283 /*****************************************************************************/ 284 /* oslSocketDialupImpl */ 285 /*****************************************************************************/ 286 static oslSocketDialupImpl *pDialupImpl = NULL; 287 288 #if 0 /* INTERNAL DEBUG ONLY */ 289 BOOL WINAPI __osl_autodial_Impl (DWORD dwFlags, DWORD dwReserved) 290 { 291 return 0; 292 } 293 294 BOOL WINAPI __osl_autodialHangup_Impl (DWORD dwReserved) 295 { 296 return 1; 297 } 298 299 BOOL WINAPI __osl_getConnectedState_Impl (LPDWORD lpdwFlags, DWORD dwReserved) 300 { 301 if (lpdwFlags) 302 *lpdwFlags = 0; 303 return 0; 304 } 305 #endif /* INTERNAL DEBUG ONLY */ 306 307 /* 308 * __osl_createSocketDialupImpl. 309 */ 310 static oslSocketDialupImpl* __osl_createSocketDialupImpl (void) 311 { 312 oslSocketDialupImpl *pImpl; 313 pImpl = (oslSocketDialupImpl*)rtl_allocateZeroMemory( sizeof (oslSocketDialupImpl)); 314 315 InitializeCriticalSection (&pImpl->m_hMutex); 316 317 return (pImpl); 318 } 319 320 /* 321 * __osl_initSocketDialupImpl. 322 */ 323 static void __osl_initSocketDialupImpl (oslSocketDialupImpl *pImpl) 324 { 325 #ifdef SOCKET_USE_AUTODIAL 326 if (pImpl) 327 { 328 HINSTANCE hModule; 329 330 EnterCriticalSection (&pImpl->m_hMutex); 331 332 hModule = LoadLibrary (INTERNET_MODULE_NAME); 333 if (!(hModule <= (HINSTANCE)HINSTANCE_ERROR)) 334 { 335 pImpl->m_pfnAttemptConnect = (INTERNETATTEMPTCONNECT) 336 (GetProcAddress (hModule, "InternetAttemptConnect")); 337 pImpl->m_pfnAutodial = (INTERNETAUTODIAL) 338 (GetProcAddress (hModule, "InternetAutodial")); 339 pImpl->m_pfnAutodialHangup = (INTERNETAUTODIALHANGUP) 340 (GetProcAddress (hModule, "InternetAutodialHangup")); 341 pImpl->m_pfnGetConnectedState = (INTERNETGETCONNECTEDSTATE) 342 (GetProcAddress (hModule, "InternetGetConnectedState")); 343 pImpl->m_hModule = hModule; 344 } 345 346 LeaveCriticalSection (&pImpl->m_hMutex); 347 } 348 #else 349 pImpl = pImpl; /* avoid warnings */ 350 #endif 351 } 352 353 /* 354 * __osl_destroySocketDialupImpl. 355 */ 356 static void __osl_destroySocketDialupImpl (oslSocketDialupImpl *pImpl) 357 { 358 if (pImpl) 359 { 360 EnterCriticalSection (&pImpl->m_hMutex); 361 362 if (pImpl->m_dwFlags & INTERNET_CONNECTION_HANGUP) 363 { 364 if (pImpl->m_pfnAutodialHangup) 365 { 366 (pImpl->m_pfnAutodialHangup)(0); 367 pImpl->m_dwFlags &= ~INTERNET_CONNECTION_HANGUP; 368 } 369 } 370 371 if (pImpl->m_hModule) 372 FreeLibrary (pImpl->m_hModule); 373 374 LeaveCriticalSection (&pImpl->m_hMutex); 375 DeleteCriticalSection (&pImpl->m_hMutex); 376 377 rtl_freeMemory (pImpl); 378 } 379 } 380 381 /* 382 * __osl_querySocketDialupImpl. 383 */ 384 static sal_Bool __osl_querySocketDialupImpl (void) 385 { 386 sal_Bool result; 387 388 if (pDialupImpl == NULL) 389 { 390 pDialupImpl = __osl_createSocketDialupImpl(); 391 __osl_initSocketDialupImpl (pDialupImpl); 392 } 393 394 EnterCriticalSection (&pDialupImpl->m_hMutex); 395 396 result = sal_True; 397 if (pDialupImpl->m_pfnGetConnectedState) 398 { 399 DWORD dwFlags = 0; 400 401 result = (sal_Bool)(pDialupImpl->m_pfnGetConnectedState)(&dwFlags, 0); 402 pDialupImpl->m_dwFlags |= dwFlags; 403 } 404 405 LeaveCriticalSection (&pDialupImpl->m_hMutex); 406 return (result); 407 } 408 409 /* 410 * __osl_attemptSocketDialupImpl. 411 */ 412 static sal_Bool __osl_attemptSocketDialupImpl (void) 413 { 414 sal_Bool result; 415 416 if (pDialupImpl == NULL) 417 { 418 pDialupImpl = __osl_createSocketDialupImpl(); 419 __osl_initSocketDialupImpl (pDialupImpl); 420 } 421 422 EnterCriticalSection (&pDialupImpl->m_hMutex); 423 424 result = __osl_querySocketDialupImpl(); 425 if (!result) 426 { 427 result = sal_True; 428 if (pDialupImpl->m_pfnAutodial) 429 { 430 result = (sal_Bool)(pDialupImpl->m_pfnAutodial)(0, 0); 431 if (result) 432 pDialupImpl->m_dwFlags |= INTERNET_CONNECTION_HANGUP; 433 else 434 WSASetLastError (WSAENETDOWN); 435 } 436 } 437 438 LeaveCriticalSection (&pDialupImpl->m_hMutex); 439 return (result); 440 } 441 442 /*****************************************************************************/ 443 /* oslSocketImpl */ 444 /*****************************************************************************/ 445 static sal_uInt32 g_nSocketImpl = 0; 446 447 #if OSL_DEBUG_LEVEL > 1 448 static sal_uInt32 g_nSocketAddr = 0; 449 struct LeakWarning 450 { 451 ~LeakWarning() 452 { 453 if( g_nSocketImpl ) 454 OSL_TRACE( "sal_socket: %d socket instances leak\n" , g_nSocketImpl ); 455 if( g_nSocketAddr ) 456 OSL_TRACE( "sal_socket: %d socket address instances leak\n" , g_nSocketAddr ); 457 } 458 }; 459 LeakWarning socketWarning; 460 #endif 461 462 /* 463 * __osl_createSocketImpl. 464 */ 465 oslSocket __osl_createSocketImpl(SOCKET Socket) 466 { 467 oslSocket pSockImpl = (oslSocket) rtl_allocateZeroMemory( sizeof(struct oslSocketImpl)); 468 pSockImpl->m_Socket = Socket; 469 pSockImpl->m_nRefCount = 1; 470 471 g_nSocketImpl++; 472 473 return (pSockImpl); 474 } 475 476 /* 477 * __osl_destroySocketImpl. 478 */ 479 void __osl_destroySocketImpl(oslSocketImpl *pImpl) 480 { 481 if (pImpl) 482 { 483 if (--g_nSocketImpl == 0) 484 { 485 __osl_destroySocketDialupImpl (pDialupImpl); 486 pDialupImpl = NULL; 487 } 488 rtl_freeMemory (pImpl); 489 } 490 } 491 /*****************************************************************************/ 492 static oslSocketAddr __osl_createSocketAddr( ) 493 { 494 oslSocketAddr pAddr = (oslSocketAddr) rtl_allocateZeroMemory( sizeof( struct oslSocketAddrImpl )); 495 pAddr->m_nRefCount = 1; 496 #if OSL_DEBUG_LEVEL > 1 497 g_nSocketAddr ++; 498 #endif 499 return pAddr; 500 } 501 502 static oslSocketAddr __osl_createSocketAddrWithFamily( 503 oslAddrFamily family, sal_Int32 port, sal_uInt32 nAddr ) 504 { 505 OSL_ASSERT( family == osl_Socket_FamilyInet ); 506 507 oslSocketAddr pAddr = __osl_createSocketAddr(); 508 switch( family ) 509 { 510 case osl_Socket_FamilyInet: 511 { 512 struct sockaddr_in* pInetAddr= (struct sockaddr_in*)&(pAddr->m_sockaddr); 513 514 pInetAddr->sin_family = FAMILY_TO_NATIVE(osl_Socket_FamilyInet); 515 pInetAddr->sin_addr.s_addr = nAddr; 516 pInetAddr->sin_port = (sal_uInt16)(port&0xffff); 517 break; 518 } 519 default: 520 pAddr->m_sockaddr.sa_family = FAMILY_TO_NATIVE(family); 521 } 522 return pAddr; 523 } 524 525 static oslSocketAddr __osl_createSocketAddrFromSystem( struct sockaddr *pSystemSockAddr ) 526 { 527 oslSocketAddr pAddr = __osl_createSocketAddr(); 528 memcpy( &(pAddr->m_sockaddr), pSystemSockAddr, sizeof( sockaddr ) ); 529 return pAddr; 530 } 531 532 static void __osl_destroySocketAddr( oslSocketAddr addr ) 533 { 534 #if OSL_DEBUG_LEVEL > 1 535 g_nSocketAddr --; 536 #endif 537 rtl_freeMemory( addr ); 538 } 539 /*****************************************************************************/ 540 /* osl_createEmptySocketAddr */ 541 /*****************************************************************************/ 542 oslSocketAddr SAL_CALL osl_createEmptySocketAddr(oslAddrFamily Family) 543 { 544 oslSocketAddr pAddr = 0; 545 546 /* is it an internet-Addr? */ 547 if (Family == osl_Socket_FamilyInet) 548 { 549 pAddr = __osl_createSocketAddrWithFamily(Family, 0 , htonl(INADDR_ANY) ); 550 } 551 else 552 { 553 pAddr = __osl_createSocketAddrWithFamily( Family , 0 , 0 ); 554 } 555 556 return pAddr; 557 } 558 559 /*****************************************************************************/ 560 /* osl_copySocketAddr */ 561 /*****************************************************************************/ 562 // @deprecated, to be removed 563 oslSocketAddr SAL_CALL osl_copySocketAddr(oslSocketAddr Addr) 564 { 565 oslSocketAddr pCopy = 0; 566 if (Addr) 567 { 568 pCopy = __osl_createSocketAddr(); 569 570 if (pCopy) 571 memcpy(&(pCopy->m_sockaddr),&(Addr->m_sockaddr), sizeof(struct sockaddr)); 572 } 573 return pCopy; 574 } 575 576 /*****************************************************************************/ 577 /* osl_isEqualSocketAddr */ 578 /*****************************************************************************/ 579 sal_Bool SAL_CALL osl_isEqualSocketAddr(oslSocketAddr Addr1, oslSocketAddr Addr2) 580 { 581 struct sockaddr* pAddr1= &(Addr1->m_sockaddr); 582 struct sockaddr* pAddr2= &(Addr2->m_sockaddr); 583 584 OSL_ASSERT(pAddr1); 585 OSL_ASSERT(pAddr2); 586 587 if (pAddr1->sa_family == pAddr2->sa_family) 588 { 589 switch (pAddr1->sa_family) 590 { 591 case AF_INET: 592 { 593 struct sockaddr_in* pInetAddr1= (struct sockaddr_in*)pAddr1; 594 struct sockaddr_in* pInetAddr2= (struct sockaddr_in*)pAddr2; 595 596 if ((pInetAddr1->sin_family == pInetAddr2->sin_family) && 597 (pInetAddr1->sin_addr.s_addr == pInetAddr2->sin_addr.s_addr) && 598 (pInetAddr1->sin_port == pInetAddr2->sin_port)) 599 return (sal_True); 600 } 601 602 default: 603 { 604 return (memcmp(pAddr1, Addr2, sizeof(struct sockaddr)) == 0); 605 } 606 } 607 } 608 609 return (sal_False); 610 } 611 612 /*****************************************************************************/ 613 /* osl_createInetBroadcastAddr */ 614 /*****************************************************************************/ 615 oslSocketAddr SAL_CALL osl_createInetBroadcastAddr ( 616 rtl_uString *strDottedAddr, 617 sal_Int32 Port) 618 { 619 sal_uInt32 nAddr = OSL_INADDR_NONE; 620 621 if (strDottedAddr && strDottedAddr->length) 622 { 623 /* Dotted host address for limited broadcast */ 624 rtl_String *pDottedAddr = NULL; 625 626 rtl_uString2String ( 627 &pDottedAddr, strDottedAddr->buffer, strDottedAddr->length, 628 RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS); 629 630 nAddr = inet_addr (pDottedAddr->buffer); 631 rtl_string_release (pDottedAddr); 632 } 633 634 if (nAddr != OSL_INADDR_NONE) 635 { 636 /* Limited broadcast */ 637 nAddr = ntohl(nAddr); 638 if (IN_CLASSA(nAddr)) 639 { 640 nAddr &= IN_CLASSA_NET; 641 nAddr |= IN_CLASSA_HOST; 642 } 643 else if (IN_CLASSB(nAddr)) 644 { 645 nAddr &= IN_CLASSB_NET; 646 nAddr |= IN_CLASSB_HOST; 647 } 648 else if (IN_CLASSC(nAddr)) 649 { 650 nAddr &= IN_CLASSC_NET; 651 nAddr |= IN_CLASSC_HOST; 652 } 653 else 654 { 655 /* No broadcast in class D */ 656 return ((oslSocketAddr)NULL); 657 } 658 nAddr = htonl(nAddr); 659 } 660 661 oslSocketAddr pAddr = 662 __osl_createSocketAddrWithFamily( osl_Socket_FamilyInet, htons( (sal_uInt16) Port), nAddr ); 663 return pAddr; 664 } 665 666 /*****************************************************************************/ 667 /* osl_createInetSocketAddr */ 668 /*****************************************************************************/ 669 oslSocketAddr SAL_CALL osl_createInetSocketAddr ( 670 rtl_uString *strDottedAddr, 671 sal_Int32 Port) 672 { 673 DWORD Addr; 674 rtl_String *pDottedAddr=NULL; 675 676 rtl_uString2String( 677 &pDottedAddr, strDottedAddr->buffer, strDottedAddr->length, 678 RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS); 679 680 Addr= inet_addr (pDottedAddr->buffer); 681 rtl_string_release (pDottedAddr); 682 683 oslSocketAddr pAddr = 0; 684 if(Addr != -1) 685 { 686 pAddr = __osl_createSocketAddrWithFamily( osl_Socket_FamilyInet, htons( (sal_uInt16)Port), Addr ); 687 } 688 return pAddr; 689 } 690 691 oslSocketResult SAL_CALL osl_setAddrOfSocketAddr( oslSocketAddr pAddr, sal_Sequence *pByteSeq ) 692 { 693 OSL_ASSERT( pAddr ); 694 OSL_ASSERT( pByteSeq ); 695 696 oslSocketResult res = osl_Socket_Error; 697 if( pAddr && pByteSeq ) 698 { 699 OSL_ASSERT( pAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE( osl_Socket_FamilyInet ) ); 700 OSL_ASSERT( pByteSeq->nElements == 4 ); 701 struct sockaddr_in * pSystemInetAddr = (struct sockaddr_in * ) &(pAddr->m_sockaddr); 702 memcpy( &(pSystemInetAddr->sin_addr) , pByteSeq->elements , 4 ); 703 res = osl_Socket_Ok; 704 } 705 return res; 706 } 707 708 /** Returns the addr field in the struct sockaddr. ppByteSeq is in network byteorder. *ppByteSeq may 709 either be 0 or contain a constructed sal_Sequence. 710 */ 711 oslSocketResult SAL_CALL osl_getAddrOfSocketAddr( oslSocketAddr pAddr, sal_Sequence **ppByteSeq ) 712 { 713 OSL_ASSERT( pAddr ); 714 OSL_ASSERT( ppByteSeq ); 715 716 oslSocketResult res = osl_Socket_Error; 717 if( pAddr && ppByteSeq ) 718 { 719 struct sockaddr_in * pSystemInetAddr = (struct sockaddr_in * ) &(pAddr->m_sockaddr); 720 rtl_byte_sequence_constructFromArray( ppByteSeq , (sal_Int8 *) &(pSystemInetAddr->sin_addr),4); 721 res = osl_Socket_Ok; 722 } 723 return res; 724 } 725 726 /*****************************************************************************/ 727 /* oslHostAddr */ 728 /*****************************************************************************/ 729 struct oslHostAddrImpl { 730 rtl_uString *pHostName; 731 oslSocketAddr pSockAddr; 732 } ; 733 734 static oslHostAddr __osl_hostentToHostAddr (const struct hostent *he) 735 { 736 oslHostAddr pAddr= NULL; 737 oslSocketAddr pSocketAddr = 0; 738 739 rtl_uString *cn= NULL; 740 741 if ((he == NULL) || (he->h_name == NULL) || (he->h_addr_list[0] == NULL)) 742 return ((oslHostAddr)NULL); 743 744 rtl_string2UString( 745 &cn, he->h_name, strlen(he->h_name), 746 RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS); 747 OSL_ASSERT(cn != 0); 748 749 pSocketAddr = __osl_createSocketAddr(); 750 751 if (pSocketAddr == NULL) 752 { 753 rtl_uString_release(cn); 754 return ((oslHostAddr)NULL); 755 } 756 757 pSocketAddr->m_sockaddr.sa_family = he->h_addrtype; 758 if (pSocketAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet)) 759 { 760 struct sockaddr_in *sin= (struct sockaddr_in *)&(pSocketAddr->m_sockaddr); 761 memcpy ( 762 &(sin->sin_addr.s_addr), 763 he->h_addr_list[0], 764 he->h_length); 765 } 766 else 767 { 768 /* unknown address family */ 769 /* future extensions for new families might be implemented here */ 770 771 OSL_TRACE("_osl_hostentToHostAddr(): unknown address family.\n"); 772 OSL_ASSERT(sal_False); 773 774 __osl_destroySocketAddr( pSocketAddr ); 775 rtl_uString_release(cn); 776 return ((oslHostAddr)NULL); 777 } 778 779 pAddr= (oslHostAddr )rtl_allocateMemory (sizeof (struct oslHostAddrImpl)); 780 781 if (pAddr == NULL) 782 { 783 __osl_destroySocketAddr( pSocketAddr ); 784 rtl_uString_release(cn); 785 return ((oslHostAddr)NULL); 786 } 787 788 pAddr->pHostName= cn; 789 pAddr->pSockAddr= pSocketAddr; 790 791 return pAddr; 792 } 793 794 /*****************************************************************************/ 795 /* osl_createHostAddr */ 796 /*****************************************************************************/ 797 oslHostAddr SAL_CALL osl_createHostAddr ( 798 rtl_uString *strHostname, 799 const oslSocketAddr pSocketAddr) 800 { 801 oslHostAddr pAddr; 802 rtl_uString *cn= NULL; 803 804 if ((strHostname == NULL) || (strHostname->length == 0) || (pSocketAddr == NULL)) 805 return ((oslHostAddr)NULL); 806 807 rtl_uString_newFromString( &cn, strHostname); 808 809 if ( ! pSocketAddr ) 810 { 811 rtl_uString_release(cn); 812 return ((oslHostAddr)NULL); 813 } 814 815 pAddr= (oslHostAddr)rtl_allocateMemory (sizeof (struct oslHostAddrImpl)); 816 817 if (pAddr == NULL) 818 { 819 rtl_uString_release(cn); 820 return ((oslHostAddr)NULL); 821 } 822 823 pAddr->pHostName= cn; 824 pAddr->pSockAddr= osl_copySocketAddr( pSocketAddr ); 825 826 return ((oslHostAddr)pAddr); 827 } 828 829 /*****************************************************************************/ 830 /* osl_createHostAddrByName */ 831 /*****************************************************************************/ 832 oslHostAddr SAL_CALL osl_createHostAddrByName(rtl_uString *strHostname) 833 { 834 if ((strHostname == NULL) || (strHostname->length == 0)) 835 return ((oslHostAddr)NULL); 836 837 if (__osl_attemptSocketDialupImpl()) 838 { 839 struct hostent *he; 840 rtl_String *Hostname= NULL; 841 842 rtl_uString2String( 843 &Hostname, strHostname->buffer, strHostname->length, 844 RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS); 845 846 he= gethostbyname (Hostname->buffer); 847 848 rtl_string_release (Hostname); 849 return __osl_hostentToHostAddr (he); 850 } 851 return ((oslHostAddr)NULL); 852 } 853 854 /*****************************************************************************/ 855 /* osl_createHostAddrByAddr */ 856 /*****************************************************************************/ 857 oslHostAddr SAL_CALL osl_createHostAddrByAddr(const oslSocketAddr pAddr) 858 { 859 if (pAddr == NULL) 860 return ((oslHostAddr)NULL); 861 862 if (pAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet)) 863 { 864 const struct sockaddr_in *sin= (const struct sockaddr_in *)&(pAddr->m_sockaddr); 865 866 if (sin->sin_addr.s_addr == htonl(INADDR_ANY)) 867 return ((oslHostAddr)NULL); 868 869 if (__osl_attemptSocketDialupImpl()) 870 { 871 struct hostent *he; 872 he= gethostbyaddr ((const sal_Char *)&(sin->sin_addr), 873 sizeof (sin->sin_addr), 874 sin->sin_family); 875 return __osl_hostentToHostAddr (he); 876 } 877 } 878 879 return ((oslHostAddr)NULL); 880 } 881 882 /*****************************************************************************/ 883 /* osl_copyHostAddr */ 884 /*****************************************************************************/ 885 oslHostAddr SAL_CALL osl_copyHostAddr(const oslHostAddr Addr) 886 { 887 oslHostAddr pAddr= (oslHostAddr)Addr; 888 889 if (pAddr) 890 return osl_createHostAddr (pAddr->pHostName, pAddr->pSockAddr); 891 else 892 return ((oslHostAddr)NULL); 893 } 894 895 /*****************************************************************************/ 896 /* osl_getHostnameOfHostAddr */ 897 /*****************************************************************************/ 898 void SAL_CALL osl_getHostnameOfHostAddr( 899 const oslHostAddr pAddr, rtl_uString **strHostname) 900 { 901 if (pAddr) 902 rtl_uString_assign (strHostname, pAddr->pHostName); 903 else 904 rtl_uString_new (strHostname); 905 } 906 907 /*****************************************************************************/ 908 /* osl_getSocketAddrOfHostAddr */ 909 /*****************************************************************************/ 910 oslSocketAddr SAL_CALL osl_getSocketAddrOfHostAddr(const oslHostAddr pAddr) 911 { 912 if (pAddr) 913 return (const oslSocketAddr)(pAddr->pSockAddr); 914 else 915 return NULL; 916 } 917 918 /*****************************************************************************/ 919 /* osl_destroyHostAddr */ 920 /*****************************************************************************/ 921 void SAL_CALL osl_destroyHostAddr(oslHostAddr pAddr) 922 { 923 if (pAddr) 924 { 925 if (pAddr->pHostName) 926 rtl_uString_release (pAddr->pHostName); 927 if (pAddr->pSockAddr) 928 osl_destroySocketAddr( pAddr->pSockAddr ); 929 930 rtl_freeMemory (pAddr); 931 } 932 } 933 934 /*****************************************************************************/ 935 /* osl_getLocalHostname */ 936 /*****************************************************************************/ 937 oslSocketResult SAL_CALL osl_getLocalHostname (rtl_uString **strLocalHostname) 938 { 939 static sal_Unicode LocalHostname[256] = {0}; 940 941 if (rtl_ustr_getLength(LocalHostname) == 0) 942 { 943 sal_Char Host[256]= ""; 944 if (gethostname(Host, sizeof(Host)) == 0) 945 { 946 /* check if we have an FQDN */ 947 if (strchr(Host, '.') == NULL) 948 { 949 oslHostAddr pAddr; 950 rtl_uString *hostName= NULL; 951 952 rtl_string2UString( 953 &hostName, Host, strlen(Host), 954 RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS); 955 OSL_ASSERT(hostName != 0); 956 957 /* no, determine it via dns */ 958 pAddr = osl_createHostAddrByName(hostName); 959 rtl_uString_release (hostName); 960 961 if (pAddr && pAddr->pHostName) 962 memcpy(LocalHostname, pAddr->pHostName->buffer, sizeof(sal_Unicode)*(rtl_ustr_getLength(pAddr->pHostName->buffer)+1)); 963 else 964 memset(LocalHostname, 0, sizeof(LocalHostname)); 965 966 osl_destroyHostAddr ((oslHostAddr)pAddr); 967 } 968 } 969 } 970 971 if (rtl_ustr_getLength(LocalHostname) > 0) 972 { 973 rtl_uString_newFromStr (strLocalHostname, LocalHostname); 974 return osl_Socket_Ok; 975 } 976 977 return osl_Socket_Error; 978 } 979 980 /*****************************************************************************/ 981 /* osl_resolveHostname */ 982 /*****************************************************************************/ 983 oslSocketAddr SAL_CALL osl_resolveHostname(rtl_uString* strHostname) 984 { 985 oslHostAddr pAddr= 986 (oslHostAddr )osl_createHostAddrByName (strHostname); 987 if (pAddr) 988 { 989 oslSocketAddr SockAddr = osl_copySocketAddr( pAddr->pSockAddr ); 990 osl_destroyHostAddr(pAddr); 991 return (SockAddr); 992 } 993 return ((oslSocketAddr)NULL); 994 } 995 996 /*****************************************************************************/ 997 /* osl_getServicePort */ 998 /*****************************************************************************/ 999 sal_Int32 SAL_CALL osl_getServicePort ( 1000 rtl_uString* strServicename, 1001 rtl_uString* strProtocol) 1002 { 1003 struct servent* ps; 1004 1005 rtl_String *str_Servicename=NULL; 1006 rtl_String *str_Protocol=NULL; 1007 1008 rtl_uString2String( 1009 &str_Servicename, 1010 rtl_uString_getStr(strServicename), 1011 rtl_uString_getLength(strServicename), 1012 RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS); 1013 rtl_uString2String( 1014 &str_Protocol, 1015 rtl_uString_getStr(strProtocol), 1016 rtl_uString_getLength(strProtocol), 1017 RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS); 1018 1019 ps= getservbyname( 1020 rtl_string_getStr(str_Servicename), 1021 rtl_string_getStr(str_Protocol)); 1022 1023 rtl_string_release( str_Servicename ); 1024 rtl_string_release( str_Protocol ); 1025 1026 if (ps != 0) 1027 return ntohs(ps->s_port); 1028 1029 return OSL_INVALID_PORT; 1030 } 1031 1032 /*****************************************************************************/ 1033 /* osl_destroySocketAddr */ 1034 /*****************************************************************************/ 1035 void SAL_CALL osl_destroySocketAddr(oslSocketAddr pAddr) 1036 { 1037 __osl_destroySocketAddr( pAddr ); 1038 } 1039 1040 /*****************************************************************************/ 1041 /* osl_getFamilyOfSocketAddr */ 1042 /*****************************************************************************/ 1043 oslAddrFamily SAL_CALL osl_getFamilyOfSocketAddr(oslSocketAddr pAddr) 1044 { 1045 if (pAddr) 1046 return FAMILY_FROM_NATIVE(pAddr->m_sockaddr.sa_family); 1047 else 1048 return osl_Socket_FamilyInvalid; 1049 } 1050 1051 /*****************************************************************************/ 1052 /* osl_getInetPortOfSocketAddr */ 1053 /*****************************************************************************/ 1054 sal_Int32 SAL_CALL osl_getInetPortOfSocketAddr(oslSocketAddr pAddr) 1055 { 1056 if( pAddr ) 1057 { 1058 struct sockaddr_in* pSystemInetAddr= (struct sockaddr_in*)&(pAddr->m_sockaddr); 1059 1060 if ( (pSystemInetAddr->sin_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))) 1061 return ntohs(pSystemInetAddr->sin_port); 1062 } 1063 return OSL_INVALID_PORT; 1064 } 1065 1066 /*****************************************************************************/ 1067 /* osl_setInetPortOfSocketAddr */ 1068 /*****************************************************************************/ 1069 sal_Bool SAL_CALL osl_setInetPortOfSocketAddr ( 1070 oslSocketAddr pAddr, 1071 sal_Int32 Port) 1072 { 1073 if (pAddr == NULL) 1074 return sal_False; 1075 1076 struct sockaddr_in* pSystemInetAddr= (struct sockaddr_in*)&(pAddr->m_sockaddr); 1077 1078 if (pSystemInetAddr->sin_family != FAMILY_TO_NATIVE(osl_Socket_FamilyInet)) 1079 return sal_False; 1080 1081 pSystemInetAddr->sin_port= htons((short)Port); 1082 return sal_True; 1083 } 1084 1085 /*****************************************************************************/ 1086 /* osl_getHostnameOfSocketAddr */ 1087 /*****************************************************************************/ 1088 oslSocketResult SAL_CALL osl_getHostnameOfSocketAddr ( 1089 oslSocketAddr Addr, 1090 rtl_uString **strHostName) 1091 { 1092 oslHostAddr pAddr= osl_createHostAddrByAddr (Addr); 1093 1094 if (pAddr) 1095 { 1096 rtl_uString_newFromString(strHostName, pAddr->pHostName); 1097 1098 osl_destroyHostAddr(pAddr); 1099 1100 return osl_Socket_Ok; 1101 } 1102 1103 return osl_Socket_Error; 1104 } 1105 1106 /*****************************************************************************/ 1107 /* osl_getDottedInetAddrOfSocketAddr */ 1108 /*****************************************************************************/ 1109 oslSocketResult SAL_CALL osl_getDottedInetAddrOfSocketAddr ( 1110 oslSocketAddr pAddr, 1111 rtl_uString **strDottedInetAddr) 1112 { 1113 sal_Char *pDotted; 1114 1115 if (pAddr == NULL) 1116 return osl_Socket_Error; 1117 1118 struct sockaddr_in *pSystemInetAddr = (struct sockaddr_in*) &(pAddr->m_sockaddr); 1119 if (pSystemInetAddr->sin_family != FAMILY_TO_NATIVE(osl_Socket_FamilyInet)) 1120 return osl_Socket_Error; 1121 1122 pDotted = inet_ntoa (pSystemInetAddr->sin_addr); 1123 rtl_string2UString( 1124 strDottedInetAddr, pDotted, strlen (pDotted), 1125 RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS); 1126 OSL_ASSERT(*strDottedInetAddr != 0); 1127 1128 return osl_Socket_Ok; 1129 } 1130 1131 /*****************************************************************************/ 1132 /* osl_createSocket */ 1133 /*****************************************************************************/ 1134 oslSocket SAL_CALL osl_createSocket ( 1135 oslAddrFamily Family, 1136 oslSocketType Type, 1137 oslProtocol Protocol) 1138 { 1139 /* alloc memory */ 1140 oslSocket pSocket = __osl_createSocketImpl(0); 1141 1142 if (pSocket == NULL) 1143 return 0; 1144 1145 /* create socket */ 1146 pSocket->m_Socket= socket(FAMILY_TO_NATIVE(Family), 1147 TYPE_TO_NATIVE(Type), 1148 PROTOCOL_TO_NATIVE(Protocol)); 1149 1150 /* creation failed => free memory */ 1151 if(pSocket->m_Socket == OSL_INVALID_SOCKET) 1152 { 1153 __osl_destroySocketImpl(pSocket); 1154 pSocket= 0; 1155 } 1156 else 1157 { 1158 pSocket->m_Flags = 0; 1159 pSocket->m_CloseCallback = NULL; 1160 pSocket->m_CallbackArg = NULL; 1161 } 1162 1163 return pSocket; 1164 } 1165 1166 void SAL_CALL osl_acquireSocket( oslSocket pSocket ) 1167 { 1168 osl_incrementInterlockedCount( &(pSocket->m_nRefCount) ); 1169 } 1170 1171 void SAL_CALL osl_releaseSocket( oslSocket pSocket ) 1172 { 1173 if( pSocket && 0 == osl_decrementInterlockedCount( &(pSocket->m_nRefCount) ) ) 1174 { 1175 osl_closeSocket( pSocket ); 1176 __osl_destroySocketImpl( pSocket ); 1177 } 1178 } 1179 1180 /*****************************************************************************/ 1181 /* osl_closeSocket */ 1182 /*****************************************************************************/ 1183 void SAL_CALL osl_closeSocket(oslSocket pSocket) 1184 { 1185 /* socket already invalid */ 1186 if(pSocket==0) 1187 return; 1188 1189 /* close */ 1190 closesocket(pSocket->m_Socket); 1191 1192 pSocket->m_Socket = OSL_INVALID_SOCKET; 1193 1194 /* registrierten Callback ausfuehren */ 1195 if (pSocket->m_CloseCallback != NULL) 1196 { 1197 pSocket->m_CloseCallback(pSocket->m_CallbackArg); 1198 } 1199 } 1200 1201 /*****************************************************************************/ 1202 /* osl_getLocalAddrOfSocket */ 1203 /* Note that I rely on the fact that oslSocketAddr and struct sockaddr */ 1204 /* are the same! I don't like it very much but see no other easy way */ 1205 /* to conceal the struct sockaddr from the eyes of the user. */ 1206 /*****************************************************************************/ 1207 oslSocketAddr SAL_CALL osl_getLocalAddrOfSocket(oslSocket pSocket) 1208 { 1209 struct sockaddr Addr; 1210 int AddrLen; 1211 1212 if (pSocket == NULL) /* ENOTSOCK */ 1213 return ((oslSocketAddr)NULL); 1214 1215 AddrLen= sizeof(struct sockaddr); 1216 1217 if (getsockname(pSocket->m_Socket, &Addr, &AddrLen) == OSL_SOCKET_ERROR) 1218 return ((oslSocketAddr)NULL); 1219 1220 oslSocketAddr pAddr = __osl_createSocketAddrFromSystem( &Addr ); 1221 return pAddr; 1222 } 1223 1224 /*****************************************************************************/ 1225 /* osl_getPeerAddrOfSocket */ 1226 /*****************************************************************************/ 1227 oslSocketAddr SAL_CALL osl_getPeerAddrOfSocket(oslSocket pSocket) 1228 { 1229 struct sockaddr Addr; 1230 int AddrLen; 1231 1232 if (pSocket == NULL) /* ENOTSOCK */ 1233 return ((oslSocketAddr)NULL); 1234 1235 AddrLen= sizeof(struct sockaddr); 1236 1237 if (getpeername(pSocket->m_Socket, &Addr, &AddrLen) == OSL_SOCKET_ERROR) 1238 return ((oslSocketAddr)NULL); 1239 1240 oslSocketAddr pAddr = __osl_createSocketAddrFromSystem( &Addr ); 1241 return pAddr; 1242 } 1243 1244 /*****************************************************************************/ 1245 /* osl_bindAddrToSocket */ 1246 /*****************************************************************************/ 1247 sal_Bool SAL_CALL osl_bindAddrToSocket ( oslSocket pSocket, oslSocketAddr pAddr) 1248 { 1249 OSL_ASSERT( pAddr ); 1250 1251 if (pSocket == NULL) /* ENOTSOCK */ 1252 return sal_False; 1253 1254 return (bind(pSocket->m_Socket, 1255 &(pAddr->m_sockaddr), 1256 sizeof(struct sockaddr)) != OSL_SOCKET_ERROR); 1257 } 1258 1259 /*****************************************************************************/ 1260 /* osl_connectSocketTo */ 1261 /*****************************************************************************/ 1262 oslSocketResult SAL_CALL osl_connectSocketTo ( 1263 oslSocket pSocket, 1264 oslSocketAddr pAddr, 1265 const TimeValue* pTimeout) 1266 { 1267 1268 if (pSocket == NULL) /* ENOTSOCK */ 1269 return osl_Socket_Error; 1270 1271 if (pAddr == NULL) /* EDESTADDRREQ */ 1272 return osl_Socket_Error; 1273 1274 if (!__osl_attemptSocketDialupImpl()) /* ENETDOWN */ 1275 return osl_Socket_Error; 1276 1277 if (pTimeout == NULL) 1278 { 1279 if(connect(pSocket->m_Socket, 1280 &(pAddr->m_sockaddr), 1281 sizeof(struct sockaddr)) == OSL_SOCKET_ERROR) 1282 return osl_Socket_Error; 1283 else 1284 return osl_Socket_Ok; 1285 } 1286 else 1287 { 1288 fd_set fds; 1289 int error; 1290 struct timeval tv; 1291 unsigned long Param; 1292 oslSocketResult Result= osl_Socket_Ok; 1293 1294 if (pSocket->m_Flags & OSL_SOCKET_FLAGS_NONBLOCKING) 1295 { 1296 if (connect(pSocket->m_Socket, 1297 &(pAddr->m_sockaddr), 1298 sizeof(struct sockaddr)) == OSL_SOCKET_ERROR) 1299 { 1300 switch (WSAGetLastError()) 1301 { 1302 case WSAEWOULDBLOCK: 1303 case WSAEINPROGRESS: 1304 return osl_Socket_InProgress; 1305 1306 default: 1307 return osl_Socket_Error; 1308 } 1309 } 1310 else 1311 return osl_Socket_Ok; 1312 } 1313 1314 /* set socket temporarily to non-blocking */ 1315 Param= 1; 1316 OSL_VERIFY(ioctlsocket( 1317 pSocket->m_Socket, FIONBIO, &Param) != OSL_SOCKET_ERROR); 1318 1319 /* initiate connect */ 1320 if (connect(pSocket->m_Socket, 1321 &(pAddr->m_sockaddr), 1322 sizeof(struct sockaddr)) != OSL_SOCKET_ERROR) 1323 { 1324 /* immediate connection */ 1325 1326 Param= 0; 1327 ioctlsocket(pSocket->m_Socket, FIONBIO, &Param); 1328 1329 return osl_Socket_Ok; 1330 } 1331 else 1332 { 1333 error = WSAGetLastError(); 1334 1335 /* really an error or just delayed? */ 1336 if (error != WSAEWOULDBLOCK && error != WSAEINPROGRESS) 1337 { 1338 Param= 0; 1339 ioctlsocket(pSocket->m_Socket, FIONBIO, &Param); 1340 1341 return osl_Socket_Error; 1342 } 1343 } 1344 1345 /* prepare select set for socket */ 1346 FD_ZERO(&fds); 1347 FD_SET(pSocket->m_Socket, &fds); 1348 1349 /* divide milliseconds into seconds and microseconds */ 1350 tv.tv_sec= pTimeout->Seconds; 1351 tv.tv_usec= pTimeout->Nanosec / 1000L; 1352 1353 /* select */ 1354 error= select(pSocket->m_Socket+1, 1355 0, 1356 &fds, 1357 0, 1358 &tv); 1359 1360 if (error > 0) /* connected */ 1361 { 1362 OSL_POSTCOND( 1363 FD_ISSET(pSocket->m_Socket, &fds), 1364 "osl_connectSocketTo(): select returned but socket not set\n"); 1365 1366 Result= osl_Socket_Ok; 1367 1368 } 1369 else if(error < 0) /* error */ 1370 { 1371 /* errno == EBADF: most probably interrupted by close() */ 1372 if(WSAGetLastError() == WSAEBADF) 1373 { 1374 /* do not access pSockImpl because it is about to be or */ 1375 /* already destroyed */ 1376 return osl_Socket_Interrupted; 1377 } 1378 else 1379 Result= osl_Socket_Error; 1380 1381 } 1382 else /* timeout */ 1383 Result= osl_Socket_TimedOut; 1384 1385 1386 /* clean up */ 1387 Param= 0; 1388 ioctlsocket(pSocket->m_Socket, FIONBIO, &Param); 1389 1390 return Result; 1391 } 1392 } 1393 1394 /*****************************************************************************/ 1395 /* osl_listenOnSocket */ 1396 /*****************************************************************************/ 1397 sal_Bool SAL_CALL osl_listenOnSocket ( 1398 oslSocket pSocket, 1399 sal_Int32 MaxPendingConnections) 1400 { 1401 if (pSocket == NULL) /* ENOTSOCK */ 1402 return sal_False; 1403 1404 return (listen(pSocket->m_Socket, 1405 MaxPendingConnections == -1 ? 1406 SOMAXCONN : 1407 MaxPendingConnections) != OSL_SOCKET_ERROR); 1408 } 1409 1410 /*****************************************************************************/ 1411 /* osl_acceptConnectionOnSocket */ 1412 /*****************************************************************************/ 1413 oslSocket SAL_CALL osl_acceptConnectionOnSocket ( 1414 oslSocket pSocket, 1415 oslSocketAddr* ppAddr) 1416 { 1417 if (pSocket == NULL) /* ENOTSOCK */ 1418 return ((oslSocket)NULL); 1419 1420 SOCKET Connection; 1421 if(ppAddr) 1422 { 1423 if( *ppAddr ) 1424 { 1425 osl_destroySocketAddr( *ppAddr ); 1426 *ppAddr = 0; 1427 } 1428 int AddrLen= sizeof(struct sockaddr); 1429 1430 /* user wants to know peer Addr */ 1431 struct sockaddr Addr; 1432 1433 Connection= accept(pSocket->m_Socket, &Addr, &AddrLen); 1434 OSL_ASSERT(AddrLen == sizeof(struct sockaddr)); 1435 1436 if(Connection != OSL_SOCKET_ERROR) 1437 *ppAddr= __osl_createSocketAddrFromSystem(&Addr); 1438 else 1439 *ppAddr = NULL; 1440 } 1441 else 1442 { 1443 /* user is not interested in peer-addr */ 1444 Connection= accept(pSocket->m_Socket, 0, 0); 1445 } 1446 1447 /* accept failed? */ 1448 if(Connection == OSL_SOCKET_ERROR) 1449 return ((oslSocket)NULL); 1450 1451 /* alloc memory */ 1452 oslSocket pConnectionSocket; 1453 pConnectionSocket= __osl_createSocketImpl(Connection); 1454 1455 pConnectionSocket->m_Flags = 0; 1456 pConnectionSocket->m_CloseCallback = NULL; 1457 pConnectionSocket->m_CallbackArg = NULL; 1458 1459 return pConnectionSocket; 1460 } 1461 1462 /*****************************************************************************/ 1463 /* osl_receiveSocket */ 1464 /*****************************************************************************/ 1465 sal_Int32 SAL_CALL osl_receiveSocket ( 1466 oslSocket pSocket, 1467 void* pBuffer, 1468 sal_uInt32 BytesToRead, 1469 oslSocketMsgFlag Flag) 1470 { 1471 if (pSocket == NULL) /* ENOTSOCK */ 1472 return osl_Socket_Error; 1473 1474 return recv(pSocket->m_Socket, 1475 (sal_Char*)pBuffer, 1476 BytesToRead, 1477 MSG_FLAG_TO_NATIVE(Flag)); 1478 } 1479 1480 /*****************************************************************************/ 1481 /* osl_receiveFromSocket */ 1482 /*****************************************************************************/ 1483 sal_Int32 SAL_CALL osl_receiveFromSocket ( 1484 oslSocket pSocket, 1485 oslSocketAddr SenderAddr, 1486 void* pBuffer, 1487 sal_uInt32 BufferSize, 1488 oslSocketMsgFlag Flag) 1489 { 1490 struct sockaddr *pSystemSockAddr = 0; 1491 int AddrLen = 0; 1492 if( SenderAddr ) 1493 { 1494 AddrLen = sizeof( struct sockaddr ); 1495 pSystemSockAddr = &(SenderAddr->m_sockaddr); 1496 } 1497 1498 if (pSocket == NULL) /* ENOTSOCK */ 1499 return osl_Socket_Error; 1500 1501 return recvfrom(pSocket->m_Socket, 1502 (sal_Char*)pBuffer, 1503 BufferSize, 1504 MSG_FLAG_TO_NATIVE(Flag), 1505 pSystemSockAddr, 1506 &AddrLen); 1507 } 1508 1509 /*****************************************************************************/ 1510 /* osl_sendSocket */ 1511 /*****************************************************************************/ 1512 sal_Int32 SAL_CALL osl_sendSocket ( 1513 oslSocket pSocket, 1514 const void* pBuffer, 1515 sal_uInt32 BytesToSend, 1516 oslSocketMsgFlag Flag) 1517 { 1518 if (pSocket == NULL) /* ENOTSOCK */ 1519 return osl_Socket_Error; 1520 1521 return send(pSocket->m_Socket, 1522 (sal_Char*)pBuffer, 1523 BytesToSend, 1524 MSG_FLAG_TO_NATIVE(Flag)); 1525 } 1526 1527 /*****************************************************************************/ 1528 /* osl_sendToSocket */ 1529 /*****************************************************************************/ 1530 sal_Int32 SAL_CALL osl_sendToSocket ( 1531 oslSocket pSocket, 1532 oslSocketAddr ReceiverAddr, 1533 const void* pBuffer, 1534 sal_uInt32 BytesToSend, 1535 oslSocketMsgFlag Flag) 1536 { 1537 if (pSocket == NULL) /* ENOTSOCK */ 1538 return osl_Socket_Error; 1539 1540 /* ReceiverAddr might be 0 when used on a connected socket. */ 1541 /* Then sendto should behave like send. */ 1542 1543 struct sockaddr *pSystemSockAddr = 0; 1544 if( ReceiverAddr ) 1545 pSystemSockAddr = &(ReceiverAddr->m_sockaddr); 1546 1547 return sendto(pSocket->m_Socket, 1548 (sal_Char*)pBuffer, 1549 BytesToSend, 1550 MSG_FLAG_TO_NATIVE(Flag), 1551 pSystemSockAddr, 1552 pSystemSockAddr == 0 ? 0 : sizeof(struct sockaddr)); 1553 } 1554 1555 /*****************************************************************************/ 1556 /* osl_readSocket */ 1557 /*****************************************************************************/ 1558 sal_Int32 SAL_CALL osl_readSocket( oslSocket pSocket, void *pBuffer, sal_Int32 n ) 1559 { 1560 sal_uInt8 * Ptr = (sal_uInt8 *)pBuffer; 1561 1562 OSL_ASSERT( pSocket); 1563 1564 /* loop until all desired bytes were read or an error occured */ 1565 sal_uInt32 BytesRead= 0; 1566 sal_uInt32 BytesToRead= n; 1567 while (BytesToRead > 0) 1568 { 1569 sal_Int32 RetVal; 1570 RetVal= osl_receiveSocket(pSocket, 1571 Ptr, 1572 BytesToRead, 1573 osl_Socket_MsgNormal); 1574 1575 /* error occured? */ 1576 if(RetVal <= 0) 1577 { 1578 break; 1579 } 1580 1581 BytesToRead -= RetVal; 1582 BytesRead += RetVal; 1583 Ptr += RetVal; 1584 } 1585 1586 return BytesRead; 1587 } 1588 1589 /*****************************************************************************/ 1590 /* osl_writeSocket */ 1591 /*****************************************************************************/ 1592 sal_Int32 SAL_CALL osl_writeSocket( oslSocket pSocket, const void *pBuffer, sal_Int32 n ) 1593 { 1594 OSL_ASSERT( pSocket ); 1595 1596 /* loop until all desired bytes were send or an error occured */ 1597 sal_uInt32 BytesSend= 0; 1598 sal_uInt32 BytesToSend= n; 1599 sal_uInt8 *Ptr = ( sal_uInt8 * )pBuffer; 1600 while (BytesToSend > 0) 1601 { 1602 sal_Int32 RetVal; 1603 1604 RetVal= osl_sendSocket( pSocket,Ptr,BytesToSend,osl_Socket_MsgNormal); 1605 1606 /* error occured? */ 1607 if(RetVal <= 0) 1608 { 1609 break; 1610 } 1611 1612 BytesToSend -= RetVal; 1613 BytesSend += RetVal; 1614 Ptr += RetVal; 1615 1616 } 1617 return BytesSend; 1618 } 1619 1620 1621 /*****************************************************************************/ 1622 /* osl_isReceiveReady */ 1623 /*****************************************************************************/ 1624 sal_Bool SAL_CALL osl_isReceiveReady ( 1625 oslSocket pSocket, 1626 const TimeValue* pTimeout) 1627 { 1628 fd_set fds; 1629 struct timeval tv; 1630 1631 if (pSocket == NULL) /* ENOTSOCK */ 1632 return sal_False; 1633 1634 FD_ZERO(&fds); 1635 FD_SET(pSocket->m_Socket, &fds); 1636 1637 if (pTimeout) 1638 { 1639 tv.tv_sec = pTimeout->Seconds; 1640 tv.tv_usec = pTimeout->Nanosec / 1000L; 1641 } 1642 1643 return (select(pSocket->m_Socket + 1, /* no of sockets to monitor */ 1644 &fds, /* check read operations */ 1645 0, /* check write ops */ 1646 0, /* ckeck for OOB */ 1647 (pTimeout) ? &tv : 0)==1); /* use timeout? */ 1648 } 1649 1650 /*****************************************************************************/ 1651 /* osl_isSendReady */ 1652 /*****************************************************************************/ 1653 sal_Bool SAL_CALL osl_isSendReady ( 1654 oslSocket pSocket, 1655 const TimeValue* pTimeout) 1656 { 1657 fd_set fds; 1658 struct timeval tv; 1659 1660 if (pSocket == NULL) /* ENOTSOCK */ 1661 return sal_False; 1662 1663 FD_ZERO(&fds); 1664 FD_SET(pSocket->m_Socket, &fds); 1665 1666 if (pTimeout) 1667 { 1668 tv.tv_sec = pTimeout->Seconds; 1669 tv.tv_usec = pTimeout->Nanosec / 1000L; 1670 } 1671 1672 return (select(pSocket->m_Socket + 1, /* no of sockets to monitor */ 1673 0, /* check read operations */ 1674 &fds, /* check write ops */ 1675 0, /* ckeck for OOB */ 1676 (pTimeout) ? &tv : 0)==1); /* use timeout? */ 1677 } 1678 1679 /*****************************************************************************/ 1680 /* osl_isExceptionPending */ 1681 /*****************************************************************************/ 1682 sal_Bool SAL_CALL osl_isExceptionPending ( 1683 oslSocket pSocket, 1684 const TimeValue* pTimeout) 1685 { 1686 fd_set fds; 1687 struct timeval tv; 1688 1689 if (pSocket == NULL) /* ENOTSOCK */ 1690 return sal_False; 1691 1692 FD_ZERO(&fds); 1693 FD_SET(pSocket->m_Socket, &fds); 1694 1695 if (pTimeout) 1696 { 1697 tv.tv_sec = pTimeout->Seconds; 1698 tv.tv_usec = pTimeout->Nanosec / 1000L; 1699 } 1700 1701 return (select(pSocket->m_Socket + 1, /* no of sockets to monitor */ 1702 0, /* check read operations */ 1703 0, /* check write ops */ 1704 &fds, /* ckeck for OOB */ 1705 (pTimeout) ? &tv : 0)==1); /* use timeout? */ 1706 } 1707 1708 /*****************************************************************************/ 1709 /* osl_shutdownSocket */ 1710 /*****************************************************************************/ 1711 sal_Bool SAL_CALL osl_shutdownSocket ( 1712 oslSocket pSocket, 1713 oslSocketDirection Direction) 1714 { 1715 if (pSocket == NULL) /* ENOTSOCK */ 1716 return sal_False; 1717 1718 return (shutdown(pSocket->m_Socket, DIRECTION_TO_NATIVE(Direction))==0); 1719 } 1720 1721 /*****************************************************************************/ 1722 /* osl_getSocketOption */ 1723 /*****************************************************************************/ 1724 sal_Int32 SAL_CALL osl_getSocketOption ( 1725 oslSocket pSocket, 1726 oslSocketOptionLevel Level, 1727 oslSocketOption Option, 1728 void* pBuffer, 1729 sal_uInt32 BufferLen) 1730 { 1731 if (pSocket == NULL) /* ENOTSOCK */ 1732 return osl_Socket_Error; 1733 1734 if (getsockopt(pSocket->m_Socket, 1735 OPTION_LEVEL_TO_NATIVE(Level), 1736 OPTION_TO_NATIVE(Option), 1737 (sal_Char*)pBuffer, 1738 (int*)&BufferLen) == -1) 1739 { 1740 return -1; 1741 } 1742 1743 return (sal_Int32)BufferLen; 1744 } 1745 1746 /*****************************************************************************/ 1747 /* osl_setSocketOption */ 1748 /*****************************************************************************/ 1749 sal_Bool SAL_CALL osl_setSocketOption ( 1750 oslSocket pSocket, 1751 oslSocketOptionLevel Level, 1752 oslSocketOption Option, 1753 void* pBuffer, 1754 sal_uInt32 BufferLen) 1755 { 1756 if (pSocket == NULL) /* ENOTSOCK */ 1757 return sal_False; 1758 1759 return(setsockopt(pSocket->m_Socket, 1760 OPTION_LEVEL_TO_NATIVE(Level), 1761 OPTION_TO_NATIVE(Option), 1762 (sal_Char*)pBuffer, 1763 BufferLen) == 0); 1764 } 1765 1766 /*****************************************************************************/ 1767 /* osl_enableNonBlockingMode */ 1768 /*****************************************************************************/ 1769 sal_Bool SAL_CALL osl_enableNonBlockingMode ( oslSocket pSocket, sal_Bool On) 1770 { 1771 unsigned long Param= On ? 1 : 0; 1772 1773 if (pSocket == NULL) /* ENOTSOCK */ 1774 return sal_False; 1775 1776 pSocket->m_Flags = Param ? 1777 (pSocket->m_Flags | OSL_SOCKET_FLAGS_NONBLOCKING) : 1778 (pSocket->m_Flags & ~OSL_SOCKET_FLAGS_NONBLOCKING) ; 1779 1780 return ( 1781 ioctlsocket(pSocket->m_Socket, FIONBIO, &Param) != OSL_SOCKET_ERROR); 1782 } 1783 1784 /*****************************************************************************/ 1785 /* osl_isNonBlockingMode */ 1786 /*****************************************************************************/ 1787 sal_Bool SAL_CALL osl_isNonBlockingMode(oslSocket pSocket) 1788 { 1789 if (pSocket == NULL) /* ENOTSOCK */ 1790 return sal_False; 1791 1792 return (sal_Bool)((pSocket->m_Flags & OSL_SOCKET_FLAGS_NONBLOCKING) != 0); 1793 } 1794 1795 /*****************************************************************************/ 1796 /* osl_getSocketType */ 1797 /*****************************************************************************/ 1798 oslSocketType SAL_CALL osl_getSocketType(oslSocket pSocket) 1799 { 1800 int Type=0; 1801 int TypeSize= sizeof(Type); 1802 1803 if (pSocket == NULL) /* ENOTSOCK */ 1804 return osl_Socket_TypeInvalid; 1805 1806 if(getsockopt(pSocket->m_Socket, 1807 OPTION_LEVEL_TO_NATIVE(osl_Socket_LevelSocket), 1808 OPTION_TO_NATIVE(osl_Socket_OptionType), 1809 (sal_Char *)&Type, 1810 &TypeSize) == -1) 1811 { 1812 /* error */ 1813 return osl_Socket_TypeInvalid; 1814 } 1815 1816 return TYPE_FROM_NATIVE(Type); 1817 } 1818 1819 /*****************************************************************************/ 1820 /* osl_getLastSocketErrorDescription */ 1821 /*****************************************************************************/ 1822 void SAL_CALL osl_getLastSocketErrorDescription ( 1823 oslSocket /*Socket*/, 1824 rtl_uString **strError) 1825 { 1826 int error; 1827 1828 switch(error = WSAGetLastError()) 1829 { 1830 case WSAENOTSOCK: 1831 rtl_uString_newFromAscii (strError, "WSAENOTSOCK, Socket operation on non-socket. A socket created in one process is used by another process."); 1832 break; 1833 1834 case WSAEDESTADDRREQ: 1835 rtl_uString_newFromAscii (strError, "WSAEDESTADDRREQ, Destination Addr required"); 1836 break; 1837 1838 case WSAEMSGSIZE: 1839 rtl_uString_newFromAscii (strError, "WSAEMSGSIZE, Message too long"); 1840 break; 1841 1842 case WSAEPROTOTYPE: 1843 rtl_uString_newFromAscii (strError, "WSAEPROTOTYPE, Protocol wrong type for socket"); 1844 break; 1845 1846 case WSAENOPROTOOPT: 1847 rtl_uString_newFromAscii (strError, "WSAENOPROTOOPT, Protocol not available"); 1848 break; 1849 1850 case WSAEPROTONOSUPPORT: 1851 rtl_uString_newFromAscii (strError, "WSAEPROTONOSUPPORT, Protocol not supported"); 1852 break; 1853 1854 case WSAESOCKTNOSUPPORT: 1855 rtl_uString_newFromAscii (strError, "WSAESOCKTNOSUPPORT, Socket type not supported"); 1856 break; 1857 1858 case WSAEOPNOTSUPP: 1859 rtl_uString_newFromAscii (strError, "WSAEOPNOTSUPP, Operation not supported on socket"); 1860 break; 1861 1862 case WSAEPFNOSUPPORT: 1863 rtl_uString_newFromAscii (strError, "WSAEPFNOSUPPORT, Protocol family not supported"); 1864 break; 1865 1866 case WSAEAFNOSUPPORT: 1867 rtl_uString_newFromAscii (strError, "WSEAFNOSUPPORT, Addr family not supported by protocol family"); 1868 break; 1869 1870 case WSAEADDRINUSE: 1871 rtl_uString_newFromAscii (strError, "WSAEADDRINUSE, Triggered by bind() because a process went down without closing a socket."); 1872 break; 1873 1874 case WSAEADDRNOTAVAIL: 1875 rtl_uString_newFromAscii (strError, "WSAEADDRNOTAVAIL, Can't assign requested Addr"); 1876 break; 1877 1878 case WSAENETDOWN: 1879 rtl_uString_newFromAscii (strError, "WSAENETDOWN, Network is down"); 1880 break; 1881 1882 case WSAENETUNREACH: 1883 rtl_uString_newFromAscii (strError, "WSAENETUNREACH, Network is unreachable"); 1884 break; 1885 1886 case WSAENETRESET: 1887 rtl_uString_newFromAscii (strError, "WSAENETRESET, Network dropped connection or reset"); 1888 break; 1889 1890 case WSAECONNABORTED: 1891 rtl_uString_newFromAscii (strError, "WSAECONNABORTED, Software caused connection abort"); 1892 break; 1893 1894 case WSAECONNRESET: 1895 rtl_uString_newFromAscii (strError, "WSAECONNRESET, Connection reset by peer"); 1896 break; 1897 1898 case WSAENOBUFS: 1899 rtl_uString_newFromAscii (strError, "WSAENOBUFS, No buffer space available."); 1900 break; 1901 1902 case WSAEISCONN: 1903 rtl_uString_newFromAscii (strError, "WSAEISCONN, Socket is already connected"); 1904 break; 1905 1906 case WSAENOTCONN: 1907 rtl_uString_newFromAscii (strError, "WSAENOTCONN, Socket is not connected"); 1908 break; 1909 1910 case WSAESHUTDOWN: 1911 rtl_uString_newFromAscii (strError, "WSAESHUTDOWN, Can't send after socket shutdown"); 1912 break; 1913 1914 case WSAETIMEDOUT: 1915 rtl_uString_newFromAscii (strError, "WSAETIMEDOUT, Connection timed out"); 1916 break; 1917 1918 case WSAECONNREFUSED: 1919 rtl_uString_newFromAscii (strError, "WSAECONNREFUSED, Connection refused"); 1920 break; 1921 1922 case WSAEHOSTDOWN: 1923 rtl_uString_newFromAscii (strError, "WSAEHOSTDOWN, Networking subsystem not started"); 1924 break; 1925 1926 case WSAEHOSTUNREACH: 1927 rtl_uString_newFromAscii (strError, "WSAEHOSTUNREACH, No route to host"); 1928 break; 1929 1930 case WSAEWOULDBLOCK: 1931 rtl_uString_newFromAscii (strError, "WSAEWOULDBLOCK, Operation would block"); 1932 break; 1933 1934 case WSAEINPROGRESS: 1935 rtl_uString_newFromAscii (strError, "WSAEINPROGRESS, Operation now in progress"); 1936 break; 1937 1938 case WSAEALREADY: 1939 rtl_uString_newFromAscii (strError, "WSAEALREADY, Operation already in progress"); 1940 break; 1941 1942 case WSAEINTR: 1943 rtl_uString_newFromAscii (strError, "WSAEALREADY, Operation was interrupted"); 1944 break; 1945 1946 case WSAEBADF: 1947 rtl_uString_newFromAscii (strError, "WSAEBADF, Bad file number"); 1948 break; 1949 1950 case WSAEACCES: 1951 rtl_uString_newFromAscii (strError, "WSAEACCES, Access is denied"); 1952 break; 1953 1954 case WSAEFAULT: 1955 rtl_uString_newFromAscii (strError, "WSAEFAULT, Bad memory Addr"); 1956 break; 1957 1958 case WSAEINVAL: 1959 rtl_uString_newFromAscii (strError, "WSAEINVAL, The socket has not been bound with bind() or is already connected"); 1960 break; 1961 1962 case WSAEMFILE: 1963 rtl_uString_newFromAscii (strError, "WSAEMFILE, No more file descriptors are available"); 1964 break; 1965 1966 case WSAETOOMANYREFS: 1967 rtl_uString_newFromAscii (strError, "WSAETOOMANYREFS, Undocumented WinSock error"); 1968 break; 1969 1970 case WSAENAMETOOLONG: 1971 rtl_uString_newFromAscii (strError, "WSAENAMETOOLONG, Undocumented WinSock error"); 1972 break; 1973 1974 case WSAENOTEMPTY: 1975 rtl_uString_newFromAscii (strError, "WSAENOTEMPTY, Undocumented WinSock error"); 1976 break; 1977 1978 case WSAEPROCLIM: 1979 rtl_uString_newFromAscii (strError, "WSAEPROCLIM, Undocumented WinSock error"); 1980 break; 1981 1982 case WSAEUSERS: 1983 rtl_uString_newFromAscii (strError, "WSAEUSERS, Undocumented WinSock error"); 1984 break; 1985 1986 case WSAEDQUOT: 1987 rtl_uString_newFromAscii (strError, "WSAEDQUOT, Undocumented WinSock error"); 1988 break; 1989 1990 case WSAESTALE: 1991 rtl_uString_newFromAscii (strError, "WSAESTALE, Undocumented WinSock error"); 1992 break; 1993 1994 case WSAEREMOTE: 1995 rtl_uString_newFromAscii (strError, "WSAEREMOTE, Undocumented WinSock error"); 1996 break; 1997 1998 case WSAEDISCON: 1999 rtl_uString_newFromAscii (strError, "WSAEDISCON, Circuit was gracefully terminated"); 2000 break; 2001 2002 case WSASYSNOTREADY: 2003 rtl_uString_newFromAscii (strError, "WSASYSNOTREADY, The underlying network subsystem is not ready for network communication"); 2004 break; 2005 2006 case WSAVERNOTSUPPORTED: 2007 rtl_uString_newFromAscii (strError, "WSAVERNOTSUPPORTED, The version of Windows Sockets API support requested is not provided by this particular Windows Sockets implementation"); 2008 break; 2009 2010 case WSANOTINITIALISED: 2011 rtl_uString_newFromAscii (strError, "WSANOTINITIALISED, WSAStartup() has not been called"); 2012 break; 2013 2014 case WSAHOST_NOT_FOUND: 2015 rtl_uString_newFromAscii (strError, "WSAHOST_NOT_FOUND, Authoritative answer host not found"); 2016 break; 2017 2018 case WSATRY_AGAIN: 2019 rtl_uString_newFromAscii (strError, "WSATRY_AGAIN, Non-authoritative answer host not found or SERVERFAIL"); 2020 break; 2021 2022 case WSANO_RECOVERY: 2023 rtl_uString_newFromAscii (strError, "WSANO_RECOVERY, Non recoverable errors, FORMERR, REFUSED, NOTIMP"); 2024 break; 2025 2026 case WSANO_DATA: 2027 rtl_uString_newFromAscii (strError, "WSANO_DATA or WSANO_ADDRESS, Valid name, no data record of requested type"); 2028 break; 2029 2030 default: 2031 { 2032 sal_Unicode message[128]; 2033 2034 wsprintfW(reinterpret_cast<LPWSTR>(message), L"Unknown WinSock Error Number %d", error); 2035 rtl_uString_newFromStr (strError, message); 2036 } 2037 2038 return; 2039 2040 } 2041 } 2042 2043 /*****************************************************************************/ 2044 /* osl_getLastSocketError */ 2045 /*****************************************************************************/ 2046 oslSocketError SAL_CALL osl_getLastSocketError(oslSocket /*Socket*/) 2047 { 2048 return ERROR_FROM_NATIVE(WSAGetLastError()); 2049 } 2050 2051 /*****************************************************************************/ 2052 /* SocketSet */ 2053 /*****************************************************************************/ 2054 typedef struct _TSocketSetImpl 2055 { 2056 fd_set m_Set; /* the set of descriptors */ 2057 2058 } TSocketSetImpl; 2059 2060 /*****************************************************************************/ 2061 /* osl_createSocketSet */ 2062 /*****************************************************************************/ 2063 oslSocketSet SAL_CALL osl_createSocketSet() 2064 { 2065 TSocketSetImpl* pSet; 2066 2067 pSet = (TSocketSetImpl*) rtl_allocateMemory(sizeof(TSocketSetImpl)); 2068 2069 if(pSet) 2070 { 2071 FD_ZERO(&pSet->m_Set); 2072 } 2073 2074 return (oslSocketSet)pSet; 2075 } 2076 2077 /*****************************************************************************/ 2078 /* osl_destroySocketSet */ 2079 /*****************************************************************************/ 2080 void SAL_CALL osl_destroySocketSet (oslSocketSet Set) 2081 { 2082 if(Set) 2083 rtl_freeMemory(Set); 2084 } 2085 2086 /*****************************************************************************/ 2087 /* osl_clearSocketSet */ 2088 /*****************************************************************************/ 2089 void SAL_CALL osl_clearSocketSet (oslSocketSet Set) 2090 { 2091 TSocketSetImpl* pSet; 2092 2093 pSet= (TSocketSetImpl*)Set; 2094 2095 if (pSet) 2096 FD_ZERO(&pSet->m_Set); 2097 } 2098 2099 /*****************************************************************************/ 2100 /* osl_addToSocketSet */ 2101 /*****************************************************************************/ 2102 void SAL_CALL osl_addToSocketSet ( 2103 oslSocketSet Set, 2104 oslSocket Socket) 2105 { 2106 TSocketSetImpl* pSet; 2107 oslSocketImpl* pSockImpl; 2108 2109 pSet= (TSocketSetImpl*)Set; 2110 pSockImpl= (oslSocketImpl*)Socket; 2111 2112 if (pSet && pSockImpl) 2113 FD_SET(pSockImpl->m_Socket, &pSet->m_Set); 2114 } 2115 2116 /*****************************************************************************/ 2117 /* osl_removeFromSocketSet */ 2118 /*****************************************************************************/ 2119 void SAL_CALL osl_removeFromSocketSet ( 2120 oslSocketSet Set, 2121 oslSocket Socket) 2122 { 2123 TSocketSetImpl* pSet; 2124 oslSocketImpl* pSockImpl; 2125 2126 pSet= (TSocketSetImpl*)Set; 2127 pSockImpl= (oslSocketImpl*)Socket; 2128 2129 if (pSet && pSockImpl) 2130 FD_CLR(pSockImpl->m_Socket, &pSet->m_Set); 2131 } 2132 2133 /*****************************************************************************/ 2134 /* osl_isInSocketSet */ 2135 /*****************************************************************************/ 2136 sal_Bool SAL_CALL osl_isInSocketSet ( 2137 oslSocketSet Set, 2138 oslSocket Socket) 2139 { 2140 TSocketSetImpl* pSet; 2141 oslSocketImpl* pSockImpl; 2142 2143 pSet= (TSocketSetImpl*)Set; 2144 pSockImpl= (oslSocketImpl*)Socket; 2145 2146 if (pSet && pSockImpl) 2147 return (FD_ISSET(pSockImpl->m_Socket, &pSet->m_Set) != 0); 2148 else 2149 return sal_False; 2150 } 2151 2152 /*****************************************************************************/ 2153 /* osl_demultiplexSocketEvents */ 2154 /*****************************************************************************/ 2155 sal_Int32 SAL_CALL osl_demultiplexSocketEvents ( 2156 oslSocketSet IncomingSet, 2157 oslSocketSet OutgoingSet, 2158 oslSocketSet OutOfBandSet, 2159 const TimeValue* pTimeout) 2160 { 2161 int MaxHandle= 0; 2162 struct timeval tv; 2163 TSocketSetImpl* pInSet; 2164 TSocketSetImpl* pOutSet; 2165 TSocketSetImpl* pOOBSet; 2166 2167 if(pTimeout) 2168 { 2169 /* divide milliseconds into seconds and microseconds */ 2170 tv.tv_sec = pTimeout->Seconds; 2171 tv.tv_usec = pTimeout->Nanosec / 1000L; 2172 } 2173 2174 /* map opaque data to impl-types */ 2175 pInSet= (TSocketSetImpl*)IncomingSet; 2176 pOutSet= (TSocketSetImpl*)OutgoingSet; 2177 pOOBSet= (TSocketSetImpl*)OutOfBandSet; 2178 2179 return select(MaxHandle, /* redundant in WIN32 */ 2180 pInSet ? &pInSet->m_Set : 0, 2181 pOutSet ? &pOutSet->m_Set : 0, 2182 pOOBSet ? &pOOBSet->m_Set : 0, 2183 pTimeout ? &tv : 0); 2184 } 2185 2186 } 2187