[deb_xorg-server.git] / hw / xfree86 / os-support / linux / lnx_init.c

/*
 * Copyright 1992 by Orest Zborowski <obz@Kodak.com>
 * Copyright 1993 by David Wexelblat <dwex@goblin.org>
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the names of Orest Zborowski and David Wexelblat
 * not be used in advertising or publicity pertaining to distribution of
 * the software without specific, written prior permission.  Orest Zborowski
 * and David Wexelblat make no representations about the suitability of this
 * software for any purpose.  It is provided "as is" without express or
 * implied warranty.
 *
 * OREST ZBOROWSKI AND DAVID WEXELBLAT DISCLAIMS ALL WARRANTIES WITH REGARD
 * TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS, IN NO EVENT SHALL OREST ZBOROWSKI OR DAVID WEXELBLAT BE LIABLE
 * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 */

#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif

#include <X11/X.h>
#include <X11/Xmd.h>

#include "compiler.h"

#include "xf86.h"
#include "xf86Priv.h"
#include "xf86_OSlib.h"

#include <sys/stat.h>

#ifndef K_OFF
#define K_OFF 0x4
#endif

#ifndef KDSKBMUTE
#define KDSKBMUTE 0x4B51
#endif

static Bool KeepTty = FALSE;
static int activeVT = -1;

static char vtname[11];
static struct termios tty_attr; /* tty state to restore */
static int tty_mode;            /* kbd mode to restore */

static void
drain_console(int fd, void *closure)
{
    errno = 0;
    if (tcflush(fd, TCIOFLUSH) == -1 && errno == EIO) {
        xf86SetConsoleHandler(NULL, NULL);
    }
}

static void
switch_to(int vt, const char *from)
{
    int ret;

    SYSCALL(ret = ioctl(xf86Info.consoleFd, VT_ACTIVATE, vt));
    if (ret < 0)
        FatalError("%s: VT_ACTIVATE failed: %s\n", from, strerror(errno));

    SYSCALL(ret = ioctl(xf86Info.consoleFd, VT_WAITACTIVE, vt));
    if (ret < 0)
        FatalError("%s: VT_WAITACTIVE failed: %s\n", from, strerror(errno));
}

