commands.c

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

static int send_wontcmd(char *name) {
    return(send_tncmd(send_wont, "wont", name));
}

static int send_help() {
    struct sendlist *s;	/* pointer to current command */

    for (s = Sendlist; s->name; s++) {
	if (s->help) printf("%-15s %s\n", s->name, s->help);
    }

    return(0);
}

/* The following are the routines and data structures referred to by the     */
/* arguments to the "toggle" command.                                        */
static int lclchars() {
    donelclchars = 1;
    return 1;
}

static int togdebug() {
#ifdef NOT43
    if (!debug) {
	printf("Cannot turn off socket debugging\n");
	return 1;
    }
#endif

    if (net > 0 && SetSockOpt(net, SOL_SOCKET, SO_DEBUG, 0) < 0)
	perror("setsockopt (SO_DEBUG)");

    return 1;
}

static int togcrlf() {
    if (crlf) {
	printf("Will send carriage returns as telnet <CR><LF>.\n");
    } else {
	printf("Will send carriage returns as telnet <CR><NUL>.\n");
    }

    return 1;
}

int binmode;

static int togbinary(int val) {
    donebinarytoggle = 1;

    if (val >= 0) {
	binmode = val;
    } else {
	if (my_want_state_is_will(TELOPT_BINARY) &&
	    my_want_state_is_do(TELOPT_BINARY)) {
	    binmode = 1;
	} else if (my_want_state_is_wont(TELOPT_BINARY) &&
		   my_want_state_is_dont(TELOPT_BINARY)) {
	    binmode = 0;
	}

	val = binmode ? 0 : 1;
    }

    if (val == 1) {
	if (my_want_state_is_will(TELOPT_BINARY) &&
	    my_want_state_is_do(TELOPT_BINARY)) {
	    printf("Already operating in binary mode with remote host.\n");
	} else {
	    printf("Negotiating binary mode with remote host.\n");
	    tel_enter_binary(3);
	}
    } else {
	if (my_want_state_is_wont(TELOPT_BINARY) &&
	    my_want_state_is_dont(TELOPT_BINARY)) {
	    printf("Already in network ascii mode with remote host.\n");
	} else {
	    printf("Negotiating network ascii mode with remote host.\n");
	    tel_leave_binary(3);
	}
    }

    return 1;
}

static int togrbinary(int val) {
    donebinarytoggle = 1;
    
    if (val == -1) {
	val = my_want_state_is_do(TELOPT_BINARY) ? 0 : 1;
    }

    if (val == 1) {
	if (my_want_state_is_do(TELOPT_BINARY)) {
	    printf("Already receiving in binary mode.\n");
	} else {
	    printf("Negotiating binary mode on input.\n");
	    tel_enter_binary(1);
	}
    } else {
	if (my_want_state_is_dont(TELOPT_BINARY)) {
	    printf("Already receiving in network ascii mode.\n");
	} else {
	    printf("Negotiating network ascii mode on input.\n");
	    tel_leave_binary(1);
	}
    }

    return 1;
}

static int togxbinary(int val) {
    donebinarytoggle = 1;

    if (val == -1) {
	val = my_want_state_is_will(TELOPT_BINARY) ? 0 : 1;
    }

    if (val == 1) {
	if (my_want_state_is_will(TELOPT_BINARY)) {
	    printf("Already transmitting in binary mode.\n");
	} else {
	    printf("Negotiating binary mode on output.\n");
	    tel_enter_binary(2);
	}
    } else {
	if (my_want_state_is_wont(TELOPT_BINARY)) {
	    printf("Already transmitting in network ascii mode.\n");
	} else {
	    printf("Negotiating network ascii mode on output.\n");
	    tel_leave_binary(2);
	}
    }

    return 1;
}


static int togglehelp P((void));


struct togglelist {
    char	*name;		/* name of toggle */
    char	*help;		/* help message */
    int		(*handler)();	/* routine to do actual setting */
    int		*variable;
    char	*actionexplanation;
};

