OpenSG: OSGSocket.cpp Source File

00001 /*---------------------------------------------------------------------------*\
00002  *                                OpenSG                                     *
00003  *                                                                           *
00004  *                                                                           *
00005  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
00006  *                                                                           *
00007  *                            www.opensg.org                                 *
00008  *                                                                           *
00009  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
00010  *                                                                           *
00011 \*---------------------------------------------------------------------------*/
00012 /*---------------------------------------------------------------------------*\
00013  *                                License                                    *
00014  *                                                                           *
00015  * This library is free software; you can redistribute it and/or modify it   *
00016  * under the terms of the GNU Library General Public License as published    *
00017  * by the Free Software Foundation, version 2.                               *
00018  *                                                                           *
00019  * This library is distributed in the hope that it will be useful, but       *
00020  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
00021  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
00022  * Library General Public License for more details.                          *
00023  *                                                                           *
00024  * You should have received a copy of the GNU Library General Public         *
00025  * License along with this library; if not, write to the Free Software       *
00026  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
00027  *                                                                           *
00028 \*---------------------------------------------------------------------------*/
00029 /*---------------------------------------------------------------------------*\
00030  *                                Changes                                    *
00031  *                                                                           *
00032  *                                                                           *
00033  *                                                                           *
00034  *                                                                           *
00035  *                                                                           *
00036  *                                                                           *
00037 \*---------------------------------------------------------------------------*/
00038 
00039 //---------------------------------------------------------------------------
00040 //  Includes
00041 //---------------------------------------------------------------------------
00042 
00043 #if defined(__sun)
00044 #define BSD_COMP
00045 #endif
00046 
00047 #include "OSGConfig.h"
00048 
00049 #include <sys/types.h>
00050 #ifdef WIN32
00051 #ifdef WIN32_LEAN_AND_MEAN
00052 #include <winsock2.h>  
00053 #endif
00054 #include <io.h>
00055 #else
00056 #include <sys/socket.h>
00057 #include <netinet/in.h>
00058 #include <netinet/tcp.h>
00059 #include <arpa/inet.h>
00060 #include <netdb.h>
00061 #include <unistd.h>
00062 #include <fcntl.h>
00063 #include <sys/time.h>
00064 #include <sys/ioctl.h>
00065 #endif
00066 #include <errno.h>
00067 #include <stdio.h>
00068 #include <math.h>
00069 #include <map>
00070 #include <OSGBase.h>
00071 #include <OSGBaseFunctions.h>
00072 #include <OSGSocketAddress.h>
00073 #include <OSGSocket.h>
00074 #include <OSGSocketSelection.h>
00075 #include <OSGNetworkMessage.h>
00076 
00077 OSG_USING_NAMESPACE
00078 
00098 int Socket::initialized=0;
00099 
00100 /*-------------------------------------------------------------------------*/
00101 /*                            constructor destructor                       */
00102 
00108 Socket::Socket(void):
00109     _sd(-1)
00110 {
00111     if(!initialized)
00112     {
00113         initialized=1;
00114 #ifdef WIN32
00115         WSADATA wsaData;
00116         
00117         WORD wVersionRequested = MAKEWORD( 2, 2 ); 
00118         if(WSAStartup( wVersionRequested, &wsaData )!=0)
00119         {
00120             throw SocketError("WSAStartup()");
00121         }
00122 #endif
00123     }
00124 }
00125 
00128 Socket::Socket(const Socket &source):
00129     _sd(source._sd)
00130 {
00131 }
00132 
00136 Socket::~Socket()
00137 {
00138 }
00139 
00140 /*-------------------------------------------------------------------------*/
00141 /*                        open, close, connect                             */
00142 
00153 void Socket::bind(const SocketAddress &address)
00154 {
00155     SocketAddress result=address;
00156     
00157     if( ::bind(_sd,
00158                result.getSockAddr(),
00159                result.getSockAddrSize()) < 0)
00160     {
00161         if(getError() ==
00162 #if defined WIN32
00163             WSAEADDRINUSE 
00164 #else
00165             EADDRINUSE
00166 #endif
00167         )
00168         {
00169             throw SocketInUse("bind()");
00170         }
00171         else
00172         {
00173             throw SocketError("bind()");
00174         }
00175     }
00176 }
00177 
00180 void Socket::listen(int maxPending)
00181 {
00182     if(::listen(_sd,maxPending)<0)
00183     {
00184         throw SocketError("listen()");
00185     }
00186 }
00187 
00191 void Socket::connect(const SocketAddress &address)
00192 {
00193     if( ::connect(_sd,
00194                   address.getSockAddr(),
00195                   address.getSockAddrSize()) )
00196     {
00197         throw SocketError("connect()");
00198     }
00199 }
00200 
00201 /*-------------------------------------------------------------------------*/
00202 /*                        read, write    nnect                             */
00203 
00209 int Socket::recv(void *buf,int size)
00210 {
00211     int readSize;
00212     int pos=0;
00213 
00214     while(size)
00215     {
00216         readSize=::recv(_sd,((char*)buf) + pos,size,0);
00217         if(readSize < 0)
00218         {
00219 #if defined WIN32
00220             if(getError() == WSAECONNRESET)
00221             {
00222                 throw SocketConnReset("recv");
00223             }
00224             if(getError() == WSAEMSGSIZE)
00225             {
00226                 readSize=size;
00227             }
00228             else
00229 #endif
00230             throw SocketError("recv()");
00231         }
00232         if(readSize == 0)
00233         {
00234             return 0;
00235         }
00236         size-=readSize;
00237         pos +=readSize;
00238     }
00239     return pos;
00240 }
00241 
00246 int Socket::recvAvailable(void *buf,int size)
00247 {
00248     int len;
00249 
00250 #ifndef WIN32
00251     do
00252     {
00253 #endif
00254         len=::recv(_sd,(char*)buf,size,0);
00255 #ifndef WIN32
00256     } 
00257     while(len < 0 && errno == EAGAIN);
00258 #endif
00259     if(len==-1)
00260     {
00261 #if defined WIN32
00262         switch(getError())
00263         {
00264         case WSAECONNRESET:
00265             throw SocketConnReset("recvAvailable()");
00266             break;
00267         case WSAEMSGSIZE:
00268             len=size;
00269             break;
00270         default:
00271             throw SocketError("recv()");
00272         }
00273 #else
00274         throw SocketError("recv()");
00275 #endif
00276     }
00277     return len;
00278 }
00279 
00283 int Socket::recv(NetworkMessage &msg)
00284 {
00285     NetworkMessage::Header hdr;
00286     peek(&hdr,sizeof(hdr));
00287     msg.setSize(osgntohl(hdr.size));
00288     return recv(msg.getBuffer(),msg.getSize());
00289 }
00290 
00298 int Socket::peek(void *buf,int size)
00299 {
00300     int readSize;
00301     int pos=0;
00302 
00303     do
00304     {
00305         readSize=::recv(_sd,((char*)buf)+pos,size,MSG_PEEK);
00306         if(readSize<0)
00307         {
00308 #if defined WIN32
00309             if(getError() == WSAECONNRESET)
00310             {
00311                 throw SocketConnReset("peek");
00312             }
00313             if(getError() == WSAEMSGSIZE)
00314             {
00315                 readSize=size;
00316             }
00317             else
00318 #endif
00319                 throw SocketError("peek");
00320         }
00321         if(readSize == 0)
00322         {
00323             return 0;
00324         }
00325     }
00326     while(readSize != size);
00327     return readSize;
00328 }
00329 
00333 int Socket::send(const void *buf,int size)
00334 {
00335     int writeSize;
00336     int pos=0;
00337     while(size)
00338     {
00339 #if defined(WIN32) && defined(MSG_NOSIGNAL)
00340         writeSize=::send(_sd,((const char*)buf)+pos,size,MSG_NOSIGNAL);
00341 #else
00342         writeSize=::send(_sd,((const char*)buf)+pos,size,0);
00343 #endif
00344         if(writeSize == -1)
00345         {
00346             throw SocketError("send()");
00347         }
00348         if(writeSize == 0)
00349         {
00350             return 0;
00351         }
00352         size-=writeSize;
00353         pos+=writeSize;
00354     }
00355     return pos;
00356 }
00357 
00361 int Socket::send(NetworkMessage &msg)
00362 {
00363     NetworkMessage::Header &hdr=msg.getHeader();
00364     hdr.size=osghtonl(msg.getSize());
00365     return send(msg.getBuffer(),msg.getSize());
00366 }
00367 
00368 /*-------------------------------------------------------------------------*/
00369 /*                        socket state access                              */
00370 
00377 void Socket::setReusePort(bool value)
00378 {
00379     int v=(int)value;
00380 #ifdef SO_REUSEPORT
00381     ::setsockopt(_sd,SOL_SOCKET,SO_REUSEPORT,(SocketOptT*)&v,sizeof(v));
00382 #endif
00383     ::setsockopt(_sd,SOL_SOCKET,SO_REUSEADDR,(SocketOptT*)&v,sizeof(v));
00384 }
00385 
00394 void Socket::setBlocking(bool value)
00395 {
00396 #ifndef WIN32
00397     int val=0;
00398     
00399     if(value==false)
00400         val=O_NDELAY;
00401     if (fcntl(_sd, F_GETFL, &val) < 0) 
00402     {
00403         throw SocketError("fcntl()");
00404     }    
00405     val|=O_NDELAY;
00406     if(value)
00407     {
00408         val^=O_NDELAY;
00409     }
00410     if (fcntl(_sd, F_SETFL, val) < 0) 
00411     {
00412         throw SocketError("fcntl()");
00413     }    
00414 #else
00415     u_long ulVal = !value;
00416     if( (ioctlsocket(_sd, FIONBIO, &ulVal)) != 0) 
00417     {
00418         throw SocketError("ioctlsocket()");
00419     }    
00420 #endif
00421 }
00422 
00426 SocketAddress Socket::getAddress()
00427 {
00428     SocketAddress result;
00429     SocketLenT len;
00430 
00431     len=result.getSockAddrSize();
00432     if( ::getsockname(_sd,result.getSockAddr(),&len) < 0)
00433     {
00434         throw SocketError("getsockname()");
00435     }
00436     return result;
00437 }
00438 
00442 void Socket::setReadBufferSize(int size)
00443 {
00444     int v=(int)size;
00445     ::setsockopt(_sd,SOL_SOCKET,SO_RCVBUF,(SocketOptT*)&v,sizeof(v));
00446 }
00447 
00451 void Socket::setWriteBufferSize(int size)
00452 {
00453     int v=(int)size;
00454     ::setsockopt(_sd,SOL_SOCKET,SO_SNDBUF,(SocketOptT*)&v,sizeof(v));
00455 }
00456 
00460 int Socket::getReadBufferSize() 
00461 {
00462     int v;
00463     SocketLenT len=sizeof(v);
00464     ::getsockopt(_sd,SOL_SOCKET,SO_RCVBUF,(SocketOptT*)&v,&len);
00465     return v;
00466 }
00467 
00471 int Socket::getWriteBufferSize() 
00472 {
00473     int v;
00474     SocketLenT len=sizeof(v);
00475     ::getsockopt(_sd,SOL_SOCKET,SO_SNDBUF,(SocketOptT*)&v,&len);
00476     return v;
00477 }
00478 
00481 int Socket::getAvailable(void)
00482 {
00483 #ifndef WIN32
00484     int value;
00485     if(::ioctl(_sd, FIONREAD, &value)<0)
00486     {    
00487         throw SocketError("ioctl()");
00488     }
00489     return value;
00490 #else
00491     u_long ulVal;
00492     if( (ioctlsocket(_sd, FIONREAD, &ulVal)) != 0) 
00493     {    
00494         throw SocketError("ioctlsocket()");
00495     }
00496     return (int)ulVal;
00497 #endif
00498 }
00499 
00503 bool Socket::waitReadable(double duration)
00504 {
00505     SocketSelection selection;
00506     selection.setRead(*this);
00507     if(selection.select(duration)==1)
00508         return true;
00509     else
00510         return false;
00511 }
00512 
00516 bool Socket::waitWritable(double duration)
00517 {
00518     SocketSelection selection;
00519     selection.setWrite(*this);
00520     if(selection.select(duration)==1)
00521         return true;
00522     else
00523         return false;
00524 }
00525 
00528 const Socket & Socket::operator =(const Socket &source)
00529 {
00530     _sd=source._sd;
00531     return *this;
00532 }
00533 
00534 /*-------------------------------------------------------------------------*/
00535 /*                              error information                          */
00536 
00539 int Socket::getError(void)
00540 {
00541 #ifdef WIN32
00542     return WSAGetLastError();
00543 #else
00544     return errno;
00545 #endif
00546 }
00547 
00550 int Socket::getHostError(void)
00551 {
00552 #ifdef WIN32
00553     return WSAGetLastError();
00554 #else
00555     return h_errno;
00556 #endif
00557 }
00558 
00561 std::string Socket::getErrorStr(void)
00562 {
00563     const char *err=NULL;
00564 
00565 #ifdef WIN32
00566     switch(getError())
00567     {
00568         case WSAEINTR: err= "WSAEINTR"; break;
00569         case WSAEBADF: err= "WSAEBADF"; break;
00570         case WSAEFAULT: err= "WSAEFAULT"; break; 
00571         case WSAEINVAL: err= "WSAEINVAL"; break; 
00572         case WSAEMFILE: err= "WSAEMFILE"; break; 
00573         case WSAEWOULDBLOCK: err= "WSAEWOULDBLOCK"; break; 
00574         case WSAEINPROGRESS: err= "WSAEINPROGRESS"; break; 
00575         case WSAEALREADY: err= "WSAEALREADY"; break; 
00576         case WSAENOTSOCK: err= "WSAENOTSOCK"; break; 
00577         case WSAEDESTADDRREQ: err= "WSAEDESTADDRREQ"; break; 
00578         case WSAEMSGSIZE: err= "WSAEMSGSIZE"; break; 
00579         case WSAEPROTOTYPE: err= "WSAEPROTOTYPE"; break; 
00580         case WSAENOPROTOOPT: err= "WSAENOPROTOOPT"; break; 
00581         case WSAEPROTONOSUPPORT: err= "WSAEPROTONOSUPPORT"; break; 
00582         case WSAESOCKTNOSUPPORT: err= "WSAESOCKTNOSUPPORT"; break; 
00583         case WSAEOPNOTSUPP: err= "WSAEOPNOTSUPP"; break; 
00584         case WSAEPFNOSUPPORT: err= "WSAEPFNOSUPPORT"; break; 
00585         case WSAEAFNOSUPPORT: err= "WSAEAFNOSUPPORT"; break; 
00586         case WSAEADDRINUSE: err= "WSAEADDRINUSE"; break; 
00587         case WSAEADDRNOTAVAIL: err= "WSAEADDRNOTAVAIL"; break; 
00588         case WSAENETDOWN: err= "WSAENETDOWN"; break; 
00589         case WSAENETUNREACH: err= "WSAENETUNREACH"; break; 
00590         case WSAENETRESET: err= "WSAENETRESET"; break; 
00591         case WSAECONNABORTED: err= "WSAECONNABORTED"; break; 
00592         case WSAECONNRESET: err= "WSAECONNRESET"; break; 
00593         case WSAENOBUFS: err= "WSAENOBUFS"; break; 
00594         case WSAEISCONN: err= "WSAEISCONN"; break; 
00595         case WSAENOTCONN: err= "WSAENOTCONN"; break; 
00596         case WSAESHUTDOWN: err= "WSAESHUTDOWN"; break; 
00597         case WSAETOOMANYREFS: err= "WSAETOOMANYREFS"; break; 
00598         case WSAETIMEDOUT: err= "WSAETIMEDOUT"; break; 
00599         case WSAECONNREFUSED: err= "WSAECONNREFUSED"; break; 
00600         case WSAELOOP: err= "WSAELOOP"; break; 
00601         case WSAENAMETOOLONG: err= "WSAENAMETOOLONG"; break; 
00602         case WSAEHOSTDOWN: err= "WSAEHOSTDOWN"; break; 
00603         case WSAEHOSTUNREACH: err= "WSAEHOSTUNREACH"; break; 
00604         case WSASYSNOTREADY: err= "WSASYSNOTREADY"; break; 
00605         case WSAVERNOTSUPPORTED: err= "WSAVERNOTSUPPORTED"; break; 
00606         case WSANOTINITIALISED: err= "WSANOTINITIALISED"; break; 
00607         case WSAHOST_NOT_FOUND: err= "WSAHOST_NOT_FOUND"; break; 
00608         case WSATRY_AGAIN: err= "WSATRY_AGAIN"; break; 
00609         case WSANO_RECOVERY: err= "WSANO_RECOVERY"; break; 
00610         case WSANO_DATA: err= "WSANO_DATA"; break; 
00611     }
00612 #else
00613     err=strerror(getError());
00614 #endif
00615     if(err)
00616         return std::string(err);
00617     else
00618         return std::string("Unknown error");
00619 }
00620 
00623 std::string Socket::getHostErrorStr(void)
00624 {
00625     const char *err;
00626 #if defined(WIN32) || defined(__hpux)
00627     err = strerror(getHostError());
00628 #else
00629     err = hstrerror(getHostError());
00630 #endif
00631     if(err)
00632         return std::string(err);
00633     else
00634         return std::string("Unknown error");
00635 }
00636 
00637 /*-------------------------------------------------------------------------*/
00638 /*                              cvs id's                                   */
00639 
00640 #ifdef __sgi
00641 #pragma set woff 1174
00642 #endif
00643 
00644 #ifdef OSG_LINUX_ICC
00645 #pragma warning( disable : 177 )
00646 #endif
00647 
00648 namespace
00649 {
00650     static Char8 cvsid_cpp       [] = "@(#)$Id: $";
00651     static Char8 cvsid_hpp       [] = OSG_SOCKET_HEADER_CVSID;
00652 }
00653