void
xf86OpenConsole(void)
{
    int i, fd = -1, ret;
    struct vt_mode VT;
    struct vt_stat vts;
    MessageType from = X_PROBED;
    char *tty0[] = { "/dev/tty0", "/dev/vc/0", NULL };
    char *vcs[] = { "/dev/vc/%d", "/dev/tty%d", NULL };

    if (serverGeneration == 1) {

        /* when KeepTty check if we're run with euid==0 */
        if (KeepTty && geteuid() != 0)
            FatalError("xf86OpenConsole:"
                       " Server must be suid root for option \"KeepTTY\"\n");

        /*
         * setup the virtual terminal manager
         */
        if (xf86Info.vtno != -1) {
            from = X_CMDLINE;
        }
        else {

            i = 0;
            while (tty0[i] != NULL) {
                if ((fd = open(tty0[i], O_WRONLY, 0)) >= 0)
                    break;
                i++;
            }

            if (fd < 0)
                FatalError("xf86OpenConsole: Cannot open /dev/tty0 (%s)\n",
                           strerror(errno));

            if (xf86Info.ShareVTs) {
                SYSCALL(ret = ioctl(fd, VT_GETSTATE, &vts));
                if (ret < 0)
                    FatalError("xf86OpenConsole: Cannot find the current"
                               " VT (%s)\n", strerror(errno));
                xf86Info.vtno = vts.v_active;
            }
            else {
                SYSCALL(ret = ioctl(fd, VT_OPENQRY, &xf86Info.vtno));
                if (ret < 0)
                    FatalError("xf86OpenConsole: Cannot find a free VT: "
                               "%s\n", strerror(errno));
                if (xf86Info.vtno == -1)
                    FatalError("xf86OpenConsole: Cannot find a free VT\n");
            }
            close(fd);
        }

        xf86Msg(from, "using VT number %d\n\n", xf86Info.vtno);

        if (!KeepTty) {
            pid_t ppid = getppid();
            pid_t ppgid;

            ppgid = getpgid(ppid);

            /*
             * change to parent process group that pgid != pid so
             * that setsid() doesn't fail and we become process
             * group leader
             */
            if (setpgid(0, ppgid) < 0)
                xf86Msg(X_WARNING, "xf86OpenConsole: setpgid failed: %s\n",
                        strerror(errno));

            /* become process group leader */
            if ((setsid() < 0))
                xf86Msg(X_WARNING, "xf86OpenConsole: setsid failed: %s\n",
                        strerror(errno));
        }

        i = 0;
        while (vcs[i] != NULL) {
            snprintf(vtname, sizeof(vtname), vcs[i], xf86Info.vtno);    /* /dev/tty1-64 */
            if ((xf86Info.consoleFd = open(vtname, O_RDWR | O_NDELAY, 0)) >= 0)
                break;
            i++;
        }

        if (xf86Info.consoleFd < 0)
            FatalError("xf86OpenConsole: Cannot open virtual console"
                       " %d (%s)\n", xf86Info.vtno, strerror(errno));

        /*
         * Linux doesn't switch to an active vt after the last close of a vt,
         * so we do this ourselves by remembering which is active now.
         */
        SYSCALL(ret = ioctl(xf86Info.consoleFd, VT_GETSTATE, &vts));
        if (ret < 0)
            xf86Msg(X_WARNING, "xf86OpenConsole: VT_GETSTATE failed: %s\n",
                    strerror(errno));
        else
            activeVT = vts.v_active;

#if 0
        if (!KeepTty) {
            /*
             * Detach from the controlling tty to avoid char loss
             */
            if ((i = open("/dev/tty", O_RDWR)) >= 0) {
                SYSCALL(ioctl(i, TIOCNOTTY, 0));
                close(i);
            }
        }
#endif

        if (!xf86Info.ShareVTs) {
            struct termios nTty;

            /*
             * now get the VT.  This _must_ succeed, or else fail completely.
             */
            switch_to(xf86Info.vtno, "xf86OpenConsole");

            SYSCALL(ret = ioctl(xf86Info.consoleFd, VT_GETMODE, &VT));
            if (ret < 0)
                FatalError("xf86OpenConsole: VT_GETMODE failed %s\n",
                           strerror(errno));

            signal(SIGUSR1, xf86VTRequest);

            VT.mode = VT_PROCESS;
            VT.relsig = SIGUSR1;
            VT.acqsig = SIGUSR1;

            SYSCALL(ret = ioctl(xf86Info.consoleFd, VT_SETMODE, &VT));
            if (ret < 0)
                FatalError
                    ("xf86OpenConsole: VT_SETMODE VT_PROCESS failed: %s\n",
                     strerror(errno));

            SYSCALL(ret = ioctl(xf86Info.consoleFd, KDSETMODE, KD_GRAPHICS));
            if (ret < 0)
                FatalError("xf86OpenConsole: KDSETMODE KD_GRAPHICS failed %s\n",
                           strerror(errno));

            tcgetattr(xf86Info.consoleFd, &tty_attr);
            SYSCALL(ioctl(xf86Info.consoleFd, KDGKBMODE, &tty_mode));

            /* disable kernel special keys and buffering, new style */
            SYSCALL(ret = ioctl(xf86Info.consoleFd, KDSKBMUTE, 1));
            if (ret < 0)
            {
                /* disable kernel special keys and buffering, old style */
                SYSCALL(ret = ioctl(xf86Info.consoleFd, KDSKBMODE, K_OFF));
                if (ret < 0)
                {
                    /* fine, just disable special keys */
                    SYSCALL(ret = ioctl(xf86Info.consoleFd, KDSKBMODE, K_RAW));
                    if (ret < 0)
                        FatalError("xf86OpenConsole: KDSKBMODE K_RAW failed %s\n",
                                   strerror(errno));

                    /* ... and drain events, else the kernel gets angry */
                    xf86SetConsoleHandler(drain_console, NULL);
                }
            }

            nTty = tty_attr;
            nTty.c_iflag = (IGNPAR | IGNBRK) & (~PARMRK) & (~ISTRIP);
            nTty.c_oflag = 0;
            nTty.c_cflag = CREAD | CS8;
            nTty.c_lflag = 0;
            nTty.c_cc[VTIME] = 0;
            nTty.c_cc[VMIN] = 1;
            cfsetispeed(&nTty, 9600);
            cfsetospeed(&nTty, 9600);
            tcsetattr(xf86Info.consoleFd, TCSANOW, &nTty);
        }
    }
    else {                      /* serverGeneration != 1 */
        if (!xf86Info.ShareVTs && xf86Info.autoVTSwitch) {
            /* now get the VT */
            switch_to(xf86Info.vtno, "xf86OpenConsole");
        }
    }
}

