[gssapi-openssh.git] / openssh / openbsd-compat / bsd-cygwin_util.c

/*
 *
 * cygwin_util.c
 *
 * Author: Corinna Vinschen <vinschen@cygnus.com>
 *
 * Copyright (c) 2000 Corinna Vinschen <vinschen@cygnus.com>, Duisburg, Germany
 *                    All rights reserved
 *
 * Created: Sat Sep 02 12:17:00 2000 cv
 *
 * This file contains functions for forcing opened file descriptors to
 * binary mode on Windows systems.
 */

#include "includes.h"

RCSID("$Id$");

#ifdef HAVE_CYGWIN

#include <fcntl.h>
#include <stdlib.h>
#include <sys/utsname.h>
#include <sys/vfs.h>
#include <windows.h>
#define is_winnt       (GetVersion() < 0x80000000)

#define ntsec_on(c)	((c) && strstr((c),"ntsec") && !strstr((c),"nontsec"))
#define ntea_on(c)	((c) && strstr((c),"ntea") && !strstr((c),"nontea"))

#if defined(open) && open == binary_open
# undef open
#endif
#if defined(pipe) && open == binary_pipe
# undef pipe
#endif

int binary_open(const char *filename, int flags, ...)
{
	va_list ap;
	mode_t mode;
	
	va_start(ap, flags);
	mode = va_arg(ap, mode_t);
	va_end(ap);
	return open(filename, flags | O_BINARY, mode);
}

int binary_pipe(int fd[2])
{
	int ret = pipe(fd);

	if (!ret) {
		setmode (fd[0], O_BINARY);
		setmode (fd[1], O_BINARY);
	}
	return ret;
}

int check_nt_auth(int pwd_authenticated, struct passwd *pw)
{
	/*
	* The only authentication which is able to change the user
	* context on NT systems is the password authentication. So
	* we deny all requsts for changing the user context if another
	* authentication method is used.
	*
	* This doesn't apply to Cygwin versions >= 1.3.2 anymore which
	* uses the undocumented NtCreateToken() call to create a user
	* token if the process has the appropriate privileges and if
	* CYGWIN ntsec setting is on.
	*/
	static int has_create_token = -1;

	if (pw == NULL)
		return 0;
	if (is_winnt) {
		if (has_create_token < 0) {
			struct utsname uts;
		        int major_high = 0, major_low = 0, minor = 0;
			char *cygwin = getenv("CYGWIN");

			has_create_token = 0;
			if (ntsec_on(cygwin) && !uname(&uts)) {
				sscanf(uts.release, "%d.%d.%d",
				       &major_high, &major_low, &minor);
				if (major_high > 1 ||
				    (major_high == 1 && (major_low > 3 ||
				     (major_low == 3 && minor >= 2))))
					has_create_token = 1;
			}
		}
		if (has_create_token < 1 &&
		    !pwd_authenticated && geteuid() != pw->pw_uid)
			return 0;
	}
	return 1;
}

int check_ntsec(const char *filename)
{
	char *cygwin;
	int allow_ntea = 0;
	int allow_ntsec = 0;
	struct statfs fsstat;

	/* Windows 95/98/ME don't support file system security at all. */
	if (!is_winnt)
		return 0;

	/* Evaluate current CYGWIN settings. */
	cygwin = getenv("CYGWIN");
	allow_ntea = ntea_on(cygwin);
	allow_ntsec = ntsec_on(cygwin);

	/*
	 * `ntea' is an emulation of POSIX attributes. It doesn't support
	 * real file level security as ntsec on NTFS file systems does
	 * but it supports FAT filesystems. `ntea' is minimum requirement
	 * for security checks.
	 */
	if (allow_ntea)
		return 1;

	/*
	 * Retrieve file system flags. In Cygwin, file system flags are
	 * copied to f_type which has no meaning in Win32 itself.
	 */
	if (statfs(filename, &fsstat))
		return 1;

	/*
	 * Only file systems supporting ACLs are able to set permissions.
	 * `ntsec' is the setting in Cygwin which switches using of NTFS
	 * ACLs to support POSIX permissions on files.
	 */
	if (fsstat.f_type & FS_PERSISTENT_ACLS)
		return allow_ntsec;

	return 0;
}

void register_9x_service(void)
{
        HINSTANCE kerneldll;
        DWORD (*RegisterServiceProcess)(DWORD, DWORD);

	/* The service register mechanism in 9x/Me is pretty different from
	 * NT/2K/XP.  In NT/2K/XP we're using a special service starter
	 * application to register and control sshd as service.  This method
	 * doesn't play nicely with 9x/Me.  For that reason we register here
	 * as service when running under 9x/Me.  This function is only called
	 * by the child sshd when it's going to daemonize.
	 */
	if (is_winnt)
		return;
	if (! (kerneldll = LoadLibrary("KERNEL32.DLL")))
		return;
	if (! (RegisterServiceProcess = (DWORD (*)(DWORD, DWORD))
			  GetProcAddress(kerneldll, "RegisterServiceProcess")))
		return;
	RegisterServiceProcess(0, 1);
}

