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