rconnect.c

Linux下的socks的程序源程序,用于socks的代理服务

			syslog(LOG_LOW, "Connection failed.\n");
		}
		return(-1);
	} else if (socks_conn_init) {
#ifdef DEBUG
fprintf(stderr, "Rconnect 200, Rconnect(%d, %s, %s)\n", sock, socks_dst_name, socks_dst_serv);
#endif /* #ifdef DEBUG */
		wait_ret = waitpid(socks_conn_init, &status, WNOHANG);
		if (wait_ret == 0) {
			errno = EALREADY;
#ifdef DEBUG
fprintf(stderr, "Rconnect 300, ret=-1, errno=EALREADY\n");
#endif /* #ifdef DEBUG */
			return(-1);
		} else if (wait_ret == socks_conn_init) {
			socks_conn_init = 0;
			socks_conn_code = 0;
			socks_conn_sock = 0;
			socks_conn_port = 0;
			socks_conn_host = 0;
			if (status & 0x00ff) {
				kill(socks_conn_init, SIGKILL);
				errno = ECONNREFUSED;
#ifdef DEBUG
fprintf(stderr, "Rconnect 400, ret=-1, errno=ECONNREFUSED\n");
#endif /* #ifdef DEBUG */
				syslog(LOG_LOW, "Connection failed.\n");
				return(-1);
			} else {
				status = (status >> 8) & 0x00ff;
				res_ret = check_result(status);
#ifdef DEBUG
fprintf(stderr, "Rconnect 500, ret=%d, status=%d\n", res_ret, status);
#endif /* #ifdef DEBUG */
				if (res_ret == 0) {
					errno = EISCONN;
					socks_last_conn_host = sin->sin_addr.s_addr;
					socks_last_conn_port = sin->sin_port;
				} else {
					syslog(LOG_LOW, "Connection failed.\n");
				}
				return(-1);
			}
		} else {
			kill(socks_conn_init, SIGKILL);
			errno = ECONNREFUSED;
#ifdef DEBUG
fprintf(stderr, "Rconnect 600, ret=-1, errno=ECONNREFUSED\n");
#endif /* #ifdef DEBUG */
			socks_conn_init = 0;
			socks_conn_code = 0;
			socks_conn_sock = 0;
			socks_conn_port = 0;
			socks_conn_host = 0;
			syslog(LOG_LOW, "Connection failed.\n");
			return(-1);
		}
	}

#ifdef DEBUG
fprintf(stderr, "Rconnect 700, Rconnect(%d, %s, %s)\n", sock, socks_dst_name, socks_dst_serv);
#endif /* #ifdef DEBUG */

#ifdef VERSATILE_CLIENTS
	direct = socks_check_cconf(&me, sin);
#ifdef DEBUG
fprintf(stderr, "Rconnect() 800: direct = %d\n", direct);
#endif /* #ifdef DEBUG */
	if (direct < 0) {
		syslog(LOG_LOW, "refused -- connect() from %s(%s) to %s (%s)",
			socks_src_user, socks_real_user, socks_dst_name, socks_dst_serv);
		errno = ECONNREFUSED;
#ifdef DEBUG
fprintf(stderr, "Rconnect 900, ret=-1, errno=EALREADY\n");
#endif /* #ifdef DEBUG */
		return(-1);
	}

	if (direct == 1) {
		syslog(LOG_LOW, "connect() directly from %s(%s) to %s (%s)",
			socks_src_user, socks_real_user, socks_dst_name, socks_dst_serv);
		con_ret = connect(sock, (struct sockaddr *)sin, size);
		if (con_ret == 0) {
			socks_last_conn_host = sin->sin_addr.s_addr;
			socks_last_conn_port = sin->sin_port;
		}
#ifdef DEBUG
fprintf(stderr, "Rconnect 1000, ret=%d, ", con_ret);
perror(" ");
#endif /* #ifdef DEBUG */
		return(con_ret);
	}
#endif /* #ifdef VERSATILE_CLIENTS */
	
	con_ret = connect_sockd(sock, &lport);
#ifdef DEBUG
	fprintf(stderr, "con_ret=connect_sockd()=%d", con_ret);
	if(con_ret < 0)
		perror("");
	else
		fprintf(stderr,"\n");