static struct togglelist Togglelist[] = {
    { "autoflush", 
      "flushing of output when sending interrupt characters",
      0,
      &autoflush,
      "flush output when sending interrupt characters" },
    { "autosynch",
      "automatic sending of interrupt characters in urgent mode",
      0,
      &autosynch,
      "send interrupt characters in urgent mode" },
    { "skiprc",
      "don't read ~/.telnetrc file",
      0,
      &skiprc,
      "skip reading of ~/.telnetrc file" },
    { "binary",
      "sending and receiving of binary data",
      togbinary,
      0,
      0 },
    { "inbinary",
      "receiving of binary data",
      togrbinary,
      0,
      0 },
    { "outbinary",
      "sending of binary data",
      togxbinary,
      0,
      0 },
    { "crlf",
      "sending carriage returns as telnet <CR><LF>",
      togcrlf,
      &crlf,
      0 },
    { "crmod",
      "mapping of received carriage returns",
      0,
      &crmod,
      "map carriage return on output" },
    { "localchars",
      "local recognition of certain control characters",
      lclchars,
      &localchars,
      "recognize certain control characters" },
    { " ", "", 0 },		/* empty line */
#ifdef TN3270
    { "apitrace",
      "(debugging) toggle tracing of API transactions",
      0,
      &apitrace,
      "trace API transactions" },
    { "cursesdata",
      "(debugging) toggle printing of hexadecimal curses data",
      0,
      &cursesdata,
      "print hexadecimal representation of curses data" },
#endif
    { "debug",
      "debugging",
      togdebug,
      &debug,
      "turn on socket level debugging" },
    { "netdata",
      "printing of hexadecimal network data (debugging)",
      0,
      &netdata,
      "print hexadecimal representation of network traffic" },
    { "prettydump",
      "output of \"netdata\" to user readable format (debugging)",
      0,
      &prettydump,
      "print user readable output for \"netdata\"" },
    { "options",
      "viewing of options processing (debugging)",
      0,
      &showoptions,
      "show option processing" },
    { "termdata",
      "(debugging) toggle printing of hexadecimal terminal data",
      0,
      &termdata,
      "print hexadecimal representation of terminal traffic" },
    { "?",
      0,
      togglehelp },
    { "help",
      0,
      togglehelp },
    { 0 }
};

static int togglehelp() {
    struct togglelist *c;

    for (c = Togglelist; c->name; c++) {
	if (c->help) {
	    if (*c->help) printf("%-15s toggle %s\n", c->name, c->help);
	    else printf("\n");
	}
    }

    printf("\n");
    printf("%-15s %s\n", "?", "display help information");

    return 0;
}

static void settogglehelp(int set) {
    struct togglelist *c;

    for (c = Togglelist; c->name; c++) {
	if (c->help) {
	    if (*c->help) printf("%-15s %s %s\n", c->name, set ? "enable" : "disable", c->help);
	    else printf("\n");
	}
    }
}

#define	GETTOGGLE(name) (struct togglelist *) genget(name, (char **) Togglelist, sizeof(struct togglelist))

static int toggle(int argc, char *argv[]) {
    int retval = 1;
    char *name;
    struct togglelist *c;

    if (argc < 2) {
	fprintf(stderr, "Need an argument to 'toggle' command.  'toggle ?' for help.\n");
	return 0;
    }

    argc--;
    argv++;

    while (argc--) {
	name = *argv++;
	c = GETTOGGLE(name);

	if (Ambiguous(c)) {
	    fprintf(stderr, "'%s': ambiguous argument ('toggle ?' for help).\n", name);
	    return 0;
	} else if (c == 0) {
	    fprintf(stderr, "'%s': unknown argument ('toggle ?' for help).\n", name);
	    return 0;
	} else {
	    if (c->variable) {
		*c->variable = !*c->variable;		/* invert it */
		if (c->actionexplanation) {
		    printf("%s %s.\n", *c->variable? "Will" : "Won't", c->actionexplanation);
		}
	    }

	    if (c->handler) {
		retval &= (*c->handler)(-1);
	    }
	}
    }

    return retval;
}

/* The following perform the "set" command.                                  */
#ifdef	USE_TERMIO
struct termio new_tc = { 0 };
#endif

struct setlist {
    char *name;				/* name */
    char *help;				/* help information */
    void (*handler)();
    cc_t *charp;			/* where it is located at */
};

static struct setlist Setlist[] = {
#ifdef	KLUDGELINEMODE
    { "echo", 	"character to toggle local echoing on/off", 0, &echoc },
#endif
    { "escape",	"character to escape back to telnet command mode", 0, &escape },
    { "rlogin", "rlogin escape character", 0, &rlogin },
    { "tracefile", "file to write trace information to", SetNetTrace, (cc_t *)NetTraceFile},
    { " ", "" },
    { " ", "The following need 'localchars' to be toggled true", 0, 0 },
    { "flushoutput", "character to cause an Abort Output", 0, termFlushCharp },
    { "interrupt", "character to cause an Interrupt Process", 0, termIntCharp },
    { "quit",	"character to cause an Abort process", 0, termQuitCharp },
    { "eof",	"character to cause an EOF ", 0, termEofCharp },
    { " ", "" },
    { " ", "The following are for local editing in linemode", 0, 0 },
    { "erase",	"character to use to erase a character", 0, termEraseCharp },
    { "kill",	"character to use to erase a line", 0, termKillCharp },
    { "lnext",	"character to use for literal next", 0, termLiteralNextCharp },
    { "susp",	"character to cause a Suspend Process", 0, termSuspCharp },
    { "reprint", "character to use for line reprint", 0, termRprntCharp },
    { "worderase", "character to use to erase a word", 0, termWerasCharp },
    { "start",	"character to use for XON", 0, termStartCharp },
    { "stop",	"character to use for XOFF", 0, termStopCharp },
    { "forw1",	"alternate end of line character", 0, termForw1Charp },
    { "forw2",	"alternate end of line character", 0, termForw2Charp },
    { "ayt",	"alternate AYT character", 0, termAytCharp },
    { 0 }
};