#endif /* HAVE_CYGWIN */
Commit	Line	Data
3c0ef626	1	/*
	2	*
	3	* cygwin_util.c
	4	*
	5	* Author: Corinna Vinschen <vinschen@cygnus.com>
	6	*
	7	* Copyright (c) 2000 Corinna Vinschen <vinschen@cygnus.com>, Duisburg, Germany
	8	* All rights reserved
	9	*
	10	* Created: Sat Sep 02 12:17:00 2000 cv
	11	*
	12	* This file contains functions for forcing opened file descriptors to
	13	* binary mode on Windows systems.
	14	*/
	15
	16	#include "includes.h"
	17
	18	RCSID("$Id$");
	19
	20	#ifdef HAVE_CYGWIN
	21
	22	#include <fcntl.h>
	23	#include <stdlib.h>
	24	#include <sys/utsname.h>
	25	#include <sys/vfs.h>
	26	#include <windows.h>
	27	#define is_winnt (GetVersion() < 0x80000000)
	28
	29	#define ntsec_on(c) ((c) && strstr((c),"ntsec") && !strstr((c),"nontsec"))
	30	#define ntea_on(c) ((c) && strstr((c),"ntea") && !strstr((c),"nontea"))
	31
	32	#if defined(open) && open == binary_open
	33	# undef open
	34	#endif
	35	#if defined(pipe) && open == binary_pipe
	36	# undef pipe
	37	#endif
	38
	39	int binary_open(const char *filename, int flags, ...)
	40	{
	41	va_list ap;
	42	mode_t mode;
	43
	44	va_start(ap, flags);
	45	mode = va_arg(ap, mode_t);
	46	va_end(ap);
	47	return open(filename, flags \| O_BINARY, mode);
	48	}
	49
	50	int binary_pipe(int fd[2])
	51	{
	52	int ret = pipe(fd);
	53
	54	if (!ret) {
	55	setmode (fd[0], O_BINARY);
	56	setmode (fd[1], O_BINARY);
	57	}
	58	return ret;
	59	}
	60
e9a17296	61	int check_nt_auth(int pwd_authenticated, struct passwd *pw)
3c0ef626	62	{
	63	/*
	64	* The only authentication which is able to change the user
	65	* context on NT systems is the password authentication. So
	66	* we deny all requsts for changing the user context if another
	67	* authentication method is used.
	68	*
	69	* This doesn't apply to Cygwin versions >= 1.3.2 anymore which
	70	* uses the undocumented NtCreateToken() call to create a user
	71	* token if the process has the appropriate privileges and if
	72	* CYGWIN ntsec setting is on.
	73	*/
	74	static int has_create_token = -1;
	75
e9a17296	76	if (pw == NULL)
e9a17296	77	return 0;
3c0ef626	78	if (is_winnt) {
	79	if (has_create_token < 0) {
	80	struct utsname uts;
	81	int major_high = 0, major_low = 0, minor = 0;
	82	char *cygwin = getenv("CYGWIN");
	83
	84	has_create_token = 0;
	85	if (ntsec_on(cygwin) && !uname(&uts)) {
	86	sscanf(uts.release, "%d.%d.%d",
	87	&major_high, &major_low, &minor);
	88	if (major_high > 1 \|\|
	89	(major_high == 1 && (major_low > 3 \|\|
	90	(major_low == 3 && minor >= 2))))
	91	has_create_token = 1;
	92	}
	93	}
	94	if (has_create_token < 1 &&
e9a17296	95	!pwd_authenticated && geteuid() != pw->pw_uid)
3c0ef626	96	return 0;
	97	}
	98	return 1;
	99	}
	100
	101	int check_ntsec(const char *filename)
	102	{
	103	char *cygwin;
	104	int allow_ntea = 0;
	105	int allow_ntsec = 0;
	106	struct statfs fsstat;
	107
	108	/* Windows 95/98/ME don't support file system security at all. */
	109	if (!is_winnt)
	110	return 0;
	111
	112	/* Evaluate current CYGWIN settings. */
	113	cygwin = getenv("CYGWIN");
	114	allow_ntea = ntea_on(cygwin);
	115	allow_ntsec = ntsec_on(cygwin);
	116
	117	/*
	118	* `ntea' is an emulation of POSIX attributes. It doesn't support
	119	* real file level security as ntsec on NTFS file systems does
	120	* but it supports FAT filesystems. `ntea' is minimum requirement
	121	* for security checks.
	122	*/
	123	if (allow_ntea)
	124	return 1;
	125
	126	/*
	127	* Retrieve file system flags. In Cygwin, file system flags are
	128	* copied to f_type which has no meaning in Win32 itself.
	129	*/
	130	if (statfs(filename, &fsstat))
	131	return 1;
	132
	133	/*
	134	* Only file systems supporting ACLs are able to set permissions.
	135	* `ntsec' is the setting in Cygwin which switches using of NTFS
	136	* ACLs to support POSIX permissions on files.
	137	*/
	138	if (fsstat.f_type & FS_PERSISTENT_ACLS)
	139	return allow_ntsec;
	140
	141	return 0;
	142	}
	143
e9a17296	144	void register_9x_service(void)
	145	{
	146	HINSTANCE kerneldll;
	147	DWORD (*RegisterServiceProcess)(DWORD, DWORD);
	148
	149	/* The service register mechanism in 9x/Me is pretty different from
	150	* NT/2K/XP. In NT/2K/XP we're using a special service starter
	151	* application to register and control sshd as service. This method
	152	* doesn't play nicely with 9x/Me. For that reason we register here
	153	* as service when running under 9x/Me. This function is only called
	154	* by the child sshd when it's going to daemonize.
	155	*/
	156	if (is_winnt)
	157	return;
	158	if (! (kerneldll = LoadLibrary("KERNEL32.DLL")))
	159	return;
	160	if (! (RegisterServiceProcess = (DWORD (*)(DWORD, DWORD))
	161	GetProcAddress(kerneldll, "RegisterServiceProcess")))
	162	return;
	163	RegisterServiceProcess(0, 1);
	164	}
	165
3c0ef626	166	#endif /* HAVE_CYGWIN */