telnet.c

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

    if (*argv == 0) {
	if (name) *argv = name;
	else for (--argvp, avt = argv; avt < argvp; avt++) *avt = *(avt+1);
    }
    if (*argv) return(argv);
    else return(unknown);
}

#ifndef HAVE_SETUPTERM
extern int tgetent(char *, char *);
char termbuf[1024];

/*ARGSUSED*/
int setupterm(char *tname, int fd, int *errp) {
    if (tgetent(termbuf, tname) == 1) {
	termbuf[1023] = '\0';
	if (errp) *errp = 1;
	return(0);
    }

    if (errp) *errp = 0;
    return(-1);
}
#else
#define	termbuf	ttytype
extern char ttytype[];
#endif

int resettermname = 1;

char *gettermname() {
    static char **tnamep = 0;
    static char **next;
    char *tname;
    int err;

    if (resettermname) {
	resettermname = 0;

	if (tnamep && tnamep != unknown) free(tnamep);

	if ((tname = (char *)env_getvalue((unsigned char *)"TERM")) && (setupterm(tname, 1, &err) == 0)) {
	    tnamep = mklist(termbuf, tname);
	} else {
	    if (tname && ((int)strlen(tname) <= 40)) {
		unknown[0] = tname;
		upcase(tname);
	    } else {
		unknown[0] = name_unknown;
	    }

	    tnamep = unknown;
	}

	next = tnamep;
    }

    if (*next == 0) next = tnamep;
    return(*next++);
}

/* suboption()                                                               */
/*                                                                           */
/* Look at the sub-option buffer, and try to be helpful to the other         */
/* side.                                                                     */
/*                                                                           */
/* Currently we recognize:                                                   */
/*                                                                           */
/* Terminal type, send request.                                              */
/* Terminal speed (send request).                                            */
/* Local flow control (is request).                                          */
/* Linemode                                                                  */

static void suboption() {
    unsigned char subchar;

    printsub('<', subbuffer, SB_LEN()+2);
    switch (subchar = SB_GET()) {
	case TELOPT_TTYPE:
	    if (my_want_state_is_wont(TELOPT_TTYPE))
		return;
	    if (SB_EOF() || SB_GET() != TELQUAL_SEND) {
		return;
	    } else {
		unsigned char temp[50];
		char *name;
		int len;

#ifdef TN3270
		if (tn3270_ttype()) {
		    return;
		}
#endif
		name = gettermname();
		len = strlen(name) + 4 + 2;

		if (len < NETROOM()) {
		    sprintf((char *)temp, "%c%c%c%c%s%c%c", IAC, SB, TELOPT_TTYPE, TELQUAL_IS, name, IAC, SE);
		    ring_supply_data(&netoring, temp, len);
		    printsub('>', &temp[2], len-2);
		} else {
		    ExitString("No room in buffer for terminal type.\n", 1);
		    /*NOTREACHED*/
		}
	    }
	    break;
	case TELOPT_TSPEED:
	    if (my_want_state_is_wont(TELOPT_TSPEED)) return;
	    if (SB_EOF()) return;

	    if (SB_GET() == TELQUAL_SEND) {
		long ospeed, ispeed;
		unsigned char temp[50];
		int len;

		TerminalSpeeds(&ispeed, &ospeed);
		
		sprintf((char *)temp, "%c%c%c%c%d,%d%c%c", IAC, SB, TELOPT_TSPEED, TELQUAL_IS, (int)ospeed, (int)ispeed, IAC, SE);
		len = strlen((char *)temp+4) + 4;	/* temp[3] is 0 ... */
		
		if (len < NETROOM()) {
		    ring_supply_data(&netoring, temp, len);
		    printsub('>', temp+2, len - 2);
		}
		/*@*/	    else printf("lm_will: not enough room in buffer\n");
	    }
	    break;
	case TELOPT_LFLOW:
	    if (my_want_state_is_wont(TELOPT_LFLOW)) return;
	    if (SB_EOF()) return;
	    switch(SB_GET()) {
		case LFLOW_RESTART_ANY:
		    restartany = 1;
		    break;
		case LFLOW_RESTART_XON:
		    restartany = 0;
		    break;
		case LFLOW_ON:
		    localflow = 1;
		    break;
		case LFLOW_OFF:
		    localflow = 0;
		    break;
		default:
		    return;
	    }

	    setcommandmode();
	    setconnmode(0);
	    break;
	case TELOPT_LINEMODE:
	    if (my_want_state_is_wont(TELOPT_LINEMODE)) return;
	    if (SB_EOF()) return;
	    switch (SB_GET()) {
		case WILL:
		    lm_will(subpointer, SB_LEN());
		    break;
		case WONT:
		    lm_wont(subpointer, SB_LEN());
		    break;
		case DO:
		    lm_do(subpointer, SB_LEN());
		    break;
		case DONT:
		    lm_dont(subpointer, SB_LEN());
		    break;
		case LM_SLC:
		    slc(subpointer, SB_LEN());
		    break;
		case LM_MODE:
		    lm_mode(subpointer, SB_LEN(), 0);
		    break;
		default:
		    break;
	    }
	    break;
#ifdef OLD_ENVIRON
	case TELOPT_OLD_ENVIRON:
#endif
	case TELOPT_NEW_ENVIRON:
	    if (SB_EOF()) return;
	    switch(SB_PEEK()) {
		case TELQUAL_IS:
		case TELQUAL_INFO:
		    if (my_want_state_is_dont(subchar)) return;
		    break;
		case TELQUAL_SEND:
		    if (my_want_state_is_wont(subchar)) return;
		    break;
		default:
		    return;
	    }
	    env_opt(subpointer, SB_LEN());
	    break;
	case TELOPT_XDISPLOC:
	    if (my_want_state_is_wont(TELOPT_XDISPLOC)) return;
	    if (SB_EOF()) return;

	    if (SB_GET() == TELQUAL_SEND) {
		unsigned char temp[50], *dp;
		int len;

		if ((dp = env_getvalue((unsigned char *)"DISPLAY")) == NULL) {
		    /* Something happened, we no longer have a DISPLAY       */
		    /* variable.  So, turn off the option.                   */
		    send_wont(TELOPT_XDISPLOC, 1);
		    break;
		}

		sprintf((char *)temp, "%c%c%c%c%s%c%c", IAC, SB, TELOPT_XDISPLOC, TELQUAL_IS, dp, IAC, SE);
		len = strlen((char *)temp+4) + 4;	/* temp[3] is 0 ... */
		
		if (len < NETROOM()) {
		    ring_supply_data(&netoring, temp, len);
		    printsub('>', temp+2, len - 2);
		}
		/*@*/	    else printf("lm_will: not enough room in buffer\n");
	    }
	    break;

	default:
	    break;
    }
}