#if defined(CRAY) && !defined(__STDC__)
/* Work around compiler bug in pcc 4.1.5 */
void _setlist_init() {
#ifndef	KLUDGELINEMODE
#define	N 5
#else
#define	N 6
#endif
	Setlist[N+0].charp = &termFlushChar;
	Setlist[N+1].charp = &termIntChar;
	Setlist[N+2].charp = &termQuitChar;
	Setlist[N+3].charp = &termEofChar;
	Setlist[N+6].charp = &termEraseChar;
	Setlist[N+7].charp = &termKillChar;
	Setlist[N+8].charp = &termLiteralNextChar;
	Setlist[N+9].charp = &termSuspChar;
	Setlist[N+10].charp = &termRprntChar;
	Setlist[N+11].charp = &termWerasChar;
	Setlist[N+12].charp = &termStartChar;
	Setlist[N+13].charp = &termStopChar;
	Setlist[N+14].charp = &termForw1Char;
	Setlist[N+15].charp = &termForw2Char;
	Setlist[N+16].charp = &termAytChar;
#undef	N
}
#endif	/* defined(CRAY) && !defined(__STDC__) */

static struct setlist *getset(char *name) {
    return (struct setlist *)genget(name, (char **) Setlist, sizeof(struct setlist));
}

void set_escape_char(char *s) {
    if (rlogin != _POSIX_VDISABLE) {
	rlogin = (s && *s) ? special(s) : _POSIX_VDISABLE;
	printf("Telnet rlogin escape character is '%s'.\n", control(rlogin));
    } else {
	escape = (s && *s) ? special(s) : _POSIX_VDISABLE;
	printf("Telnet escape character is '%s'.\n", control(escape));
    }
}

static int setcmd(int argc, char *argv[]) {
    int value;
    struct setlist *ct;
    struct togglelist *c;

    if (argc < 2 || argc > 3) {
	printf("Format is 'set Name Value'\n'set ?' for help.\n");
	return 0;
    }

    if ((argc == 2) && (isprefix(argv[1], "?") || isprefix(argv[1], "help"))) {
	for (ct = Setlist; ct->name; ct++) printf("%-15s %s\n", ct->name, ct->help);
	printf("\n");

	settogglehelp(1);

	printf("%-15s %s\n", "?", "display help information");
	return 0;
    }

    ct = getset(argv[1]);

    if (ct == 0) {
	c = GETTOGGLE(argv[1]);

	if (c == 0) { 
	    fprintf(stderr, "'%s': unknown argument ('set ?' for help).\n", argv[1]);
	    return 0;
	} else if (Ambiguous(c)) {
	    fprintf(stderr, "'%s': ambiguous argument ('set ?' for help).\n", argv[1]);
	    return 0;
	}

	if (c->variable) {
	    if ((argc == 2) || (strcmp("on", argv[2]) == 0))
		*c->variable = 1;
	    else if (strcmp("off", argv[2]) == 0)
		*c->variable = 0;
	    else {
		printf("Format is 'set togglename [on|off]'\n'set ?' for help.\n");
		return 0;
	    }

	    if (c->actionexplanation) {
		printf("%s %s.\n", *c->variable? "Will" : "Won't", c->actionexplanation);
	    }
	}

	if (c->handler) (*c->handler)(1);
    } else if (argc != 3) {
	printf("Format is 'set Name Value'\n'set ?' for help.\n");
	return 0;
    } else if (Ambiguous(ct)) {
	fprintf(stderr, "'%s': ambiguous argument ('set ?' for help).\n", argv[1]);
	return 0;
    } else if (ct->handler) {
	(*ct->handler)(argv[2]);
	printf("%s set to \"%s\".\n", ct->name, (char *)ct->charp);
    } else {
	if (strcmp("off", argv[2])) {
	    value = special(argv[2]);
	} else {
	    value = _POSIX_VDISABLE;
	}

	*(ct->charp) = (cc_t)value;
	printf("%s character is '%s'.\n", ct->name, control(*(ct->charp)));
    }

    slc_check();
    return 1;
}

static int unsetcmd(int argc, char *argv[]) {
    struct setlist *ct;
    struct togglelist *c;
    register char *name;

    if (argc < 2) {
	fprintf(stderr, "Need an argument to 'unset' command.  'unset ?' for help.\n");
	return 0;
    }

    if (isprefix(argv[1], "?") || isprefix(argv[1], "help")) {
	for (ct = Setlist; ct->name; ct++) printf("%-15s %s\n", ct->name, ct->help);
	printf("\n");

	settogglehelp(0);

	printf("%-15s %s\n", "?", "display help information");
	return 0;
    }

    argc--;
    argv++;

    while (argc--) {
	name = *argv++;
	ct = getset(name);

	if (ct == 0) {
	    c = GETTOGGLE(name);
	    if (c == 0) {
		fprintf(stderr, "'%s': unknown argument ('unset ?' for help).\n", name);
		return 0;