#endif /* #ifdef DEBUG */
	if (con_ret == 0) {
		syslog(LOG_LOW, "connect() from %s(%s) to %s (%s) using sockd at %s",
				socks_src_user, socks_real_user, socks_dst_name, socks_dst_serv, socks_server);
		dst.version = SOCKS_VERSION;
		dst.cmd = SOCKS_CONNECT;
		dst.port = sin->sin_port;
		dst.host = sin->sin_addr.s_addr;
		if (socksC_proto(sock, &dst) < 0) {
			return(-1);
		}
		res_ret = check_result(dst.cmd);
#ifdef DEBUG
fprintf(stderr, "Rconnect 1100, ret=%d, ", res_ret);
perror(" ");
#endif /* #ifdef DEBUG */
		if (res_ret == 0) {
			socks_last_conn_host = sin->sin_addr.s_addr;
			socks_last_conn_port = sin->sin_port;
		}
		return(res_ret);
	}
	if ((con_ret < 0) && (errno != EINPROGRESS)) {
#ifdef DEBUG
fprintf(stderr, "Rconnect 1200, ret=%d, ", con_ret);
perror(" ");
#endif /* #ifdef DEBUG */
		return(-1);
	}
/*
	con_errno = errno;
*/
	syslog(LOG_LOW, "connect() from %s(%s) to %s (%s) using sockd at %s",
			socks_src_user, socks_real_user, socks_dst_name, socks_dst_serv, socks_server);

	switch (child_pid = fork()) {
	case -1:
		perror("fork()");
		errno = ECONNREFUSED;
#ifdef DEBUG
fprintf(stderr, "Rconnect 1300, ret=-1, ");
perror(" ");
#endif /* #ifdef DEBUG */
		return(-1);
	case 0:
		do_C_proto(sock, sin->sin_port, sin->sin_addr.s_addr);
	default:
		socks_conn_init = child_pid;
		socks_conn_code = 0;
		socks_conn_sock = sock;
		socks_conn_port = sin->sin_port;
		socks_conn_host = sin->sin_addr.s_addr;
		errno = EINPROGRESS;
#ifdef DEBUG
fprintf(stderr, "Rconnect 1400, ret=-1 ");
perror(" ");
#endif /* #ifdef DEBUG */
		return(-1);
	}
}