void
xf86CloseConsole(void)
{
    struct vt_mode VT;
    int ret;

    if (xf86Info.ShareVTs) {
        close(xf86Info.consoleFd);
        return;
    }

    /*
     * unregister the drain_console handler
     * - what to do if someone else changed it in the meantime?
     */
    xf86SetConsoleHandler(NULL, NULL);

    /* Back to text mode ... */
    SYSCALL(ret = ioctl(xf86Info.consoleFd, KDSETMODE, KD_TEXT));
    if (ret < 0)
        xf86Msg(X_WARNING, "xf86CloseConsole: KDSETMODE failed: %s\n",
                strerror(errno));

    SYSCALL(ioctl(xf86Info.consoleFd, KDSKBMUTE, 0));
    SYSCALL(ioctl(xf86Info.consoleFd, KDSKBMODE, tty_mode));
    tcsetattr(xf86Info.consoleFd, TCSANOW, &tty_attr);

    SYSCALL(ret = ioctl(xf86Info.consoleFd, VT_GETMODE, &VT));
    if (ret < 0)
        xf86Msg(X_WARNING, "xf86CloseConsole: VT_GETMODE failed: %s\n",
                strerror(errno));
    else {
        /* set dflt vt handling */
        VT.mode = VT_AUTO;
        SYSCALL(ret = ioctl(xf86Info.consoleFd, VT_SETMODE, &VT));
        if (ret < 0)
            xf86Msg(X_WARNING, "xf86CloseConsole: VT_SETMODE failed: %s\n",
                    strerror(errno));
    }

    if (xf86Info.autoVTSwitch) {
        /*
         * Perform a switch back to the active VT when we were started
         */
        if (activeVT >= 0) {
            switch_to(activeVT, "xf86CloseConsole");
            activeVT = -1;
        }
    }
    close(xf86Info.consoleFd);  /* make the vt-manager happy */
}

int
xf86ProcessArgument(int argc, char *argv[], int i)
{
    /*
     * Keep server from detaching from controlling tty.  This is useful
     * when debugging (so the server can receive keyboard signals.
     */
    if (!strcmp(argv[i], "-keeptty")) {
        KeepTty = TRUE;
        return 1;
    }

    if ((argv[i][0] == 'v') && (argv[i][1] == 't')) {
        if (sscanf(argv[i], "vt%2d", &xf86Info.vtno) == 0) {
            UseMsg();
            xf86Info.vtno = -1;
            return 0;
        }
        return 1;
    }
    return 0;
}

