Commit 96b8a0e2d525152b2bddab86861b0edcdeaeb90e - conserver

Import Upstream version 8.1.14 Bernhard Schmidt 4 years ago

35 changed file(s) with 1337 addition(s) and 598 deletion(s). Raw diff Collapse all Expand all

+31

-1

CHANGES less more

0	0	CHANGES
1	1	=======
	2
	3	version 8.1.14 (Apr 9, 2006):
	4	- fixed rpm conserver.spec file - based on patch by Martin Evans
	5	<m.d.t.evans@qmul.ac.uk>
	6	- added 'uds' console type for unix domain socket connections -
	7	based on patch by DJ Gregor <dj@gregor.com>
	8	- probing of interfaces under cygwin (and possibly others?) now
	9	skips unconfigured interfaces (even if flagged as up!) -
	10	reported by Chris Riddoch <chrisr@digeo.com>
	11	- added the '!login' console option to prevent clients from
	12	connecting to a console - suggested by Greg Tillman
	13	<gregtillman@comcast.net>
	14	- added a 'noop' console type for consoles you'd like to name,
	15	but have no connection to - suggested by Greg Tillman
	16	<gregtillman@comcast.net>
	17	- deprecated escape commands removed from the code
	18	- added '^EcP' and '^EcR' sequences to set the playback and
	19	replay line lengths
	20	- new console config options 'playback' and 'replay' to let the
	21	client set prefered output lengths (with a special feature for
	22	a size of zero)
	23	- prefer strlcpy() over strcpy() - based on patch by Peter
	24	Valchev <pvalchev@openbsd.org>
	25	- fixed bug where '^Eco' by user on an 'exec' console with an
	26	'initcmd' causes input by user to be ignored (could be other
	27	console types as well) - reported by Mark Wedel
	28	<Mark.Wedel@sun.com>
	29	- made POSIX termios code in autologin a requirement (since
	30	conserver requires it) and cleaned up a few other issues -
	31	based on reports by Arthur Clune <ajc22@york.ac.uk>
2	32
3	33	version 8.1.13 (Jan 15, 2006):
4	34	- use SIOCGIFNUM for interface count (if available) and catch

822	852	and enhancements of various types were applied.
823	853
824	854	#
825		# $Id: CHANGES,v 1.212 2006/01/15 17:11:42 bryan Exp $
	855	# $Id: CHANGES,v 1.215 2006/04/10 02:07:13 bryan Exp $
826	856	#

-2

README less more

20	20	Mirrors of the site are at:
21	21
22	22	Australia http://planetmirror.com/pub/conserver/
	23	Ireland http://conserver.oss-mirror.org/
	24	Germany http://conserver.linux-mirror.org/
23	25	Russia http://conserver.rinet.ru/
24	26
25	27

34	36	Cygwin (w2k),gcc 2.95.3
35	37	DEC Tru64 4.0, gcc
36	38	DEC Tru64 4.0/5.1, native cc
37		FreeBSD 4.2/4.8/5.1 (x86), gcc
	39	FreeBSD 4.x (i386) gcc
	40	FreeBSD 5.x (i386/amd64/sparc64) gcc
	41	FreeBSD 6.x/7.x (i386/amd64/sparc64/ia64) gcc
38	42	HP-UX 10.20, gcc
39	43	HP-UX 11.10 parisc and ia64, native cc
40	44	Irix 6.15, native cc

60	64	http://www.columbia.edu/acis/sy/unixdev/zinc
61	65
62	66	#
63		# $Id: README,v 1.24 2005/09/05 21:46:43 bryan Exp $
	67	# $Id: README,v 1.25 2006/03/20 16:48:37 bryan Exp $
64	68	#

-6

TODO less more

53	53
54	54	- cyclades ts1000/2000 port : "Moses, Joel" <jmoses@deloitte.com>
55	55
56		- config file for client (list of masters, for example)
57
58	56	- strftime() idea for logfile names : Lars Kellogg-Stedman <lars@larsshack.org>
59	57
60	58	- 9600baud log replay?

85	83	- not even sure if this is possible w/o confusing the client,
86	84	but maybe with the new 8.1.0 client-server protocol, we can!
87	85
88		- allow for very long replays (hundres of lines) : John Stoffel
89		<stoffel@lucent.com>
90
91	86	- log rotation by date : Tom Pachla <tom.pachla@nlc-bnc.ca>
92	87
93	88	- strict file permission checks on conserver.passwd/conserver.cf : Erik

108	103	- reintroduce console grouping : Martin Turba
109	104	<martin.turba@igd.fraunhofer.de>
110	105
	106	- quick-recheck of down consoles (for uds) and possibly only log state
	107	changes (instead of each try) : DJ Gregor <dj@gregor.com>
	108
111	109	#
112		# $Id: TODO,v 1.55 2005/06/06 23:02:36 bryan Exp $
	110	# $Id: TODO,v 1.56 2006/04/03 22:20:34 bryan Exp $
113	111	#

-80

autologin/autologin.c less more

68	68	*/
69	69
70	70	#ifndef lint
71		char *rcsid = "$Id: autologin.c,v 1.24 2004/12/12 07:36:07 bryan Exp $";
	71	char *rcsid = "$Id: autologin.c,v 1.25 2006/04/10 01:50:16 bryan Exp $";
72	72	#endif /* not lint */
73	73	extern char *progname;
74	74	gid_t awGrps[NGROUPS_MAX];

87	87	int
88	88	Process()
89	89	{
90		register int c;
91	90	int iErrs = 0;
92	91	int i, iNewGrp;
93	92	gid_t wGid;
94	93	uid_t wUid;
95	94	char pcCmd = (char )0,
96	95	pcDevTty = (char )0;
97		char *pcTmp;
98	96	#ifdef HAVE_GETUSERATTR
99	97	char *pcGrps;
100	98	#endif
101	99	struct passwd *pwd;
102	100	struct stat st;
103		#ifdef HAVE_TERMIOS_H
104	101	struct termios n_tio;
105		#else
106		# ifdef TIOCNOTTY
107		# ifdef O_CBREAK
108		auto struct tc n_tchars;
109		# else
110		auto struct tchars n_tchars;
111		# endif
112		# ifdef TIOCGLTC
113		auto struct ltchars n_ltchars;
114		# endif
115		# else
116		# ifdef TIOCGETP
117		auto struct sgttyb n_sty;
118		# endif
119		# endif
120		#endif
121	102	#if defined(HAVE_BSM_AUDIT_H) && defined(HAVE_LIBBSM)
122	103	char my_hostname[MAXHOSTNAMELEN];
123	104	#endif

319	300	# endif
320	301	(void)au_write(iAuditFile, ptAuditToken);
321	302	if(0 > au_close(iAuditFile, AU_TO_WRITE, AUE_autologin)) {
322		fprintf(stderr, "%s: audit write failed",
	303	fprintf(stderr, "%s: audit write failed: %s",
323	304	progname,
324	305	strerror(errno));
325	306	}

371	352
372	353	/* put the tty in the correct mode
373	354	*/
374		#ifndef HAVE_TERMIOS_H
375		if (0 != ioctl(0, TIOCGETP, (char *)&n_sty)) {
376		fprintf(stderr, "%s: iotcl: getp: %s\n", progname, strerror(errno));
377		exit(10);
378		}
379		#ifdef O_CBREAK
380		n_sty.sg_flags &= ~(O_CBREAK);
381		n_sty.sg_flags \|= (O_CRMOD\|O_ECHO);
382		#else
383		n_sty.sg_flags &= ~(CBREAK);
384		n_sty.sg_flags \|= (CRMOD\|ECHO);
385		#endif
386		n_sty.sg_kill = '\025'; /* ^U */
387		n_sty.sg_erase = '\010'; /* ^H */
388		if (0 != ioctl(0, TIOCSETP, (char *)&n_sty)) {
389		fprintf(stderr, "%s: iotcl: setp: %s\n", progname, strerror(errno));
390		exit(10);
391		}
392
393		/* stty undef all tty chars
394		*/
395		#if 0
396		if (-1 == ioctl(0, TIOCGETC, (char *)&n_tchars)) {
397		fprintf(stderr, "%s: ioctl: getc: %s\n", progname, strerror(errno));
398		return;
399		}
400		n_tchars.t_intrc = -1;
401		n_tchars.t_quitc = -1;
402		if (-1 == ioctl(0, TIOCSETC, (char *)&n_tchars)) {
403		fprintf(stderr, "%s: ioctl: setc: %s\n", progname, strerror(errno));
404		return;
405		}
406		#endif
407		#ifdef TIOCGLTC
408		if (-1 == ioctl(0, TIOCGLTC, (char *)&n_ltchars)) {
409		fprintf(stderr, "%s: ioctl: gltc: %s\n", progname, strerror(errno));
410		return;
411		}
412		n_ltchars.t_suspc = -1;
413		n_ltchars.t_dsuspc = -1;
414		n_ltchars.t_flushc = -1;
415		n_ltchars.t_lnextc = -1;
416		if (-1 == ioctl(0, TIOCSLTC, (char *)&n_ltchars)) {
417		fprintf(stderr, "%s: ioctl: sltc: %s\n", progname, strerror(errno));
418		return;
419		}
420		#endif
421		#else /* not using ioctl, using POSIX or sun stuff */
422	355	#ifdef HAVE_TCGETATTR
423	356	if (0 != tcgetattr(0, &n_tio)) {
424	357	(void) fprintf(stderr, "%s: tcgetattr: %s\n", progname, strerror(errno));

454	387	exit(1);
455	388	/* NOTREACHED */
456	389	}
457		#else
458		#ifndef HAVE_TERMIOS_H
459		if (0 != ioctl(0, TCSETS, &n_tio)) {
460		(void) fprintf(stderr, "%s: ioctl: TCSETS: %s\n", progname, strerror(errno));
461		exit(1);
462		/* NOTREACHED */
463		}
464		#endif
465		#endif
466		#endif /* setup tty */
	390	#endif
467	391
468	392	if (fMakeUtmp) {
469	393	extern char *ttyname();

531	455	register int fdUtmp;
532	456	register char *pcDev;
533	457	register struct utmp *up;
534		auto struct utmp outmp, utmp;
	458	auto struct utmp utmp;
535	459
536	460
537	461	if ((char *)0 == pctty) {

+23

-2

compat.h less more

7	7	#include <sys/stat.h>
8	8	#include <fcntl.h>
9	9	#include <netinet/in.h>
10		#if USE_UNIX_DOMAIN_SOCKETS
11	10	#include <sys/un.h>
12		#endif
13	11	#include <arpa/inet.h>
14	12	#include <netdb.h>
15	13	#include <ctype.h>

34	32	#endif
35	33	#if !defined(DEFESC)
36	34	# define DEFESC 'c'
	35	#endif
	36
	37	/* set the default length of the replay functions
	38	* DEFREPLAY for 'r'
	39	* DEFPLAYBACK for 'p'
	40	*/
	41	#if !defined(DEFREPLAY)
	42	# define DEFREPLAY 20
	43	#endif
	44	#if !defined(PLAYBACK)
	45	# define DEFPLAYBACK 60
37	46	#endif
38	47
39	48	/* For legacy compile-time setting of the port...

93	102
94	103	#include <termios.h>
95	104
	105	#ifndef TAB3
	106	# ifdef OXTABS
	107	# define TAB3 OXTABS
	108	# else
	109	# ifdef XTABS
	110	# define TAB3 XTABS
	111	# else
	112	# define TAB3 0
	113	# endif
	114	# endif
	115	#endif
	116
96	117	#ifdef HAVE_STROPTS_H
97	118	# include <stropts.h>
98	119	#endif

+25

-9

config.guess less more

0	0	#! /bin/sh
1	1	# Attempt to guess a canonical system name.
2	2	# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3		# 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4
5		timestamp='2006-01-02'
	3	# 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation,
	4	# Inc.
	5
	6	timestamp='2006-03-13'
6	7
7	8	# This file is free software; you can redistribute it and/or modify it
8	9	# under the terms of the GNU General Public License as published by

105	106	trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
106	107	trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
107	108	: ${TMPDIR=/tmp} ;
108		{ tmp=`(umask 077 && mktemp -d -q "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } \|\|
	109	{ tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } \|\|
109	110	{ test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } \|\|
110	111	{ tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } \|\|
111	112	{ echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;

787	788	echo ${UNAME_MACHINE}-pc-pw32
788	789	exit ;;
789	790	x86:Interix:[345])
790		echo i586-pc-interix${UNAME_RELEASE}\|sed -e 's/\..*//'
	791	echo i586-pc-interix${UNAME_RELEASE}
	792	exit ;;
	793	EM64T:Interix:[345])
	794	echo x86_64-unknown-interix${UNAME_RELEASE}
791	795	exit ;;
792	796	[345]86:Windows_95:* \| [345]86:Windows_98:* \| [345]86:Windows_NT:*)
793	797	echo i${UNAME_MACHINE}-pc-mks

858	862	#endif
859	863	#endif
860	864	EOF
861		eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null \| sed -n '/^CPU/{s: ::g;p;}'`"
	865	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null \| sed -n '
	866	/^CPU/{
	867	s: ::g
	868	p
	869	}'`"
862	870	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
863	871	;;
864	872	mips64:Linux::)

877	885	#endif
878	886	#endif
879	887	EOF
880		eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null \| sed -n '/^CPU/{s: ::g;p;}'`"
	888	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null \| sed -n '
	889	/^CPU/{
	890	s: ::g
	891	p
	892	}'`"
881	893	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
882	894	;;
883	895	or32:Linux::)

974	986	LIBC=gnulibc1
975	987	# endif
976	988	#else
977		#if defined(__INTEL_COMPILER) \|\| defined(__PGI)
	989	#if defined(__INTEL_COMPILER) \|\| defined(__PGI) \|\| defined(__sun)
978	990	LIBC=gnu
979	991	#else
980	992	LIBC=gnuaout

984	996	LIBC=dietlibc
985	997	#endif
986	998	EOF
987		eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null \| sed -n '/^LIBC/{s: ::g;p;}'`"
	999	eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null \| sed -n '
	1000	/^LIBC/{
	1001	s: ::g
	1002	p
	1003	}'`"
988	1004	test x"${LIBC}" != x && {
989	1005	echo "${UNAME_MACHINE}-pc-linux-${LIBC}"
990	1006	exit

-0

config.h.in less more

194	194	/* Define to 1 if you have the <string.h> header file. */
195	195	#undef HAVE_STRING_H
196	196
	197	/* Define to 1 if you have the `strlcpy' function. */
	198	#undef HAVE_STRLCPY
	199
197	200	/* Define to 1 if you have the <stropts.h> header file. */
198	201	#undef HAVE_STROPTS_H
199	202

241	244
242	245	/* Define to 1 if you have the <sys/uio.h> header file. */
243	246	#undef HAVE_SYS_UIO_H
	247
	248	/* Define to 1 if you have the <sys/un.h> header file. */
	249	#undef HAVE_SYS_UN_H
244	250
245	251	/* Define to 1 if you have the <sys/vlimit.h> header file. */
246	252	#undef HAVE_SYS_VLIMIT_H

+13

-10

config.sub less more

0	0	#! /bin/sh
1	1	# Configuration validation subroutine script.
2	2	# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3		# 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4
5		timestamp='2006-01-02'
	3	# 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation,
	4	# Inc.
	5
	6	timestamp='2006-03-07'
6	7
7	8	# This file is (in principle) common to ALL GNU software.
8	9	# The presence of a machine in this file suggests that SOME GNU software

267	268	\| mn10200 \| mn10300 \
268	269	\| mt \
269	270	\| msp430 \
	271	\| nios \| nios2 \
270	272	\| ns16k \| ns32k \
271	273	\| or32 \
272	274	\| pdp10 \| pdp11 \| pj \| pjl \
273	275	\| powerpc \| powerpc64 \| powerpc64le \| powerpcle \| ppcbe \
274	276	\| pyramid \
275		\| sh \| sh[1234] \| sh[24]a \| sh[23]e \| sh[34]eb \| shbe \| shle \| sh[1234]le \| sh3ele \
	277	\| sh \| sh[1234] \| sh[24]a \| sh[23]e \| sh[34]eb \| sheb \| shbe \| shle \| sh[1234]le \| sh3ele \
276	278	\| sh64 \| sh64le \
277		\| sparc \| sparc64 \| sparc64b \| sparc86x \| sparclet \| sparclite \
278		\| sparcv8 \| sparcv9 \| sparcv9b \
	279	\| sparc \| sparc64 \| sparc64b \| sparc64v \| sparc86x \| sparclet \| sparclite \
	280	\| sparcv8 \| sparcv9 \| sparcv9b \| sparcv9v \
279	281	\| strongarm \
280	282	\| tahoe \| thumb \| tic4x \| tic80 \| tron \
281	283	\| v850 \| v850e \

349	351	\| mmix-* \
350	352	\| mt-* \
351	353	\| msp430-* \
	354	\| nios-* \| nios2-* \
352	355	\| none-* \| np1-* \| ns16k-* \| ns32k-* \
353	356	\| orion-* \
354	357	\| pdp10-* \| pdp11-* \| pj-* \| pjl-* \| pn-* \| power-* \
355	358	\| powerpc-* \| powerpc64-* \| powerpc64le-* \| powerpcle-* \| ppcbe-* \
356	359	\| pyramid-* \
357	360	\| romp-* \| rs6000-* \
358		\| sh-* \| sh[1234]-* \| sh[24]a-* \| sh[23]e-* \| sh[34]eb-* \| shbe-* \
	361	\| sh-* \| sh[1234]-* \| sh[24]a-* \| sh[23]e-* \| sh[34]eb-* \| sheb-* \| shbe-* \
359	362	\| shle-* \| sh[1234]le-* \| sh3ele-* \| sh64-* \| sh64le-* \
360		\| sparc-* \| sparc64-* \| sparc64b-* \| sparc86x-* \| sparclet-* \
	363	\| sparc-* \| sparc64-* \| sparc64b-* \| sparc64v-* \| sparc86x-* \| sparclet-* \
361	364	\| sparclite-* \
362		\| sparcv8-* \| sparcv9-* \| sparcv9b-* \| strongarm-* \| sv1-* \| sx?-* \
	365	\| sparcv8-* \| sparcv9-* \| sparcv9b-* \| sparcv9v-* \| strongarm-* \| sv1-* \| sx?-* \
363	366	\| tahoe-* \| thumb-* \
364	367	\| tic30-* \| tic4x-* \| tic54x-* \| tic55x-* \| tic6x-* \| tic80-* \
365	368	\| tron-* \

1125	1128	sh[1234] \| sh[24]a \| sh[34]eb \| sh[1234]le \| sh[23]ele)
1126	1129	basic_machine=sh-unknown
1127	1130	;;
1128		sparc \| sparcv8 \| sparcv9 \| sparcv9b)
	1131	sparc \| sparcv8 \| sparcv9 \| sparcv9b \| sparcv9v)
