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
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
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
00188
00189
00190
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 * , int )
00233 {
00234
00235
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
00243
00244
00245 return buf;
00246 }
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258