commands.c

socket5 代理服务代码 socket5 代理服务代码

    return(NULL);
}

void env_init() {
    extern char **environ;
    register char **epp, *cp;
    register struct env_lst *ep;

    for (epp = environ; *epp; epp++) {
	if ((cp = strchr(*epp, '='))) {
	    *cp = '\0';
	    ep = env_define((unsigned char *)*epp, (unsigned char *)cp+1);
	    ep->export = 0;
	    *cp = '=';
	}
    }

    /* Special case for DISPLAY variable.  If it is ":0.0" or "unix:0.0", we */
    /* have to get rid of "unix" and insert our hostname.                    */
    if ((ep = env_find((unsigned char *)"DISPLAY")) && ((*ep->value == ':') || (strncmp((char *)ep->value, "unix:", 5) == 0))) {
	char hbuf[256+1];
	char *cp2 = strchr((char *)ep->value, ':');
	
	gethostname(hbuf, 256);
	hbuf[256] = '\0';
	cp = (char *)malloc(strlen(hbuf) + strlen(cp2) + 1);
	sprintf((char *)cp, "%s%s", hbuf, cp2);
	free(ep->value);
	ep->value = (unsigned char *)cp;
    }

    /* If USER is not defined, but LOGNAME is, then add USER with the value  */
    /* from LOGNAME.  By default, we don't export the USER variable.         */
    if ((env_find((unsigned char *)"USER") == NULL) && (ep = env_find((unsigned char *)"LOGNAME"))) {
	env_define((unsigned char *)"USER", ep->value);
	env_unexport((unsigned char *)"USER");
    }

    env_export((unsigned char *)"DISPLAY");
    env_export((unsigned char *)"PRINTER");
}

struct env_lst *env_define(unsigned char *var, unsigned char *value) {
    register struct env_lst *ep;
	
    if ((ep = env_find(var))) {
	if (ep->var)   free(ep->var);
	if (ep->value) free(ep->value);
    } else {
	ep = (struct env_lst *)malloc(sizeof(struct env_lst));
	ep->next = envlisthead.next;
	envlisthead.next = ep;
	ep->prev = &envlisthead;
	if (ep->next) ep->next->prev = ep;
    }

    ep->welldefined = opt_welldefined((char *)var);
    ep->export = 1;
    ep->var = (unsigned char *)strdup((char *)var);
    ep->value = (unsigned char *)strdup((char *)value);
    return(ep);
}

void env_undefine(unsigned char *var) {
    register struct env_lst *ep;
	
    if ((ep = env_find(var))) {
	ep->prev->next = ep->next;
	if (ep->next)  ep->next->prev = ep->prev;
	if (ep->var)   free(ep->var);
	if (ep->value) free(ep->value);
	free(ep);
    }
}

void env_export(unsigned char *var) {
    register struct env_lst *ep;
    
    if ((ep = env_find(var))) ep->export = 1;
}

void env_unexport(unsigned char *var) {
    register struct env_lst *ep;
	
    if ((ep = env_find(var))) ep->export = 0;
}

void env_send(unsigned char *var) {
    register struct env_lst *ep;

    if (my_state_is_wont(TELOPT_NEW_ENVIRON)
#ifdef	OLD_ENVIRON
	&& my_state_is_wont(TELOPT_OLD_ENVIRON)
#endif
	) {
	fprintf(stderr, "Cannot send '%s': Telnet ENVIRON option not enabled\n", var);
	return;
    }

    ep = env_find(var);
    
    if (ep == 0) {
	fprintf(stderr, "Cannot send '%s': variable not defined\n", var);
	return;
    }

    env_opt_start_info();
    env_opt_add(ep->var);
    env_opt_end(0);
}

void env_list() {
    register struct env_lst *ep;
    
    for (ep = envlisthead.next; ep; ep = ep->next) {
	printf("%c %-20s %s\n", ep->export ? '*' : ' ', ep->var, ep->value);
    }
}

	unsigned char *