static unsigned char str_lm[] = { IAC, SB, TELOPT_LINEMODE, 0, 0, IAC, SE };

    void
lm_will(cmd, len)
    unsigned char *cmd;
    int len;
{
    if (len < 1) {
/*@*/	printf("lm_will: no command!!!\n");	/* Should not happen... */
	return;
    }
    switch(cmd[0]) {
    case LM_FORWARDMASK:	/* We shouldn't ever get this... */
    default:
	str_lm[3] = DONT;
	str_lm[4] = cmd[0];
	if (NETROOM() > sizeof(str_lm)) {
	    ring_supply_data(&netoring, str_lm, sizeof(str_lm));
	    printsub('>', &str_lm[2], sizeof(str_lm)-2);
	}
/*@*/	else printf("lm_will: not enough room in buffer\n");
	break;
    }
}

    void
lm_wont(cmd, len)
    unsigned char *cmd;
    int len;
{
    if (len < 1) {
/*@*/	printf("lm_wont: no command!!!\n");	/* Should not happen... */
	return;
    }
    switch(cmd[0]) {
    case LM_FORWARDMASK:	/* We shouldn't ever get this... */
    default:
	/* We are always DONT, so don't respond */
	return;
    }
}

    void
lm_do(cmd, len)
    unsigned char *cmd;
    int len;
{
    if (len < 1) {
/*@*/	printf("lm_do: no command!!!\n");	/* Should not happen... */
	return;
    }
    switch(cmd[0]) {
    case LM_FORWARDMASK:
    default:
	str_lm[3] = WONT;
	str_lm[4] = cmd[0];
	if (NETROOM() > sizeof(str_lm)) {
	    ring_supply_data(&netoring, str_lm, sizeof(str_lm));
	    printsub('>', &str_lm[2], sizeof(str_lm)-2);
	}
/*@*/	else printf("lm_do: not enough room in buffer\n");
	break;
    }
}

    void
lm_dont(cmd, len)
    unsigned char *cmd;
    int len;
{
    if (len < 1) {
/*@*/	printf("lm_dont: no command!!!\n");	/* Should not happen... */
	return;
    }
    switch(cmd[0]) {
    case LM_FORWARDMASK:
    default:
	/* we are always WONT, so don't respond */
	break;
    }
}

