00001 #include "Socket.h"
00002 #include <stdio.h>
00003 #include "Wireless.h"
00004 #include "Shared/Config.h"
00005 #include <unistd.h>
00006
00007 Socket* sout=NULL;
00008 Socket* serr=NULL;
00009
00010 byte*
00011 Socket::getWriteBuffer(int bytesreq)
00012 {
00013 if (sendBufSize-writeSize>=bytesreq
00014 && state==CONNECTION_CONNECTED)
00015 return writeData+writeSize;
00016 if (state!=CONNECTION_CONNECTED) {
00017 if(forwardSock!=NULL)
00018 return forwardSock->getWriteBuffer(bytesreq);
00019 if(textForward)
00020 return (byte*)(textForwardBuf=new char[bytesreq]);
00021 }
00022 return NULL;
00023 }
00024
00025 void
00026 Socket::write(int size)
00027 {
00028 writeSize+=size;
00029 if(textForwardBuf) {
00030 ::write(STDOUT_FILENO,textForwardBuf,size);
00031 delete textForwardBuf;
00032 textForwardBuf=NULL;
00033 } else
00034 flush();
00035 }
00036
00037 int
00038 Socket::read()
00039 {
00040 return -1;
00041 }
00042
00043 byte*
00044 Socket::getReadBuffer()
00045 {
00046 return NULL;
00047
00048 }
00049
00050 void
00051 Socket::init()
00052 {
00053 sendSize=0;
00054 writeSize=0;
00055 }
00056
00057 int
00058 Socket::setFlushType(FlushType_t fType)
00059 {
00060 if (state != CONNECTION_CLOSED) return -1;
00061 flType=fType;
00062 return 0;
00063 }
00064
00065 void
00066 Socket::flush()
00067 {
00068 if (state!=CONNECTION_CONNECTED) {
00069 if(forwardSock!=NULL)
00070 return forwardSock->flush();
00071 } else {
00072 if (flType==FLUSH_NONBLOCKING) {
00073 if (!tx) {
00074 byte *tempData=sendData;
00075 int tempSize=sendSize;
00076 sendData=writeData;
00077 writeData=tempData;
00078 sendSize=writeSize;
00079 writeSize=tempSize;
00080 wireless->send(sock);
00081 }
00082 } else {
00083 sendData=writeData;
00084 sendSize=writeSize;
00085 wireless->blockingSend(sock);
00086 writeSize=0;
00087 }
00088 }
00089 }
00090
00091 int
00092 Socket::pprintf(int vlevel, const char *fmt, ...)
00093 {
00094 if (vlevel>verbosity) return 0;
00095
00096 int ret;
00097 va_list al;
00098 va_start(al,fmt);
00099 ret=this->printf(fmt, al);
00100 va_end(al);
00101
00102 return ret;
00103 }
00104
00105 int
00106 Socket::printf(const char *fmt, ...)
00107 {
00108 va_list al;
00109 va_start(al,fmt);
00110 int ret=vprintf(fmt,al);
00111 va_end(al);
00112 return ret;
00113 }
00114
00115 int
00116 Socket::vprintf(const char *fmt, va_list al)
00117 {
00118 if (state==CONNECTION_CONNECTED && (sendBufSize-writeSize<256)) {
00119 flush();
00120 if (sendBufSize-writeSize<256)
00121 return -1;
00122 }
00123
00124 if (state!=CONNECTION_CONNECTED) {
00125 if(forwardSock!=NULL)
00126 return forwardSock->vprintf(fmt,al);
00127 if(textForward)
00128 return vfprintf(stdout, fmt, al);
00129 } else {
00130 int ret=vsprintf((char *)(writeData+writeSize), fmt, al);
00131 writeSize+=ret;
00132 flush();
00133 return ret;
00134 }
00135 return -1;
00136 }
00137
00138 int
00139 Socket::write(const byte *buf, int size)
00140 {
00141 if (state!=CONNECTION_CONNECTED) {
00142 if(forwardSock!=NULL)
00143 return forwardSock->write(buf,size);
00144 if(textForward)
00145 return ::write(STDOUT_FILENO,buf,size);
00146 } else {
00147 byte *destbuf=getWriteBuffer(size);
00148 if (destbuf==NULL) return -1;
00149 memcpy(destbuf, buf, size);
00150 write(size);
00151 return size;
00152 }
00153 return -1;
00154 }
00155
00156 int
00157 Socket::read(byte * , int )
00158 {
00159
00160
00161 return -1;
00162 }
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174