/* >>> YDL 94/01/25 */
#ifdef SHORTENED_RBIND
Rbind(sock, sin, size)
int			sock;
struct sockaddr_in	*sin;
int			size;
#else
/*
**  Set up a bind for a remote host, add fill 'cursin' in with the
**   remote server information.
**  If using reserved port, the port must have already been reserved
**   through a rresvport() call.
*/
Rbind(sock, sin, size, dsthost)
int			sock;
struct sockaddr_in	*sin;
int			size;
u_int32		dsthost; /* as in sin_addr.s_addr */
#endif /* #ifdef SHORTENED_RBIND */
/* <<< YDL 94/01/25 */
{
	Socks_t			dst;
	struct sockaddr_in	psin;
	int	i;
	int	new_sock, lport;
	u_int32	remhost;
	int	con_ret;
	struct timeval tmo;
	fd_set fds;
	int	s;

	if (socks_init_done == 0)
		SOCKSinit("SOCKSclient");
	bzero((char *)&psin, sizeof(psin));
	lport = ntohs(sin->sin_port);
	strcpy(socks_cmd, "bind");
#ifdef SHORTENED_RBIND
# ifdef NO_GUESSING_REMHOST
	remhost = 0L;
	strcpy(socks_dst_name, "Unspecified.Host");
# else
	remhost = socks_last_conn_host;
	socks_saddrtoname(&remhost, socks_dst_name, sizeof(socks_dst_name));
# endif /* # ifdef NO_GUESSING_REMHOST */
#else
	remhost = dsthost;
	socks_saddrtoname(&remhost, socks_dst_name, sizeof(socks_dst_name));
#endif /* #ifdef SHORTENED_RBIND */
	socks_porttoserv(socks_last_conn_port, socks_dst_serv, sizeof(socks_dst_serv));
#ifdef DEBUG
fprintf(stderr, "Rbind 100, lport=%u, socks_dst_name=>%s<, socks_dst_serv=>%s<\n", lport, socks_dst_name, socks_dst_serv);
fprintf(stderr, "Rbind(%d, %s, %s)\n", sock, socks_dst_name, socks_dst_serv);
#endif /* #ifdef DEBUG */

	psin.sin_addr.s_addr = remhost;
	psin.sin_port = socks_last_conn_port;
#ifdef VERSATILE_CLIENTS
	direct = socks_check_cconf(&me, &psin);
#ifdef DEBUG
fprintf(stderr, "Rbind() 200, direct = %d\n", direct);
#endif /* #ifdef DEBUG */
	if (direct < 0) {
		syslog(LOG_LOW, "Refused -- bind() from %s(%s) for %s (%s)",
			socks_src_user, socks_real_user, socks_dst_name, socks_dst_serv);
		errno = ECONNREFUSED;
		return -1;
	}

	if (direct == 1) {
		syslog(LOG_LOW, "bind() directly from %s(%s) for %s (%s)",
			socks_src_user, socks_real_user, socks_dst_name, socks_dst_serv);
#ifdef DEBUG
fprintf(stderr,"Rbind() 300, direct=1, lport=%u\n", lport);
#endif /* #ifdef DEBUG */
#if defined(SUPPORT_RCMD)
		if ((lport >= IPPORT_RESERVED) || (lport < IPPORT_RESERVED/2))
			return (bind(sock, (struct sockaddr *)sin, size));
		else
			return 0;
#else /* SUPPORT_RCMD not defined */
		return (bind(sock, (struct sockaddr *)sin, size));
#endif /* #if defined(SUPPORT_RCMD) */
	}
#endif /* #ifdef VERSATILE_CLIENTS */
	
	con_ret = connect_sockd(sock, &lport);
	if (con_ret == 0) {
		;
#ifdef SVR4
	} else if ((errno == EINPROGRESS) || (errno == EAGAIN)) {
#else
	} else if (errno == EINPROGRESS) {
#endif
		while (1) {
			tmo.tv_sec = 0;
			tmo.tv_usec = 100000;
			FD_ZERO(&fds);
			FD_SET(sock, &fds);
			s = select(sock+1, NULL, &fds, NULL, &tmo);
			if ((s == 0) || ((s == -1) && (errno == EINTR)))
				continue;
			if (s < 0) {
				syslog(LOG_LOW, "select() in Rbind(): %m");
				errno = ECONNREFUSED;
				return -1;
			}
			con_ret = connect(sock, (struct sockaddr *)&socks_nsin, sizeof(struct sockaddr_in));
			if ((con_ret < 0) && (errno == EISCONN)) {
				con_ret = 0;
				break;
#if defined(SVR4)
			} else if ((con_ret < 0) && ((errno == EALREADY) || 
				(errno == EAGAIN))) {
#else /* !defined(SVR4) */
			} else if ((con_ret < 0) && (errno == EALREADY)) {
#endif /* #if defined(SVR4) */
				continue;
			} else
				break;
		}
	}
	if (con_ret < 0) {
		syslog(LOG_LOW, "Failed -- bind() from %s(%s) for %s (%s)",
			socks_src_user, socks_real_user, socks_dst_name, socks_dst_serv);
		errno = ECONNREFUSED;
		return -1;
	}
	syslog(LOG_LOW, "bind() from %s(%s) for %s (%s) using sockd at %s",
		socks_src_user, socks_real_user, socks_dst_name, socks_dst_serv, socks_server);

	dst.version = SOCKS_VERSION;
	dst.cmd     = SOCKS_BIND;
	dst.port    = socks_last_conn_port;
	dst.host    = remhost;
	if (socksC_proto(sock, &dst) < 0)
		return(-1);
	cursin.sin_family = AF_INET;
	cursin.sin_port = dst.port;
	if (ntohl(dst.host) == INADDR_ANY)
		cursin.sin_addr.s_addr = socks_nsin.sin_addr.s_addr;
	else
		cursin.sin_addr.s_addr = dst.host;
/*
        fprintf(stderr,"Rbind interface: %s, port: %u\n",
                inet_ntoa(cursin.sin_addr), htons(cursin.sin_port));
*/

	return (check_result(dst.cmd));
}

