Homepage
Demos
Overview
Downloads
Dev. Resources
Reference
Credits

Socket.cc

Go to the documentation of this file.
00001 #include "Socket.h"
00002 #include <stdio.h>
00003 #include "Wireless.h"
00004 #ifndef PLATFORM_APERIOS
00005 #  include "IPC/Thread.h"
00006 #  include <sys/types.h>
00007 #  include <sys/socket.h>
00008 #  include <netinet/in.h>
00009 #  include <netdb.h>
00010 #  include <arpa/inet.h>
00011 #  include <fcntl.h>
00012 #endif
00013 #include "Shared/Config.h"
00014 #include <unistd.h>
00015 
00016 Socket* sout=NULL;
00017 Socket* serr=NULL;
00018 
00019 int Socket::setTransport(TransportType_t tr) {
00020 #ifdef PLATFORM_APERIOS
00021   trType=tr;
00022 #else
00023   if(trType==tr && endpoint!=-1)
00024     return 0;
00025   trType=tr;
00026   init();
00027 #endif
00028   return 0;
00029 }
00030 
00031 
00032 Socket::~Socket() {
00033 #ifndef PLATFORM_APERIOS
00034   if(endpoint!=-1)
00035     ::close ( endpoint );
00036   if(recvBuffer!=NULL)
00037     delete [] recvBuffer;
00038   if(sendBuffer!=NULL)
00039     delete [] sendBuffer;
00040 #endif
00041 }
00042 
00043 byte*
00044 Socket::getWriteBuffer(int bytesreq)
00045 {
00046 #ifndef PLATFORM_APERIOS
00047   wireless->getLock().lock();
00048 #endif
00049   if (sendBufSize-writeSize>=bytesreq
00050       && state==CONNECTION_CONNECTED)
00051     return writeData+writeSize;
00052   if (state!=CONNECTION_CONNECTED) {
00053     if(forwardSock!=NULL)
00054       return forwardSock->getWriteBuffer(bytesreq);
00055     if(textForward)
00056       return (byte*)(textForwardBuf=new char[bytesreq]);
00057   }
00058   return NULL;
00059 }
00060 
00061 void
00062 Socket::write(int size)
00063 {
00064   writeSize+=size;
00065   if(textForwardBuf) {
00066 		::write(STDOUT_FILENO,textForwardBuf,size);
00067     delete textForwardBuf;
00068     textForwardBuf=NULL;
00069   } else
00070     flush();
00071 #ifndef PLATFORM_APERIOS
00072   wireless->getLock().unlock();
00073 #endif
00074 }
00075 
00076 int
00077 Socket::read()
00078 {
00079   return -1;
00080 }
00081 
00082 byte*
00083 Socket::getReadBuffer()
00084 {
00085   return NULL;
00086 //  return readData+readSize;
00087 }
00088 
00089 void
00090 Socket::init()
00091 {
00092 #ifndef PLATFORM_APERIOS
00093   ThreadNS::Lock(wireless->getLock());
00094 #endif
00095   sendSize=0;
00096   writeSize=0;
00097   peer_addr=peer_port=-1;
00098 #ifndef PLATFORM_APERIOS
00099   if(endpoint!=-1)
00100     ::close(endpoint);
00101   endpoint = ::socket ( AF_INET,trType,0 );
00102   if(endpoint==-1) {
00103     perror("Socket::init(): socket()");
00104     return;
00105   }
00106   // TIME_WAIT - argh
00107   int on = 1;
00108   if ( ::setsockopt ( endpoint, SOL_SOCKET, SO_REUSEADDR, ( const char* ) &on, sizeof ( on ) ) == -1 ) {
00109     perror("Socket::init(): SO_REUSEADDR setsockopt");
00110   }
00111   if(trType==SocketNS::SOCK_DGRAM) {
00112     if ( ::setsockopt ( endpoint, SOL_SOCKET, SO_BROADCAST, ( const char* ) &on, sizeof ( on ) ) == -1 ) {
00113       perror("Socket::init(): SO_BROADCAST setsockopt");
00114     }
00115   }
00116   if( ::fcntl(endpoint,F_SETFL,O_NONBLOCK) ==-1 ) {
00117     perror("Socket::init(): fcntl");
00118   }
00119 #endif
00120 }
00121 
00122 int
00123 Socket::setFlushType(FlushType_t fType)
00124 {
00125   if (state != CONNECTION_CLOSED) return -1;
00126   flType=fType;
00127   return 0;
00128 }
00129 
00130 void
00131 Socket::flush()
00132 {
00133 #ifndef PLATFORM_APERIOS
00134   ThreadNS::Lock(wireless->getLock());
00135 #endif
00136   if (state!=CONNECTION_CONNECTED) {
00137     if(forwardSock!=NULL)
00138       return forwardSock->flush();
00139   } else {
00140     if (flType==FLUSH_NONBLOCKING) {
00141       if (!tx) {
00142         byte *tempData=sendData;
00143         int tempSize=sendSize;
00144         sendData=writeData;
00145         writeData=tempData;
00146         sendSize=writeSize;
00147         writeSize=tempSize;
00148         wireless->send(sock);
00149       }
00150     } else {
00151       sendData=writeData;
00152       sendSize=writeSize;
00153       wireless->blockingSend(sock);
00154       writeSize=0;
00155     }
00156   }
00157 }
00158 
00159 int
00160 Socket::pprintf(int vlevel, const char *fmt, ...)
00161 {
00162   if (vlevel>verbosity) return 0;
00163 
00164   int ret;
00165   va_list al;
00166   va_start(al,fmt);
00167   ret=this->printf(fmt, al); 
00168   va_end(al);
00169 
00170   return ret;
00171 }
00172 
00173 int
00174 Socket::printf(const char *fmt, ...)
00175 {
00176   va_list al;
00177   va_start(al,fmt);
00178   int ret=vprintf(fmt,al);
00179   va_end(al);
00180   return ret;
00181 }
00182 
00183 int
00184 Socket::vprintf(const char *fmt, va_list al)
00185 {
00186   /*
00187   if (state==CONNECTION_CONNECTED && (sendBufSize-writeSize<256)) {
00188     flush();
00189     if (sendBufSize-writeSize<256)
00190       return -1;
00191   }*/
00192 
00193   if (state!=CONNECTION_CONNECTED) {
00194     if(forwardSock!=NULL)
00195       return forwardSock->vprintf(fmt,al);
00196     if(textForward)
00197       return vfprintf(stdout, fmt, al);
00198   } else {
00199 #ifndef PLATFORM_APERIOS
00200     ThreadNS::Lock(wireless->getLock());
00201 #endif
00202     int ret=vsnprintf((char *)(writeData+writeSize), sendBufSize-writeSize, fmt, al);
00203     writeSize+=ret;
00204     flush();
00205     return ret;
00206   }
00207   return -1;
00208 }
00209 
00210 int
00211 Socket::write(const byte *buf, int size)
00212 {
00213   if (state!=CONNECTION_CONNECTED) {
00214     if(forwardSock!=NULL)
00215       return forwardSock->write(buf,size);
00216     if(textForward)
00217       return ::write(STDOUT_FILENO,buf,size);
00218   } else {
00219 #ifndef PLATFORM_APERIOS
00220     ThreadNS::Lock(wireless->getLock());
00221 #endif
00222     byte *destbuf=getWriteBuffer(size);
00223     if (destbuf==NULL) return -1;
00224     memcpy(destbuf, buf, size);
00225     write(size);
00226     return size;
00227   }
00228   return -1;
00229 }
00230 
00231 int
00232 Socket::read(byte * /*buf*/, int /*size*/)
00233 {  
00234 /*  if (size>=recvBufSize-recvPos) return -1;
00235   memcpy(buf,recvData+recvPos,size);*/
00236   return -1;
00237 }
00238 
00239 std::string Socket::getPeerAddressAsString() const {
00240   char buf[20];
00241   snprintf(buf,20,"%hhu.%hhu.%hhu.%hhu",(peer_addr>>24)&0xFF,(peer_addr>>16)&0xFF,(peer_addr>>8)&0xFF,peer_addr&0xFF);
00242   //const unsigned char *b=(const unsigned char*)&peer_addr;
00243   //snprintf(buf,20,"%hhu.%hhu.%hhu.%hhu",b[0],b[1],b[2],b[3]);
00244   //snprintf(buf,20,"%hhu.%hhu.%hhu.%hhu",peer_addr&0xFF,(peer_addr>>8)&0xFF,(peer_addr>>16)&0xFF,(peer_addr>>24)&0xFF);
00245   return buf;
00246 }
00247 
00248 /*! @file
00249  * @brief Implements Tekkotsu wireless Socket class, also sout and serr
00250  * @author alokl (Creator)
00251  * 
00252  * $Author: ejt $
00253  * $Name: tekkotsu-2_4_1 $
00254  * $Revision: 1.20 $
00255  * $State: Exp $
00256  * $Date: 2005/08/02 22:24:29 $
00257  */
00258 

Tekkotsu v2.4.1
Generated Tue Aug 16 16:32:48 2005 by Doxygen 1.4.4