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