env_default(init, welldefined)
    int init, welldefined;
{
	static struct env_lst *nep = NULL;

	if (init) {
		nep = &envlisthead;
		return NULL;
	}
	if (nep) {
		while ((nep = nep->next)) {
			if (nep->export && (nep->welldefined == welldefined))
				return(nep->var);
		}
	}
	return(NULL);
}

	unsigned char *
env_getvalue(var)
	unsigned char *var;
{
	register struct env_lst *ep;
	
	if ((ep = env_find(var)))
		return(ep->value);
	return(NULL);
}

#if defined(OLD_ENVIRON) && defined(ENV_HACK)
	void
env_varval(what)
	unsigned char *what;
{
	extern int old_env_var, old_env_value, env_auto;
	int len = strlen((char *)what);

	if (len == 0)
		goto unknown;

	if (strncasecmp((char *)what, "status", len) == 0) {
		if (env_auto)
			printf("%s%s", "VAR and VALUE are/will be ",
					"determined automatically\n");
		if (old_env_var == OLD_ENV_VAR)
			printf("VAR and VALUE set to correct definitions\n");
		else
			printf("VAR and VALUE definitions are reversed\n");
	} else if (strncasecmp((char *)what, "auto", len) == 0) {
		env_auto = 1;
		old_env_var = OLD_ENV_VALUE;
		old_env_value = OLD_ENV_VAR;
	} else if (strncasecmp((char *)what, "right", len) == 0) {
		env_auto = 0;
		old_env_var = OLD_ENV_VAR;
		old_env_value = OLD_ENV_VALUE;
	} else if (strncasecmp((char *)what, "wrong", len) == 0) {
		env_auto = 0;
		old_env_var = OLD_ENV_VALUE;
		old_env_value = OLD_ENV_VAR;
	} else {
unknown:
		printf("Unknown \"varval\" command. (\"auto\", \"right\", \"wrong\", \"status\")\n");
	}
}
#endif



#ifdef TN3270
    static void
filestuff(fd)
    int fd;
{
    int res;

#ifdef	F_GETOWN
    setconnmode(0);
    res = fcntl(fd, F_GETOWN, 0);
    setcommandmode();

    if (res == -1) {
	perror("fcntl");
	return;
    }
    printf("\tOwner is %d.\n", res);
#endif

    setconnmode(0);
    res = fcntl(fd, F_GETFL, 0);
    setcommandmode();

    if (res == -1) {
	perror("fcntl");
	return;
    }
#ifdef notdef
    printf("\tFlags are 0x%x: %s\n", res, decodeflags(res));
#endif
}
#endif

/*
 * Print status about the connection.
 */
    /*ARGSUSED*/
    static int 
status(argc, argv)
    int	 argc;
    char *argv[];
{
    if (connected) {
	printf("Connected to %s.\n", hostname);
	if ((argc < 2) || strcmp(argv[1], "notmuch")) {
	    int mode = getconnmode();

	    if (my_want_state_is_will(TELOPT_LINEMODE)) {
		printf("Operating with LINEMODE option\n");
		printf("%s line editing\n", (mode&MODE_EDIT) ? "Local" : "No");
		printf("%s catching of signals\n",
					(mode&MODE_TRAPSIG) ? "Local" : "No");
		slcstate();
#ifdef	KLUDGELINEMODE
	    } else if (kludgelinemode && my_want_state_is_dont(TELOPT_SGA)) {
		printf("Operating in obsolete linemode\n");
#endif
	    } else {
		printf("Operating in single character mode\n");
		if (localchars)
		    printf("Catching signals locally\n");
	    }
	    printf("%s character echo\n", (mode&MODE_ECHO) ? "Local" : "Remote");
	    if (my_want_state_is_will(TELOPT_LFLOW))
		printf("%s flow control\n", (mode&MODE_FLOW) ? "Local" : "No");
	}
    } else {
	printf("No connection.\n");
    }
#ifndef TN3270
    printf("Escape character is '%s'.\n", control(escape));
    (void) fflush(stdout);
#   else /* !defined(TN3270) */
    if ((!In3270) && ((argc < 2) || strcmp(argv[1], "notmuch"))) {
	printf("Escape character is '%s'.\n", control(escape));
    }

    if ((argc >= 2) && !strcmp(argv[1], "everything")) {
	printf("SIGIO received %d time%s.\n",
				sigiocount, (sigiocount == 1)? "":"s");
	if (In3270) {
	    printf("Process ID %d, process group %d.\n",
					    getpid(), getpgrp(getpid()));
	    printf("Terminal input:\n");
	    filestuff(tin);
	    printf("Terminal output:\n");
	    filestuff(tout);
	    printf("Network socket:\n");
	    filestuff(net);
	}
    }
    if (In3270 && transcom) {
       printf("Transparent mode command is '%s'.\n", transcom);
    }

    fflush(stdout);
    if (In3270) return 0;
#   endif /* defined(TN3270) */
    return 1;
}