static unsigned char str_lm_mode[] = {
	IAC, SB, TELOPT_LINEMODE, LM_MODE, 0, IAC, SE
};

	void
lm_mode(cmd, len, init)
	unsigned char *cmd;
	int len, init;
{
	if (len != 1)
		return;
	if ((linemode&MODE_MASK&~MODE_ACK) == *cmd)
		return;
	if (*cmd&MODE_ACK)
		return;
	linemode = *cmd&(MODE_MASK&~MODE_ACK);
	str_lm_mode[4] = linemode;
	if (!init)
	    str_lm_mode[4] |= MODE_ACK;
	if (NETROOM() > sizeof(str_lm_mode)) {
	    ring_supply_data(&netoring, str_lm_mode, sizeof(str_lm_mode));
	    printsub('>', &str_lm_mode[2], sizeof(str_lm_mode)-2);
	}
/*@*/	else printf("lm_mode: not enough room in buffer\n");
	setconnmode(0);	/* set changed mode */
}



/*
 * slc()
 * Handle special character suboption of LINEMODE.
 */

struct spc {
	cc_t val;
	cc_t *valp;
	char flags;	/* Current flags & level */
	char mylevel;	/* Maximum level & flags */
} spc_data[NSLC+1];

#define SLC_IMPORT	0
#define	SLC_EXPORT	1
#define SLC_RVALUE	2
static int slc_mode = SLC_EXPORT;

	void
slc_init()
{
	register struct spc *spcp;

	localchars = 1;
	for (spcp = spc_data; spcp < &spc_data[NSLC+1]; spcp++) {
		spcp->val = 0;
		spcp->valp = 0;
		spcp->flags = spcp->mylevel = SLC_NOSUPPORT;
	}

#define	initfunc(func, flags) { \
					spcp = &spc_data[func]; \
					if ((spcp->valp = tcval(func))) { \
					    spcp->val = *spcp->valp; \
					    spcp->mylevel = SLC_VARIABLE|flags; \
					} else { \
					    spcp->val = 0; \
					    spcp->mylevel = SLC_DEFAULT; \
					} \
				    }

	initfunc(SLC_SYNCH, 0);
	/* No BRK */
	initfunc(SLC_AO, 0);
	initfunc(SLC_AYT, 0);
	/* No EOR */
	initfunc(SLC_ABORT, SLC_FLUSHIN|SLC_FLUSHOUT);
	initfunc(SLC_EOF, 0);
#ifndef	SYSV_TERMIO
	initfunc(SLC_SUSP, SLC_FLUSHIN);
#endif
	initfunc(SLC_EC, 0);
	initfunc(SLC_EL, 0);
#ifndef	SYSV_TERMIO
	initfunc(SLC_EW, 0);
	initfunc(SLC_RP, 0);
	initfunc(SLC_LNEXT, 0);
#endif
	initfunc(SLC_XON, 0);
	initfunc(SLC_XOFF, 0);
#ifdef	SYSV_TERMIO
	spc_data[SLC_XON].mylevel = SLC_CANTCHANGE;
	spc_data[SLC_XOFF].mylevel = SLC_CANTCHANGE;
#endif
	initfunc(SLC_FORW1, 0);
#ifdef	USE_TERMIO
	initfunc(SLC_FORW2, 0);
	/* No FORW2 */
#endif

	initfunc(SLC_IP, SLC_FLUSHIN|SLC_FLUSHOUT);
#undef	initfunc

	if (slc_mode == SLC_EXPORT)
		slc_export();
	else
		slc_import(1);

}

    void
slcstate()
{
    printf("Special characters are %s values\n",
		slc_mode == SLC_IMPORT ? "remote default" :
		slc_mode == SLC_EXPORT ? "local" :
					 "remote");
}

    void
slc_mode_export()
{
    slc_mode = SLC_EXPORT;
    if (my_state_is_will(TELOPT_LINEMODE))
	slc_export();
}

    void
slc_mode_import(def)
    int def;
{
    slc_mode = def ? SLC_IMPORT : SLC_RVALUE;
    if (my_state_is_will(TELOPT_LINEMODE))
	slc_import(def);
}

unsigned char slc_import_val[] = {
	IAC, SB, TELOPT_LINEMODE, LM_SLC, 0, SLC_VARIABLE, 0, IAC, SE
};
unsigned char slc_import_def[] = {
	IAC, SB, TELOPT_LINEMODE, LM_SLC, 0, SLC_DEFAULT, 0, IAC, SE
};

    void
