00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include <config.h>
00021
00022 #include <errno.h>
00023 #include <sys/types.h>
00024 #include <sys/socket.h>
00025
00026 #if defined(HAVE_UNISTD_H)
00027 #include <unistd.h>
00028 #endif
00029
00030 #include "ksocks.h"
00031 #include "ksocketaddress.h"
00032 #include "kresolver.h"
00033 #include "ksockssocketdevice.h"
00034
00035 using namespace KNetwork;
00036
00037
00038
00039 KSocksSocketDevice::KSocksSocketDevice(const KSocketBase* obj)
00040 : KSocketDevice(obj)
00041 {
00042 }
00043
00044
00045
00046 KSocksSocketDevice::KSocksSocketDevice(int fd)
00047 : KSocketDevice(fd)
00048 {
00049 }
00050
00051
00052
00053 KSocksSocketDevice::~KSocksSocketDevice()
00054 {
00055 }
00056
00057
00058 int KSocksSocketDevice::capabilities() const
00059 {
00060 return 0;
00061 }
00062
00063
00064
00065
00066 bool KSocksSocketDevice::bind(const KResolverEntry& address)
00067 {
00068 resetError();
00069
00070 if (m_sockfd == -1 && !create(address))
00071 return false;
00072
00073
00074 if (KSocks::self()->bind(m_sockfd, address.address(), address.length()) == -1)
00075 {
00076 if (errno == EADDRINUSE)
00077 setError(IO_BindError, AddressInUse);
00078 else if (errno == EINVAL)
00079 setError(IO_BindError, AlreadyBound);
00080 else
00081
00082 setError(IO_BindError, NotSupported);
00083 return false;
00084 }
00085
00086 return true;
00087 }
00088
00089
00090 bool KSocksSocketDevice::listen(int backlog)
00091 {
00092 if (m_sockfd != -1)
00093 {
00094 if (KSocks::self()->listen(m_sockfd, backlog) == -1)
00095 {
00096 setError(IO_ListenError, NotSupported);
00097 return false;
00098 }
00099
00100 resetError();
00101 setFlags(IO_Sequential | IO_Raw | IO_ReadWrite);
00102 setState(IO_Open);
00103 return true;
00104 }
00105
00106
00107
00108 setError(IO_ListenError, NotCreated);
00109 return false;
00110 }
00111
00112 bool KSocksSocketDevice::connect(const KResolverEntry& address)
00113 {
00114 resetError();
00115
00116 if (m_sockfd == -1 && !create(address))
00117 return false;
00118
00119 if (KSocks::self()->connect(m_sockfd, address.address(), address.length()) == -1)
00120 {
00121 if (errno == EISCONN)
00122 return true;
00123 else if (errno == EALREADY || errno == EINPROGRESS)
00124 {
00125 setError(IO_ConnectError, InProgress);
00126 return true;
00127 }
00128 else if (errno == ECONNREFUSED)
00129 setError(IO_ConnectError, ConnectionRefused);
00130 else if (errno == ENETDOWN || errno == ENETUNREACH ||
00131 errno == ENETRESET || errno == ECONNABORTED ||
00132 errno == ECONNRESET || errno == EHOSTDOWN ||
00133 errno == EHOSTUNREACH)
00134 setError(IO_ConnectError, NetFailure);
00135 else
00136 setError(IO_ConnectError, NotSupported);
00137
00138 return false;
00139 }
00140
00141 setFlags(IO_Sequential | IO_Raw | IO_ReadWrite);
00142 setState(IO_Open);
00143 return true;
00144 }
00145
00146 KSocksSocketDevice* KSocksSocketDevice::accept()
00147 {
00148 if (m_sockfd == -1)
00149 {
00150
00151 setError(IO_AcceptError, NotCreated);
00152 return 0L;
00153 }
00154
00155 struct sockaddr sa;
00156 socklen_t len = sizeof(sa);
00157 int newfd = KSocks::self()->accept(m_sockfd, &sa, &len);
00158 if (newfd == -1)
00159 {
00160 if (errno == EAGAIN || errno == EWOULDBLOCK)
00161 setError(IO_AcceptError, WouldBlock);
00162 else
00163 setError(IO_AcceptError, UnknownError);
00164 return NULL;
00165 }
00166
00167 return new KSocksSocketDevice(newfd);
00168 }
00169
00170 static int socks_read_common(int sockfd, char *data, Q_ULONG maxlen, KSocketAddress* from, ssize_t &retval, bool peek = false)
00171 {
00172 socklen_t len;
00173 if (from)
00174 {
00175 from->setLength(len = 128);
00176 retval = KSocks::self()->recvfrom(sockfd, data, maxlen, peek ? MSG_PEEK : 0, from->address(), &len);
00177 }
00178 else
00179 retval = KSocks::self()->recvfrom(sockfd, data, maxlen, peek ? MSG_PEEK : 0, NULL, NULL);
00180
00181 if (retval == -1)
00182 {
00183 if (errno == EAGAIN || errno == EWOULDBLOCK)
00184 return KSocketDevice::WouldBlock;
00185 else
00186 return KSocketDevice::UnknownError;
00187 }
00188
00189 if (from)
00190 from->setLength(len);
00191 return 0;
00192 }
00193
00194 Q_LONG KSocksSocketDevice::readBlock(char *data, Q_ULONG maxlen)
00195 {
00196 resetError();
00197 if (m_sockfd == -1)
00198 return -1;
00199
00200 if (maxlen == 0 || data == 0L)
00201 return 0;
00202
00203 ssize_t retval;
00204 int err = socks_read_common(m_sockfd, data, maxlen, 0L, retval);
00205
00206 if (err)
00207 {
00208 setError(IO_ReadError, static_cast<SocketError>(err));
00209 return -1;
00210 }
00211
00212 return retval;
00213 }
00214
00215 Q_LONG KSocksSocketDevice::readBlock(char *data, Q_ULONG maxlen, KSocketAddress &from)
00216 {
00217 resetError();
00218 if (m_sockfd == -1)
00219 return -1;
00220
00221 if (data == 0L || maxlen == 0)
00222 return 0;
00223
00224 ssize_t retval;
00225 int err = socks_read_common(m_sockfd, data, maxlen, &from, retval);
00226
00227 if (err)
00228 {
00229 setError(IO_ReadError, static_cast<SocketError>(err));
00230 return -1;
00231 }
00232
00233 return retval;
00234 }
00235
00236 Q_LONG KSocksSocketDevice::peekBlock(char *data, Q_ULONG maxlen)
00237 {
00238 resetError();
00239 if (m_sockfd == -1)
00240 return -1;
00241
00242 if (maxlen == 0 || data == 0L)
00243 return 0;
00244
00245 ssize_t retval;
00246 int err = socks_read_common(m_sockfd, data, maxlen, 0L, retval, true);
00247
00248 if (err)
00249 {
00250 setError(IO_ReadError, static_cast<SocketError>(err));
00251 return -1;
00252 }
00253
00254 return retval;
00255 }
00256
00257 Q_LONG KSocksSocketDevice::peekBlock(char *data, Q_ULONG maxlen, KSocketAddress& from)
00258 {
00259 resetError();
00260 if (m_sockfd == -1)
00261 return -1;
00262
00263 if (data == 0L || maxlen == 0)
00264 return 0;
00265
00266 ssize_t retval;
00267 int err = socks_read_common(m_sockfd, data, maxlen, &from, retval, true);
00268
00269 if (err)
00270 {
00271 setError(IO_ReadError, static_cast<SocketError>(err));
00272 return -1;
00273 }
00274
00275 return retval;
00276 }
00277
00278 Q_LONG KSocksSocketDevice::writeBlock(const char *data, Q_ULONG len)
00279 {
00280 return writeBlock(data, len, KSocketAddress());
00281 }
00282
00283 Q_LONG KSocksSocketDevice::writeBlock(const char *data, Q_ULONG len, const KSocketAddress& to)
00284 {
00285 resetError();
00286 if (m_sockfd == -1)
00287 return -1;
00288
00289 if (data == 0L || len == 0)
00290 return 0;
00291
00292 ssize_t retval = KSocks::self()->sendto(m_sockfd, data, len, 0, to.address(), to.length());
00293 if (retval == -1)
00294 {
00295 if (errno == EAGAIN || errno == EWOULDBLOCK)
00296 setError(IO_WriteError, WouldBlock);
00297 else
00298 setError(IO_WriteError, UnknownError);
00299 return -1;
00300 }
00301
00302 return retval;
00303 }
00304
00305 KSocketAddress KSocksSocketDevice::localAddress() const
00306 {
00307 if (m_sockfd == -1)
00308 return KSocketAddress();
00309
00310 socklen_t len;
00311 KSocketAddress localAddress;
00312 localAddress.setLength(len = 32);
00313 if (KSocks::self()->getsockname(m_sockfd, localAddress.address(), &len) == -1)
00314
00315 return KSocketAddress();
00316
00317 if (len <= localAddress.length())
00318 {
00319
00320 localAddress.setLength(len);
00321 return localAddress;
00322 }
00323
00324
00325
00326 localAddress.setLength(len);
00327 if (KSocks::self()->getsockname(m_sockfd, localAddress.address(), &len) == -1)
00328
00329 return KSocketAddress();
00330
00331 return localAddress;
00332 }
00333
00334 KSocketAddress KSocksSocketDevice::peerAddress() const
00335 {
00336 if (m_sockfd == -1)
00337 return KSocketAddress();
00338
00339 socklen_t len;
00340 KSocketAddress peerAddress;
00341 peerAddress.setLength(len = 32);
00342 if (KSocks::self()->getpeername(m_sockfd, peerAddress.address(), &len) == -1)
00343
00344 return KSocketAddress();
00345
00346 if (len <= peerAddress.length())
00347 {
00348
00349 peerAddress.setLength(len);
00350 return peerAddress;
00351 }
00352
00353
00354
00355 peerAddress.setLength(len);
00356 if (KSocks::self()->getpeername(m_sockfd, peerAddress.address(), &len) == -1)
00357
00358 return KSocketAddress();
00359
00360 return peerAddress;
00361 }
00362
00363 KSocketAddress KSocksSocketDevice::externalAddress() const
00364 {
00365
00366 return KSocketAddress();
00367 }
00368
00369 bool KSocksSocketDevice::poll(bool *input, bool *output, bool *exception,
00370 int timeout, bool *timedout)
00371 {
00372 if (m_sockfd == -1)
00373 {
00374 setError(IO_UnspecifiedError, NotCreated);
00375 return false;
00376 }
00377
00378 resetError();
00379 fd_set readfds, writefds, exceptfds;
00380 fd_set *preadfds = 0L, *pwritefds = 0L, *pexceptfds = 0L;
00381
00382 if (input)
00383 {
00384 preadfds = &readfds;
00385 FD_ZERO(preadfds);
00386 FD_SET(m_sockfd, preadfds);
00387 *input = false;
00388 }
00389 if (output)
00390 {
00391 pwritefds = &writefds;
00392 FD_ZERO(pwritefds);
00393 FD_SET(m_sockfd, pwritefds);
00394 *output = false;
00395 }
00396 if (exception)
00397 {
00398 pexceptfds = &exceptfds;
00399 FD_ZERO(pexceptfds);
00400 FD_SET(m_sockfd, pexceptfds);
00401 *exception = false;
00402 }
00403
00404 int retval;
00405 if (timeout < 0)
00406 retval = KSocks::self()->select(m_sockfd + 1, preadfds, pwritefds, pexceptfds, 0L);
00407 else
00408 {
00409
00410 struct timeval tv;
00411 tv.tv_sec = timeout / 1000;
00412 tv.tv_usec = timeout % 1000 * 1000;
00413
00414 retval = select(m_sockfd + 1, preadfds, pwritefds, pexceptfds, &tv);
00415 }
00416
00417 if (retval == -1)
00418 {
00419 setError(IO_UnspecifiedError, UnknownError);
00420 return false;
00421 }
00422 if (retval == 0)
00423 {
00424
00425 if (timedout)
00426 *timedout = true;
00427 return true;
00428 }
00429
00430 if (input && FD_ISSET(m_sockfd, preadfds))
00431 *input = true;
00432 if (output && FD_ISSET(m_sockfd, pwritefds))
00433 *output = true;
00434 if (exception && FD_ISSET(m_sockfd, pexceptfds))
00435 *exception = true;
00436
00437 return true;
00438 }