void
xf86UseMsg(void)
{
    ErrorF("vtXX                   use the specified VT number\n");
    ErrorF("-keeptty               ");
    ErrorF("don't detach controlling tty (for debugging only)\n");
}
Commit	Line	Data
a09e091a JB	1	/*
	2	* Copyright 1992 by Orest Zborowski <obz@Kodak.com>
	3	* Copyright 1993 by David Wexelblat <dwex@goblin.org>
	4	*
	5	* Permission to use, copy, modify, distribute, and sell this software and its
	6	* documentation for any purpose is hereby granted without fee, provided that
	7	* the above copyright notice appear in all copies and that both that
	8	* copyright notice and this permission notice appear in supporting
	9	* documentation, and that the names of Orest Zborowski and David Wexelblat
	10	* not be used in advertising or publicity pertaining to distribution of
	11	* the software without specific, written prior permission. Orest Zborowski
	12	* and David Wexelblat make no representations about the suitability of this
	13	* software for any purpose. It is provided "as is" without express or
	14	* implied warranty.
	15	*
	16	* OREST ZBOROWSKI AND DAVID WEXELBLAT DISCLAIMS ALL WARRANTIES WITH REGARD
	17	* TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
	18	* FITNESS, IN NO EVENT SHALL OREST ZBOROWSKI OR DAVID WEXELBLAT BE LIABLE
	19	* FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	20	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	21	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	22	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	23	*
	24	*/
	25
	26	#ifdef HAVE_XORG_CONFIG_H
	27	#include <xorg-config.h>
	28	#endif
	29
	30	#include <X11/X.h>
	31	#include <X11/Xmd.h>
	32
	33	#include "compiler.h"
	34
	35	#include "xf86.h"
	36	#include "xf86Priv.h"
	37	#include "xf86_OSlib.h"
	38
	39	#include <sys/stat.h>
	40
	41	#ifndef K_OFF
	42	#define K_OFF 0x4
	43	#endif
	44
	45	#ifndef KDSKBMUTE
	46	#define KDSKBMUTE 0x4B51
	47	#endif
	48
	49	static Bool KeepTty = FALSE;
	50	static int activeVT = -1;
	51
	52	static char vtname[11];
	53	static struct termios tty_attr; /* tty state to restore */
	54	static int tty_mode; /* kbd mode to restore */
	55
	56	static void
	57	drain_console(int fd, void *closure)
	58	{
	59	errno = 0;
	60	if (tcflush(fd, TCIOFLUSH) == -1 && errno == EIO) {
	61	xf86SetConsoleHandler(NULL, NULL);
	62	}
	63	}
	64