slc_import(def)
    int def;
{
    if (NETROOM() > sizeof(slc_import_val)) {
	if (def) {
	    ring_supply_data(&netoring, slc_import_def, sizeof(slc_import_def));
	    printsub('>', &slc_import_def[2], sizeof(slc_import_def)-2);
	} else {
	    ring_supply_data(&netoring, slc_import_val, sizeof(slc_import_val));
	    printsub('>', &slc_import_val[2], sizeof(slc_import_val)-2);
	}
    }
/*@*/ else printf("slc_import: not enough room\n");
}

    void
slc_export()
{
    register struct spc *spcp;

    TerminalDefaultChars();

    slc_start_reply();
    for (spcp = &spc_data[1]; spcp < &spc_data[NSLC+1]; spcp++) {
	if (spcp->mylevel != SLC_NOSUPPORT) {
	    if (spcp->val == (cc_t)(_POSIX_VDISABLE))
		spcp->flags = SLC_NOSUPPORT;
	    else
		spcp->flags = spcp->mylevel;
	    if (spcp->valp)
		spcp->val = *spcp->valp;
	    slc_add_reply(spcp - spc_data, spcp->flags, spcp->val);
	}
    }
    slc_end_reply();
    (void)slc_update();
    setconnmode(1);	/* Make sure the character values are set */
}

	void
slc(cp, len)
	register unsigned char *cp;
	int len;
{
	register struct spc *spcp;
	register int func,level;

	slc_start_reply();

	for (; len >= 3; len -=3, cp +=3) {

		func = cp[SLC_FUNC];

		if (func == 0) {
			/*
			 * Client side: always ignore 0 function.
			 */
			continue;
		}
		if (func > NSLC) {
			if ((cp[SLC_FLAGS] & SLC_LEVELBITS) != SLC_NOSUPPORT)
				slc_add_reply(func, SLC_NOSUPPORT, 0);
			continue;
		}

		spcp = &spc_data[func];

		level = cp[SLC_FLAGS]&(SLC_LEVELBITS|SLC_ACK);

		if ((cp[SLC_VALUE] == (unsigned char)spcp->val) &&
		    ((level&SLC_LEVELBITS) == (spcp->flags&SLC_LEVELBITS))) {
			continue;
		}

		if (level == (SLC_DEFAULT|SLC_ACK)) {
			/*
			 * This is an error condition, the SLC_ACK
			 * bit should never be set for the SLC_DEFAULT
			 * level.  Our best guess to recover is to
			 * ignore the SLC_ACK bit.
			 */
			cp[SLC_FLAGS] &= ~SLC_ACK;
		}

		if (level == ((spcp->flags&SLC_LEVELBITS)|SLC_ACK)) {
			spcp->val = (cc_t)cp[SLC_VALUE];
			spcp->flags = cp[SLC_FLAGS];	/* include SLC_ACK */
			continue;
		}

		level &= ~SLC_ACK;

		if (level <= (spcp->mylevel&SLC_LEVELBITS)) {
			spcp->flags = cp[SLC_FLAGS]|SLC_ACK;
			spcp->val = (cc_t)cp[SLC_VALUE];
		}
		if (level == SLC_DEFAULT) {
			if ((spcp->mylevel&SLC_LEVELBITS) != SLC_DEFAULT)
				spcp->flags = spcp->mylevel;
			else
				spcp->flags = SLC_NOSUPPORT;
		}
		slc_add_reply(func, spcp->flags, spcp->val);
	}
	slc_end_reply();
	if (slc_update())
		setconnmode(1);	/* set the  new character values */
}

    void
slc_check()
{
    register struct spc *spcp;

    slc_start_reply();
    for (spcp = &spc_data[1]; spcp < &spc_data[NSLC+1]; spcp++) {
	if (spcp->valp && spcp->val != *spcp->valp) {
	    spcp->val = *spcp->valp;
	    if (spcp->val == (cc_t)(_POSIX_VDISABLE))
		spcp->flags = SLC_NOSUPPORT;
	    else
		spcp->flags = spcp->mylevel;
	    slc_add_reply(spcp - spc_data, spcp->flags, spcp->val);
	}
    }
    slc_end_reply();
    setconnmode(1);
}


unsigned char slc_reply[128];
unsigned char *slc_replyp;

	void
slc_start_reply()
{
	slc_replyp = slc_reply;
	*slc_replyp++ = IAC;
	*slc_replyp++ = SB;
	*slc_replyp++ = TELOPT_LINEMODE;
	*slc_replyp++ = LM_SLC;