Logo Search packages:      
Sourcecode: dante version File versions

Rconnect.c

/*
 * Copyright (c) 1997, 1998, 1999, 2000, 2001, 2002, 2003
 *      Inferno Nettverk A/S, Norway.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. The above copyright notice, this list of conditions and the following
 *    disclaimer must appear in all copies of the software, derivative works
 *    or modified versions, and any portions thereof, aswell as in all
 *    supporting documentation.
 * 2. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by
 *      Inferno Nettverk A/S, Norway.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Inferno Nettverk A/S requests users of this software to return to
 *
 *  Software Distribution Coordinator  or  sdc@inet.no
 *  Inferno Nettverk A/S
 *  Oslo Research Park
 *  Gaustadalléen 21
 *  NO-0349 Oslo
 *  Norway
 *
 * any improvements or extensions that they make and grant Inferno Nettverk A/S
 * the rights to redistribute these changes.
 *
 */

#include "common.h"

static const char rcsid[] =
"$Id: Rconnect.c,v 1.120 2003/07/01 13:21:22 michaels Exp $";

int
Rconnect(s, name, namelen)
      int s;
      const struct sockaddr *name;
      socklen_t namelen;
{
      const char *function = "Rconnect()";
      struct sockshost_t src, dst;
      struct socksfd_t socksfdmem, *socksfd;
      struct socks_t packet;
      socklen_t len;
      char namestring[MAXSOCKADDRSTRING];
      int type, p;

      clientinit();

      if (name == NULL) {
            slog(LOG_DEBUG,
            "%s: sockaddr argument NULL, fallback to system connect()", function);
            return connect(s, name, namelen);
      }

      if (name->sa_family != AF_INET) {
            slog(LOG_DEBUG,
            "%s: unsupported address family '%d', fallback to system connect()",
            function, name->sa_family);
            return connect(s, name, namelen);
      }

      slog(LOG_DEBUG, "%s: %s",
      function, sockaddr2string(name, namestring, sizeof(namestring)));

      if (socks_addrisok((unsigned int)s)) {
            socksfd = socks_getaddr((unsigned int)s);

            switch (socksfd->state.command) {
                  case SOCKS_BIND:
                        /*
                         * Our guess; the client has succeeded to bind a specific
                         * address and is now trying to connect out from it.
                         * That also indicates the socksserver is listening on a port
                         * for this client.  Can't accept() on a connected socket so
                         * lets close the connection to the server so it can stop
                         * listening on our behalf and we continue as if this was an
                         * ordinary connect().  Can only hope the server will use
                         * same port as we for connecting out.
                         */
                        socks_rmaddr((unsigned int)s);
                        break;

                  case SOCKS_CONNECT:
                        if (socksfd->state.err != 0)
                              errno = socksfd->state.err;
                        else
                              if (socksfd->state.inprogress)
                                    errno = EALREADY;
                              else
                                    errno = EISCONN;
                        return -1;

                  case SOCKS_UDPASSOCIATE:
                        /*
                         * Trying to connect a udp socket (to a new address)?
                         * Just continue as usual, udpsetup() will reuse existing
                         * setup and we just assign the new ("connected") address.
                         */
                        break;

                  default:
                        SERRX(socksfd->state.command);
            }
      }
      else
            socks_rmaddr((unsigned int)s);

      len = sizeof(type);
      if (getsockopt(s, SOL_SOCKET, SO_TYPE, &type, &len) != 0)
            return -1;

      switch (type) {
            case SOCK_DGRAM:
                  if (udpsetup(s, name, SOCKS_SEND) == 0) {
                        socksfd = socks_getaddr((unsigned int)s);
                        SASSERTX(socksfd != NULL);

                        if (connect(s, &socksfd->reply, sizeof(socksfd->reply)) != 0) {
                              socks_rmaddr((unsigned int)s);
                              return -1;
                        }

                        socksfd->state.udpconnect     = 1;
                        socksfd->forus.connected      = *name;

                        return 0;
                  }
                  else {
                        if (errno == 0)
                              /* not a network error, try standard connect. */
                              return connect(s, name, namelen);
                        else
                              return -1;
                  }
      }

      socksfd = &socksfdmem;
      bzero(socksfd, sizeof(*socksfd));
      len = sizeof(socksfd->local);
      if (getsockname(s, &socksfd->local, &len) != 0)
            return -1;

      src.atype         = SOCKS_ADDR_IPV4;
      /* LINTED pointer casts may be troublesome */
      src.addr.ipv4     = TOIN(&socksfd->local)->sin_addr;
      /* LINTED pointer casts may be troublesome */
      src.port                = TOIN(&socksfd->local)->sin_port;

      fakesockaddr2sockshost(name, &dst);

      bzero(&packet, sizeof(packet));
      packet.req.host         = dst;
      packet.req.version      = SOCKS_V5;
      packet.req.command      = SOCKS_CONNECT;

      if (socks_requestpolish(&packet.req, &src, &dst) == NULL)
            return connect(s, name, namelen);

      packet.version = packet.req.version;

      switch (packet.req.version) {
            case SOCKS_V4:
            case SOCKS_V5:
                  socksfd->control = s;
                  break;

            case MSPROXY_V2:
                  /* always needs a separate controlchannel. */
                  if ((socksfd->control = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
                        return -1;
                  break;

            case HTTP_V1_0:
                  socksfd->control = s;
                  break;

            default:
                  SERRX(packet.req.version);
      }

      if ((p = fcntl(s, F_GETFL, 0)) == -1)
            return -1;

      if (p & NONBLOCKING)
            socksfd->route
            = socks_nbconnectroute(s, socksfd->control, &packet, &src, &dst);
      else
            socksfd->route
            = socks_connectroute(socksfd->control, &packet, &src, &dst);

      slog(LOG_DEBUG, "%s: route = %s, errno = %d",
      function, socksfd->route == NULL ? "null" : "found", errno);

      if (socksfd->route == NULL) {
            if (s != socksfd->control)
                  close(socksfd->control);

            switch (errno) {
                  case EADDRINUSE: {
                        /*
                         * This problem can arise when we are socksifying
                         * a serverapplication that does several outbound
                         * connections from the same address (e.g. ftpd) to the
                         * same socksserver.
                         * It has by now successfully bound the address (it thinks)
                         * and is not expecting this error.
                         * Not sure what is best to do, just failing here prevents
                         * ftpd from working for clients using the PORT command.
                         *
                         * For now, lets retry with a new socket.
                         * This means the server no longer has bound the address
                         * it (may) think it has ofcourse, so not sure how smart this
                         * really is.
                         */
                        int tmp_s;

                        swarn("%s: server socksified?  trying to work around problem...",
                        function);

                        if ((tmp_s = socketoptdup(s)) == -1)
                              break;
                        if (dup2(tmp_s, s) == -1)
                              break;
                        close(tmp_s);

                        /*
                         * if s was bound to a privileged port, try to bind the new
                         * s too to a privileged port.
                         */
                        /* LINTED pointer casts may be troublesome */
                        if (PORTISRESERVED(TOIN(&socksfd->local)->sin_port)) {
                              /* LINTED pointer casts may be troublesome */
                              TOIN(&socksfd->local)->sin_port = htons(0);

                              /* LINTED pointer casts may be troublesome */
                              bindresvport(s, TOIN(&socksfd->local));
                        }
                        return Rconnect(s, name, namelen);
                  }
            }

            return errno == 0 ? connect(s, name, namelen) : -1;
      }

      if (p & NONBLOCKING)
            return -1; /* got route, nonblocking connect in progress. */

      if (socks_negotiate(s, socksfd->control, &packet, socksfd->route) != 0)
            return -1;

      socksfd->state.auth                       = packet.auth;
      socksfd->state.command              = packet.req.command;
      socksfd->state.version              = packet.req.version;
      socksfd->state.protocol.tcp   = 1;
      socksfd->state.msproxy              = packet.state.msproxy;
      sockshost2sockaddr(&packet.res.host, &socksfd->remote);
      socksfd->forus.connected            = *name;

      /* LINTED pointer casts may be troublesome */
      if (TOIN(&socksfd->local)->sin_port != htons(0)
      &&  TOIN(&socksfd->local)->sin_port != TOIN(&socksfd->remote)->sin_port) {
            /*
             * unfortunate; the client is trying to connect from a specific
             * port, a port it has successfully bound, but the port is currently
             * in use on the serverside or the server doesn't care.
             */

            /* LINTED pointer casts may be troublesome */
            slog(LOG_DEBUG, "failed to get wanted port: %d",
            ntohs(TOIN(&socksfd->local)->sin_port));
      }

      len = sizeof(socksfd->server);
      if (getpeername(s, &socksfd->server, &len) != 0) {
            if (s != socksfd->control)
                  close(socksfd->control);
            return -1;
      }

      len = sizeof(socksfd->local);
      if (getsockname(s, &socksfd->local, &len) != 0) {
            if (s != socksfd->control)
                  close(socksfd->control);
            return -1;
      }

      socks_addaddr((unsigned int)s, socksfd);

      sockscf.state.lastconnect = *name;  /* needed for standard socks bind. */

      return 0;
}

Generated by  Doxygen 1.6.0   Back to index