00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
#include <config.h>
00020
00021
#ifdef HAVE_SYS_TIME_H
00022
#include <sys/time.h>
00023
#endif
00024
00025
#include <qfile.h>
00026
#include <qstring.h>
00027
#include <qmap.h>
00028
00029
#include <klocale.h>
00030
#include <kdebug.h>
00031
#include "klibloader.h"
00032
#include <kconfig.h>
00033
#include <kapplication.h>
00034
00035
#include <sys/types.h>
00036
#include <sys/socket.h>
00037
00038
#include <unistd.h>
00039
00040
#include "ksocks.h"
00041
00042
00043
enum SymbolKeys {
00044 S_SOCKSinit = 0,
00045 S_connect = 1,
00046 S_read = 2,
00047 S_write = 3,
00048 S_recvfrom = 4,
00049 S_sendto = 5,
00050 S_recv = 6,
00051 S_send = 7,
00052 S_getsockname = 8,
00053 S_getpeername = 9,
00054 S_accept = 10,
00055 S_select = 11,
00056 S_listen = 12,
00057 S_bind = 13
00058 };
00059
00060
00061
extern "C" {
00062
00063
static int (*F_SOCKSinit) (
char *) = 0L;
00064
static int (*F_connect) (
int,
const struct sockaddr *, ksocklen_t) = 0L;
00065
static signed long int (*F_read) (
int,
void *,
unsigned long int) = 0L;
00066
static signed long int (*F_write) (
int,
const void *,
unsigned long int) = 0L;
00067
static int (*F_recvfrom) (
int,
void *,
unsigned long int,
int,
struct sockaddr *,
00068 ksocklen_t *) = 0L;
00069
static int (*F_sendto) (
int,
const void *,
unsigned long int,
int,
00070
const struct sockaddr *, ksocklen_t) = 0L;
00071
static int (*F_recv) (
int,
void *,
unsigned long int,
int) = 0L;
00072
static int (*F_send) (
int,
const void *,
unsigned long int,
int) = 0L;
00073
static int (*F_getsockname) (
int,
struct sockaddr *, ksocklen_t *) = 0L;
00074
static int (*F_getpeername) (
int,
struct sockaddr *, ksocklen_t *) = 0L;
00075
static int (*F_accept) (
int,
struct sockaddr *, ksocklen_t *) = 0L;
00076
static int (*F_select) (
int, fd_set *, fd_set *, fd_set *,
00077
struct timeval *) = 0L;
00078
static int (*F_listen) (
int,
int) = 0L;
00079
static int (*F_bind) (
int,
const struct sockaddr *, ksocklen_t) = 0L;
00080 }
00081
00082
00083
class KSocksTable {
00084
public:
00085 KSocksTable();
00086
virtual ~KSocksTable();
00087
00088
00089
QMap<SymbolKeys,QString> symbols;
00090
00091
QString myname;
00092
bool hasWorkingAsyncConnect;
00093 };
00094
00095
00096 KSocksTable::KSocksTable() : myname(
"Unknown"), hasWorkingAsyncConnect(true) {
00097 }
00098
00099 KSocksTable::~KSocksTable() {
00100 }
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00121
00122
00123
00124
00125
00126
00127
class KNECSocksTable :
public KSocksTable {
00128
public:
00129 KNECSocksTable();
00130
virtual ~KNECSocksTable();
00131 };
00132
00133
00134 KNECSocksTable::KNECSocksTable() : KSocksTable() {
00135 myname = i18n(
"NEC SOCKS client");
00136 symbols.insert(S_SOCKSinit,
"SOCKSinit");
00137 symbols.insert(S_connect,
"connect");
00138 symbols.insert(S_read,
"read");
00139 symbols.insert(S_write,
"write");
00140 symbols.insert(S_recvfrom,
"recvfrom");
00141 symbols.insert(S_sendto,
"sendto");
00142 symbols.insert(S_recv,
"recv");
00143 symbols.insert(S_send,
"send");
00144 symbols.insert(S_getsockname,
"getsockname");
00145 symbols.insert(S_getpeername,
"getpeername");
00146 symbols.insert(S_accept,
"accept");
00147 symbols.insert(S_select,
"select");
00148 symbols.insert(S_listen,
"listen");
00149 symbols.insert(S_bind,
"bind");
00150 }
00151
00152 KNECSocksTable::~KNECSocksTable() {
00153 }
00154
00155
00156
00157
00158
00159
00160
00161
00162
class KDanteSocksTable :
public KSocksTable {
00163
public:
00164 KDanteSocksTable();
00165
virtual ~KDanteSocksTable();
00166 };
00167
00168 KDanteSocksTable::KDanteSocksTable() : KSocksTable() {
00169 hasWorkingAsyncConnect =
false;
00170 myname = i18n(
"Dante SOCKS client");
00171 symbols.insert(S_SOCKSinit,
"SOCKSinit");
00172 symbols.insert(S_connect,
"Rconnect");
00173 symbols.insert(S_read,
"Rread");
00174 symbols.insert(S_write,
"Rwrite");
00175 symbols.insert(S_recvfrom,
"Rrecvfrom");
00176 symbols.insert(S_sendto,
"Rsendto");
00177 symbols.insert(S_recv,
"Rrecv");
00178 symbols.insert(S_send,
"Rsend");
00179 symbols.insert(S_getsockname,
"Rgetsockname");
00180 symbols.insert(S_getpeername,
"Rgetpeername");
00181 symbols.insert(S_accept,
"Raccept");
00182 symbols.insert(S_select,
"Rselect");
00183 symbols.insert(S_listen,
"Rlisten");
00184 symbols.insert(S_bind,
"Rbind");
00185 }
00186
00187
00188 KDanteSocksTable::~KDanteSocksTable() {
00189 }
00190
00191
00192
00196
00197
00198
KSocks *KSocks::_me = 0;
00199
bool KSocks::_disabled =
false;
00200
00201 void KSocks::disable()
00202 {
00203
if (!_me)
00204 _disabled =
true;
00205 }
00206
00207 KSocks *
KSocks::self() {
00208
00209
if (!_me) {
00210
if (kapp) {
00211
KConfigGroup cfg(kapp->config(),
"Socks");
00212 _me =
new KSocks(&cfg);
00213 }
else {
00214 _disabled =
true;
00215 _me =
new KSocks(0);
00216 }
00217 }
00218
return _me;
00219 }
00220
00221 void KSocks::setConfig(
KConfigBase *config)
00222 {
00223
00224
00225
if (_me && _disabled) {
00226
delete _me;
00227 _me = 0;
00228 _disabled =
false;
00229 }
00230
if (!_me)
00231 _me =
new KSocks(config);
00232 }
00233
00234 bool KSocks::activated() {
return (_me != 0L); }
00235
00236
00237 KSocks::KSocks(
KConfigBase *config) : _socksLib(0L), _st(0L) {
00238 _hasSocks =
false;
00239 _useSocks =
false;
00240
00241
if (!config)
00242
return;
00243
00244
if (!(config->
readBoolEntry(
"SOCKS_enable",
false))) {
00245 _disabled =
true;
00246 }
00247
00248
if (_disabled)
00249
return;
00250
00251 _libPaths <<
""
00252 <<
"/usr/lib" KDELIBSUFF
"/"
00253 <<
"/usr/lib/"
00254 <<
"/usr/local/lib" KDELIBSUFF
"/"
00255 <<
"/usr/local/lib/"
00256 <<
"/usr/local/socks5/lib" KDELIBSUFF
"/"
00257 <<
"/usr/local/socks5/lib/"
00258 <<
"/opt/socks5/lib" KDELIBSUFF
"/"
00259 <<
"/opt/socks5/lib/";
00260 _libNames <<
"libsocks.so"
00261 <<
"libdsocksd.so.0"
00262
00263 <<
"libsocks5.so"
00264 <<
"libsocks5_sh.so";
00265
00266
00267
QStringList newlibs = config->
readListEntry(
"SOCKS_lib_path");
00268
00269
for (QStringList::Iterator it = newlibs.begin();
00270 it != newlibs.end();
00271 ++it) {
00272
QString thisone = *it;
00273
if (thisone[thisone.length()-1] !=
'/') thisone +=
"/";
00274 _libPaths << thisone;
00275 kdDebug(171) <<
"KSocks added a new library path: " << thisone <<
endl;
00276 }
00277
00278
00279
KLibLoader *ll =
KLibLoader::self();
00280
00281
00282
int _meth = config->
readNumEntry(
"SOCKS_method", 1);
00283
00284
00285
00286
00287
00288
if (_meth == 4) {
00289 _socksLib = ll->
library(config->
readPathEntry(
"SOCKS_lib").latin1());
00290
if (_socksLib && _socksLib->
symbol(
"Rconnect")) {
00291 _st =
new KDanteSocksTable;
00292 _useSocks =
true;
00293 _hasSocks =
true;
00294 }
else if (_socksLib && _socksLib->
symbol(
"connect")) {
00295 _st =
new KNECSocksTable;
00296 _useSocks =
true;
00297 _hasSocks =
true;
00298 }
else if (_socksLib) {
00299 _socksLib->
unload();
00300 _socksLib = 0L;
00301 }
00302 }
else
00303
for (QStringList::Iterator pit = _libPaths.begin();
00304 !_hasSocks && pit != _libPaths.end();
00305 ++pit)
00306
for (QStringList::Iterator it = _libNames.begin();
00307 it != _libNames.end();
00308 ++it) {
00309 _socksLib = ll->
library((*pit + *it).latin1());
00310
if (_socksLib) {
00311
if ((_meth == 1 || _meth == 2) &&
00312 _socksLib->
symbol(
"S5LogShowThreadIDS") != 0L) {
00313 kdDebug(171) <<
"Found NEC SOCKS" <<
endl;
00314 _st =
new KNECSocksTable;
00315 _useSocks =
true;
00316 _hasSocks =
true;
00317
break;
00318 }
else if ((_meth == 1 || _meth == 3) &&
00319 _socksLib->
symbol(
"sockaddr2ruleaddress") != 0L) {
00320 kdDebug(171) <<
"Found Dante SOCKS" <<
endl;
00321 _st =
new KDanteSocksTable;
00322 _useSocks =
true;
00323 _hasSocks =
true;
00324
break;
00325 }
else {
00326 _socksLib->
unload();
00327 _socksLib = 0L;
00328 }
00329 }
00330 }
00331
00332
00333
if (_st) {
00334
for (
QMap<SymbolKeys,QString>::Iterator it = _st->symbols.begin();
00335 it != _st->symbols.end();
00336 ++it) {
00337
switch(it.key()) {
00338
case S_SOCKSinit:
00339 F_SOCKSinit = (int (*)(
char *))
00340 _socksLib->
symbol(it.data().latin1());
00341
break;
00342
case S_connect:
00343 F_connect = (int (*)(
int,
const struct sockaddr *, ksocklen_t))
00344 _socksLib->
symbol(it.data().latin1());
00345
break;
00346
case S_read:
00347 F_read = (
signed long int (*)(
int,
void *,
unsigned long int))
00348 _socksLib->
symbol(it.data().latin1());
00349
break;
00350
case S_write:
00351 F_write = (
signed long int (*)(
int,
const void *,
unsigned long int))
00352 _socksLib->
symbol(it.data().latin1());
00353
break;
00354
case S_recvfrom:
00355 F_recvfrom = (int (*)(
int,
void *,
unsigned long int,
int,
00356
struct sockaddr *, ksocklen_t *))
00357 _socksLib->
symbol(it.data().latin1());
00358
break;
00359
case S_sendto:
00360 F_sendto = (int (*)(
int,
const void *,
unsigned long int,
int,
00361
const struct sockaddr *, ksocklen_t))
00362 _socksLib->
symbol(it.data().latin1());
00363
break;
00364
case S_recv:
00365 F_recv = (int (*)(
int,
void *,
unsigned long int,
int))
00366 _socksLib->
symbol(it.data().latin1());
00367
break;
00368
case S_send:
00369 F_send = (int (*)(
int,
const void *,
unsigned long int,
int))
00370 _socksLib->
symbol(it.data().latin1());
00371
break;
00372
case S_getsockname:
00373 F_getsockname = (int (*)(
int,
struct sockaddr *, ksocklen_t *))
00374 _socksLib->
symbol(it.data().latin1());
00375
break;
00376
case S_getpeername:
00377 F_getpeername = (int (*)(
int,
struct sockaddr *, ksocklen_t *))
00378 _socksLib->
symbol(it.data().latin1());
00379
break;
00380
case S_accept:
00381 F_accept = (int (*)(
int,
struct sockaddr *, ksocklen_t *))
00382 _socksLib->
symbol(it.data().latin1());
00383
break;
00384
case S_select:
00385 F_select = (int (*)(
int, fd_set *, fd_set *, fd_set *,
struct timeval *))
00386 _socksLib->
symbol(it.data().latin1());
00387
break;
00388
case S_listen:
00389 F_listen = (int (*)(
int,
int))
00390 _socksLib->
symbol(it.data().latin1());
00391
break;
00392
case S_bind:
00393 F_bind = (int (*)(
int,
const struct sockaddr *, ksocklen_t))
00394 _socksLib->
symbol(it.data().latin1());
00395
break;
00396
default:
00397 kdDebug(171) <<
"KSocks got a symbol it doesn't know about!" <<
endl;
00398
break;
00399 }
00400 }
00401
00402
00403
if (F_SOCKSinit) {
00404
int rc = (*F_SOCKSinit)((
char *)
"KDE");
00405
if (rc != 0)
00406 stopSocks();
00407
else kdDebug(171) <<
"SOCKS has been activated!" <<
endl;
00408 }
else {
00409 stopSocks();
00410 }
00411 }
00412 }
00413
00414
00415 KSocks::~KSocks() {
00416 stopSocks();
00417 _me = 0;
00418 }
00419
00420 void KSocks::die() {
00421
if (_me ==
this) {
00422 _me = 0;
00423
delete this;
00424 }
00425 }
00426
00427
void KSocks::stopSocks() {
00428
if (_hasSocks) {
00429
00430
00431 _useSocks =
false;
00432 _hasSocks =
false;
00433
if (_socksLib) {
00434 _socksLib->
unload();
00435 _socksLib = 0L;
00436 }
00437
delete _st;
00438 _st = 0L;
00439 }
00440 }
00441
00442
00443 bool KSocks::usingSocks() {
00444
return _useSocks;
00445 }
00446
00447
00448 bool KSocks::hasSocks() {
00449
return _hasSocks;
00450 }
00451
00452
00453 void KSocks::disableSocks() {
00454 _useSocks =
false;
00455 }
00456
00457
00458 void KSocks::enableSocks() {
00459
if (_hasSocks)
00460 _useSocks =
true;
00461 }
00462
00463 bool KSocks::hasWorkingAsyncConnect()
00464 {
00465
return (_useSocks && _st) ? _st->hasWorkingAsyncConnect :
true;
00466 }
00467
00468
00469
00470
00471
00472
00473
00474 int KSocks::connect (
int sockfd,
const sockaddr *serv_addr,
00475 ksocklen_t addrlen) {
00476
if (_useSocks && F_connect)
00477
return (*F_connect)(sockfd, serv_addr, addrlen);
00478
else return ::connect(sockfd, (sockaddr*) serv_addr, (socklen_t)addrlen);
00479 }
00480
00481
00482 signed long int KSocks::read (
int fd,
void *buf,
unsigned long int count) {
00483
if (_useSocks && F_read)
00484
return (*F_read)(fd, buf, count);
00485
else return ::read(fd, buf, count);
00486 }
00487
00488
00489 signed long int KSocks::write (
int fd,
const void *buf,
unsigned long int count) {
00490
if (_useSocks && F_write)
00491
return (*F_write)(fd, buf, count);
00492
else return ::write(fd, buf, count);
00493 }
00494
00495
00496 int KSocks::recvfrom (
int s,
void *buf,
unsigned long int len,
int flags,
00497 sockaddr *from, ksocklen_t *fromlen) {
00498
if (_useSocks && F_recvfrom) {
00499
return (*F_recvfrom)(s, buf, len, flags, from, fromlen);
00500 }
else {
00501 socklen_t casted_len = (socklen_t) *fromlen;
00502
int rc = ::recvfrom(s, (
char*) buf, len, flags, from, &casted_len);
00503 *fromlen = casted_len;
00504
return rc;
00505 }
00506 }
00507
00508
00509 int KSocks::sendto (
int s,
const void *msg,
unsigned long int len,
int flags,
00510
const sockaddr *to, ksocklen_t tolen) {
00511
if (_useSocks && F_sendto)
00512
return (*F_sendto)(s, msg, len, flags, to, tolen);
00513
else return ::sendto(s, (
char*) msg, len, flags, to, (socklen_t)tolen);
00514 }
00515
00516
00517 int KSocks::recv (
int s,
void *buf,
unsigned long int len,
int flags) {
00518
if (_useSocks && F_recv)
00519
return (*F_recv)(s, buf, len, flags);
00520
else return ::recv(s, (
char*) buf, len, flags);
00521 }
00522
00523
00524 int KSocks::send (
int s,
const void *msg,
unsigned long int len,
int flags) {
00525
if (_useSocks && F_send)
00526
return (*F_send)(s, msg, len, flags);
00527
else return ::send(s, (
char*) msg, len, flags);
00528 }
00529
00530
00531 int KSocks::getsockname (
int s, sockaddr *name, ksocklen_t *namelen) {
00532
if (_useSocks && F_getsockname) {
00533
return (*F_getsockname)(s, name, namelen);
00534 }
else {
00535 socklen_t casted_len = *namelen;
00536
int rc = ::getsockname(s, name, &casted_len);
00537 *namelen = casted_len;
00538
return rc;
00539 }
00540 }
00541
00542
00543 int KSocks::getpeername (
int s, sockaddr *name, ksocklen_t *namelen) {
00544
if (_useSocks && F_getpeername) {
00545
return (*F_getpeername)(s, name, namelen);
00546 }
else {
00547 socklen_t casted_len = *namelen;
00548
int rc = ::getpeername(s, name, &casted_len);
00549 *namelen = casted_len;
00550
return rc;
00551 }
00552 }
00553
00554
00555 int KSocks::accept (
int s, sockaddr *addr, ksocklen_t *addrlen) {
00556
if (_useSocks && F_accept) {
00557
return (*F_accept)(s, addr, addrlen);
00558 }
else {
00559 socklen_t casted_len = *addrlen;
00560
int rc = ::accept(s, addr, &casted_len);
00561 *addrlen = casted_len;
00562
return rc;
00563 }
00564 }
00565
00566
00567 int KSocks::select (
int n, fd_set *readfds, fd_set *writefds,
00568 fd_set *exceptfds,
struct timeval *timeout) {
00569
if (_useSocks && F_select)
00570
return (*F_select)(n, readfds, writefds, exceptfds, timeout);
00571
else return ::select(n, readfds, writefds, exceptfds, timeout);
00572 }
00573
00574
00575 int KSocks::listen (
int s,
int backlog) {
00576
if (_useSocks && F_listen)
00577
return (*F_listen)(s, backlog);
00578
else return ::listen(s, backlog);
00579 }
00580
00581
00582
int KSocks::bind (
int sockfd,
const sockaddr *my_addr, ksocklen_t addrlen) {
00583
if (_useSocks && F_bind)
00584
return (*F_bind)(sockfd, my_addr, addrlen);
00585
else return ::bind(sockfd, my_addr, (socklen_t)addrlen);
00586 }
00587
00588 int KSocks::bind (
int sockfd, sockaddr *my_addr, ksocklen_t addrlen) {
00589
if (_useSocks && F_bind)
00590
return (*F_bind)(sockfd, my_addr, addrlen);
00591
else return ::bind(sockfd, my_addr, (socklen_t)addrlen);
00592 }
00593
00594
00595