1129	1132	basic_machine=sparc-sun
1130	1133	;;
1131	1134	cydra)

-2

configure less more

3769	3769
3770	3770
3771	3771
3772		for ac_header in unistd.h getopt.h sys/vlimit.h sys/resource.h ttyent.h sys/ttold.h sys/uio.h sys/ioctl_compat.h usersec.h sys/select.h stropts.h sys/audit.h shadow.h sys/time.h crypt.h sysexits.h types.h sys/sockio.h sys/param.h
	3772
	3773	for ac_header in unistd.h getopt.h sys/vlimit.h sys/resource.h ttyent.h sys/ttold.h sys/uio.h sys/ioctl_compat.h usersec.h sys/select.h stropts.h sys/audit.h shadow.h sys/time.h crypt.h sysexits.h types.h sys/sockio.h sys/param.h sys/un.h
3773	3774	do
3774	3775	as_ac_Header=`echo "ac_cv_header_$ac_header" \| $as_tr_sh`
3775	3776	if eval "test \"\${$as_ac_Header+set}\" = set"; then

6954	6955
6955	6956
6956	6957
6957		for ac_func in getopt strerror getrlimit getsid setsid getuserattr setgroups tcgetpgrp tcsetpgrp tcgetattr tcsetattr tcsendbreak setpgrp getutent setttyent getspnam setlinebuf setvbuf ptsname grantpt unlockpt sigaction setsockopt getdtablesize putenv memset memcpy memcmp memmove sysconf getlogin inet_aton setproctitle gettimeofday
	6958
	6959	for ac_func in getopt strerror getrlimit getsid setsid getuserattr setgroups tcgetpgrp tcsetpgrp tcgetattr tcsetattr tcsendbreak setpgrp getutent setttyent getspnam setlinebuf setvbuf ptsname grantpt unlockpt sigaction setsockopt getdtablesize putenv memset memcpy memcmp memmove sysconf getlogin inet_aton setproctitle gettimeofday strlcpy
6958	6960	do
6959	6961	as_ac_var=`echo "ac_cv_func_$ac_func" \| $as_tr_sh`
6960	6962	echo "$as_me:$LINENO: checking for $ac_func" >&5

-2

configure.in less more

325	325	AC_MSG_ERROR([POSIX termios interface required])
326	326	fi
327	327
328		AC_CHECK_HEADERS(unistd.h getopt.h sys/vlimit.h sys/resource.h ttyent.h sys/ttold.h sys/uio.h sys/ioctl_compat.h usersec.h sys/select.h stropts.h sys/audit.h shadow.h sys/time.h crypt.h sysexits.h types.h sys/sockio.h sys/param.h)
	328	AC_CHECK_HEADERS(unistd.h getopt.h sys/vlimit.h sys/resource.h ttyent.h sys/ttold.h sys/uio.h sys/ioctl_compat.h usersec.h sys/select.h stropts.h sys/audit.h shadow.h sys/time.h crypt.h sysexits.h types.h sys/sockio.h sys/param.h sys/un.h)
