kdecore Library API Documentation

ksocks.cpp

00001 /* This file is part of the KDE libraries
00002    Copyright (C) 2001-2003 George Staikos <staikos@kde.org>
00003 
00004    This library is free software; you can redistribute it and/or
00005    modify it under the terms of the GNU Library General Public
00006    License version 2 as published by the Free Software Foundation.
00007 
00008    This library is distributed in the hope that it will be useful,
00009    but WITHOUT ANY WARRANTY; without even the implied warranty of
00010    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00011    Library General Public License for more details.
00012 
00013    You should have received a copy of the GNU Library General Public License
00014    along with this library; see the file COPYING.LIB.  If not, write to
00015    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00016    Boston, MA 02111-1307, USA.
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 // DO NOT RE-ORDER THESE.
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 // Function pointer table
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    // The name of each symbol and it's SOCKS replacement
00089    QMap<SymbolKeys,QString>  symbols;
00090    // The name of this library
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  *   How to add support for a new SOCKS package.
00105  *
00106  *   1) Subclass KSocksTable as is done below and write out all the symbols
00107  *   1.b) Give the class a "myname"
00108  *   2) Make sure that all possible library names are written into the
00109  *      _libNames string list.  Don't forget that different OSes name shared
00110  *      libraries differently.  Expect .so, .sl, .a (!) (AIX does this).
00111  *   3) Find a unique symbol in the library that we can use to identify that
00112  *      library and write out the test case in the constructor
00113  *   4) Make necessary changes to the KControl module in kdebase/kcontrol/....
00114  *   5) TEST!
00115  *
00116  */
00117 
00121 
00122 
00123 //
00124 //    Support for NEC SOCKS client
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 //    Support for Dante SOCKS client
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   // Note that we don't use a static deleter here. It makes no sense and tends to cause crashes.
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   // We can change the config from disabled to enabled
00224   // but not the other way around.
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/"
00253              << "/usr/local/lib/"
00254              << "/usr/local/socks5/lib/"
00255              << "/opt/socks5/lib/";
00256    _libNames << "libsocks.so"                  // Dante
00257              << "libdsocksd.so.0"              // Dante 1.1.14-2 on
00258                                                // Debian unstable 17-12-2003
00259              << "libsocks5.so"                 // ?
00260              << "libsocks5_sh.so";             // NEC
00261 
00262    // Add the custom library paths here
00263    QStringList newlibs = config->readListEntry("SOCKS_lib_path");
00264 
00265    for (QStringList::Iterator it = newlibs.begin();
00266                               it != newlibs.end();
00267                               ++it) {
00268       QString thisone = *it;
00269       if (thisone[thisone.length()-1] != '/') thisone += "/";
00270       _libPaths << thisone;
00271       kdDebug(171) << "KSocks added a new library path: " << thisone << endl;
00272    }
00273 
00274    // Load the proper libsocks and KSocksTable
00275    KLibLoader *ll = KLibLoader::self();
00276 
00277 
00278    int _meth = config->readNumEntry("SOCKS_method", 1);
00279          /****       Current methods
00280           *   1) Autodetect (read: any)     2) NEC
00281           *   3) Dante                      4) Custom
00282           */
00283 
00284    if (_meth == 4) {         // try to load^H^H^H^Hguess at a custom library
00285       _socksLib = ll->library(config->readPathEntry("SOCKS_lib").latin1());
00286       if (_socksLib && _socksLib->symbol("Rconnect")) {  // Dante compatible?
00287          _st = new KDanteSocksTable;
00288          _useSocks = true;
00289          _hasSocks = true;
00290       } else if (_socksLib && _socksLib->symbol("connect")) { // NEC compatible?
00291          _st = new KNECSocksTable;
00292          _useSocks = true;
00293          _hasSocks = true;
00294       } else if (_socksLib) {
00295          _socksLib->unload();
00296          _socksLib = 0L;
00297       }
00298    } else              // leave this here   "else for {}"
00299    for (QStringList::Iterator pit  = _libPaths.begin();
00300                               !_hasSocks && pit != _libPaths.end();
00301                               ++pit)
00302    for (QStringList::Iterator it  = _libNames.begin();
00303                               it != _libNames.end();
00304                               ++it) {
00305       _socksLib = ll->library((*pit + *it).latin1());
00306       if (_socksLib) {
00307          if ((_meth == 1 || _meth == 2) &&
00308              _socksLib->symbol("S5LogShowThreadIDS") != 0L) {  // NEC SOCKS
00309             kdDebug(171) << "Found NEC SOCKS" << endl;
00310             _st = new KNECSocksTable;
00311             _useSocks = true;
00312             _hasSocks = true;
00313             break;
00314          } else if ((_meth == 1 || _meth == 3) &&
00315                     _socksLib->symbol("sockaddr2ruleaddress") != 0L) { //Dante
00316             kdDebug(171) << "Found Dante SOCKS" << endl;
00317             _st = new KDanteSocksTable;
00318             _useSocks = true;
00319             _hasSocks = true;
00320             break;
00321          } else {
00322            _socksLib->unload();
00323            _socksLib = 0L;
00324          }
00325       }
00326    }
00327 
00328    // Load in all the symbols
00329    if (_st) {
00330       for (QMap<SymbolKeys,QString>::Iterator it  = _st->symbols.begin();
00331                                               it != _st->symbols.end();
00332                                               ++it) {
00333          switch(it.key()) {
00334          case S_SOCKSinit:
00335            F_SOCKSinit = (int (*)(char *))
00336                          _socksLib->symbol(it.data().latin1());
00337           break;
00338          case S_connect:
00339            F_connect = (int (*)(int, const struct sockaddr *, ksocklen_t))
00340                        _socksLib->symbol(it.data().latin1());
00341           break;
00342          case S_read:
00343            F_read = (signed long int (*)(int, void *, unsigned long int))
00344                     _socksLib->symbol(it.data().latin1());
00345           break;
00346          case S_write:
00347            F_write = (signed long int (*)(int, const void *, unsigned long int))
00348                      _socksLib->symbol(it.data().latin1());
00349           break;
00350          case S_recvfrom:
00351            F_recvfrom = (int (*)(int, void *, unsigned long int, int,
00352                                  struct sockaddr *, ksocklen_t *))
00353                         _socksLib->symbol(it.data().latin1());
00354           break;
00355          case S_sendto:
00356            F_sendto = (int (*)(int, const void *, unsigned long int, int,
00357                                const struct sockaddr *, ksocklen_t))
00358                       _socksLib->symbol(it.data().latin1());
00359           break;
00360          case S_recv:
00361            F_recv = (int (*)(int, void *, unsigned long int, int))
00362                     _socksLib->symbol(it.data().latin1());
00363           break;
00364          case S_send:
00365            F_send = (int (*)(int, const void *, unsigned long int, int))
00366                     _socksLib->symbol(it.data().latin1());
00367           break;
00368          case S_getsockname:
00369            F_getsockname = (int (*)(int, struct sockaddr *, ksocklen_t *))
00370                            _socksLib->symbol(it.data().latin1());
00371           break;
00372          case S_getpeername:
00373            F_getpeername = (int (*)(int, struct sockaddr *, ksocklen_t *))
00374                            _socksLib->symbol(it.data().latin1());
00375           break;
00376          case S_accept:
00377            F_accept = (int (*)(int, struct sockaddr *, ksocklen_t *))
00378                       _socksLib->symbol(it.data().latin1());
00379           break;
00380          case S_select:
00381            F_select = (int (*)(int, fd_set *, fd_set *, fd_set *, struct timeval *))
00382                       _socksLib->symbol(it.data().latin1());
00383           break;
00384          case S_listen:
00385            F_listen = (int (*)(int, int))
00386                       _socksLib->symbol(it.data().latin1());
00387           break;
00388          case S_bind:
00389            F_bind = (int (*)(int, const struct sockaddr *, ksocklen_t))
00390                     _socksLib->symbol(it.data().latin1());
00391           break;
00392          default:
00393           kdDebug(171) << "KSocks got a symbol it doesn't know about!" << endl;
00394           break;
00395          }
00396       }
00397 
00398       // Now we check for the critical stuff.
00399       if (F_SOCKSinit) {
00400          int rc = (*F_SOCKSinit)((char *)"KDE");
00401          if (rc != 0)
00402             stopSocks();
00403          else kdDebug(171) << "SOCKS has been activated!" << endl;
00404       } else {
00405          stopSocks();
00406       }
00407    }
00408 }
00409 
00410 
00411 KSocks::~KSocks() {
00412    stopSocks();
00413    _me = 0;
00414 }
00415 
00416 void KSocks::die() {
00417    if (_me == this) {
00418       _me = 0;
00419       delete this;
00420    }
00421 }
00422 
00423 void KSocks::stopSocks() {
00424    if (_hasSocks) {
00425       // This library doesn't even provide the basics.
00426       // It's probably broken.  Let's abort.
00427       _useSocks = false;
00428       _hasSocks = false;
00429       if (_socksLib) {
00430          _socksLib->unload();
00431          _socksLib = 0L;
00432       }
00433       delete _st;
00434       _st = 0L;
00435    }
00436 }
00437 
00438 
00439 bool KSocks::usingSocks() {
00440    return _useSocks;
00441 }
00442 
00443 
00444 bool KSocks::hasSocks() {
00445    return _hasSocks;
00446 }
00447 
00448 
00449 void KSocks::disableSocks() {
00450    _useSocks = false;
00451 }
00452 
00453 
00454 void KSocks::enableSocks() {
00455    if (_hasSocks)
00456       _useSocks = true;
00457 }
00458 
00459 bool KSocks::hasWorkingAsyncConnect()
00460 {
00461    return (_useSocks && _st) ? _st->hasWorkingAsyncConnect : true;
00462 }
00463 
00464 
00465 /*
00466  *   REIMPLEMENTED FUNCTIONS FROM LIBC
00467  *
00468  */
00469 
00470 int KSocks::connect (int sockfd, const sockaddr *serv_addr,
00471                                                    ksocklen_t addrlen) {
00472    if (_useSocks && F_connect)
00473       return (*F_connect)(sockfd, serv_addr, addrlen);
00474    else return ::connect(sockfd, (sockaddr*) serv_addr, (socklen_t)addrlen);
00475 }
00476 
00477 
00478 signed long int KSocks::read (int fd, void *buf, unsigned long int count) {
00479    if (_useSocks && F_read)
00480       return (*F_read)(fd, buf, count);
00481    else return ::read(fd, buf, count);
00482 }
00483 
00484 
00485 signed long int KSocks::write (int fd, const void *buf, unsigned long int count) {
00486    if (_useSocks && F_write)
00487       return (*F_write)(fd, buf, count);
00488    else return ::write(fd, buf, count);
00489 }
00490 
00491 
00492 int KSocks::recvfrom (int s, void *buf, unsigned long int len, int flags,
00493                                 sockaddr *from, ksocklen_t *fromlen) {
00494    if (_useSocks && F_recvfrom) {
00495       return (*F_recvfrom)(s, buf, len, flags, from, fromlen);
00496    } else {
00497       socklen_t casted_len = (socklen_t) *fromlen;
00498       int rc = ::recvfrom(s, (char*) buf, len, flags, from, &casted_len);
00499       *fromlen = casted_len;
00500       return rc;
00501    }
00502 }
00503 
00504 
00505 int KSocks::sendto (int s, const void *msg, unsigned long int len, int flags,
00506                              const sockaddr *to, ksocklen_t tolen) {
00507    if (_useSocks && F_sendto)
00508       return (*F_sendto)(s, msg, len, flags, to, tolen);
00509    else return ::sendto(s, (char*) msg, len, flags, to, (socklen_t)tolen);
00510 }
00511 
00512 
00513 int KSocks::recv (int s, void *buf, unsigned long int len, int flags) {
00514    if (_useSocks && F_recv)
00515       return (*F_recv)(s, buf, len, flags);
00516    else return ::recv(s, (char*) buf, len, flags);
00517 }
00518 
00519 
00520 int KSocks::send (int s, const void *msg, unsigned long int len, int flags) {
00521    if (_useSocks && F_send)
00522       return (*F_send)(s, msg, len, flags);
00523    else return ::send(s, (char*) msg, len, flags);
00524 }
00525 
00526 
00527 int KSocks::getsockname (int s, sockaddr *name, ksocklen_t *namelen) {
00528    if (_useSocks && F_getsockname) {
00529       return (*F_getsockname)(s, name, namelen);
00530    } else {
00531      socklen_t casted_len = *namelen;
00532      int rc = ::getsockname(s, name, &casted_len);
00533      *namelen = casted_len;
00534      return rc;
00535    }
00536 }
00537 
00538 
00539 int KSocks::getpeername (int s, sockaddr *name, ksocklen_t *namelen) {
00540    if (_useSocks && F_getpeername) {
00541       return (*F_getpeername)(s, name, namelen);
00542    } else {
00543       socklen_t casted_len = *namelen;
00544       int rc = ::getpeername(s, name, &casted_len);
00545       *namelen = casted_len;
00546       return rc;
00547    }
00548 }
00549 
00550 
00551 int KSocks::accept (int s, sockaddr *addr, ksocklen_t *addrlen) {
00552    if (_useSocks && F_accept) {
00553      return (*F_accept)(s, addr, addrlen);
00554    } else {
00555       socklen_t casted_len = *addrlen;
00556       int rc = ::accept(s, addr, &casted_len);
00557       *addrlen = casted_len;
00558       return rc;
00559    }
00560 }
00561 
00562 
00563 int KSocks::select (int n, fd_set *readfds, fd_set *writefds,
00564                                 fd_set *exceptfds, struct timeval *timeout) {
00565    if (_useSocks && F_select)
00566       return (*F_select)(n, readfds, writefds, exceptfds, timeout);
00567    else return ::select(n, readfds, writefds, exceptfds, timeout);
00568 }
00569 
00570 
00571 int KSocks::listen (int s, int backlog) {
00572    if (_useSocks && F_listen)
00573       return (*F_listen)(s, backlog);
00574    else return ::listen(s, backlog);
00575 }
00576 
00577 
00578 int KSocks::bind (int sockfd, const sockaddr *my_addr, ksocklen_t addrlen) {
00579    if (_useSocks && F_bind)
00580       return (*F_bind)(sockfd, my_addr, addrlen);
00581    else return ::bind(sockfd, my_addr, (socklen_t)addrlen);
00582 }
00583 
00584 int KSocks::bind (int sockfd, sockaddr *my_addr, ksocklen_t addrlen) {
00585    if (_useSocks && F_bind)
00586       return (*F_bind)(sockfd, my_addr, addrlen);
00587    else return ::bind(sockfd, my_addr, (socklen_t)addrlen);
00588 }
00589 
00590 
00591 
KDE Logo
This file is part of the documentation for kdecore Library Version 3.2.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed May 12 09:03:50 2004 by doxygen 1.3.4 written by Dimitri van Heesch, © 1997-2003