#ifdef	SIGINFO
/*
 * Function that gets called when SIGINFO is received.
 */
     void
ayt_status()
{
    (void) call(status, "status", "notmuch", 0);
}
#endif

    int
tn(argc, argv)
    int argc;
    char *argv[];
{
    register struct hostent *host = 0;
    struct sockaddr_in sin;
    struct servent *sp = 0;
    unsigned int temp;
#if defined(IP_OPTIONS) && defined(IPPROTO_IP)
    char *srp = 0;
    unsigned int sourceroute(), srlen;
#endif
    char *cmd, *hostp = 0, *portp = 0, *user = 0;

    /* clear the socket address prior to use */
    memset((char *)&sin, 0, sizeof(sin));

    if (connected) {
	printf("?Already connected to %s\n", hostname);
	setuid(getuid());
	return 0;
    }
    if (argc < 2) {
	(void) strcpy(line, "open ");
	printf("(to) ");
	(void) fgets(&line[strlen(line)], sizeof(line) - strlen(line), stdin);
	makeargv();
	argc = margc;
	argv = margv;
    }
    cmd = *argv;
    --argc; ++argv;
    while (argc) {
	if (isprefix(*argv, "help") || isprefix(*argv, "?"))
	    goto usage;
	if (strcmp(*argv, "-l") == 0) {
	    --argc; ++argv;
	    if (argc == 0)
		goto usage;
	    user = *argv++;
	    --argc;
	    continue;
	}
	if (strcmp(*argv, "-a") == 0) {
	    --argc; ++argv;
	    autologin = 1;
	    continue;
	}
	if (hostp == 0) {
	    hostp = *argv++;
	    --argc;
	    continue;
	}
	if (portp == 0) {
	    portp = *argv++;
	    --argc;
	    continue;
	}
    usage:
	printf("usage: %s [-l user] [-a] host-name [port]\n", cmd);
	setuid(getuid());
	return 0;
    }
    if (hostp == 0)
	goto usage;

#if defined(IP_OPTIONS) && defined(IPPROTO_IP)
    if (hostp[0] == '@' || hostp[0] == '!') {
	if ((hostname = strrchr(hostp, ':')) == NULL)
	    hostname = strrchr(hostp, '@');
	hostname++;
	srp = 0;
	temp = sourceroute(hostp, &srp, &srlen);
	if (temp == 0) {
	    herror(srp);
	    setuid(getuid());
	    return 0;
	} else if (temp == -1) {
	    printf("Bad source route option: %s\n", hostp);
	    setuid(getuid());
	    return 0;
	} else {
	    sin.sin_addr.s_addr = temp;
	    sin.sin_family = AF_INET;
	}
    } else {
#endif
	temp = (unsigned int)inet_addr(hostp);
	if (temp != (unsigned int) -1) {
	    sin.sin_addr.s_addr = temp;
	    sin.sin_family = AF_INET;
	    (void) strcpy(_hostname, hostp);
	    hostname = _hostname;
	} else {
	    host = gethostbyname(hostp);
	    if (host) {
		sin.sin_family = host->h_addrtype;
#ifdef h_addr		/* In 4.3, this is a #define */
		memmove((caddr_t)&sin.sin_addr,
				host->h_addr_list[0], host->h_length);
#else	/* defined(h_addr) */
		memmove((caddr_t)&sin.sin_addr, host->h_addr, host->h_length);
#endif	/* defined(h_addr) */
		strncpy(_hostname, host->h_name, sizeof(_hostname));
		_hostname[sizeof(_hostname)-1] = '\0';
		hostname = _hostname;
	    } else {
		herror(hostp);
		setuid(getuid());
		return 0;
	    }
	}
#if defined(IP_OPTIONS) && defined(IPPROTO_IP)
    }
#endif
    if (portp) {
	if (*portp == '-') {
	    portp++;
	    telnetport = 1;
	} else
	    telnetport = 0;
	sin.sin_port = atoi(portp);
	if (sin.sin_port == 0) {
	    sp = getservbyname(portp, "tcp");
	    if (sp)
		sin.sin_port = sp->s_port;
	    else {
		printf("%s: bad port number\n", portp);
		setuid(getuid());
		return 0;
	    }
	} else {
	    sin.sin_port = htons(sin.sin_port);
	}
    } else {
	if (sp == 0) {
	    sp = getservbyname("telnet", "tcp");
	    if (sp == 0) {
		fprintf(stderr, "telnet: tcp/telnet: unknown service\n");
		setuid(getuid());
		return 0;
	    }
	    sin.sin_port = sp->s_port;
	}
	telnetport = 1;
    }
    printf("Trying %s...\n", inet_ntoa(sin.sin_addr));
    do {
	net = socket(AF_INET, SOCK_STREAM, 0);
	setuid(getuid());
	if (net < 0) {
	    perror("telnet: socket");
	    return 0;
	}
#if defined(IP_OPTIONS) && defined(IPPROTO_IP)
	if (srp && setsockopt(net, IPPROTO_IP, IP_OPTIONS, (char *)srp, srlen) < 0)
		perror("setsockopt (IP_OPTIONS)");
#endif
#if defined(IPPROTO_IP) && defined(IP_TOS)
	{
#ifdef HAS_GETTOS
	    struct tosent *tp;
	    if (tos < 0 && (tp = gettosbyname("telnet", "tcp")))
		tos = tp->t_tos;
# endif
	    if (tos < 0)
		tos = 020;	/* Low Delay bit */
	    if (tos
		&& (setsockopt(net, IPPROTO_IP, IP_TOS,
		    (char *)&tos, sizeof(int)) < 0)
		&& (errno != ENOPROTOOPT))
		    perror("telnet: setsockopt (IP_TOS) (ignored)");
	}
#endif	/* defined(IPPROTO_IP) && defined(IP_TOS) */

	if (debug && SetSockOpt(net, SOL_SOCKET, SO_DEBUG, 1) < 0) {
		perror("setsockopt (SO_DEBUG)");
	}

	if (connect(net, (struct sockaddr *)&sin, sizeof (sin)) < 0) {
#ifdef h_addr		/* In 4.3, this is a #define */
	    if (host && host->h_addr_list[1]) {
		int oerrno = errno;

		fprintf(stderr, "telnet: connect to address %s: ",
						inet_ntoa(sin.sin_addr));
		errno = oerrno;
		perror((char *)0);
		host->h_addr_list++;
		memmove((caddr_t)&sin.sin_addr,
			host->h_addr_list[0], host->h_length);
		NetClose(net);
		continue;
	    }
#endif	/* defined(h_addr) */
	    perror("telnet: Unable to connect to remote host");
	    return 0;