329	329	dnl sys/proc.h needs sys/param.h on openbsd, apparently
330	330	AC_CHECK_HEADERS(sys/proc.h, [], [],
331	331	[#if HAVE_SYS_PARAM_H

609	609	AC_CHECK_LIB(util, openpty)
610	610	AC_CHECK_FUNCS(openpty)
611	611
612		AC_CHECK_FUNCS(getopt strerror getrlimit getsid setsid getuserattr setgroups tcgetpgrp tcsetpgrp tcgetattr tcsetattr tcsendbreak setpgrp getutent setttyent getspnam setlinebuf setvbuf ptsname grantpt unlockpt sigaction setsockopt getdtablesize putenv memset memcpy memcmp memmove sysconf getlogin inet_aton setproctitle gettimeofday)
	612	AC_CHECK_FUNCS(getopt strerror getrlimit getsid setsid getuserattr setgroups tcgetpgrp tcsetpgrp tcgetattr tcsetattr tcsendbreak setpgrp getutent setttyent getspnam setlinebuf setvbuf ptsname grantpt unlockpt sigaction setsockopt getdtablesize putenv memset memcpy memcmp memmove sysconf getlogin inet_aton setproctitle gettimeofday strlcpy)
613	613	AC_FUNC_SETPGRP
614	614	AC_CHECK_FUNC(strcasecmp,
615	615	[AC_DEFINE(HAVE_STRCASECMP, 1, [Define if strcasecmp is available])],

+166

-161

conserver/client.c less more

0	0	/*
1		* $Id: client.c,v 5.89 2005/09/04 00:28:58 bryan Exp $
	1	* $Id: client.c,v 5.90 2006/04/03 13:32:08 bryan Exp $
2	2	*
3	3	* Copyright conserver.com, 2000
4	4	*

106	106	pCE->pCLwr = (CONSCLIENT *)0;
107	107	}
108	108
109		/* replay last iBack lines of the log file upon connect to console (ksb)
	109	/* replay last 'back' lines of the log file upon connect to console (ksb)
110	110	*
111	111	* NB: we know the console might be spewing when the replay happens,
112	112	* we want to just output what is in the log file and get out,
113	113	* so we don't drop chars...
114	114	*/
	115	#define REPLAYBUFFER 4096
	116
115	117	void
116	118	#if PROTOTYPES
117		Replay(CONSENT pCE, CONSFILE fdOut, int iBack)
118		#else
119		Replay(pCE, fdOut, iBack)
	119	Replay(CONSENT pCE, CONSFILE fdOut, unsigned short back)
	120	#else
	121	Replay(pCE, fdOut, back)
120	122	CONSENT *pCE;
121	123	CONSFILE *fdOut;
122		int iBack;
	124	unsigned short back;
123	125	#endif
124	126	{
125	127	CONSFILE fdLog = (CONSFILE )0;
	128	STRING line = (STRING )0;
126	129	off_t file_pos;
127	130	off_t buf_pos;
128	131	char *buf;
129	132	char bp = (char )0;
130		char *s;
131		int r;
132	133	int ch;
133	134	struct stat stLog;
134		struct lines {
135		int is_mark;
136		STRING *line;
137		STRING *mark_end;
138		} *lines;
139		int n_lines;
140	135	int ln;
141		int i;
142		int j;
143		int u;
144		int is_mark;
145		char dummy[4];
	136	int was_mark = 0;
146	137	#if HAVE_DMALLOC && DMALLOC_MARK_REPLAY
147	138	unsigned long dmallocMarkReplay = 0;
148	139	#endif
149	140
150		if (pCE != (CONSENT *)0) {
151		fdLog = pCE->fdlog;
152
153		/* no logfile and down and logfile defined? try and open it */
154		if (fdLog == (CONSFILE *)0 && !pCE->fup &&
155		pCE->logfile != (char *)0)
156		fdLog = FileOpen(pCE->logfile, O_RDONLY, 0644);
157		}
	141	if (pCE != (CONSENT )0 && pCE->logfile != (char )0)
	142	fdLog = FileOpen(pCE->logfile, O_RDONLY, 0644);
158	143
159	144	if (fdLog == (CONSFILE *)0) {
160	145	FileWrite(fdOut, FLAGFALSE, "[no log file on this console]\r\n",
161	146	-1);
162	147	return;
163	148	}
	149	#if HAVE_DMALLOC && DMALLOC_MARK_REPLAY
	150	dmallocMarkReplay = dmalloc_mark();
	151	#endif
164	152
165	153	/* find the size of the file
166	154	*/
167		if (0 != FileStat(fdLog, &stLog)) {
168		return;
169		}
170		#if HAVE_DMALLOC && DMALLOC_MARK_REPLAY
171		dmallocMarkReplay = dmalloc_mark();
172		#endif
173
174		file_pos = stLog.st_size - 1;
	155	if (0 != FileStat(fdLog, &stLog))
	156	goto common_exit;
	157
	158	file_pos = stLog.st_size - 1; /* point at last byte */
175	159	buf_pos = file_pos + 1;
176	160
177		/* get space for the line information and initialize it
178		*
179		* we allocate room for one more line than requested to be able to
180		* do the mark ranges
181		*/
182		if ((char *)0 == (buf = malloc(BUFSIZ))) {
	161	if ((char *)0 == (buf = malloc(REPLAYBUFFER)))
183	162	OutOfMem();
184		}
185		n_lines = iBack + 1;
186		lines = (struct lines )calloc(n_lines, sizeof(lines));
187		if ((struct lines *)0 == lines) {
188		OutOfMem();
189		}
190		for (i = 0; i < n_lines; i++) {
191		lines[i].mark_end = AllocString();
192		lines[i].line = AllocString();
193		}
194		ln = -1;
	163	bp = buf + 1; /* just give it something - it resets below */
	164
	165	line = AllocString();
195	166
196	167	/* loop as long as there is data in the file or we have not found
197	168	* the requested number of lines
198	169	*/
199		while (file_pos >= 0) {
	170	ln = -1;
	171	for (; file_pos >= 0; file_pos--, bp--) {
200	172	if (file_pos < buf_pos) {
	173	int r;
201	174
202	175	/* read one buffer worth of data a buffer boundary
203	176	*
204	177	* the first read will probably not get a full buffer but
205	178	* the rest (as we work our way back in the file) should be
206	179	*/
207		buf_pos = (file_pos / BUFSIZ) * BUFSIZ;
	180	buf_pos = (file_pos / REPLAYBUFFER) * REPLAYBUFFER;
208	181	if (FileSeek(fdLog, buf_pos, SEEK_SET) < 0) {
209	182	goto common_exit;
210	183	}
211		if ((r = FileRead(fdLog, buf, BUFSIZ)) < 0) {
	184	if ((r = FileRead(fdLog, buf, REPLAYBUFFER)) < 0) {
212	185	goto common_exit;
213	186	}
214		bp = buf + r;
	187	bp = buf + r - 1;
215	188	}
216	189
217	190	/* process the next character
218	191	*/
219		--file_pos;
220		if ((ch = *--bp) == '\n') {
	192	if ((ch = *bp) == '\n') {
221	193	if (ln >= 0) {
	194	int i;
	195	int u;
	196	int is_mark = 0;
222	197
223	198	/* reverse the text to put it in forward order
224	199	*/
225		u = lines[ln].line->used - 1;
	200	u = line->used - 1;
226	201	for (i = 0; i < u / 2; i++) {
227	202	int temp;
228	203
229		temp = lines[ln].line->string[i];
230		lines[ln].line->string[i]
231		= lines[ln].line->string[u - i - 1];
232		lines[ln].line->string[u - i - 1] = temp;
	204	temp = line->string[i];
	205	line->string[i] = line->string[u - i - 1];
	206	line->string[u - i - 1] = temp;
233	207	}
234	208
235	209	/* see if this line is a MARK
236	210	*/
237		if (lines[ln].line->used > 0 &&
238		lines[ln].line->string[0] == '[') {
239		i = sscanf(lines[ln].line->string + 1,
	211	if (line->used > 0 && line->string[0] == '[') {
	212	char dummy[4];
	213	int j;
	214	i = sscanf(line->string + 1,
240	215	"-- MARK -- %3c %3c %d %d:%d:%d %d]\r\n",
241	216	dummy, dummy, &j, &j, &j, &j, &j);
242	217	is_mark = (i == 7);
243		} else {
244		is_mark = 0;
245	218	}
246	219
247	220	/* process this line
248	221	*/
249		if (is_mark && ln > 0 && lines[ln - 1].is_mark) {
	222	if (is_mark && was_mark) {
250	223	/* this is a mark and the previous line is also
251		* a mark, so make (or continue) that range
	224	* a mark, so reduce the line count 'cause it'll
	225	* go up by one and we're joining them on output.
252	226	*/
253		if (0 == lines[ln - 1].mark_end->used) {
254		/* this is a new range - shuffle pointers
255		*
256		* remember that we are moving backward
257		*/
258		BuildStringN(lines[ln - 1].line->string,
259		lines[ln - 1].line->used - 1,
260		lines[ln - 1].mark_end);
261		BuildString((char *)0, lines[ln - 1].line);
262		}
263		BuildString((char *)0, lines[ln - 1].line);
264		BuildStringN(lines[ln].line->string,
265		lines[ln].line->used - 1,
266		lines[ln - 1].line);
267		BuildString((char *)0, lines[ln].line);
268	227	ln--;
269	228	}
270		lines[ln].is_mark = is_mark;
	229	was_mark = is_mark;
271	230	}
272	231
273	232	/* advance to the next line and break if we have enough
274	233	*/
275	234	ln++;
276		if (ln >= n_lines - 1) {
	235	BuildString((char *)0, line);
	236	if (ln >= back) {
277	237	break;
278	238	}
279	239	}

284	244	if (ln < 0) {
285	245	ln = 0;
286	246	}
287		BuildStringChar(ch, lines[ln].line);
	247	BuildStringChar(ch, line);
288	248
289	249	/* if we've processed "a lot" of data for a line, then bail
290	250	* why? there must be some very long non-newline terminated
291	251	* strings and if we just keep going back, we could spew lots
292	252	* of data and chew up lots of memory
293	253	*/
294		if (lines[ln].line->used > MAXREPLAYLINELEN) {
	254	if (line->used > MAXREPLAYLINELEN) {
295	255	break;
296	256	}
297	257	}
298		free(buf);
299		buf = (char *)0;
300
301		/* if we got back to beginning of file but saw some data, include it
	258
	259	/* move forward. either we hit the beginning of the file and we
	260	* move to the first byte, or we hit a \n and we move past it
302	261	*/
303		if (ln >= 0 && lines[ln].line->used > 0) {
304
305		/* reverse the text to put it in forward order
306		*/
307		u = lines[ln].line->used - 1;
308		for (i = 0; i < u / 2; i++) {
309		int temp;
310
311		temp = lines[ln].line->string[i];
312		lines[ln].line->string[i]
313		= lines[ln].line->string[u - i - 1];
314		lines[ln].line->string[u - i - 1] = temp;
315		}
316		ln++;
317		}
318
319		/* copy the lines into the buffer and put them in order
320		*/
321		for (i = ln - 1; i >= 0; i--) {
322		if (lines[i].is_mark && 0 != lines[i].mark_end->used) {
323		int mark_len;
324
325		/* output the start of the range, stopping at the ']'
326		*/
327		s = strrchr(lines[i].line->string, ']');
328		if ((char *)0 != s) {
329		*s = '\000';
330		}
331		FileWrite(fdOut, FLAGTRUE, lines[i].line->string, -1);
332		FileWrite(fdOut, FLAGTRUE, " .. ", 4);
333
334		/* build the end string by removing the leading "[-- MARK -- "
335		* and replacing "]\r\n" on the end with " -- MARK --]\r\n"
336		*/
337		mark_len = sizeof("[-- MARK -- ") - 1;
338
339		s = strrchr(lines[i].mark_end->string + mark_len, ']');
340		if ((char *)0 != s) {
341		*s = '\000';
342		}
343		FileWrite(fdOut, FLAGTRUE,
344		lines[i].mark_end->string + mark_len, -1);
345		FileWrite(fdOut, FLAGFALSE, " -- MARK --]\r\n", -1);
346		u = lines[i].mark_end->used;
347		s = lines[i].mark_end->string;
348		} else
349		FileWrite(fdOut, FLAGFALSE, lines[i].line->string,
350		lines[i].line->used - 1);
	262	file_pos++;
	263
	264	/* Now output the lines, starting from where we stopped */
	265	if (FileSeek(fdLog, file_pos, SEEK_SET) >= 0) {
	266	int eof = 0;
	267	int i = 0;
	268	int r = 0;
	269	STRING mark_beg = (STRING )0;
	270	STRING mark_end = (STRING )0;
	271
	272	mark_beg = AllocString();
	273	mark_end = AllocString();
	274
	275	ln = 0; /* number of lines output */
	276	BuildString((char *)0, line);
	277
	278	while (ln < back && !eof) {
	279	if (r <= 0) {
	280	if ((r = FileRead(fdLog, buf, REPLAYBUFFER)) < 0)
	281	eof = 1;
	282	i = 0;
	283	}
	284
	285	if (!eof)
	286	BuildStringChar(buf[i], line);
	287
	288	if (buf[i] == '\n' \|\| eof) {
	289	int is_mark = 0;
	290	if (line->used > 0 && line->string[0] == '[') {
	291	char dummy[4];
	292	int j;
	293	int i;
	294	i = sscanf(line->string + 1,
	295	"-- MARK -- %3c %3c %d %d:%d:%d %d]\r\n",
	296	dummy, dummy, &j, &j, &j, &j, &j);
	297	is_mark = (i == 7);
	298	}
	299	if (is_mark) {
	300	if (mark_beg->used > 1) {
	301	BuildString((char *)0, mark_end);
	302	BuildString(line->string, mark_end);
	303	} else
	304	BuildString(line->string, mark_beg);
	305	} else {
	306	if (mark_beg->used > 1) {
	307	if (mark_end->used > 1) {
	308	char *s;
	309
	310	/* output the start of the range, stopping at the ']' */
	311	s = strrchr(mark_beg->string, ']');
	312	if ((char *)0 != s)
	313	*s = '\000';
	314	FileWrite(fdOut, FLAGTRUE, mark_beg->string,
	315	-1);
	316	FileWrite(fdOut, FLAGTRUE, " .. ", 4);
	317
	318	/* build the end string by removing the leading "[-- MARK -- "
	319	* and replacing "]\r\n" on the end with " -- MARK --]\r\n"
	320	*/
	321	s = strrchr(mark_end->string, ']');
	322	if ((char *)0 != s)
	323	*s = '\000';
	324	FileWrite(fdOut, FLAGTRUE,
	325	mark_end->string +
	326	sizeof("[-- MARK -- ") - 1, -1);
	327	FileWrite(fdOut, FLAGFALSE, " -- MARK --]\r\n",
	328	-1);
	329	} else {
	330	FileWrite(fdOut, FLAGFALSE, mark_beg->string,
	331	mark_beg->used - 1);
	332	}
	333	BuildString((char *)0, mark_beg);
	334	BuildString((char *)0, mark_end);
	335	ln++;
	336	if (ln >= back)
	337	break;
	338	}
	339	FileWrite(fdOut, FLAGFALSE, line->string,
	340	line->used - 1);
	341	ln++;
	342	}
	343	BuildString((char *)0, line);
	344	}
	345
	346	/* move the counters */
	347	i++;
	348	r--;
	349	}
	350	DestroyString(mark_end);
	351	DestroyString(mark_beg);
351	352	}
352	353
353	354	common_exit:
354	355
355		/* if we opened the logfile, close it */
356		if (fdLog != pCE->fdlog)
	356	if (line != (STRING *)0)
	357	DestroyString(line);
	358	if (buf != (char *)0)
	359	free(buf);
	360	if (fdLog != (CONSFILE *)0)
357	361	FileClose(&fdLog);
358	362
359		if ((struct lines *)0 != lines) {
360		for (i = 0; i < n_lines; i++) {
361		DestroyString(lines[i].mark_end);
362		DestroyString(lines[i].line);
363		}
364		free(lines);
365		lines = (struct lines *)0;
366		}
367		if ((char *)0 != buf) {
368		free(buf);
369		buf = (char *)0;
370		}
371	363	#if HAVE_DMALLOC && DMALLOC_MARK_REPLAY
372	364	CONDDEBUG((1, "Replay(): dmalloc / MarkReplay"));
373	365	dmalloc_log_changed(dmallocMarkReplay, 1, 0, 1);

407	399	{WHEN_ATTACH, "l1-9 send specific break sequence"},
408	400	{WHEN_ALWAYS, "m display the message of the day"},
409	401	{WHEN_ALWAYS, "o (re)open the tty and log file"},
410		{WHEN_ALWAYS, "p replay the last 60 lines"},
411		{WHEN_ALWAYS, "r replay the last 20 lines"},
412		{WHEN_ATTACH, "s spy read only"},
	402	{WHEN_ALWAYS, "p playback the last %hu lines"},
	403	{WHEN_ALWAYS, "P set number of playback lines"},
	404	{WHEN_ALWAYS, "r replay the last %hu lines"},
	405	{WHEN_ALWAYS, "R set number of replay lines"},
	406	{WHEN_ATTACH, "s spy mode (read only)"},
413	407	{WHEN_ALWAYS, "u show host status"},
414	408	{WHEN_ALWAYS, "v show version info"},
415	409	{WHEN_ALWAYS, "w who is on this console"},

453	447
454	448	BuildString((char *)0, acLine);
455	449	for (i = 0; i < sizeof(aHLTable) / sizeof(HELP); ++i) {
	450	char *text;
	451
456	452	if (aHLTable[i].iwhen & IS_LIMITED &&
457	453	ConsentUserOk(pLUList, pCL->username->string) == 1)
458	454	continue;

460	456	if (0 == (aHLTable[i].iwhen & iCmp))
461	457	continue;
462	458
	459	text = aHLTable[i].actext;
	460	if (text[0] == 'p') {
	461	BuildTmpString((char *)0);
	462	text = BuildTmpStringPrint(text, pCL->playback);
	463	} else if (text[0] == 'r') {
	464	BuildTmpString((char *)0);
	465	text = BuildTmpStringPrint(text, pCL->replay);
	466	}
	467
463	468	if (acLine->used != 0) { /* second part of line */
464		if (strlen(aHLTable[i].actext) < HALFLINE) {
	469	if (strlen(text) < HALFLINE) {
465	470	for (j = acLine->used; j <= HALFLINE; ++j) {
466	471	BuildStringChar(' ', acLine);
467	472	}
468		BuildString(aHLTable[i].actext, acLine);
	473	BuildString(text, acLine);
469	474	BuildString(acEoln, acLine);
470	475	FileWrite(pCL->fd, FLAGTRUE, acLine->string,
471	476	acLine->used - 1);

480	485	}
481	486	if (acLine->used == 0) { /* at new line */
482	487	BuildStringChar(' ', acLine);
483		BuildString(aHLTable[i].actext, acLine);
	488	BuildString(text, acLine);
484	489	if (acLine->used > HALFLINE) {
485	490	BuildString(acEoln, acLine);
486	491	FileWrite(pCL->fd, FLAGTRUE, acLine->string,

-4

conserver/client.h less more

0	0	/*
1		* $Id: client.h,v 5.40 2005/06/07 19:55:51 bryan Exp $
	1	* $Id: client.h,v 5.41 2006/04/03 13:32:08 bryan Exp $
2	2	*
3	3	* Copyright conserver.com, 2000
4	4	*

47	47	S_QUOTE, /* send any character we can spell */
48	48	S_BCAST, /* send a broadcast message to all clients */
49	49	S_CWAIT, /* wait for client */
50		S_CEXEC /* client execing a program */
	50	S_CEXEC, /* client execing a program */
	51	S_REPLAY, /* set replay length for 'r' */
	52	S_PLAYBACK /* set replay length for 'p' */
51	53	} CLIENTSTATE;
52	54
53	55	typedef struct client { /* Connection Information: */

74	76	pCLnext; / next person on this list */
75	77	/* next lists link clients on a console */
76	78	char ic[2]; /* two character escape sequence */
	79	unsigned short replay; /* lines to replay for 'r' */
	80	unsigned short playback; /* lines to replay for 'p' */
77	81	CLIENTSTATE iState; /* state for fsm in server */
78	82	char caccess; /* did we trust the remote machine */
79	83	IOSTATE ioState; /* state of the socket */
80	84	time_t stateTimer; /* timer for various ioState states */
81	85	STRING accmd; / the command the user issued */
82		STRING msg; / the broadcast message */
83	86	struct sockaddr_in
84	87	cnct_port; /* where from */
85	88	} CONSCLIENT;
86	89
87		extern void Replay PARAMS((CONSENT , CONSFILE , int));
	90	extern void Replay PARAMS((CONSENT , CONSFILE , unsigned short));
88	91	extern void HelpUser PARAMS((CONSCLIENT *));
89	92	extern void FindWrite PARAMS((CONSENT *));
90	93	extern int ClientAccessOk PARAMS((CONSCLIENT *));

+96

-10

conserver/consent.c less more

0	0	/*
1		* $Id: consent.c,v 5.145 2005/06/08 18:09:40 bryan Exp $
	1	* $Id: consent.c,v 5.149 2006/04/07 15:47:20 bryan Exp $
2	2	*
3	3	* Copyright conserver.com, 2000
4	4	*

274	274	{
275	275	if (pCE->initcmd == (char *)0)
276	276	return;
	277
	278	if (pCE->initpid != 0 \|\| pCE->initfile != (CONSFILE *)0)
	279	SendIWaitClientsMsg(pCE,
	280	(pCE->fup &&
	281	pCE->ioState ==
	282	ISNORMAL) ? "up]\r\n" : "down]\r\n");
277	283
278	284	if (pCE->initpid != 0) {
279	285	kill(pCE->initpid, SIGHUP);

777	783
778	784	switch (pCE->type) {
779	785	case UNKNOWNTYPE: /* shut up gcc */
	786	break;
	787	case NOOP:
	788	pCE->fup = 1;
	789	pCE->ioState = ISNORMAL;
780	790	break;
781	791	case EXEC:
782	792	if ((cofile =

886	896	}
887	897	pCE->fup = 1;
888	898	break;
	899	case UDS:
	900	{
	901	struct sockaddr_un port;
	902
	903	#if HAVE_MEMSET
	904	memset((void *)&port, 0, sizeof(port));
	905	#else
	906	bzero((char *)&port, sizeof(port));
	907	#endif
	908
	909	/* we ensure that pCE->uds exists and fits inside port.sun_path
	910	* in readcfg.c, so we can just defend ourselves here (which
	911	* should never trigger).
	912	*/
	913	if (strlen(pCE->uds) >= sizeof(port.sun_path)) {
	914	Error
	915	("[%s] strlen(uds path) > sizeof(port.sun_path): forcing down",
	916	pCE->server);
	917	ConsDown(pCE, FLAGTRUE, FLAGTRUE);
	918	return;
	919	}
	920	StrCpy(port.sun_path, pCE->uds, sizeof(port.sun_path));
	921	port.sun_family = AF_UNIX;
	922
	923	if ((cofile = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
	924	Error
	925	("[%s] socket(AF_UNIX,SOCK_STREAM): %s: forcing down",
	926	pCE->server, strerror(errno));
	927	ConsDown(pCE, FLAGTRUE, FLAGTRUE);
	928	return;
	929	}
	930
	931	if (!SetFlags(cofile, O_NONBLOCK, 0)) {
	932	ConsDown(pCE, FLAGTRUE, FLAGTRUE);
	933	return;
	934	}
	935
	936	if ((ret =
	937	connect(cofile, (struct sockaddr *)&port,
	938	sizeof(port))) < 0) {
	939	if (errno != EINPROGRESS) {
	940	Error("[%s] connect(%u): %s: forcing down",
	941	pCE->server, cofile, strerror(errno));
	942	ConsDown(pCE, FLAGTRUE, FLAGTRUE);
	943	return;
	944	}
	945	}
	946	}
	947	if ((pCE->cofile =
	948	FileOpenFD(cofile, simpleSocket)) == (CONSFILE *)0) {
	949	Error
	950	("[%s] FileOpenFD(%d,simpleSocket) failed: forcing down",
	951	pCE->server, cofile);
	952	ConsDown(pCE, FLAGTRUE, FLAGTRUE);
	953	return;
	954	}
	955	if (ret == 0) {
	956	pCE->ioState = ISNORMAL;
	957	pCE->stateTimer = 0;
	958	} else {
	959	pCE->ioState = INCONNECT;
	960	pCE->stateTimer = time((time_t *)0) + CONNECTTIMEOUT;
	961	if (timers[T_STATE] == (time_t)0 \|\|
	962	timers[T_STATE] > pCE->stateTimer)
	963	timers[T_STATE] = pCE->stateTimer;
	964	}
	965	pCE->fup = 1;
	966	break;
889	967	case DEVICE:
890	968	if (-1 ==
891	969	(cofile = open(pCE->device, O_RDWR \| O_NONBLOCK, 0600))) {

924	1002	Verbose("[%s] port %hu on %s", pCE->server, pCE->netport,
925	1003	pCE->host);
926	1004	break;
	1005	case NOOP:
	1006	Verbose("[%s] noop", pCE->server);
	1007	break;
	1008	case UDS:
	1009	Verbose("[%s] uds %s", pCE->server, pCE->uds);
	1010	break;
927	1011	case DEVICE:
928	1012	Verbose("[%s] at %s%c on %s", pCE->server, pCE->baud->acrate,
929	1013	pCE->parity->key[0], pCE->device);
930	1014	break;
931	1015	}
932	1016
933		/* if we're waiting for connect() to finish, watch the
934		* write bit, otherwise watch for the read bit
935		*/
936		if (pCE->ioState == INCONNECT)
937		FD_SET(cofile, &winit);
938		else
939		FD_SET(cofile, &rinit);
940		if (maxfd < cofile + 1)
941		maxfd = cofile + 1;
	1017	if (cofile != -1) {
	1018	/* if we're waiting for connect() to finish, watch the
	1019	* write bit, otherwise watch for the read bit
	1020	*/
	1021	if (pCE->ioState == INCONNECT)
	1022	FD_SET(cofile, &winit);
	1023	else
	1024	FD_SET(cofile, &rinit);
	1025	if (maxfd < cofile + 1)
	1026	maxfd = cofile + 1;
	1027	}
942	1028
943	1029	tyme = time((time_t *)0);
944	1030

-2

conserver/consent.h less more

0	0	/*
1		* $Id: consent.h,v 5.63 2005/06/08 18:09:40 bryan Exp $
	1	* $Id: consent.h,v 5.66 2006/03/20 16:47:03 bryan Exp $
2	2	*
3	3	* Copyright conserver.com, 2000
4	4	*

54	54	UNKNOWNTYPE = 0,
55	55	DEVICE,
56	56	EXEC,
57		HOST
	57	HOST,
	58	NOOP,
	59	UDS
58	60	} CONSTYPE;
59	61
60	62	typedef struct names {

101	103	char execsubst; / exec substitution pattern */
102	104	uid_t execuid; /* user to run exec as */
103	105	gid_t execgid; /* group to run exec as */
	106	/* type == UDS */
	107	char uds; / socket file */
	108	char udssubst; / socket file substitution pattern */
104	109	/* global stuff */
105	110	char master; / master hostname */
106	111	unsigned short breakNum; /* break type [1-9] */

126	131	FLAG striphigh; /* strip high-bit of console data */
127	132	FLAG autoreinit; /* auto-reinitialize if failed */
128	133	FLAG unloved; /* copy "unloved" data to stdout */
	134	FLAG login; /* allow logins to the console */
129	135
130	136	/* runtime settings */
131	137	CONSFILE fdlog; / the local log file */

-3

conserver/conserver.man less more

0	0	.\" @(#)conserver.8 01/06/91 OSU CIS; Thomas A. Fine
1		.\" $Id: conserver.man,v 1.51 2005/04/02 09:59:48 bryan Exp $
2		.TH CONSERVER 8 "2005/04/02" "conserver-8.1.13" "conserver"
	1	.\" $Id: conserver.man,v 1.53 2006/03/20 16:47:03 bryan Exp $
	2	.TH CONSERVER 8 "2006/03/20" "conserver-8.1.14" "conserver"
3	3	.SH NAME
4	4	conserver \- console server daemon
5	5	.SH SYNOPSIS

379	379	.I type
380	380	The type of console.
381	381	Values will be a `/' for a local device, `\|' for
382		a command, or `!' for a remote port.
	382	a command, `!' for a remote port, `%' for a Unix domain socket,
	383	and `#' for a noop console.
383	384	.TP
384	385	.I details
385	386	Multiple values are comma-separated and depend on the type of the console.
386	387	Local devices will have the values of the device file and baud rate/parity.
387	388	Commands will have string to invoke.
388	389	Remote ports will have the values of the remote hostname and port number.
	390	Unix domain sockets will have the path to the socket.
	391	Noop consoles will have nothing.
389	392	.RE
390	393	.TP
391	394	.B \-u

-2

conserver/convert.c less more

0	0	/*
1		* $Id: convert.c,v 1.10 2004/05/28 01:08:28 bryan Exp $
	1	* $Id: convert.c,v 1.12 2006/04/07 15:47:20 bryan Exp $
2	2	*
3	3	* Copyright conserver.com, 2000
4	4	*

85	85	\|\| peek) {
86	86	/* If we have a previously saved line, use it instead */
87	87	if (save->used) {
88		strcpy(buf, save->string);
	88	StrCpy(buf, save->string, sizeof(buf));
89	89	BuildString((char *)0, save);
90	90	}
91	91

+87

-14

conserver/cutil.c less more

0	0	/*
1		* $Id: cutil.c,v 1.125 2006/01/15 17:10:14 bryan Exp $
	1	* $Id: cutil.c,v 1.130 2006/04/07 15:47:20 bryan Exp $
2	2	*
3	3	* Copyright conserver.com, 2000
4	4	*

8	8	#include <compat.h>
9	9
10	10	#include <cutil.h>
	11	#include <version.h>
11	12
12	13	#include <net/if.h>
13	14	#if HAVE_SYS_SOCKIO_H

83	84	time_t tyme;
84	85
85	86	tyme = time((time_t *)0);
86		strcpy(curtime, ctime(&tyme));
	87	StrCpy(curtime, ctime(&tyme), sizeof(curtime));
87	88	curtime[24] = '\000'; /* might need to adjust this at some point */
88	89	if (ltime != NULL)
89	90	*ltime = tyme;

423	424	\|\| peek) {
424	425	/* If we have a previously saved line, use it instead */
425	426	if (save->used) {
426		strcpy(buf, save->string);
	427	StrCpy(buf, save->string, sizeof(buf));
427	428	BuildString((char *)0, save);
428	429	}
429	430

2289	2290
2290	2291	if (sa->sa_family == AF_INET) {
2291	2292	struct sockaddr_in sin = (struct sockaddr_in )sa;
	2293
	2294	/* make sure the address isn't 0.0.0.0, which is how we
	2295	* signal the end of our list
	2296	*/
	2297	if (
	2298	#if HAVE_MEMCMP
	2299	memcmp(&(myAddrs[m]), &(sin->sin_addr),
	2300	sizeof(struct in_addr))
	2301	#else
	2302	bcmp(&(myAddrs[m]), &(sin->sin_addr),
	2303	sizeof(struct in_addr))
	2304	#endif
	2305	== 0)
	2306	continue;
	2307
2292	2308	#ifdef SIOCGIFFLAGS
2293	2309	/* make sure the interface is up */
2294	2310	ifrcopy = *ifr;

2296	2312	((ifrcopy.ifr_flags & IFF_UP) == 0))
2297	2313	continue;
2298	2314	#endif
	2315
2299	2316	CONDDEBUG((1, "ProbeInterfaces(): name=%s addr=%s",
2300	2317	ifr->ifr_name, inet_ntoa(sin->sin_addr)));
	2318
2301	2319	#if HAVE_MEMCPY
2302	2320	memcpy(&myAddrs[m], &(sin->sin_addr), sizeof(struct in_addr));
2303	2321	#else
2304	2322	bcopy(&(sin->sin_addr), &myAddrs[m], sizeof(struct in_addr));
2305	2323	#endif
	2324
2306	2325	Verbose("interface address %s (%s)", inet_ntoa(myAddrs[m]),
2307	2326	ifr->ifr_name);
2308	2327	m++;

2507	2526
2508	2527	char *
2509	2528	#if PROTOTYPES
2510		StrDup(char *msg)
	2529	StrDup(const char *msg)
2511	2530	#else
2512	2531	StrDup(msg)
2513		char *msg;
	2532	const char *msg;
2514	2533	#endif
2515	2534	{
2516	2535	int len;

3162	3181	REP_END
3163	3182	} state;
3164	3183
	3184	if (s == (SUBST *)0) {
	3185	Error("ProcessSubst(): WTF? No substitute support structure?!?!");
	3186	Bye(EX_SOFTWARE);
	3187	}
	3188
3165	3189	if (str != (char **)0) {
3166	3190	if (str != (char )0) {
3167	3191	free(*str);

3203	3227	break;
3204	3228	case REP_EQ:
3205	3229	repfmt[repnum] = p;
3206		if (s->tokens[(unsigned)(*(repfmt[repnum]))] != ISNOTHING)
	3230	if (s->token(*(repfmt[repnum])) != ISNOTHING)
3207	3231	state = REP_INT;
3208	3232	else
3209	3233	goto subst_err;

3211	3235	case REP_INT:
3212	3236	if (p == 'd' \|\| p == 'x' \|\| p == 'X' \|\| p == 'a' \|\|
3213	3237	*p == 'A') {
3214		if (s->tokens[(unsigned)(*(repfmt[repnum]))] !=
3215		ISNUMBER)
	3238	if (s->token(*(repfmt[repnum])) != ISNUMBER)
3216	3239	goto subst_err;
3217	3240	state = REP_END;
3218	3241	} else if (*p == 's') {
3219		if (s->tokens[(unsigned)(*(repfmt[repnum]))] !=
3220		ISSTRING)
	3242	if (s->token(*(repfmt[repnum])) != ISSTRING)
3221	3243	goto subst_err;
3222	3244	state = REP_END;
3223	3245	} else if (!isdigit((int)(*p)))

3245	3267	OutOfMem();
3246	3268	}
3247	3269
3248		if (s != (SUBST )0 && repl != (char *)0) {
	3270	if (s != (SUBST )0 && repl != (char )0 && repl != (char *)0) {
3249	3271	static STRING result = (STRING )0;
3250	3272
3251	3273	if (result == (STRING *)0)

3259	3281	char c = (char )0;
3260	3282	int o = 0;
3261	3283
3262		if (s->tokens[(unsigned)(*r)] == ISSTRING) {
	3284	if (s->token(*r) == ISSTRING) {
3263	3285	/* check the pattern for a length */
3264	3286	if (isdigit((int)(*(r + 1))))
3265	3287	plen = atoi(r + 1);
3266	3288
3267	3289	/* this should never return zero, but just in case */
3268		if ((s->callback) (r, &c, (int *)0) == 0)
	3290	if ((s->value) (r, &c, (int *)0) == 0)
3269	3291	c = "";
3270	3292	plen -= strlen(c);
3271	3293

3287	3309	BuildString((char *)0, num);
3288	3310
3289	3311	/* this should never return zero, but just in case */
3290		if ((s->callback) (r, (char **)0, &i) == 0)
	3312	if ((s->value) (r, (char **)0, &i) == 0)
3291	3313	port = 0;
3292	3314	else
3293	3315	port = (unsigned short)i;

3364	3386
3365	3387	return;
3366	3388	}
	3389
	3390	char *
	3391	#if PROTOTYPES
	3392	MyVersion(void)
	3393	#else
	3394	MyVersion()
	3395	#endif
	3396	{
	3397	static STRING version = (STRING )0;
	3398	if (version != (STRING *)0)
	3399	return version->string;
	3400	version = AllocString();
	3401	BuildStringPrint(version, "%s %d.%d.%d", VERSION_TEXT, VERSION_MAJOR,
	3402	VERSION_MINOR, VERSION_REV);
	3403	return version->string;
	3404	}
	3405
	3406	unsigned int
	3407	#if PROTOTYPES
	3408	AtoU(char *str)
	3409	#else
	3410	AtoU(c)
	3411	char *str;
	3412	#endif
	3413	{
	3414	unsigned int v;
	3415	int i;
	3416	v = 0;
	3417	for (i = 0; isdigit((int)str[i]); i++) {
	3418	v *= 10;
	3419	v += str[i] - '0';
	3420	}
	3421	return v;
	3422	}
	3423
	3424	void
	3425	#if PROTOTYPES
	3426	StrCpy(char dst, const char src, unsigned int size)
	3427	#else
	3428	StrCpy(dst, src, size)
	3429	char *dst;
	3430	const char *src;
	3431	unsigned int size;
	3432	#endif
	3433	{
	3434	#ifdef HAVE_STRLCPY
	3435	strlcpy(dst, src, size);
	3436	#else
	3437	strcpy(dst, src);
	3438	#endif
	3439	}

-4

conserver/cutil.h less more

0	0	/*
1		* $Id: cutil.h,v 1.64 2006/01/15 17:10:14 bryan Exp $
	1	* $Id: cutil.h,v 1.68 2006/04/07 15:47:20 bryan Exp $
2	2	*
3	3	* Copyright conserver.com, 2000
4	4	*

110	110	} SUBSTTOKEN;
111	111
112	112	typedef struct subst {
113		SUBSTTOKEN tokens[255];
	113	/* function to retrieve a token type based on a character
	114	*/
	115	SUBSTTOKEN (*token) PARAMS((char));
114	116	/* data for callback function
115	117	*/
116	118	void *data;
117	119	/* function to retrieve a value (as a char* or int or both) for
118	120	* a substitution
119	121	*/
120		int (callback) PARAMS((char, char , int ));
	122	int (value) PARAMS((char, char , int ));
121	123	} SUBST;
122	124
123	125	extern int isMultiProc, fDebug, fVerbose, fErrorPrinted;

188	190	extern int FileCanWrite PARAMS((CONSFILE , fd_set , fd_set *));
189	191	extern int FileBufEmpty PARAMS((CONSFILE *));
190	192	extern int SetFlags PARAMS((int, int, int));
191		extern char StrDup PARAMS((char ));
	193	extern char StrDup PARAMS((const char ));
192	194	extern int ParseIACBuf PARAMS((CONSFILE , void , int *));
193	195	extern void MemMove PARAMS((void , void *, size_t));
194	196	extern char StringChar PARAMS((STRING , int, char));

196	198	extern void ProbeInterfaces PARAMS((in_addr_t));
197	199	extern void ProcessSubst
198	200	PARAMS((SUBST , char , char , char , char *));
	201	extern char *MyVersion PARAMS((void));
	202	extern unsigned int AtoU PARAMS((char *));
	203	extern void StrCpy PARAMS((char , const char , unsigned int));
199	204	#if HAVE_OPENSSL
200	205	extern SSL FileGetSSL PARAMS((CONSFILE ));
201	206	extern void FileSetSSL PARAMS((CONSFILE , SSL ));

+222

-141

conserver/group.c less more

0	0	/*
1		* $Id: group.c,v 5.319 2005/11/28 20:46:08 bryan Exp $
	1	* $Id: group.c,v 5.325 2006/04/07 15:47:20 bryan Exp $
2	2	*
3	3	* Copyright conserver.com, 2000
4	4	*

67	67	#include <client.h>
68	68	#include <access.h>
69	69	#include <group.h>
70		#include <version.h>
71	70	#include <readcfg.h>
72	71	#include <master.h>
73	72	#include <main.h>
	73	#include <version.h>
74	74
75	75	#if HAVE_PAM
76	76	#include <security/pam_appl.h>

418	418	DestroyString(pCL->peername);
419	419	if (pCL->accmd != (STRING *)0)
420	420	DestroyString(pCL->accmd);
421		if (pCL->msg != (STRING *)0)
422		DestroyString(pCL->msg);
423	421	if (pCL->username != (STRING *)0)
424	422	DestroyString(pCL->username);
425	423	FileClose(&pCL->fd);

2084	2082	b = "Netwk";
2085	2083	p = ' ';
2086	2084	break;
	2085	case NOOP:
	2086	d = "NOOP";
	2087	b = "NOOP";
	2088	p = ' ';
	2089	break;
	2090	case UDS:
	2091	d = pCE->uds;
	2092	b = "UDS";
	2093	p = ' ';
	2094	break;
2087	2095	case UNKNOWNTYPE: /* shut up gcc */
2088	2096	break;
2089	2097	}

2258	2266	myHostname, (unsigned long)thepid, pGE->port);
2259	2267	switch (pCE->type) {
2260	2268	case EXEC:
2261		FilePrint(pCLServing->fd, FLAGTRUE, "\|:%s,%lu,%s",
	2269	FilePrint(pCLServing->fd, FLAGTRUE, "\|:%s,%lu,%s,%d:",
2262	2270	(pCE->exec != (char *)0 ? pCE->exec : "/bin/sh"),
2263		(unsigned long)pCE->ipid, pCE->execSlave);
	2271	(unsigned long)pCE->ipid, pCE->execSlave,
	2272	FileFDNum(pCE->cofile));
2264	2273	break;
2265	2274	case HOST:
2266		FilePrint(pCLServing->fd, FLAGTRUE, "!:%s,%hu,%s",
	2275	FilePrint(pCLServing->fd, FLAGTRUE, "!:%s,%hu,%s,%d:",
2267	2276	pCE->host, pCE->netport,
2268		(pCE->raw == FLAGTRUE ? "raw" : "telnet"));
	2277	(pCE->raw == FLAGTRUE ? "raw" : "telnet"),
	2278	FileFDNum(pCE->cofile));
	2279	break;
	2280	case NOOP:
	2281	FileWrite(pCLServing->fd, FLAGTRUE, "#::", 3);
	2282	break;
	2283	case UDS:
	2284	FilePrint(pCLServing->fd, FLAGTRUE, "%%:%s,%d:", pCE->uds,
	2285	FileFDNum(pCE->cofile));
2269	2286	break;
2270	2287	case DEVICE:
2271		FilePrint(pCLServing->fd, FLAGTRUE, "/:%s,%s%c",
	2288	FilePrint(pCLServing->fd, FLAGTRUE, "/:%s,%s%c,%d:",
2272	2289	pCE->device,
2273	2290	(pCE->baud ? pCE->baud->acrate : ""),
2274		(pCE->parity ? pCE->parity->key[0] : ' '));
	2291	(pCE->parity ? pCE->parity->key[0] : ' '),
	2292	FileFDNum(pCE->cofile));
2275	2293	break;
2276	2294	case UNKNOWNTYPE: /* shut up gcc */
2277	2295	break;
2278	2296	}
2279		FilePrint(pCLServing->fd, FLAGTRUE, ",%d:",
2280		FileFDNum(pCE->cofile));
2281	2297	if (pCE->pCLwr) {
2282	2298	FilePrint(pCLServing->fd, FLAGTRUE, "w@%s@%ld",
2283	2299	pCE->pCLwr->acid->string,

2350	2366	s = BuildTmpString(",autoreinit");
2351	2367	if (pCE->unloved == FLAGTRUE)
2352	2368	s = BuildTmpString(",unloved");
	2369	if (pCE->login == FLAGTRUE)
	2370	s = BuildTmpString(",login");
2353	2371	FilePrint(pCLServing->fd, FLAGFALSE, ":%s:%s:%d:%s\r\n",
2354	2372	(s == (char *)0 ? "" : s + 1),
2355	2373	(pCE->initcmd == (char *)0 ? "" : pCE->initcmd),

2796	2814	return n[cnt];
2797	2815	}
2798	2816
	2817
	2818	/* This routine is used to gather input from the
	2819	* client and save it in the accmd string.
	2820	* GatherLine returns 0 until the user signals
	2821	* they're "done" (a \r), then it returns 1.
	2822	*/
	2823	typedef enum gatherType {
	2824	G_INT,
	2825	G_TEXT
	2826	} GATHERTYPE;
	2827
	2828	int
	2829	#if PROTOTYPES
	2830	GatherLine(char c, int limit, GATHERTYPE g, CONSCLIENT *pCL)
	2831	#else
	2832	GatherLine(c, pCL)
	2833	char c;
	2834	GATHERTYPE g;
	2835	CONSCLIENT *pCL;
	2836	#endif
	2837	{
	2838	if (c == '\r')
	2839	return 1;
	2840
	2841	if ((limit <= 0 \|\| pCL->accmd->used - 1 < limit) &&
	2842	((g == G_TEXT && (c == '\a' \|\| (c >= ' ' && c <= '~'))) \|\|
	2843	(g == G_INT && isdigit((int)c)))) {
	2844	BuildStringChar(c, pCL->accmd);
	2845	FileWrite(pCL->fd, FLAGFALSE, (char *)&c, 1);
	2846	} else if ((c == '\b' \|\| c == 0x7f)
	2847	&& pCL->accmd->used > 1) {
	2848	if (pCL->accmd->string[pCL->accmd->used - 2] != '\a')
	2849	FileWrite(pCL->fd, FLAGFALSE, "\b \b", 3);
	2850	pCL->accmd->string[pCL->accmd->used - 2] = '\000';
	2851	pCL->accmd->used--;
	2852	} else if ((c == 0x15) && pCL->accmd->used > 1) {
	2853	while (pCL->accmd->used > 1) {
	2854	if (pCL->accmd->string[pCL->accmd->used - 2] != '\a')
	2855	FileWrite(pCL->fd, FLAGFALSE, "\b \b", 3);
	2856	pCL->accmd->string[pCL->accmd->used - 2] = '\000';
	2857	pCL->accmd->used--;
	2858	}
	2859	}
	2860	return 0;
	2861	}
	2862
2799	2863	void
2800	2864	#if PROTOTYPES
2801	2865	DoClientRead(GRPENT pGE, CONSCLIENT pCLServing)

3021	3085	if (pCLServing->fro == -1) {
3022	3086	FilePrint(pCLServing->fd, FLAGFALSE,
3023	3087	"%s: permission denied\r\n", pcArgs);
	3088	DisconnectClient(pGE, pCLServing, (char *)0,
	3089	FLAGFALSE);
	3090	return;
	3091	}
	3092
	3093	if (pCEwant->login != FLAGTRUE) {
	3094	if (pCEwant->motd == (char *)0) {
	3095	FilePrint(pCLServing->fd, FLAGFALSE,
	3096	"%s: no logins allowed at this time\r\n",
	3097	pcArgs);
	3098	} else {
	3099	FilePrint(pCLServing->fd, FLAGFALSE,
	3100	"%s: %s\r\n", pcArgs,
	3101	pCEwant->motd);
	3102	}
3024	3103	DisconnectClient(pGE, pCLServing, (char *)0,
3025	3104	FLAGFALSE);
3026	3105	return;

3187	3266	case S_PASSWD:
3188	3267	/* these are not used in this mode */
3189	3268	break;
	3269
3190	3270	case S_BCAST:
3191		/* gather message */
3192		if ('\r' != acIn[i]) {
3193		if (acIn[i] == '\a' \|\|
3194		(acIn[i] >= ' ' && acIn[i] <= '~')) {
3195		BuildStringChar(acIn[i], pCLServing->msg);
3196		if (pGE->pCEctl != pCEServing)
	3271	if (GatherLine(acIn[i], 0, G_TEXT, pCLServing)) {
	3272	FileWrite(pCLServing->fd, FLAGFALSE, "]\r\n",
	3273	3);
	3274	BuildString((char *)0, bcast);
	3275	BuildStringChar('[', bcast);
	3276	BuildString(pCLServing->acid->string, bcast);
	3277	BuildString(": ", bcast);
	3278	BuildString(pCLServing->accmd->string, bcast);
	3279	BuildString("]\r\n", bcast);
	3280	SendClientsMsg(pCEServing, bcast->string);
	3281
	3282	BuildString((char *)0, pCLServing->accmd);
	3283	pCLServing->iState = S_NORMAL;
	3284	}
	3285	continue;
	3286
	3287	case S_REPLAY:
	3288	case S_PLAYBACK:
	3289	if (GatherLine(acIn[i], 4, G_INT, pCLServing)) {
	3290	unsigned short *s;
	3291
	3292	if (pCLServing->iState == S_REPLAY)
	3293	s = &(pCLServing->replay);
	3294	else
	3295	s = &(pCLServing->playback);
	3296
	3297	if (pCLServing->accmd->used > 1) {
	3298	unsigned short u;
	3299	u = (unsigned short)atoi(pCLServing->
	3300	accmd->string);
	3301	/* i'm limiting the value here to 10000 for a couple
	3302	* of reasons:
	3303	*
	3304	* 1. this process could be busy parsing a file for
	3305	* a long time if the logfile and replay are big.
	3306	* 2. who needs more than 10000 lines of replay? if
	3307	* you need that much, go find the raw logfile.
	3308	* and if you don't have access, find someone who
	3309	* does.
	3310	*
	3311	* change this to something bigger if you want, but
	3312	* it would scare me...even 10000 seems a bit large,
	3313	* but no one has to set the value so large.
	3314	* and watch out...it's an unsigned short, so you
	3315	* can't go really huge.
	3316	*/
	3317	if (u > 10000)
3197	3318	FileWrite(pCLServing->fd, FLAGFALSE,
3198		(char *)&acIn[i], 1);
3199		} else if ((acIn[i] == '\b' \|\| acIn[i] == 0x7f)
3200		&& pCLServing->msg->used > 1) {
3201		if (pCLServing->msg->
3202		string[pCLServing->msg->used - 2] !=
3203		'\a' && pGE->pCEctl != pCEServing) {
3204		FileWrite(pCLServing->fd, FLAGFALSE,
3205		"\b \b", 3);
3206		}
3207		pCLServing->msg->string[pCLServing->msg->
3208		used - 2] = '\000';
3209		pCLServing->msg->used--;
3210		} else if ((acIn[i] == 0x15) &&
3211		pCLServing->msg->used > 1) {
3212		while (pCLServing->msg->used > 1) {
3213		if (pCLServing->msg->
3214		string[pCLServing->msg->used -
3215		2] != '\a' &&
3216		pGE->pCEctl != pCEServing) {
3217		FileWrite(pCLServing->fd,
3218		FLAGFALSE, "\b \b", 3);
3219		}
3220		pCLServing->msg->string[pCLServing->
3221		msg->used -
3222		2] = '\000';
3223		pCLServing->msg->used--;
3224		}
3225		}
3226		continue;
	3319	" <value too large>", 18);
	3320	else
	3321	*s = u;
	3322	} else
	3323	FilePrint(pCLServing->fd, FLAGFALSE, "%u",
	3324	*s);
	3325
	3326	FileWrite(pCLServing->fd, FLAGFALSE, "]\r\n",
	3327	3);
	3328	pCLServing->iState = S_NORMAL;
3227	3329	}
3228		FileWrite(pCLServing->fd, FLAGFALSE, "]\r\n", 3);
3229		BuildString((char *)0, bcast);
3230		BuildStringChar('[', bcast);
3231		BuildString(pCLServing->acid->string, bcast);
3232		BuildString(": ", bcast);
3233		BuildString(pCLServing->msg->string, bcast);
3234		BuildString("]\r\n", bcast);
3235		SendClientsMsg(pCEServing, bcast->string);
3236
3237		BuildString((char *)0, pCLServing->msg);
3238		pCLServing->iState = S_NORMAL;
3239	3330	continue;
3240	3331
3241	3332	case S_QUOTE: /* send octal code */

3485	3576	"no drop line]\r\n", -1);
3486	3577	break;
3487	3578
3488		#define DEPRECATED FileWrite(pCLServing->fd, FLAGFALSE, "<use of DEPRECATED (and undocumented) key> ", -1)
3489		case 'B':
3490		DEPRECATED;
3491		case 'b': /* broadcast message */
3492		FileWrite(pCLServing->fd, FLAGFALSE,
3493		"Enter message: ", -1);
3494		pCLServing->iState = S_BCAST;
3495		break;
3496
3497		case 'A':
3498		DEPRECATED;
3499	3579	case 'a': /* attach */
3500	3580	CommandAttach(pGE, pCLServing, pCEServing,
3501	3581	tyme);
3502	3582	break;
3503	3583
3504		case 'C':
3505		DEPRECATED;
	3584	case 'b': /* broadcast message */
	3585	FileWrite(pCLServing->fd, FLAGFALSE,
	3586	"Enter message: ", -1);
	3587	BuildString((char *)0, pCLServing->accmd);
	3588	pCLServing->iState = S_BCAST;
	3589	break;
	3590
3506	3591	case 'c':
3507	3592	CommandChangeFlow(pGE, pCLServing,
3508	3593	pCEServing, tyme);
3509	3594	break;
3510	3595
3511		case 'D':
3512		DEPRECATED;
3513	3596	case 'd': /* down a console */
3514	3597	CommandDown(pGE, pCLServing, pCEServing,
3515	3598	tyme);
3516	3599	break;
3517	3600
3518		case 'E':
3519		DEPRECATED;
3520	3601	case 'e': /* redefine escape keys */
3521	3602	pCLServing->iState = S_CATTN;
3522	3603	FileWrite(pCLServing->fd, FLAGFALSE,
3523	3604	"redef: ", -1);
3524	3605	break;
3525	3606
3526		case 'F':
3527		DEPRECATED;
3528	3607	case 'f': /* force attach */
3529	3608	CommandForce(pGE, pCLServing, pCEServing,
3530	3609	tyme);
3531	3610	break;
3532	3611
3533		case 'G':
3534		DEPRECATED;
3535	3612	case 'g': /* group info */
3536	3613	FilePrint(pCLServing->fd, FLAGFALSE,
3537	3614	"group %s]\r\n",

3540	3617	tyme, (char *)0);
3541	3618	break;
3542	3619
3543		case 'H':
3544		case 'P': /* DEC vt100 pf1 */
3545		DEPRECATED;
3546	3620	case 'h': /* help */
3547	3621	case '?':
3548	3622	HelpUser(pCLServing);
3549	3623	break;
3550	3624
3551		case 'I':
3552		DEPRECATED;
3553	3625	case 'i':
3554	3626	FileWrite(pCLServing->fd, FLAGFALSE,
3555	3627	"info]\r\n", -1);

3584	3656	pCEServing->motd);
3585	3657	break;
3586	3658
3587		case 'O':
3588		DEPRECATED;
3589	3659	case 'o': /* close and re-open line */
3590	3660	CommandOpen(pGE, pCLServing, pCEServing,
3591	3661	tyme);
	3662	break;
	3663
	3664	case 'P': /* broadcast message */
	3665	FilePrint(pCLServing->fd, FLAGFALSE,
	3666	"set playback (%d): ",
	3667	pCLServing->playback);
	3668	BuildString((char *)0, pCLServing->accmd);
	3669	pCLServing->iState = S_PLAYBACK;
	3670	break;
	3671
	3672	case 'p': /* replay lines (longer, in theory) */
	3673	FileWrite(pCLServing->fd, FLAGFALSE,
	3674	"playback]\r\n", -1);
	3675	Replay(pCEServing, pCLServing->fd,
	3676	pCLServing->playback);
3592	3677	break;
3593	3678
3594	3679	case '\022': /* ^R */

3597	3682	Replay(pCEServing, pCLServing->fd, 1);
3598	3683	break;
3599	3684
3600		case 'R': /* DEC vt100 pf3 */
3601		DEPRECATED;
3602		case 'r': /* replay 20 lines */
	3685	case 'R': /* broadcast message */
	3686	FilePrint(pCLServing->fd, FLAGFALSE,
	3687	"set replay (%d): ",
	3688	pCLServing->replay);
	3689	BuildString((char *)0, pCLServing->accmd);
	3690	pCLServing->iState = S_REPLAY;
	3691	break;
	3692
	3693	case 'r': /* replay lines */
3603	3694	FileWrite(pCLServing->fd, FLAGFALSE,
3604	3695	"replay]\r\n", -1);
3605		Replay(pCEServing, pCLServing->fd, 20);
	3696	Replay(pCEServing, pCLServing->fd,
	3697	pCLServing->replay);
3606	3698	break;
3607	3699
3608		case 'p': /* replay 60 lines */
3609		FileWrite(pCLServing->fd, FLAGFALSE,
3610		"long replay]\r\n", -1);
3611		Replay(pCEServing, pCLServing->fd, 60);
3612		break;
3613
3614		case 'S': /* DEC vt100 pf4 */
3615		DEPRECATED;
3616	3700	case 's': /* spy mode */
3617	3701	pCLServing->fwantwr = 0;
3618	3702	if (!pCLServing->fwr) {

3628	3712	"spying]\r\n", -1);
3629	3713	break;
3630	3714
3631		case 'U':
3632		DEPRECATED;
3633	3715	case 'u': /* hosts on server this */
3634	3716	FileWrite(pCLServing->fd, FLAGFALSE,
3635	3717	"hosts]\r\n", -1);

3637	3719	tyme, (char *)0);
3638	3720	break;
3639	3721
3640		case 'V':
3641		DEPRECATED;
3642	3722	case 'v': /* version */
3643	3723	FilePrint(pCLServing->fd, FLAGFALSE,
3644	3724	"version `%s']\r\n",
3645		THIS_VERSION);
	3725	MyVersion());
3646	3726	break;
3647	3727
3648		case 'W':
3649		DEPRECATED;
3650	3728	case 'w': /* who */
3651	3729	FilePrint(pCLServing->fd, FLAGFALSE,
3652	3730	"who %s]\r\n",

3655	3733	tyme);
3656	3734	break;
3657	3735
3658		case 'X':
3659		DEPRECATED;
3660	3736	case 'x':
3661	3737	FileWrite(pCLServing->fd, FLAGFALSE,
3662	3738	"examine]\r\n", -1);

3664	3740	tyme, (char *)0);
3665	3741	break;
3666	3742
3667		case '\|': /* wait for client */
3668		if (ConsentUserOk
3669		(pLUList,
3670		pCLServing->username->string) == 1)
3671		goto unknownchar;
3672		if (!pCLServing->fwr) {
3673		FileWrite(pCLServing->fd, FLAGFALSE,
3674		"attach to run local command]\r\n",
3675		-1);
3676		continue;
3677		}
3678		FileSetQuoteIAC(pCLServing->fd, FLAGFALSE);
3679		FilePrint(pCLServing->fd, FLAGFALSE,
3680		"%c%c", OB_IAC, OB_EXEC);
3681		FileSetQuoteIAC(pCLServing->fd, FLAGTRUE);
3682		pCLServing->fcon = 0;
3683		pCLServing->iState = S_CWAIT;
3684		break;
3685
3686		case 'Z':
3687		DEPRECATED;
3688	3743	case 'z': /* suspend the client */
3689	3744	case '\032':
3690	3745	if (ConsentUserOk

3708	3763	}
3709	3764	break;
3710	3765
	3766	case '\|': /* wait for client */
	3767	if (ConsentUserOk
	3768	(pLUList,
	3769	pCLServing->username->string) == 1)
	3770	goto unknownchar;
	3771	if (!pCLServing->fwr) {
	3772	FileWrite(pCLServing->fd, FLAGFALSE,
	3773	"attach to run local command]\r\n",
	3774	-1);
	3775	continue;
	3776	}
	3777	FileSetQuoteIAC(pCLServing->fd, FLAGFALSE);
	3778	FilePrint(pCLServing->fd, FLAGFALSE,
	3779	"%c%c", OB_IAC, OB_EXEC);
	3780	FileSetQuoteIAC(pCLServing->fd, FLAGTRUE);
	3781	pCLServing->fcon = 0;
	3782	pCLServing->iState = S_CWAIT;
	3783	break;
	3784
3711	3785	case '\t': /* toggle tab expand */
3712	3786	if (!pCLServing->fwr) {
3713	3787	FileWrite(pCLServing->fd, FLAGFALSE,

3729	3803	"failed]\r\n", -1);
3730	3804	continue;
3731	3805	}
3732		# if !defined(XTABS) /* XXX hack */
3733		# define XTABS TAB3
3734		# endif
3735		if (XTABS == (TABDLY & sbuf.c_oflag)) {
	3806	if (TAB3 == (TABDLY & sbuf.c_oflag)) {
3736	3807	sbuf.c_oflag &= ~TABDLY;
3737	3808	sbuf.c_oflag \|= TAB0;
3738	3809	} else {
3739	3810	sbuf.c_oflag &= ~TABDLY;
3740		sbuf.c_oflag \|= XTABS;
	3811	sbuf.c_oflag \|= TAB3;
3741	3812	}
3742	3813	if (-1 ==
3743	3814	tcsetattr(FileFDNum

3747	3818	"failed]\r\n", -1);
3748	3819	continue;
3749	3820	}
3750		if (XTABS == (TABDLY & sbuf.c_oflag))
	3821	if (TAB3 == (TABDLY & sbuf.c_oflag))
3751	3822	FileWrite(pCLServing->fd, FLAGFALSE,
3752	3823	"tabs OFF]\r\n", -1);
3753	3824	else

3755	3826	"tabs ON]\r\n", -1);
3756	3827	break;
3757	3828
3758		case 'Q': /* DEC vt100 PF2 */
3759		DEPRECATED;
3760	3829	case '.': /* disconnect */
3761	3830	case '\004':
3762	3831	case '\003':

3790	3859	pCLServing->iState = S_QUOTE;
3791	3860	FileWrite(pCLServing->fd, FLAGFALSE,
3792	3861	"quote \\", -1);
	3862	break;
	3863
	3864	case 0xD6: /* 'v' with high bit set */
	3865	/* this is really just used "behind the scenes",
	3866	* but of someone wants to type it, fine...we
	3867	* just need a way to query the server for what
	3868	* version it is so the client can determine
	3869	* functionality
	3870	*/
	3871	FilePrint(pCLServing->fd, FLAGFALSE,
	3872	"%u]\r\n", VERSION_UINT);
3793	3873	break;
3794	3874
3795	3875	default: /* unknown sequence */

4189	4269	pGE->pCLfree->username = AllocString();
4190	4270	pGE->pCLfree->peername = AllocString();
4191	4271	pGE->pCLfree->accmd = AllocString();
4192		pGE->pCLfree->msg = AllocString();
4193	4272
4194	4273	/* on a SIGHUP we should close and reopen our log files and
4195	4274	* reread the config file

4384	4463	/* anything on a console? */
4385	4464	for (pCEServing = pGE->pCElist; pCEServing != (CONSENT *)0;
4386	4465	pCEServing = pCEServing->pCEnext) {
4387		if (!pCEServing->fup)
	4466	if (!pCEServing->fup \|\| pCEServing->type == NOOP)
4388	4467	continue;
4389	4468	switch (pCEServing->ioState) {
4390	4469	case INCONNECT:

4629	4708	BuildString("<unknown>@", pCL->acid);
4630	4709	BuildString((char *)0, pCL->username);
4631	4710	BuildString("<unknown>", pCL->username);
4632		strcpy(pCL->actym, StrTime(&(pCL->tym)));
	4711	StrCpy(pCL->actym, StrTime(&(pCL->tym)), sizeof(pCL->actym));
4633	4712	pCL->typetym = pCL->tym;
4634	4713
4635	4714	/* link into the control list for the dummy console

4661	4740	pCL->iState = S_IDENT;
4662	4741	pCL->ic[0] = DEFATTN;
4663	4742	pCL->ic[1] = DEFESC;
	4743	pCL->replay = DEFREPLAY;
	4744	pCL->playback = DEFPLAYBACK;
4664	4745	BuildString((char *)0, pCL->accmd);
4665	4746
4666	4747	/* mark as stopped (no output from console)

4682	4763	pGE->pCLfree->username = AllocString();
4683	4764	pGE->pCLfree->peername = AllocString();
4684	4765	pGE->pCLfree->accmd = AllocString();
4685		pGE->pCLfree->msg = AllocString();
4686	4766	}
4687	4767
4688	4768	if (ClientAccessOk(pCL)) {

4740	4820	Error("Spawn(): path to socket too long: %s", portPath->string);
4741	4821	Bye(EX_OSERR);
4742	4822	}
4743		strcpy(lstn_port.sun_path, portPath->string);
	4823	StrCpy(lstn_port.sun_path, portPath->string,
	4824	sizeof(lstn_port.sun_path));
4744	4825
4745	4826	/* create a socket to listen on
4746	4827	* (prepared by master so he can see the port number of the kid)

-1

conserver/group.h less more

0	0	/*
1		* $Id: group.h,v 5.48 2005/05/21 17:56:14 bryan Exp $
	1	* $Id: group.h,v 5.49 2006/04/07 15:36:09 bryan Exp $
2	2	*
3	3	* Copyright conserver.com, 2000
4	4	*

81	81	extern int CheckPasswd PARAMS((CONSCLIENT , char ));
82	82	extern void DeUtmp PARAMS((GRPENT *, int));
83	83	extern void ClientWantsWrite PARAMS((CONSCLIENT *));
	84	extern void SendIWaitClientsMsg PARAMS((CONSENT , char ));
84	85	#if HAVE_OPENSSL
85	86	extern int AttemptSSL PARAMS((CONSCLIENT *));
86	87	#endif

+19

-7

conserver/main.c less more

0	0	/*
1		* $Id: main.c,v 5.196 2005/06/11 02:31:05 bryan Exp $
	1	* $Id: main.c,v 5.200 2006/04/03 13:32:08 bryan Exp $
2	2	*
3	3	* Copyright conserver.com, 2000
4	4	*

417	417	close(2);
418	418	dup(1);
419	419	if (isMaster && tag) {
420		Msg("%s", THIS_VERSION);
421		Msg("%s", startedMsg->string);
	420	Msg(MyVersion());
	421	Msg(startedMsg->string);
422	422	}
423	423	tag = 0;
424	424	}

618	618
619	619	isMultiProc = 0;
620	620
621		Msg("%s", THIS_VERSION);
	621	Msg(MyVersion());
622	622	Msg("default access type `%c'", defConfig.defaultaccess);
623	623	Msg("default escape sequence `%s%s'", FmtCtl(DEFATTN, acA1),
624	624	FmtCtl(DEFESC, acA2));

912	912	EMPTYSTR(pCE->host), FLAGSTR(pCE->raw),
913	913	pCE->netport, pCE->port, pCE->telnetState));
914	914	break;
	915	case NOOP:
	916	CONDDEBUG((1,
	917	"DumpDataStructures(): server=%s, type=NOOP",
	918	EMPTYSTR(pCE->server)));
	919	break;
	920	case UDS:
	921	CONDDEBUG((1,
	922	"DumpDataStructures(): server=%s, type=UDS",
	923	EMPTYSTR(pCE->server)));
	924	CONDDEBUG((1, "DumpDataStructures(): uds=%s",
	925	EMPTYSTR(pCE->uds)));
	926	break;
915	927	case UNKNOWNTYPE:
916	928	CONDDEBUG((1,
917	929	"DumpDataStructures(): server=%s, type=UNKNOWNTYPE",

952	964	CONDDEBUG((1,
953	965	"DumpDataStructures(): reinitoncc=%s, striphigh=%s",
954	966	FLAGSTR(pCE->reinitoncc), FLAGSTR(pCE->striphigh)));
955		CONDDEBUG((1, "DumpDataStructures(): unloved=%s",
956		FLAGSTR(pCE->unloved)));
	967	CONDDEBUG((1, "DumpDataStructures(): unloved=%s, login=%s",
	968	FLAGSTR(pCE->unloved), FLAGSTR(pCE->login)));
957	969	CONDDEBUG((1,
958	970	"DumpDataStructures(): initpid=%lu, initcmd=%s, initfile=%d",
959	971	(unsigned long)pCE->initpid, EMPTYSTR(pCE->initcmd),

1271	1283	Bye(EX_OK);
1272	1284	}
1273	1285
1274		Msg("%s", THIS_VERSION);
	1286	Msg(MyVersion());
1275	1287
1276	1288	#if HAVE_GETLOGIN
1277	1289	origuser = getlogin();

-4

conserver/master.c less more

0	0	/*
1		* $Id: master.c,v 5.132 2005/09/05 22:22:53 bryan Exp $
	1	* $Id: master.c,v 5.135 2006/04/07 15:47:20 bryan Exp $
2	2	*
3	3	* Copyright conserver.com, 2000
4	4	*

35	35	#include <access.h>
36	36	#include <master.h>
37	37	#include <readcfg.h>
38		#include <version.h>
39	38	#include <main.h>
40	39
41	40

614	613	} else if (pCLServing->iState == S_NORMAL &&
615	614	strcmp(pcCmd, "version") == 0) {
616	615	FilePrint(pCLServing->fd, FLAGFALSE, "version `%s'\r\n",
617		THIS_VERSION);
	616	MyVersion());
618	617	} else if (pCLServing->iState == S_NORMAL &&
619	618	strcmp(pcCmd, "quit") == 0) {
620	619	if (ConsentUserOk(pADList, pCLServing->username->string) ==

783	782	Error("Master(): path to socket too long: %s", portPath->string);
784	783	return;
785	784	}
786		strcpy(master_port.sun_path, portPath->string);
	785	StrCpy(master_port.sun_path, portPath->string,
	786	sizeof(master_port.sun_path));
787	787
788	788	if ((msfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
789	789	Error("Master(): socket(AF_UNIX,SOCK_STREAM): %s",

+280

-62

conserver/readcfg.c less more

0	0	/*
1		* $Id: readcfg.c,v 5.189 2005/09/05 21:55:49 bryan Exp $
	1	* $Id: readcfg.c,v 5.192 2006/03/20 16:47:03 bryan Exp $
2	2	*
3	3	* Copyright conserver.com, 2000
4	4	*

566	566	free(c->server);
567	567	if (c->host != (char *)0)
568	568	free(c->host);
	569	if (c->uds != (char *)0)
	570	free(c->uds);
	571	if (c->udssubst != (char *)0)
	572	free(c->udssubst);
569	573	if (c->master != (char *)0)
570	574	free(c->master);
571	575	if (c->exec != (char *)0)

692	696	c->autoreinit = d->autoreinit;
693	697	if (d->unloved != FLAGUNKNOWN)
694	698	c->unloved = d->unloved;
	699	if (d->login != FLAGUNKNOWN)
	700	c->login = d->login;
695	701	if (d->host != (char *)0) {
696	702	if (c->host != (char *)0)
697	703	free(c->host);
698	704	if ((c->host = StrDup(d->host)) == (char *)0)
	705	OutOfMem();
	706	}
	707	if (d->uds != (char *)0) {
	708	if (c->uds != (char *)0)
	709	free(c->uds);
	710	if ((c->uds = StrDup(d->uds)) == (char *)0)
	711	OutOfMem();
	712	}
	713	if (d->udssubst != (char *)0) {
	714	if (c->udssubst != (char *)0)
	715	free(c->udssubst);
	716	if ((c->udssubst = StrDup(d->udssubst)) == (char *)0)
699	717	OutOfMem();
700	718	}
701	719	if (d->master != (char *)0) {

952	970
953	971	int
954	972	#if PROTOTYPES
955		SubstCallback(char c, char *s, int i)
956		#else
957		SubstCallback(c, s, i)
	973	SubstValue(char c, char *s, int i)
	974	#else
	975	SubstValue(c, s, i)
958	976	char c;
959	977	char **s;
960	978	int *i;
961	979	#endif
962	980	{
963	981	int retval = 0;
964
965		if (substData == (SUBST *)0) {
966		if ((substData = (SUBST )calloc(1, sizeof(SUBST))) == (SUBST )0)
967		OutOfMem();
968		substData->callback = &SubstCallback;
969		substData->tokens['p'] = ISNUMBER;
970		substData->tokens['P'] = ISNUMBER;
971		substData->tokens['h'] = ISSTRING;
972		substData->tokens['c'] = ISSTRING;
973		}
974	982
975	983	if (s != (char **)0) {
976	984	CONSENT *pCE;

1004	1012	return retval;
1005	1013	}
1006	1014
	1015	int substTokenCount[255];
	1016
	1017	int
	1018	#if PROTOTYPES
	1019	SubstTokenCount(char c)
	1020	#else
	1021	SubstTokenCount(c)
	1022	char c;
	1023	#endif
	1024	{
	1025	return substTokenCount[(unsigned)c];
	1026	}
	1027
	1028	void
	1029	#if PROTOTYPES
	1030	ZeroSubstTokenCount(void)
	1031	#else
	1032	ZeroSubstTokenCount()
	1033	#endif
	1034	{
	1035	#if HAVE_MEMSET
	1036	memset((void *)&substTokenCount, 0, sizeof(substTokenCount));
	1037	#else
	1038	bzero((char *)&substTokenCount, sizeof(substTokenCount));
	1039	#endif
	1040	}
	1041
	1042	SUBSTTOKEN
	1043	#if PROTOTYPES
	1044	SubstToken(char c)
	1045	#else
	1046	SubstToken(c)
	1047	char c;
	1048	#endif
	1049	{
	1050	switch (c) {
	1051	case 'p':
	1052	case 'P':
	1053	substTokenCount[(unsigned)c]++;
	1054	return ISNUMBER;
	1055	case 'h':
	1056	case 'c':
	1057	substTokenCount[(unsigned)c]++;
	1058	return ISSTRING;
	1059	default:
	1060	return ISNOTHING;
	1061	}
	1062	}
	1063
	1064	void
	1065	#if PROTOTYPES
	1066	InitSubstCallback(void)
	1067	#else
	1068	InitSubstCallback()
	1069	#endif
	1070	{
	1071	if (substData == (SUBST *)0) {
	1072	if ((substData = (SUBST )calloc(1, sizeof(SUBST))) == (SUBST )0)
	1073	OutOfMem();
	1074	substData->value = &SubstValue;
	1075	substData->token = &SubstToken;
	1076	ZeroSubstTokenCount();
	1077	}
	1078	}
	1079
1007	1080	void
1008	1081	#if PROTOTYPES
1009	1082	DefaultItemDevicesubst(char *id)

1028	1101	CONDDEBUG((1, "DefaultItemExecsubst(%s) [%s:%d]", id, file, line));
1029	1102	ProcessSubst(substData, (char **)0, &(parserDefaultTemp->execsubst),
1030	1103	"execsubst", id);
	1104	}
	1105
	1106	void
	1107	#if PROTOTYPES
	1108	DefaultItemUdssubst(char *id)
	1109	#else
	1110	DefaultItemUdssubst(id)
	1111	char *id;
	1112	#endif
	1113	{
	1114	CONDDEBUG((1, "DefaultItemUdssubst(%s) [%s:%d]", id, file, line));
	1115	ProcessSubst(substData, (char **)0, &(parserDefaultTemp->udssubst),
	1116	"udssubst", id);
1031	1117	}
1032	1118
1033	1119	void

1256	1342
1257	1343	void
1258	1344	#if PROTOTYPES
	1345	ProcessUds(CONSENT c, char id)
	1346	#else
	1347	ProcessUds(c, id)
	1348	CONSENT *c;
	1349	char *id;
	1350	#endif
	1351	{
	1352	if (c->uds != (char *)0) {
	1353	free(c->uds);
	1354	c->uds = (char *)0;
	1355	}
	1356	if ((id == (char )0) \|\| (id == '\000'))
	1357	return;
	1358	if ((c->uds = StrDup(id))
	1359	== (char *)0)
	1360	OutOfMem();
	1361	}
	1362
	1363	void
	1364	#if PROTOTYPES
	1365	DefaultItemUds(char *id)
	1366	#else
	1367	DefaultItemUds(id)
	1368	char *id;
	1369	#endif
	1370	{
	1371	CONDDEBUG((1, "DefaultItemUds(%s) [%s:%d]", id, file, line));
	1372	ProcessUds(parserDefaultTemp, id);
	1373	}
	1374
	1375	void
	1376	#if PROTOTYPES
1259	1377	ProcessInclude(CONSENT c, char id)
1260	1378	#else
1261	1379	ProcessInclude(c, id)

1536	1654	c->reinitoncc = FLAGUNKNOWN;
1537	1655	c->autoreinit = FLAGUNKNOWN;
1538	1656	c->unloved = FLAGUNKNOWN;
	1657	c->login = FLAGUNKNOWN;
1539	1658	return;
1540	1659	}
1541	1660

1571	1690	c->autoreinit = negative ? FLAGFALSE : FLAGTRUE;
1572	1691	else if (strcasecmp("unloved", token) == 0)
1573	1692	c->unloved = negative ? FLAGFALSE : FLAGTRUE;
	1693	else if (strcasecmp("login", token) == 0)
	1694	c->login = negative ? FLAGFALSE : FLAGTRUE;
1574	1695	else if (isMaster)
1575	1696	Error("invalid option `%s' [%s:%d]", token, file, line);
1576	1697	}

2163	2284	t = EXEC;
2164	2285	else if (strcasecmp("host", id) == 0)
2165	2286	t = HOST;
	2287	else if (strcasecmp("noop", id) == 0)
	2288	t = NOOP;
	2289	else if (strcasecmp("uds", id) == 0)
	2290	t = UDS;
2166	2291	if (t == UNKNOWNTYPE) {
2167	2292	if (isMaster)
2168	2293	Error("invalid console type `%s' [%s:%d]", id, file, line);

2221	2346	OutOfMem();
2222	2347	}
2223	2348
	2349	/* returns 1 if there's an error, otherwise 0 */
	2350	int
	2351	#if PROTOTYPES
	2352	CheckSubst(char label, char subst)
	2353	#else
	2354	CheckSubst(label, subst)
	2355	char *label;
	2356	char *subst;
	2357	#endif
	2358	{
	2359	int invalid = 0;
	2360
	2361	ZeroSubstTokenCount();
	2362	ProcessSubst(substData, (char )0, (char )0, label, subst);
	2363
	2364	if (SubstTokenCount('p') && parserConsoleTemp->port == 0) {
	2365	if (isMaster)
	2366	Error
	2367	("[%s] console references 'port' in '%s' without defining 'port' attribute (ignoring %s) [%s:%d]",
	2368	parserConsoleTemp->server, label, label, file, line);
	2369	invalid = 1;
	2370	}
	2371
	2372	if (SubstTokenCount('h') && parserConsoleTemp->host == (char *)0) {
	2373	if (isMaster)
	2374	Error
	2375	("[%s] console references 'host' in '%s' without defining 'host' attribute (ignoring %s) [%s:%d]",
	2376	parserConsoleTemp->server, label, label, file, line);
	2377	invalid = 1;
	2378	}
	2379
	2380	return invalid;
	2381	}
	2382
2224	2383	void
2225	2384	#if PROTOTYPES
2226	2385	ConsoleEnd(void)

2244	2403	switch (parserConsoleTemp->type) {
2245	2404	case EXEC:
2246	2405	if (parserConsoleTemp->execsubst != (char *)0) {
2247		if (parserConsoleTemp->port == 0 \|\|
2248		parserConsoleTemp->host == (char *)0) {
2249		if (parserConsoleTemp->port == 0) {
2250		if (isMaster)
2251		Error
2252		("[%s] console has 'execsubst' attribute without 'port' attribute (ignoring) [%s:%d]",
2253		parserConsoleTemp->server, file, line);
2254		}
2255		if (parserConsoleTemp->host == (char *)0) {
2256		if (isMaster)
2257		Error
2258		("[%s] console has 'execsubst' attribute without 'host' attribute (ignoring) [%s:%d]",
2259		parserConsoleTemp->server, file, line);
2260		}
	2406	if (CheckSubst("execsubst", parserConsoleTemp->execsubst)) {
2261	2407	free(parserConsoleTemp->execsubst);
2262	2408	parserConsoleTemp->execsubst = (char *)0;
2263	2409	}

2271	2417	parserConsoleTemp->server, file, line);
2272	2418	invalid = 1;
2273	2419	}
2274		if (parserConsoleTemp->devicesubst != (char *)0) {
2275		if (parserConsoleTemp->port == 0 \|\|
2276		parserConsoleTemp->host == (char *)0) {
2277		if (parserConsoleTemp->port == 0) {
2278		if (isMaster)
2279		Error
2280		("[%s] console has 'devicesubst' attribute without 'port' attribute (ignoring) [%s:%d]",
2281		parserConsoleTemp->server, file, line);
2282		}
2283		if (parserConsoleTemp->host == (char *)0) {
2284		if (isMaster)
2285		Error
2286		("[%s] console has 'devicesubst' attribute without 'host' attribute (ignoring) [%s:%d]",
2287		parserConsoleTemp->server, file, line);
2288		}
2289		free(parserConsoleTemp->devicesubst);
2290		parserConsoleTemp->devicesubst = (char *)0;
2291		}
2292		}
2293	2420	if (parserConsoleTemp->baud == (BAUD *)0) {
2294	2421	if (isMaster)
2295	2422	Error("[%s] console missing 'baud' attribute [%s:%d]",

2302	2429	("[%s] console missing 'parity' attribute [%s:%d]",
2303	2430	parserConsoleTemp->server, file, line);
2304	2431	invalid = 1;
	2432	}
	2433	if (parserConsoleTemp->devicesubst != (char *)0) {
	2434	if (CheckSubst
	2435	("devicesubst", parserConsoleTemp->devicesubst)) {
	2436	free(parserConsoleTemp->devicesubst);
	2437	parserConsoleTemp->devicesubst = (char *)0;
	2438	}
2305	2439	}
2306	2440	break;
2307	2441	case HOST:

2318	2452	invalid = 1;
2319	2453	}
2320	2454	break;
	2455	case NOOP:
	2456	break;
	2457	case UDS:
	2458	if (parserConsoleTemp->uds == (char *)0) {
	2459	if (isMaster)
	2460	Error("[%s] console missing 'uds' attribute [%s:%d]",
	2461	parserConsoleTemp->server, file, line);
	2462	invalid = 1;
	2463	}
	2464	if (parserConsoleTemp->udssubst != (char *)0) {
	2465	if (CheckSubst("udssubst", parserConsoleTemp->udssubst)) {
	2466	free(parserConsoleTemp->udssubst);
	2467	parserConsoleTemp->udssubst = (char *)0;
	2468	}
	2469	}
	2470	break;
2321	2471	case UNKNOWNTYPE:
2322	2472	if (isMaster)
2323	2473	Error("[%s] console type unknown [%s:%d]",

2327	2477	}
2328	2478	if (parserConsoleTemp->initsubst != (char *)0 &&
2329	2479	parserConsoleTemp->initcmd != (char *)0) {
2330		if (parserConsoleTemp->port == 0 \|\|
2331		parserConsoleTemp->host == (char *)0) {
2332		if (parserConsoleTemp->port == 0) {
2333		if (isMaster)
2334		Error
2335		("[%s] console has 'initsubst' attribute without 'port' attribute (ignoring) [%s:%d]",
2336		parserConsoleTemp->server, file, line);
2337		}
2338		if (parserConsoleTemp->host == (char *)0) {
2339		if (isMaster)
2340		Error
2341		("[%s] console has 'initsubst' attribute without 'host' attribute (ignoring) [%s:%d]",
2342		parserConsoleTemp->server, file, line);
2343		}
	2480	if (CheckSubst("initsubst", parserConsoleTemp->initsubst)) {
2344	2481	free(parserConsoleTemp->initsubst);
2345	2482	parserConsoleTemp->initsubst = (char *)0;
2346	2483	}

2820	2957	closeMatch = 0;
2821	2958	}
2822	2959	break;
	2960	case NOOP:
	2961	break;
	2962	case UDS:
	2963	if (pCEmatch->uds != (char )0 && c->uds != (char )0) {
	2964	if (strcasecmp(pCEmatch->uds, c->uds) != 0) {
	2965	SwapStr(&pCEmatch->uds, &c->uds);
	2966	closeMatch = 0;
	2967	}
	2968	} else if (pCEmatch->uds != (char *)0 \|\|
	2969	c->uds != (char *)0) {
	2970	SwapStr(&pCEmatch->uds, &c->uds);
	2971	closeMatch = 0;
	2972	}
	2973	break;
2823	2974	case UNKNOWNTYPE:
2824	2975	break;
2825	2976	}

2854	3005	pCEmatch->reinitoncc = c->reinitoncc;
2855	3006	pCEmatch->autoreinit = c->autoreinit;
2856	3007	pCEmatch->unloved = c->unloved;
	3008	pCEmatch->login = c->login;
2857	3009	pCEmatch->inituid = c->inituid;
2858	3010	pCEmatch->initgid = c->initgid;
2859	3011	while (pCEmatch->aliases != (NAMES *)0) {

2968	3120	*/
2969	3121	c->netport = c->portbase + c->portinc * c->port;
2970	3122
	3123	/* prepare for substitutions */
2971	3124	substData->data = (void *)c;
	3125
2972	3126	/* check for substitutions */
2973	3127	if (c->type == DEVICE && c->devicesubst != (char *)0)
2974	3128	ProcessSubst(substData, &(c->device), (char *)0, (char )0,

2977	3131	if (c->type == EXEC && c->execsubst != (char *)0)
2978	3132	ProcessSubst(substData, &(c->exec), (char *)0, (char )0,
2979	3133	c->execsubst);
	3134
	3135	if (c->type == UDS && c->udssubst != (char *)0)
	3136	ProcessSubst(substData, &(c->uds), (char *)0, (char )0,
	3137	c->udssubst);
2980	3138
2981	3139	if (c->initcmd != (char )0 && c->initsubst != (char )0)
2982	3140	ProcessSubst(substData, &(c->initcmd), (char *)0, (char )0,

3032	3190	c->striphigh = FLAGFALSE;
3033	3191	if (c->unloved == FLAGUNKNOWN)
3034	3192	c->unloved = FLAGFALSE;
	3193	if (c->login == FLAGUNKNOWN)
	3194	c->login = FLAGTRUE;
	3195
	3196	/* set some forced options, based on situations */
	3197	if (c->type == NOOP) {
	3198	c->login = FLAGFALSE;
	3199	ProcessLogfile(c, (char *)0);
	3200	}
3035	3201
3036	3202	/* now let command-line args override things */
3037	3203	if (fNoautoreup)

3047	3213
3048	3214	/* now remember where we're headed and do the dirty work */
3049	3215	cNext = c->pCEnext;
	3216
	3217	/* perform all post-processing checks */
	3218	if (c->type == UDS) {
	3219	struct sockaddr_un port;
	3220	int limit, len;
	3221
	3222	limit = sizeof(port.sun_path);
	3223	len = strlen(c->uds);
	3224
	3225	if (len >= limit) {
	3226	if (isMaster)
	3227	Error("[%s] 'uds' path too large (%d >= %d) [%s:%d]",
	3228	c->server, len, limit, file, line);
	3229	continue;
	3230	}
	3231	}
	3232
3050	3233	if (fSyntaxOnly > 1) {
3051	3234	static STRING s = (STRING )0;
3052	3235

3075	3258	case HOST:
3076	3259	BuildString(BuildTmpStringPrint
3077	3260	("!:%s,%hu", c->host, c->netport), s);
	3261	break;
	3262	case NOOP:
	3263	BuildString("#:", s);
	3264	break;
	3265	case UDS:
	3266	BuildString(BuildTmpStringPrint("%%:%s", c->uds), s);
3078	3267	break;
3079	3268	case DEVICE:
3080	3269	BuildString(BuildTmpStringPrint

3300	3489
3301	3490	void
3302	3491	#if PROTOTYPES
	3492	ConsoleItemUdssubst(char *id)
	3493	#else
	3494	ConsoleItemUdssubst(id)
	3495	char *id;
	3496	#endif
	3497	{
	3498	CONDDEBUG((1, "ConsoleItemUdssubst(%s) [%s:%d]", id, file, line));
	3499	ProcessSubst(substData, (char **)0, &(parserConsoleTemp->udssubst),
	3500	"udssubst", id);
	3501	}
	3502
	3503	void
	3504	#if PROTOTYPES
3303	3505	ConsoleItemInitsubst(char *id)
3304	3506	#else
3305	3507	ConsoleItemInitsubst(id)

3369	3571	{
3370	3572	CONDDEBUG((1, "ConsoleItemHost(%s) [%s:%d]", id, file, line));
3371	3573	ProcessHost(parserConsoleTemp, id);
	3574	}
	3575
	3576	void
	3577	#if PROTOTYPES
	3578	ConsoleItemUds(char *id)
	3579	#else
	3580	ConsoleItemUds(id)
	3581	char *id;
	3582	#endif
	3583	{
	3584	CONDDEBUG((1, "ConsoleItemUds(%s) [%s:%d]", id, file, line));
	3585	ProcessUds(parserConsoleTemp, id);
3372	3586	}
3373	3587
3374	3588	void

4620	4834	{"rw", DefaultItemRw},
4621	4835	{"timestamp", DefaultItemTimestamp},
4622	4836	{"type", DefaultItemType},
	4837	{"uds", DefaultItemUds},
	4838	{"udssubst", DefaultItemUdssubst},
4623	4839	{(char )0, (void )0}
4624	4840	};
4625	4841

4656	4872	{"rw", ConsoleItemRw},
4657	4873	{"timestamp", ConsoleItemTimestamp},
4658	4874	{"type", ConsoleItemType},
	4875	{"uds", ConsoleItemUds},
	4876	{"udssubst", ConsoleItemUdssubst},
4659	4877	{(char )0, (void )0}
4660	4878	};
4661	4879

4748	4966	OutOfMem();
4749	4967
4750	4968	/* initialize the substition bits */
4751		SubstCallback('\000', (char *)0, (int )0);
	4969	InitSubstCallback();
4752	4970
4753	4971	/* ready to read in the data */
4754	4972	ParseFile(filename, fp, 0);

-2

conserver/version.h less more

0	0	/*
1		* $Id: version.h,v 1.72 2006/01/15 17:10:44 bryan Exp $
	1	* $Id: version.h,v 1.73 2006/04/03 13:32:08 bryan Exp $
2	2	*
3	3	* Copyright conserver.com, 2000
4	4	*

13	13	@(#) Copyright 2000 conserver.com.\n\
14	14	All rights reserved.\n"
15	15
16		#define THIS_VERSION "conserver.com version 8.1.13"
	16	#define VERSION_MAJOR 8
	17	#define VERSION_MINOR 1
	18	#define VERSION_REV 14
	19	#define VERSION_TEXT "conserver.com version"
	20	#define VERSION_UINT (VERSION_MAJOR * 1000000 + VERSION_MINOR * 1000 + VERSION_REV)

+52

-9

conserver.cf/conserver.cf.man less more

0		.\" $Id: conserver.cf.man,v 1.73 2005/06/09 07:09:31 bryan Exp $
1		.TH CONSERVER.CF 5 "2005/06/09" "conserver-8.1.13" "conserver"
	0	.\" $Id: conserver.cf.man,v 1.76 2006/03/20 16:47:03 bryan Exp $
	1	.TH CONSERVER.CF 5 "2006/03/20" "conserver-8.1.14" "conserver"
2	2	.SH NAME
3	3	conserver.cf \- console configuration file for
4	4	.BR conserver (8)

464	464	.br
465	465	Assign the serial device
466	466	.I filename
467		as the access to the console.
	467	as the path to the console.
468	468	Only consoles of type ``device'' will use this value.
469	469	.TP
470	470	\f3devicesubst\fP \f2c\fP\f3=\fP\f2t\fP[\f2n\fP]\f2f\fP[\f3,\fP...]\|\f3""\fP

884	884	will set this flag for all consoles.
885	885	Default is
886	886	.BR !unloved .
	887	.TP
	888	.B login
	889	Allow users to log into this console.
	890	If logins are not allowed, conserver will send a generic message to the
	891	client saying so and terminate the connection.
	892	You can override the generic message by setting the
	893	.B motd
	894	message.
	895	Default is
	896	.BR login .
887	897	.PD
888	898	.RE
889	899	.TP

1045	1055	.RB ` b '
1046	1056	can be specified to add logging of break sequences sent to the console.
1047	1057	.TP
1048		\f3type\fP \f3device\fP\|\f3exec\fP\|\f3host\fP
	1058	\f3type\fP \f3device\fP\|\f3exec\fP\|\f3host\fP\|\f3noop\fP\|\f3uds\fP
1049	1059	.br
1050	1060	Set the type of console.
1051		The type
	1061	A type of
1052	1062	.RB `` device ''
1053	1063	should be used for local serial ports (also set the
1054	1064	.B device
1055		option), the type
	1065	value).
	1066	A type of
1056	1067	.RB `` exec ''
1057	1068	should be used for command invocations (perhaps also set the
1058	1069	.B exec
1059		option), and the type
	1070	value).
	1071	A type of
1060	1072	.RB `` host ''
1061		should be used for terminal servers and other socket-based
	1073	should be used for terminal servers and other TCP socket-based
1062	1074	interaction (also set the
1063	1075	.B host
1064	1076	and
1065	1077	.B port
1066		options).
	1078	values).
	1079	A type of
	1080	.RB `` noop ''
	1081	should be used as a placeholder - it does nothing, ignores any
	1082	.B logfile
	1083	value and forces the
	1084	.B !nologin
	1085	option (so you might want to set the
	1086	.B motd
	1087	value).
	1088	A type of
	1089	.RB `` uds ''
	1090	should be used for Unix domain sockets (also set the
	1091	.B uds
	1092	option).
	1093	.TP
	1094	\f3uds\fP \f2filename\fP
	1095	.br
	1096	Assign the Unix domain socket
	1097	.I filename
	1098	as the path to the console.
	1099	Only consoles of type ``uds'' will use this value.
	1100	.TP
	1101	\f3udssubst\fP \f2c\fP\f3=\fP\f2t\fP[\f2n\fP]\f2f\fP[\f3,\fP...]\|\f3""\fP
	1102	.br
	1103	Perform character substitutions on the
	1104	.B uds
	1105	value.
	1106	See the
	1107	.B devicesubst
	1108	option for an explanation of the format string.
	1109	If the null string (``\f3""\fP'') is used, no replacements will be done.
1067	1110	.RE
1068	1111	.TP
1069	1112	\f3group\fP \f2name\fP

-1

conserver.cf/conserver.passwd.man less more

0	0	.\" $Id: conserver.passwd.man,v 1.10 2004/01/08 16:12:33 bryan Exp $
1		.TH CONSERVER.PASSWD 5 "2004/01/08" "conserver-8.1.13" "conserver"
	1	.TH CONSERVER.PASSWD 5 "2004/01/08" "conserver-8.1.14" "conserver"
2	2	.SH NAME
3	3	conserver.passwd \- user access information for
4	4	.BR conserver (8)

+13

-5

conserver.html less more

35	35	<TD colspan="2" align="center">Please pick your closest
36	36	mirror:   <A href=
37	37	"http://planetmirror.com/pub/conserver/">Australia</A>
	38	<A href=
	39	"http://conserver.linux-mirror.org/">Germany</A>
	40	<A href=
	41	"http://conserver.oss-mirror.org/">Ireland</A>
38	42	<A href="http://conserver.rinet.ru/">Russia</A>
39	43	<A href="http://www.conserver.com/">US-West
40	44	(Primary)</A><BR>

181	185
182	186	<H3>Downloading</H3>
183	187
184		<P>The current version, released on Jan 15, 2006, is <A
185		href="8.1.13.tar.gz">8.1.13.tar.gz</A>. You can get it
	188	<P>The current version, released on Apr 9, 2006, is <A
	189	href="8.1.14.tar.gz">8.1.14.tar.gz</A>. You can get it
186	190	via <A href=
187		"ftp://ftp.conserver.com/conserver/8.1.13.tar.gz">FTP</A>
188		or <A href="8.1.13.tar.gz">HTTP</A>. See the <A href=
	191	"ftp://ftp.conserver.com/conserver/8.1.14.tar.gz">FTP</A>
	192	or <A href="8.1.14.tar.gz">HTTP</A>. See the <A href=
189	193	"CHANGES">CHANGES</A> file for information on the latest
190	194	updates.</P>
191	195

229	233
230	234	<LI>DEC Tru64 4.0/5.1, native cc</LI>
231	235
232		<LI>FreeBSD 4.2/4.8/5.1 (x86), gcc</LI>
	236	<LI>FreeBSD 4.x (i386) gcc</LI>
	237
	238	<LI>FreeBSD 5.x (i386/amd64/sparc64) gcc</LI>
	239
	240	<LI>FreeBSD 6.x/7.x (i386/amd64/sparc64/ia64) gcc</LI>
233	241
234	242	<LI>HP-UX 10.20, gcc</LI>
235	243

+84

-25

console/console.c less more

0	0	/*
1		* $Id: console.c,v 5.176 2005/09/05 22:34:39 bryan Exp $
	1	* $Id: console.c,v 5.179 2006/04/07 15:47:20 bryan Exp $
2	2	*
3	3	* Copyright conserver.com, 2000
4	4	*

32	32
33	33	#include <getpassword.h>
34	34	#include <cutil.h>
	35	#include <readconf.h>
35	36	#include <version.h>
36		#include <readconf.h>
37	37	#if HAVE_OPENSSL
38	38	#include <openssl/ssl.h>
39	39	#include <openssl/err.h>

57	57	CONFIG optConf = (CONFIG )0;
58	58	CONFIG config = (CONFIG )0;
59	59	FLAG interact = FLAGFALSE;
	60	unsigned int sversion = 0;
	61	#if defined(TIOCGWINSZ)
	62	struct winsize ws;
	63	#endif
60	64
61	65	#if HAVE_OPENSSL
62	66	SSL_CTX ctx = (SSL_CTX )0;

280	284	if (acA2 == (STRING *)0)
281	285	acA2 = AllocString();
282	286
283		Msg("%s", THIS_VERSION);
	287	Msg(MyVersion());
284	288	#if USE_UNIX_DOMAIN_SOCKETS
285	289	Msg("default socket directory `%s\'", UDSDIR);
286	290	#else

472	476	Error("GetPort: path to socket too long: %s", portPath->string);
473	477	return (CONSFILE *)0;
474	478	}
475		strcpy(port.sun_path, portPath->string);
	479	StrCpy(port.sun_path, portPath->string, sizeof(port.sun_path));
476	480
477	481	CONDDEBUG((1, "GetPort: socket=%s", port.sun_path));
478	482

623	627
624	628	char *
625	629	#if PROTOTYPES
626		ReadReply(CONSFILE *fd, int toEOF)
627		#else
628		ReadReply(fd)
	630	ReadReply(CONSFILE *fd, FLAG toEOF)
	631	#else
	632	ReadReply(fd, toEOF)
629	633	CONSFILE *fd;
630		int toEOF;
	634	FLAG toEOF;
631	635	#endif
632	636	{
633	637	int nr;

645	649	case 0:
646	650	/* fall through */
647	651	case -1:
648		if (result->used > 1 \|\| toEOF)
	652	if (result->used > 1 \|\| toEOF == FLAGTRUE)
649	653	break;
650	654	C2Cooked();
651	655	Error("lost connection");

659	663	MemMove(buf, buf + l, nr);
660	664	}
661	665	BuildStringN(buf, nr, result);
662		if (toEOF) /* if toEOF, read until EOF */
	666	if (toEOF == FLAGTRUE) /* if toEOF, read until EOF */
663	667	continue;
664	668	if ((result->used > 1) &&
665	669	strchr(result->string, '\n') != (char *)0)

930	934	FileSetQuoteIAC(pcf, FLAGFALSE);
931	935	FilePrint(pcf, FLAGFALSE, "%c%c", OB_IAC, OB_EXEC);
932	936	FileSetQuoteIAC(pcf, FLAGTRUE);
933		r = ReadReply(pcf, 0);
	937	r = ReadReply(pcf, FLAGFALSE);
934	938	/* now back to non-blocking, now that we've got reply */
935	939	SetFlags(FileFDNum(pcf), O_NONBLOCK, 0);
936	940	/* if we aren't still r/w, abort */

1389	1393	*/
1390	1394	FilePrint(pcf, FLAGFALSE, "%c%ce%c%c", DEFATTN, DEFESC, chAttn,
1391	1395	chEsc);
1392		r = ReadReply(pcf, 0);
	1396	r = ReadReply(pcf, FLAGFALSE);
1393	1397	if (strncmp(r, "[redef:", 7) != 0) {
1394	1398	Error("protocol botch on redef of escape sequence");
1395	1399	Bye(EX_UNAVAILABLE);

1398	1402
1399	1403	/* try to grok the state of the console */
1400	1404	FilePrint(pcf, FLAGFALSE, "%c%c=", chAttn, chEsc);
1401		r = ReadReply(pcf, 0);
	1405	r = ReadReply(pcf, FLAGFALSE);
1402	1406	if (strncmp(r, "[unknown", 8) != 0 && strncmp(r, "[up]", 4) != 0)
1403	1407	FileWrite(cfstdout, FLAGFALSE, r, -1);
	1408
	1409	/* try to grok the version of the server */
	1410	FilePrint(pcf, FLAGFALSE, "%c%c%c", chAttn, chEsc, 0xD6);
	1411	r = ReadReply(pcf, FLAGFALSE);
	1412	if (strncmp(r, "[unknown", 8) != 0)
	1413	sversion = AtoU(r + 1);
1404	1414
1405	1415	printf("[Enter `");
1406	1416	PutCtlc(chAttn, stdout);

1409	1419
1410	1420	/* try and display the MOTD */
1411	1421	FilePrint(pcf, FLAGFALSE, "%c%cm", chAttn, chEsc);
1412		r = ReadReply(pcf, 0);
	1422	r = ReadReply(pcf, FLAGFALSE);
1413	1423	if (strncmp(r, "[unknown", 8) != 0 &&
1414	1424	strncmp(r, "[-- MOTD --]", 12) != 0)
1415	1425	FileWrite(cfstdout, FLAGFALSE, r, -1);
1416	1426
	1427	if (sversion >= 8001014) {
	1428	if (config->playback) {
	1429	FilePrint(pcf, FLAGFALSE, "%c%cP%hu\r", chAttn, chEsc,
	1430	#if defined(TIOCGWINSZ)
	1431	config->playback == 1 ? ws.ws_row :
	1432	#endif
	1433	config->playback - 1);
	1434	r = ReadReply(pcf, FLAGFALSE);
	1435	}
	1436
	1437	if (config->replay) {
	1438	FilePrint(pcf, FLAGFALSE, "%c%cR%hu\r", chAttn, chEsc,
	1439	#if defined(TIOCGWINSZ)
	1440	config->replay == 1 ? ws.ws_row :
	1441	#endif
	1442	config->replay - 1);
	1443	r = ReadReply(pcf, FLAGFALSE);
	1444	}
	1445	}
	1446
1417	1447	FilePrint(pcf, FLAGFALSE, "%c%c;", chAttn, chEsc);
1418		r = ReadReply(pcf, 0);
	1448	r = ReadReply(pcf, FLAGFALSE);
1419	1449	if (strncmp(r, "[unknown", 8) != 0 &&
1420	1450	strncmp(r, "[connected]", 11) != 0)
1421	1451	FileWrite(cfstdout, FLAGFALSE, r, -1);

1527	1557
1528	1558	FileSetQuoteIAC(pcf, FLAGTRUE);
1529	1559
1530		t = ReadReply(pcf, 0);
	1560	t = ReadReply(pcf, FLAGFALSE);
1531	1561	if (strcmp(t, "ok\r\n") != 0) {
1532	1562	FileClose(&pcf);
1533	1563	FilePrint(cfstdout, FLAGFALSE, "%s: %s", serverName, t);

1536	1566	#if HAVE_OPENSSL
1537	1567	if (config->sslenabled == FLAGTRUE) {
1538	1568	FileWrite(pcf, FLAGFALSE, "ssl\r\n", 5);
1539		t = ReadReply(pcf, 0);
	1569	t = ReadReply(pcf, FLAGFALSE);
1540	1570	if (strcmp(t, "ok\r\n") == 0) {
1541	1571	AttemptSSL(pcf);
1542	1572	if (FileGetType(pcf) != SSLSocket) {

1556	1586
1557	1587	FilePrint(pcf, FLAGFALSE, "login %s\r\n", config->username);
1558	1588
1559		t = ReadReply(pcf, 0);
	1589	t = ReadReply(pcf, FLAGFALSE);
1560	1590	if (strncmp(t, "passwd?", 7) == 0) {
1561	1591	static int count = 0;
1562	1592	static STRING tmpString = (STRING )0;

1587	1617	}
1588	1618	FileWrite(pcf, FLAGFALSE, tmpString->string,
1589	1619	tmpString->used - 1);
1590		t = ReadReply(pcf, 0);
	1620	t = ReadReply(pcf, FLAGFALSE);
1591	1621	if (strcmp(t, "ok\r\n") != 0) {
1592	1622	FilePrint(cfstdout, FLAGFALSE, "%s: %s", serverName, t);
1593	1623	if (++count < 3) {

1620	1650	* that the ReadReply can stop once the socket closes.
1621	1651	*/
1622	1652	if (cmdi != 0) {
1623		t = ReadReply(pcf, 0);
	1653	t = ReadReply(pcf, FLAGFALSE);
1624	1654	/* save the result */
1625	1655	if (result != (char *)0)
1626	1656	free(result);

1638	1668	Bye(EX_SOFTWARE);
1639	1669	}
1640	1670	FileWrite(pcf, FLAGFALSE, "exit\r\n", 6);
1641		t = ReadReply(pcf, 1);
	1671	t = ReadReply(pcf, FLAGTRUE);
1642	1672	} else {
1643	1673	/* if we're not trying to connect to a console */
1644	1674	if (interact == FLAGFALSE) {

1663	1693	}
1664	1694	} else if (cmds[cmdi][0] == 'q') {
1665	1695	if (cmdi == 0) {
1666		t = ReadReply(pcf, 0);
	1696	t = ReadReply(pcf, FLAGFALSE);
1667	1697	FilePrint(cfstdout, FLAGFALSE, "%s: %s", serverName, t);
1668	1698	} else {
1669	1699	FilePrint(cfstdout, FLAGFALSE, "%s: %s", serverName,

1672	1702	/* only say 'exit' if 'quit' failed...since it's dying anyway */
1673	1703	if (t[0] != 'o' \|\| t[1] != 'k') {
1674	1704	FileWrite(pcf, FLAGFALSE, "exit\r\n", 6);
1675		t = ReadReply(pcf, 1);
	1705	t = ReadReply(pcf, FLAGTRUE);
1676	1706	}
1677	1707	} else {
1678	1708	/* all done */

1684	1714	* like i said. wacky.
1685	1715	*/
1686	1716	FileWrite(pcf, FLAGFALSE, "exit\r\n", 6);
1687		t = ReadReply(pcf, cmdi == 0 ? 1 : 0);
	1717	t = ReadReply(pcf, cmdi == 0 ? FLAGTRUE : FLAGFALSE);
1688	1718
1689	1719	if (cmdi == 0) {
1690	1720	int len;

2131	2161	if (config->port == (char *)0)
2132	2162	OutOfMem();
2133	2163
	2164	if (optConf->replay != 0)
	2165	config->replay = optConf->replay;
	2166	else if (pConfig->replay != 0)
	2167	config->replay = pConfig->replay;
	2168	else
	2169	config->replay = 0;
	2170
	2171	if (optConf->playback != 0)
	2172	config->playback = optConf->playback;
	2173	else if (pConfig->playback != 0)
	2174	config->playback = pConfig->playback;
	2175	else
	2176	config->playback = 0;
	2177
2134	2178	#if HAVE_OPENSSL
2135	2179	if (optConf->sslcredentials != (char *)0 &&
2136	2180	optConf->sslcredentials[0] != '\000')

2213	2257	Error("getservbyname(%s) failed", config->port);
2214	2258	Bye(EX_UNAVAILABLE);
2215	2259	} else {
2216		bindPort = ntohs((u_short) pSE->s_port);
	2260	bindPort = ntohs((unsigned short)pSE->s_port);
2217	2261	}
2218	2262	}
2219	2263	#endif

2278	2322	if (!fLocal)
2279	2323	cmds[++cmdi] = "master";
2280	2324	}
	2325
	2326	#if defined(TIOCGWINSZ)
	2327	if (interact == FLAGTRUE) {
	2328	int fd;
	2329	#if HAVE_MEMSET
	2330	memset((void *)(&ws), '\000', sizeof(ws));
	2331	#else
	2332	bzero((char *)(&ws), sizeof(ws));
	2333	#endif
	2334	if ((fd = open("/dev/tty", O_RDONLY)) != -1) {
	2335	ioctl(fd, TIOCGWINSZ, &ws);
	2336	}
	2337	close(fd);
	2338	}
	2339	#endif
2281	2340
2282	2341	for (;;) {
2283	2342	if (gotoConsole == (CONSFILE *)0)

+36

-4

console/console.man less more

0		.\" $Id: console.man,v 1.58 2005/09/05 22:17:33 bryan Exp $
1		.TH CONSOLE 1 "2005/09/05" "conserver-8.1.13" "conserver"
	0	.\" $Id: console.man,v 1.61 2006/04/03 13:32:12 bryan Exp $
	1	.TH CONSOLE 1 "2006/04/03" "conserver-8.1.14" "conserver"
2	2	.SH NAME
3	3	console \- console server client program
4	4	.SH SYNOPSIS

425	425	.I type
426	426	The type of console.
427	427	Values will be a `/' for a local device, `\|' for
428		a command, or `!' for a remote port.
	428	a command, `!' for a remote port, `%' for a Unix domain socket,
	429	and `#' for a noop console.
429	430	.TP
430	431	.I console-details
431	432	The details regarding the console.

436	437	pseudo-tty, and file descriptor for the pseudo-tty.
437	438	Remote ports will have values of the remote hostname, remote port number,
438	439	``raw'' or ``telnet'' protocol, and file descriptor for the socket connection.
	440	Unix domain sockets will have the path to the socket and the file
	441	descriptor for the socket connection.
	442	Noop consoles will have nothing.
439	443	.TP
440	444	.I users-list
441	445	The details of each user connected to the console.

529	533	.B \-M
530	534	command-line flag).
531	535	.TP
	536	\f3playback\fP \f2num\fP\|\f3""\fP
	537	.br
	538	Override the playback length for the
	539	.B p
	540	escape command to
	541	.I num
	542	lines (if the server supports it).
	543	Using the special value of ``0'' will cause the client to use the number
	544	of lines of the current terminal (if that can be determined).
	545	If the null string (``""'') is used, the playback length will not be overridden.
	546	.TP
532	547	\f3port\fP \f2port\fP
533	548	.br
534	549	Set the default port to

536	551	(see the
537	552	.B \-p
538	553	command-line flag).
	554	.TP
	555	\f3replay\fP \f2num\fP\|\f3""\fP
	556	.br
	557	Override the replay length for the
	558	.B r
	559	escape command to
	560	.I num
	561	lines (if the server supports it).
	562	Using the special value of ``0'' will cause the client to use the number
	563	of lines of the current terminal (if that can be determined).
	564	If the null string (``""'') is used, the replay length will not be overridden.
539	565	.TP
540	566	\f3sslcredentials\fP \f2filename\fP
541	567	.br

829	855	and the log file
830	856	.TP
831	857	.B p
832		replay the last 60 lines of output
	858	playback the last 60 lines of output
	859	.TP
	860	.B P
	861	set number of playback lines
833	862	.TP
834	863	.B r
835	864	replay the last 20 lines of output
	865	.TP
	866	.B R
	867	set number of replay lines
836	868	.TP
837	869	.B s
838	870	switch to spy mode (read-only)

+104

-13

console/readconf.c less more

0	0	/*
1		* $Id: readconf.c,v 5.3 2005/06/11 02:32:21 bryan Exp $
	1	* $Id: readconf.c,v 5.5 2006/04/03 13:32:12 bryan Exp $
2	2	*
3	3	* Copyright conserver.com, 2000
4	4	*

80	80	}
81	81	if (parserConfigDefault->striphigh != FLAGUNKNOWN)
82	82	c->striphigh = parserConfigDefault->striphigh;
	83	if (parserConfigDefault->replay != FLAGUNKNOWN)
	84	c->replay = parserConfigDefault->replay;
	85	if (parserConfigDefault->playback != FLAGUNKNOWN)
	86	c->playback = parserConfigDefault->playback;
83	87	#if HAVE_OPENSSL
84	88	if (parserConfigDefault->sslcredentials != (char *)0) {
85	89	if (c->sslcredentials != (char *)0)

396	400
397	401	void
398	402	#if PROTOTYPES
	403	ConfigItemPlayback(char *id)
	404	#else
	405	ConfigItemPlayback(id)
	406	char *id;
	407	#endif
	408	{
	409	int i;
	410
	411	CONDDEBUG((1, "ConfigItemPlayback(%s) [%s:%d]", id, file, line));
	412
	413	if ((id == (char )0) \|\| (id == '\000')) {
	414	parserConfigTemp->playback = 0;
	415	return;
	416	}
	417	for (i = 0; id[i] != '\000'; i++) {
	418	if (!isdigit((int)id[i])) {
	419	Error("invalid playback value [%s:%d]", file, line);
	420	return;
	421	}
	422	}
	423	if (i > 4) {
	424	Error("playback value too large [%s:%d]", file, line);
	425	return;
	426	}
	427	parserConfigTemp->playback = (unsigned short)atoi(id) + 1;
	428	}
	429
	430	void
	431	#if PROTOTYPES
399	432	ConfigItemPort(char *id)
400	433	#else
401	434	ConfigItemPort(id)

413	446	}
414	447	if ((parserConfigTemp->port = StrDup(id)) == (char *)0)
415	448	OutOfMem();
	449	}
	450
	451	void
	452	#if PROTOTYPES
	453	ConfigItemReplay(char *id)
	454	#else
	455	ConfigItemReplay(id)
	456	char *id;
	457	#endif
	458	{
	459	int i;
	460
	461	CONDDEBUG((1, "ConfigItemReplay(%s) [%s:%d]", id, file, line));
	462
	463	if ((id == (char )0) \|\| (id == '\000')) {
	464	parserConfigTemp->replay = 0;
	465	return;
	466	}
	467	for (i = 0; id[i] != '\000'; i++) {
	468	if (!isdigit((int)id[i])) {
	469	Error("invalid replay value [%s:%d]", file, line);
	470	return;
	471	}
	472	}
	473	if (i > 4) {
	474	Error("replay value too large [%s:%d]", file, line);
	475	return;
	476	}
	477	parserConfigTemp->replay = (unsigned short)atoi(id) + 1;
416	478	}
417	479
418	480	void

511	573
512	574	SUBST substData = (SUBST )0;
513	575
	576	SUBSTTOKEN
	577	#if PROTOTYPES
	578	SubstToken(char c)
	579	#else
	580	SubstToken(c)
	581	char c;
	582	#endif
	583	{
	584	switch (c) {
	585	case 'u':
	586	case 'c':
	587	return ISSTRING;
	588	default:
	589	return ISNOTHING;
	590	}
	591	}
	592
514	593	int
515	594	#if PROTOTYPES
516		SubstCallback(char c, char *s, int i)
517		#else
518		SubstCallback(c, s, i)
	595	SubstValue(char c, char *s, int i)
	596	#else
	597	SubstValue(c, s, i)
519	598	char c;
520	599	char **s;
521	600	int *i;
522	601	#endif
523	602	{
524	603	int retval = 0;
525
526		if (substData == (SUBST *)0) {
527		if ((substData = (SUBST )calloc(1, sizeof(SUBST))) == (SUBST )0)
528		OutOfMem();
529		substData->callback = &SubstCallback;
530		substData->tokens['u'] = ISSTRING;
531		substData->tokens['c'] = ISSTRING;
532		}
533	604
534	605	if (s != (char **)0) {
535	606	CONFIG *pc;

551	622
552	623	void
553	624	#if PROTOTYPES
	625	InitSubstCallback(void)
	626	#else
	627	InitSubstCallback()
	628	#endif
	629	{
	630	if (substData == (SUBST *)0) {
	631	if ((substData = (SUBST )calloc(1, sizeof(SUBST))) == (SUBST )0)
	632	OutOfMem();
	633	substData->value = &SubstValue;
	634	substData->token = &SubstToken;
	635	}
	636	}
	637
	638
	639	void
	640	#if PROTOTYPES
554	641	TerminalItemAttach(char *id)
555	642	#else
556	643	TerminalItemAttach(id)

620	707	ITEM keyConfig[] = {
621	708	{"escape", ConfigItemEscape},
622	709	{"master", ConfigItemMaster},
	710	{"playback", ConfigItemPlayback},
623	711	{"port", ConfigItemPort},
	712	{"replay", ConfigItemReplay},
624	713	{"sslcredentials", ConfigItemSslcredentials},
625	714	{"sslrequired", ConfigItemSslrequired},
626	715	{"sslenabled", ConfigItemSslenabled},

663	752	}
664	753
665	754	/* initialize the substition bits */
666		SubstCallback('\000', (char *)0, (int )0);
	755	InitSubstCallback();
667	756
668	757	parserConfigDefault = pConfig;
669	758	pConfig = (CONFIG *)0;

698	787	CONDDEBUG((1, "pConfig->escape = %s", EMPTYSTR(pConfig->escape)));
699	788	CONDDEBUG((1, "pConfig->striphigh = %s",
700	789	FLAGSTR(pConfig->striphigh)));
	790	CONDDEBUG((1, "pConfig->replay = %hu", pConfig->replay));
	791	CONDDEBUG((1, "pConfig->playback = %hu", pConfig->playback));
701	792	#if HAVE_OPENSSL
702	793	CONDDEBUG((1, "pConfig->sslcredentials = %s",
703	794	EMPTYSTR(pConfig->sslcredentials)));

-1

console/readconf.h less more

0	0	/*
1		* $Id: readconf.h,v 5.3 2004/05/25 23:03:25 bryan Exp $
	1	* $Id: readconf.h,v 5.4 2006/04/03 13:32:12 bryan Exp $
2	2	*
3	3	* Copyright conserver.com, 2000
4	4	*

13	13	char *port;
14	14	char *escape;
15	15	FLAG striphigh;
	16	unsigned short replay;
	17	unsigned short playback;
16	18	#if HAVE_OPENSSL
17	19	char *sslcredentials;
18	20	FLAG sslrequired;

-4

contrib/redhat-rpm/conserver.spec less more

3	3	#
4	4
5	5	%define pkg conserver
6		%define ver 8.1.13
	6	%define ver 8.1.14
7	7
8	8	# define the name of the machine on which the main conserver
9	9	# daemon will be running if you don't want to use the default

11	11	%define master console
12	12
13	13	# what red hat (or other distibution) version are you running?
14		%define distver 6
	14	%define distver 1
15	15
16	16	Summary: Serial console server daemon/client
17	17	Name: %{pkg}
18	18	Version: %{ver}
19		Release: 1.%{distver}
20		Copyright: distributable
	19	Release: %{distver}
	20	License: BSD
21	21	Group: System Environment/Daemons
22	22	URL: http://www.conserver.com/
23	23	Source: http://www.conserver.com/%{pkg}-%{ver}.tar.gz

95	95	%config(noreplace) %{_sysconfdir}/conserver.passwd
96	96	%attr(555,root,root) %{_initrddir}/conserver
97	97	%{prefix}/bin/console
	98	%{prefix}/lib/conserver/convert
98	99	%{prefix}/share/man/man1/console.1.gz
99	100	%{prefix}/share/man/man8/conserver.8.gz
100	101	%{prefix}/share/man/man5/conserver.cf.5.gz

-1

contrib/solaris-package/pkginfo less more

0	0	PKG="conserver"
1	1	NAME="Console server and client"
2	2	CATEGORY="system"
3		VERSION="8.1.13"
	3	VERSION="8.1.14"
4	4	DESC="Console server and client"
5	5	CLASSES=none
6	6	ARCH=sparc

-2

test/results/test2 less more

7	7	L toggle logging on/off l? break sequence list
8	8	l0 send break per config file l1-9 send specific break sequence
9	9	m display the message of the day o (re)open the tty and log file
10		p replay the last 60 lines r replay the last 20 lines
11		s spy read only u show host status
	10	p playback the last 60 lines P set number of playback lines
	11	r replay the last 20 lines R set number of replay lines
	12	s spy mode (read only) u show host status
12	13	v show version info w who is on this console
13	14	x show console baud info z suspend the connection
14	15	\| attach local command ? print this message

-2

test/results/test7 less more

7	7	L toggle logging on/off l? break sequence list
8	8	l0 send break per config file l1-9 send specific break sequence
9	9	m display the message of the day o (re)open the tty and log file
10		p replay the last 60 lines r replay the last 20 lines
11		s spy read only u show host status
	10	p playback the last 60 lines P set number of playback lines
	11	r replay the last 20 lines R set number of replay lines
	12	s spy mode (read only) u show host status
12	13	v show version info w who is on this console
13	14	x show console baud info z suspend the connection
14	15	\| attach local command ? print this message