65	static void
66	switch_to(int vt, const char *from)
67	{
68	int ret;
69
70	SYSCALL(ret = ioctl(xf86Info.consoleFd, VT_ACTIVATE, vt));
71	if (ret < 0)
72	FatalError("%s: VT_ACTIVATE failed: %s\n", from, strerror(errno));
73
74	SYSCALL(ret = ioctl(xf86Info.consoleFd, VT_WAITACTIVE, vt));
75	if (ret < 0)
76	FatalError("%s: VT_WAITACTIVE failed: %s\n", from, strerror(errno));
77	}
78
79	void
80	xf86OpenConsole(void)
81	{
82	int i, fd = -1, ret;
83	struct vt_mode VT;
84	struct vt_stat vts;
85	MessageType from = X_PROBED;
86	char *tty0[] = { "/dev/tty0", "/dev/vc/0", NULL };
87	char *vcs[] = { "/dev/vc/%d", "/dev/tty%d", NULL };
88
89	if (serverGeneration == 1) {
90
91	/* when KeepTty check if we're run with euid==0 */
92	if (KeepTty && geteuid() != 0)
93	FatalError("xf86OpenConsole:"
94	" Server must be suid root for option \"KeepTTY\"\n");
95
96	/*
97	* setup the virtual terminal manager
98	*/
99	if (xf86Info.vtno != -1) {
100	from = X_CMDLINE;
101	}
102	else {
103
104	i = 0;
105	while (tty0[i] != NULL) {
106	if ((fd = open(tty0[i], O_WRONLY, 0)) >= 0)
107	break;
108	i++;
109	}
110
111	if (fd < 0)
112	FatalError("xf86OpenConsole: Cannot open /dev/tty0 (%s)\n",
113	strerror(errno));
114
115	if (xf86Info.ShareVTs) {
116	SYSCALL(ret = ioctl(fd, VT_GETSTATE, &vts));
117	if (ret < 0)
118	FatalError("xf86OpenConsole: Cannot find the current"
119	" VT (%s)\n", strerror(errno));
120	xf86Info.vtno = vts.v_active;
121	}
122	else {
123	SYSCALL(ret = ioctl(fd, VT_OPENQRY, &xf86Info.vtno));
124	if (ret < 0)
125	FatalError("xf86OpenConsole: Cannot find a free VT: "
126	"%s\n", strerror(errno));
127	if (xf86Info.vtno == -1)
128	FatalError("xf86OpenConsole: Cannot find a free VT\n");
129	}
130	close(fd);
131	}
132
133	xf86Msg(from, "using VT number %d\n\n", xf86Info.vtno);
134
135	if (!KeepTty) {
136	pid_t ppid = getppid();
137	pid_t ppgid;
138
139	ppgid = getpgid(ppid);
140
141	/*
142	* change to parent process group that pgid != pid so
143	* that setsid() doesn't fail and we become process
144	* group leader
145	*/
146	if (setpgid(0, ppgid) < 0)
147	xf86Msg(X_WARNING, "xf86OpenConsole: setpgid failed: %s\n",
148	strerror(errno));
149
150	/* become process group leader */
151	if ((setsid() < 0))
152	xf86Msg(X_WARNING, "xf86OpenConsole: setsid failed: %s\n",
153	strerror(errno));
154	}
155
156	i = 0;
157	while (vcs[i] != NULL) {
158	snprintf(vtname, sizeof(vtname), vcs[i], xf86Info.vtno); /* /dev/tty1-64 */
159	if ((xf86Info.consoleFd = open(vtname, O_RDWR \| O_NDELAY, 0)) >= 0)
160	break;
161	i++;
162	}
163
164	if (xf86Info.consoleFd < 0)
165	FatalError("xf86OpenConsole: Cannot open virtual console"
166	" %d (%s)\n", xf86Info.vtno, strerror(errno));
167
168	/*
169	* Linux doesn't switch to an active vt after the last close of a vt,
170	* so we do this ourselves by remembering which is active now.
171	*/
172	SYSCALL(ret = ioctl(xf86Info.consoleFd, VT_GETSTATE, &vts));
173	if (ret < 0)
174	xf86Msg(X_WARNING, "xf86OpenConsole: VT_GETSTATE failed: %s\n",
175	strerror(errno));
176	else
177	activeVT = vts.v_active;
178
179	#if 0
180	if (!KeepTty) {
181	/*
182	* Detach from the controlling tty to avoid char loss
183	*/
184	if ((i = open("/dev/tty", O_RDWR)) >= 0) {
185	SYSCALL(ioctl(i, TIOCNOTTY, 0));
186	close(i);
187	}
188	}
189	#endif
190
191	if (!xf86Info.ShareVTs) {
192	struct termios nTty;
193
194	/*
195	* now get the VT. This _must_ succeed, or else fail completely.
196	*/
197	switch_to(xf86Info.vtno, "xf86OpenConsole");
198
199	SYSCALL(ret = ioctl(xf86Info.consoleFd, VT_GETMODE, &VT));
200	if (ret < 0)
201	FatalError("xf86OpenConsole: VT_GETMODE failed %s\n",
202	strerror(errno));
203
204	signal(SIGUSR1, xf86VTRequest);
205
206	VT.mode = VT_PROCESS;
207	VT.relsig = SIGUSR1;
208	VT.acqsig = SIGUSR1;
209
210	SYSCALL(ret = ioctl(xf86Info.consoleFd, VT_SETMODE, &VT));
211	if (ret < 0)
212	FatalError
213	("xf86OpenConsole: VT_SETMODE VT_PROCESS failed: %s\n",
214	strerror(errno));
215
216	SYSCALL(ret = ioctl(xf86Info.consoleFd, KDSETMODE, KD_GRAPHICS));
217	if (ret < 0)
218	FatalError("xf86OpenConsole: KDSETMODE KD_GRAPHICS failed %s\n",
219	strerror(errno));
220
221	tcgetattr(xf86Info.consoleFd, &tty_attr);
222	SYSCALL(ioctl(xf86Info.consoleFd, KDGKBMODE, &tty_mode));
223
224	/* disable kernel special keys and buffering, new style */
225	SYSCALL(ret = ioctl(xf86Info.consoleFd, KDSKBMUTE, 1));
226	if (ret < 0)
227	{
228	/* disable kernel special keys and buffering, old style */
229	SYSCALL(ret = ioctl(xf86Info.consoleFd, KDSKBMODE, K_OFF));
230	if (ret < 0)
231	{
232	/* fine, just disable special keys */
233	SYSCALL(ret = ioctl(xf86Info.consoleFd, KDSKBMODE, K_RAW));
234	if (ret < 0)
235	FatalError("xf86OpenConsole: KDSKBMODE K_RAW failed %s\n",
236	strerror(errno));
237
238	/* ... and drain events, else the kernel gets angry */
239	xf86SetConsoleHandler(drain_console, NULL);
240	}
241	}
242
243	nTty = tty_attr;
244	nTty.c_iflag = (IGNPAR \| IGNBRK) & (~PARMRK) & (~ISTRIP);
245	nTty.c_oflag = 0;
246	nTty.c_cflag = CREAD \| CS8;
247	nTty.c_lflag = 0;
248	nTty.c_cc[VTIME] = 0;
249	nTty.c_cc[VMIN] = 1;
250	cfsetispeed(&nTty, 9600);
251	cfsetospeed(&nTty, 9600);
252	tcsetattr(xf86Info.consoleFd, TCSANOW, &nTty);
253	}
254	}
255	else { /* serverGeneration != 1 */
256	if (!xf86Info.ShareVTs && xf86Info.autoVTSwitch) {
257	/* now get the VT */
258	switch_to(xf86Info.vtno, "xf86OpenConsole");
259	}
260	}
261	}
262
263	void
264	xf86CloseConsole(void)
265	{
266	struct vt_mode VT;
267	int ret;
268
269	if (xf86Info.ShareVTs) {
270	close(xf86Info.consoleFd);
271	return;
272	}
273
274	/*
275	* unregister the drain_console handler
276	* - what to do if someone else changed it in the meantime?
277	*/
278	xf86SetConsoleHandler(NULL, NULL);
279
280	/* Back to text mode ... */
281	SYSCALL(ret = ioctl(xf86Info.consoleFd, KDSETMODE, KD_TEXT));
282	if (ret < 0)
283	xf86Msg(X_WARNING, "xf86CloseConsole: KDSETMODE failed: %s\n",
284	strerror(errno));
285
286	SYSCALL(ioctl(xf86Info.consoleFd, KDSKBMUTE, 0));
287	SYSCALL(ioctl(xf86Info.consoleFd, KDSKBMODE, tty_mode));
288	tcsetattr(xf86Info.consoleFd, TCSANOW, &tty_attr);
289
290	SYSCALL(ret = ioctl(xf86Info.consoleFd, VT_GETMODE, &VT));
291	if (ret < 0)
292	xf86Msg(X_WARNING, "xf86CloseConsole: VT_GETMODE failed: %s\n",
293	strerror(errno));
294	else {
295	/* set dflt vt handling */
296	VT.mode = VT_AUTO;
297	SYSCALL(ret = ioctl(xf86Info.consoleFd, VT_SETMODE, &VT));
298	if (ret < 0)
299	xf86Msg(X_WARNING, "xf86CloseConsole: VT_SETMODE failed: %s\n",
300	strerror(errno));
301	}
302
303	if (xf86Info.autoVTSwitch) {
304	/*
305	* Perform a switch back to the active VT when we were started
306	*/
307	if (activeVT >= 0) {
308	switch_to(activeVT, "xf86CloseConsole");
309	activeVT = -1;
310	}
311	}
312	close(xf86Info.consoleFd); /* make the vt-manager happy */
313	}
314
315	int
316	xf86ProcessArgument(int argc, char *argv[], int i)
317	{
318	/*
319	* Keep server from detaching from controlling tty. This is useful
320	* when debugging (so the server can receive keyboard signals.
321	*/
322	if (!strcmp(argv[i], "-keeptty")) {
323	KeepTty = TRUE;
324	return 1;
325	}
326
327	if ((argv[i][0] == 'v') && (argv[i][1] == 't')) {
328	if (sscanf(argv[i], "vt%2d", &xf86Info.vtno) == 0) {
329	UseMsg();
330	xf86Info.vtno = -1;
331	return 0;
332	}
333	return 1;
334	}
335	return 0;
336	}
337
338	void
339	xf86UseMsg(void)
340	{
341	ErrorF("vtXX use the specified VT number\n");
342	ErrorF("-keeptty ");
343	ErrorF("don't detach controlling tty (for debugging only)\n");
344	}