/*
**  Stub routine since the listen will have alread succeded on the
**   server.
*/
Rlisten(s, n)
int	s, n;
{
#ifdef DEBUG
	fprintf(stderr, "direct=%d, Rlisten(%d, %d)\n", direct, s, n);
#endif
#ifdef VERSATILE_CLIENTS
	if (direct)
		return (listen(s, n));
#endif /* #ifdef VERSATILE_CLIENTS */

	return 0;
}

/*
**  Well we know where we got a connection from.
*/
Rgetsockname(sock, sin, size)
int			sock;
struct sockaddr_in	*sin;
int			*size;
{
#ifdef DEBUG
	socks_saddrtoname(&sin->sin_addr, socks_dst_name, sizeof(socks_dst_name));
	socks_porttoserv(sin->sin_port, socks_dst_serv, sizeof(socks_dst_serv));
	fprintf(stderr, "direct= %d, Rgetsockname(%d, %s, %s)\n",
		direct, sock, socks_dst_name, socks_dst_serv);
#endif
#ifdef VERSATILE_CLIENTS
	if (direct)
		return (getsockname(sock, (struct sockaddr *)sin, size));
#endif /* #ifdef VERSATILE_CLIENTS */

	*size = sizeof(struct sockaddr_in);
	*sin = cursin;

	return 0;
}

/*
**  Do an accept, which is really a select for some data on
**    the present socket.
*/
Raccept(sock, sin, size)
int			sock;
struct sockaddr_in	*sin;
int			*size;
{
	fd_set		fds;
	Socks_t		dst;
	int		fdsbits = sock + 1;

#ifdef DEBUG
	fprintf(stderr, "direct= %d, Raccept(%d, sin, size)\n",
		direct, sock);
#endif

#ifdef VERSATILE_CLIENTS
	if (direct)
		return(accept(sock, (struct sockaddr *)sin, size));
#endif /* #ifdef VERSATILE_CLIENTS */

	FD_ZERO(&fds);
	FD_SET(sock, &fds);

	if (select(fdsbits, &fds, NULL, NULL, NULL) > 0)
		if (FD_ISSET(sock, &fds)) {
			socks_GetDst(sock, &dst);
			sin->sin_family = AF_INET;
			sin->sin_port = dst.port;
			sin->sin_addr.s_addr = dst.host;
			return(dup(sock));
		}
	return -1;
}

int Rselect(width, readfds, writefds, exceptfds, timeout)
int width;
fd_set *readfds, *writefds, *exceptfds;
struct timeval *timeout;
{
	int wait_ret, status;

	if(!socks_conn_init ) {
		return(select(width, readfds, writefds, exceptfds, timeout));
	}

	if (readfds != NULL)
		FD_CLR(socks_conn_sock, readfds);
	if (exceptfds != NULL)
		FD_CLR(socks_conn_sock, exceptfds);
	if ((writefds == NULL) || !FD_ISSET(socks_conn_sock, writefds))
		return(select(width, readfds, writefds, exceptfds, timeout));

	wait_ret = waitpid(socks_conn_init, &status, WNOHANG);
	if (wait_ret == 0) {
		FD_CLR(socks_conn_sock, writefds);
		return(select(width, readfds, writefds, exceptfds, timeout));
	} else if (wait_ret == socks_conn_init) {
/*
		socks_conn_init = 0;
		socks_conn_sock = 0;
		socks_conn_port = 0;
		socks_conn_host = 0;
*/
		if (status & 0x00ff) {
			kill(socks_conn_init, SIGKILL);
			socks_conn_init = 0;
			socks_conn_code = SOCKS_FAIL;
		} else {
			status = (status >> 8) & 0x00ff;
			if (status == SOCKS_RESULT) {
				socks_last_conn_host = socks_conn_host;
				socks_last_conn_port = socks_conn_port;
			} 
			socks_conn_init = 0;
			socks_conn_code = status;
		}
	} else {
		kill(socks_conn_init, SIGKILL);
		socks_conn_init = 0;
		socks_conn_code = SOCKS_FAIL;
	}

	return(select(width, readfds, writefds, exceptfds, timeout));
}