733 lines
16 KiB
C++
733 lines
16 KiB
C++
/* external.cc: Interface to Cygwin internals from external programs.
|
|
|
|
Written by Christopher Faylor <cgf@cygnus.com>
|
|
|
|
This file is part of Cygwin.
|
|
|
|
This software is a copyrighted work licensed under the terms of the
|
|
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
|
|
details. */
|
|
|
|
#include "winsup.h"
|
|
#include "sigproc.h"
|
|
#include "pinfo.h"
|
|
#include "shared_info.h"
|
|
#include "cygwin_version.h"
|
|
#include "cygerrno.h"
|
|
#include "path.h"
|
|
#include "fhandler.h"
|
|
#include "dtable.h"
|
|
#include "cygheap.h"
|
|
#include "heap.h"
|
|
#include "cygtls.h"
|
|
#include "child_info.h"
|
|
#include "environ.h"
|
|
#include "cygserver_setpwd.h"
|
|
#include "pwdgrp.h"
|
|
#include "exception.h"
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <wchar.h>
|
|
#include <iptypes.h>
|
|
|
|
child_info *get_cygwin_startup_info ();
|
|
static void exit_process (UINT, bool) __attribute__((noreturn));
|
|
|
|
static winpids pids;
|
|
|
|
static external_pinfo *
|
|
fillout_pinfo (pid_t pid, int winpid)
|
|
{
|
|
BOOL nextpid;
|
|
static external_pinfo ep;
|
|
static char ep_progname_long_buf[NT_MAX_PATH];
|
|
|
|
if ((nextpid = !!(pid & CW_NEXTPID)))
|
|
pid ^= CW_NEXTPID;
|
|
|
|
|
|
static unsigned int i;
|
|
if (!pids.npids || !nextpid)
|
|
{
|
|
pids.set (winpid);
|
|
i = 0;
|
|
}
|
|
|
|
if (!pid)
|
|
i = 0;
|
|
|
|
memset (&ep, 0, sizeof ep);
|
|
while (i < pids.npids)
|
|
{
|
|
DWORD thispid = pids.winpid (i);
|
|
_pinfo *p = pids[i];
|
|
i++;
|
|
|
|
/* Native Windows process not started from Cygwin have no procinfo
|
|
attached. They don't have a real Cygwin PID either. We fake a
|
|
Cygwin PID beyond MAX_PID. */
|
|
if (!p)
|
|
{
|
|
if (!nextpid && thispid + MAX_PID != (DWORD) pid)
|
|
continue;
|
|
ep.pid = thispid + MAX_PID;
|
|
ep.dwProcessId = thispid;
|
|
ep.process_state = PID_IN_USE;
|
|
ep.ctty = -1;
|
|
break;
|
|
}
|
|
else if (nextpid || p->pid == pid)
|
|
{
|
|
ep.ctty = (p->ctty < 0 || iscons_dev (p->ctty))
|
|
? p->ctty : device::minor (p->ctty);
|
|
ep.pid = p->pid;
|
|
ep.ppid = p->ppid;
|
|
ep.dwProcessId = p->dwProcessId;
|
|
ep.uid = p->uid;
|
|
ep.gid = p->gid;
|
|
ep.pgid = p->pgid;
|
|
ep.sid = p->sid;
|
|
ep.umask = 0;
|
|
ep.start_time = p->start_time;
|
|
ep.rusage_self = p->rusage_self;
|
|
ep.rusage_children = p->rusage_children;
|
|
ep.progname[0] = '\0';
|
|
sys_wcstombs(ep.progname, MAX_PATH, p->progname);
|
|
ep.strace_mask = 0;
|
|
ep.version = EXTERNAL_PINFO_VERSION;
|
|
|
|
ep.process_state = p->process_state;
|
|
|
|
ep.uid32 = p->uid;
|
|
ep.gid32 = p->gid;
|
|
|
|
ep.progname_long = ep_progname_long_buf;
|
|
mount_table->conv_to_posix_path (p->progname, ep.progname_long, 0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!ep.pid)
|
|
{
|
|
i = 0;
|
|
pids.reset ();
|
|
return NULL;
|
|
}
|
|
return &ep;
|
|
}
|
|
|
|
static inline uintptr_t
|
|
get_cygdrive_info (char *user, char *system, char *user_flags,
|
|
char *system_flags)
|
|
{
|
|
int res = mount_table->get_cygdrive_info (user, system, user_flags,
|
|
system_flags);
|
|
return (res == ERROR_SUCCESS) ? 1 : 0;
|
|
}
|
|
|
|
static bool
|
|
check_ntsec (const char *filename)
|
|
{
|
|
if (!filename)
|
|
return true;
|
|
path_conv pc (filename);
|
|
return pc.has_acls ();
|
|
}
|
|
|
|
/* Copy cygwin environment variables to the Windows environment. */
|
|
static PWCHAR
|
|
create_winenv (const char * const *env)
|
|
{
|
|
int unused_envc;
|
|
PWCHAR envblock = NULL;
|
|
char **envp = build_env (env ?: cur_environ (), envblock, unused_envc, false,
|
|
NULL);
|
|
PWCHAR p = envblock;
|
|
|
|
if (envp)
|
|
{
|
|
for (char **e = envp; *e; e++)
|
|
cfree (*e);
|
|
cfree (envp);
|
|
}
|
|
/* If we got an env block, just return pointer to win env. */
|
|
if (env)
|
|
return envblock;
|
|
/* Otherwise sync win env of current process with its posix env. */
|
|
if (!p)
|
|
return NULL;
|
|
while (*p)
|
|
{
|
|
PWCHAR eq = wcschr (p, L'=');
|
|
if (eq)
|
|
{
|
|
*eq = L'\0';
|
|
SetEnvironmentVariableW (p, ++eq);
|
|
p = eq;
|
|
}
|
|
p = wcschr (p, L'\0') + 1;
|
|
}
|
|
free (envblock);
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Cygwin-specific wrapper for win32 ExitProcess and TerminateProcess.
|
|
* It ensures that the correct exit code, derived from the specified
|
|
* status value, will be made available to this process's parent (if
|
|
* that parent is also a cygwin process). If useTerminateProcess is
|
|
* true, then TerminateProcess(GetCurrentProcess(),...) will be used;
|
|
* otherwise, ExitProcess(...) is called.
|
|
*
|
|
* Used by startup code for cygwin processes which is linked statically
|
|
* into applications, and is not part of the cygwin DLL -- which is why
|
|
* this interface is exposed. "Normal" programs should use ANSI exit(),
|
|
* ANSI abort(), or POSIX _exit(), rather than this function -- because
|
|
* calling ExitProcess or TerminateProcess, even through this wrapper,
|
|
* skips much of the cygwin process cleanup code.
|
|
*/
|
|
static void
|
|
exit_process (UINT status, bool useTerminateProcess)
|
|
{
|
|
pid_t pid = getpid ();
|
|
external_pinfo *ep = fillout_pinfo (pid, 1);
|
|
DWORD dwpid = ep ? ep->dwProcessId : pid;
|
|
pinfo p (pid, PID_MAP_RW);
|
|
if (ep)
|
|
pid = ep->pid;
|
|
if ((dwpid == GetCurrentProcessId()) && (p->pid == pid))
|
|
p.set_exit_code ((DWORD)status);
|
|
if (useTerminateProcess)
|
|
TerminateProcess (GetCurrentProcess(), status);
|
|
/* avoid 'else' clause to silence warning */
|
|
ExitProcess (status);
|
|
}
|
|
|
|
|
|
extern "C" uintptr_t
|
|
cygwin_internal (cygwin_getinfo_types t, ...)
|
|
{
|
|
va_list arg;
|
|
uintptr_t res = (uintptr_t) -1;
|
|
va_start (arg, t);
|
|
|
|
switch (t)
|
|
{
|
|
case CW_LOCK_PINFO:
|
|
res = 1;
|
|
break;
|
|
|
|
case CW_UNLOCK_PINFO:
|
|
res = 1;
|
|
break;
|
|
|
|
case CW_GETTHREADNAME:
|
|
res = (uintptr_t) cygthread::name (va_arg (arg, DWORD));
|
|
break;
|
|
|
|
case CW_SETTHREADNAME:
|
|
{
|
|
set_errno (ENOSYS);
|
|
res = 0;
|
|
}
|
|
break;
|
|
|
|
case CW_GETPINFO:
|
|
res = (uintptr_t) fillout_pinfo (va_arg (arg, DWORD), 0);
|
|
break;
|
|
|
|
case CW_GETVERSIONINFO:
|
|
res = (uintptr_t) cygwin_version_strings;
|
|
break;
|
|
|
|
case CW_READ_V1_MOUNT_TABLES:
|
|
set_errno (ENOSYS);
|
|
res = 1;
|
|
break;
|
|
|
|
case CW_USER_DATA:
|
|
#ifdef __i386__
|
|
/* This is a kludge to work around a version of _cygwin_common_crt0
|
|
which overwrote the cxx_malloc field with the local DLL copy.
|
|
Hilarity ensues if the DLL is not loaded like while the process
|
|
is forking. */
|
|
__cygwin_user_data.cxx_malloc = &default_cygwin_cxx_malloc;
|
|
#endif
|
|
res = (uintptr_t) &__cygwin_user_data;
|
|
break;
|
|
|
|
case CW_PERFILE:
|
|
perfile_table = va_arg (arg, struct __cygwin_perfile *);
|
|
res = 0;
|
|
break;
|
|
|
|
case CW_GET_CYGDRIVE_PREFIXES:
|
|
{
|
|
char *user = va_arg (arg, char *);
|
|
char *system = va_arg (arg, char *);
|
|
res = get_cygdrive_info (user, system, NULL, NULL);
|
|
}
|
|
break;
|
|
|
|
case CW_GETPINFO_FULL:
|
|
res = (uintptr_t) fillout_pinfo (va_arg (arg, pid_t), 1);
|
|
break;
|
|
|
|
case CW_INIT_EXCEPTIONS:
|
|
/* noop */ /* init_exceptions (va_arg (arg, exception_list *)); */
|
|
res = 0;
|
|
break;
|
|
|
|
case CW_GET_CYGDRIVE_INFO:
|
|
{
|
|
char *user = va_arg (arg, char *);
|
|
char *system = va_arg (arg, char *);
|
|
char *user_flags = va_arg (arg, char *);
|
|
char *system_flags = va_arg (arg, char *);
|
|
res = get_cygdrive_info (user, system, user_flags, system_flags);
|
|
}
|
|
break;
|
|
|
|
case CW_SET_CYGWIN_REGISTRY_NAME:
|
|
case CW_GET_CYGWIN_REGISTRY_NAME:
|
|
res = 0;
|
|
break;
|
|
|
|
case CW_STRACE_TOGGLE:
|
|
{
|
|
pid_t pid = va_arg (arg, pid_t);
|
|
pinfo p (pid);
|
|
if (p)
|
|
{
|
|
sig_send (p, __SIGSTRACE);
|
|
res = 0;
|
|
}
|
|
else
|
|
{
|
|
set_errno (ESRCH);
|
|
res = (uintptr_t) -1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CW_STRACE_ACTIVE:
|
|
{
|
|
res = strace.active ();
|
|
}
|
|
break;
|
|
|
|
case CW_CYGWIN_PID_TO_WINPID:
|
|
{
|
|
pinfo p (va_arg (arg, pid_t));
|
|
res = p ? p->dwProcessId : 0;
|
|
}
|
|
break;
|
|
|
|
case CW_WINPID_TO_CYGWIN_PID:
|
|
{
|
|
DWORD winpid = va_arg (arg, DWORD);
|
|
pid_t pid = cygwin_pid (winpid);
|
|
res = pid ?: winpid + MAX_PID;
|
|
}
|
|
break;
|
|
|
|
case CW_MAX_CYGWIN_PID:
|
|
res = MAX_PID;
|
|
break;
|
|
|
|
case CW_EXTRACT_DOMAIN_AND_USER:
|
|
{
|
|
WCHAR nt_domain[MAX_DOMAIN_NAME_LEN + 1];
|
|
WCHAR nt_user[UNLEN + 1];
|
|
|
|
struct passwd *pw = va_arg (arg, struct passwd *);
|
|
char *domain = va_arg (arg, char *);
|
|
char *user = va_arg (arg, char *);
|
|
extract_nt_dom_user (pw, nt_domain, nt_user);
|
|
if (domain)
|
|
sys_wcstombs (domain, MAX_DOMAIN_NAME_LEN + 1, nt_domain);
|
|
if (user)
|
|
sys_wcstombs (user, UNLEN + 1, nt_user);
|
|
res = 0;
|
|
}
|
|
break;
|
|
case CW_CMDLINE:
|
|
{
|
|
size_t n;
|
|
pid_t pid = va_arg (arg, pid_t);
|
|
pinfo p (pid);
|
|
res = (uintptr_t) (p ? p->cmdline (n) : NULL);
|
|
}
|
|
break;
|
|
case CW_CHECK_NTSEC:
|
|
{
|
|
char *filename = va_arg (arg, char *);
|
|
res = check_ntsec (filename);
|
|
}
|
|
break;
|
|
case CW_GET_ERRNO_FROM_WINERROR:
|
|
{
|
|
int error = va_arg (arg, int);
|
|
int deferrno = va_arg (arg, int);
|
|
res = geterrno_from_win_error (error, deferrno);
|
|
}
|
|
break;
|
|
case CW_GET_POSIX_SECURITY_ATTRIBUTE:
|
|
{
|
|
path_conv dummy;
|
|
security_descriptor sd;
|
|
int attribute = va_arg (arg, int);
|
|
PSECURITY_ATTRIBUTES psa = va_arg (arg, PSECURITY_ATTRIBUTES);
|
|
void *sd_buf = va_arg (arg, void *);
|
|
DWORD sd_buf_size = va_arg (arg, DWORD);
|
|
set_security_attribute (dummy, attribute, psa, sd);
|
|
if (!psa->lpSecurityDescriptor)
|
|
res = sd.size ();
|
|
else
|
|
{
|
|
psa->lpSecurityDescriptor = sd_buf;
|
|
res = sd.copy (sd_buf, sd_buf_size);
|
|
}
|
|
}
|
|
break;
|
|
case CW_GET_SHMLBA:
|
|
{
|
|
res = wincap.allocation_granularity ();
|
|
}
|
|
break;
|
|
case CW_GET_UID_FROM_SID:
|
|
{
|
|
cygpsid psid = va_arg (arg, PSID);
|
|
res = psid.get_uid (NULL);
|
|
}
|
|
break;
|
|
case CW_GET_GID_FROM_SID:
|
|
{
|
|
cygpsid psid = va_arg (arg, PSID);
|
|
res = psid.get_gid (NULL);
|
|
}
|
|
break;
|
|
case CW_GET_BINMODE:
|
|
{
|
|
const char *path = va_arg (arg, const char *);
|
|
path_conv p (path, PC_SYM_FOLLOW | PC_NULLEMPTY);
|
|
if (p.error)
|
|
{
|
|
set_errno (p.error);
|
|
res = (unsigned long) -1;
|
|
}
|
|
else
|
|
res = p.binmode ();
|
|
}
|
|
break;
|
|
case CW_HOOK:
|
|
{
|
|
const char *name = va_arg (arg, const char *);
|
|
const void *hookfn = va_arg (arg, const void *);
|
|
WORD subsys;
|
|
res = (uintptr_t) hook_or_detect_cygwin (name, hookfn, subsys);
|
|
}
|
|
break;
|
|
case CW_ARGV:
|
|
{
|
|
child_info_spawn *ci = (child_info_spawn *) get_cygwin_startup_info ();
|
|
res = (uintptr_t) (ci ? ci->moreinfo->argv : NULL);
|
|
}
|
|
break;
|
|
case CW_ENVP:
|
|
{
|
|
child_info_spawn *ci = (child_info_spawn *) get_cygwin_startup_info ();
|
|
res = (uintptr_t) (ci ? ci->moreinfo->envp : NULL);
|
|
}
|
|
break;
|
|
case CW_DEBUG_SELF:
|
|
error_start_init (va_arg (arg, const char *));
|
|
res = try_to_debug ();
|
|
break;
|
|
case CW_SYNC_WINENV:
|
|
create_winenv (NULL);
|
|
res = 0;
|
|
break;
|
|
case CW_CYGTLS_PADSIZE:
|
|
res = CYGTLS_PADSIZE;
|
|
break;
|
|
case CW_SET_DOS_FILE_WARNING:
|
|
res = 0;
|
|
break;
|
|
case CW_SET_PRIV_KEY:
|
|
{
|
|
const char *passwd = va_arg (arg, const char *);
|
|
const char *username = va_arg (arg, const char *);
|
|
res = setlsapwd (passwd, username);
|
|
}
|
|
break;
|
|
case CW_SETERRNO:
|
|
{
|
|
const char *file = va_arg (arg, const char *);
|
|
int line = va_arg (arg, int);
|
|
seterrno(file, line);
|
|
res = 0;
|
|
}
|
|
break;
|
|
case CW_EXIT_PROCESS:
|
|
{
|
|
UINT status = va_arg (arg, UINT);
|
|
int useTerminateProcess = va_arg (arg, int);
|
|
exit_process (status, !!useTerminateProcess); /* no return */
|
|
}
|
|
case CW_SET_EXTERNAL_TOKEN:
|
|
{
|
|
HANDLE token = va_arg (arg, HANDLE);
|
|
int type = va_arg (arg, int);
|
|
set_imp_token (token, type);
|
|
res = 0;
|
|
}
|
|
break;
|
|
case CW_GET_INSTKEY:
|
|
{
|
|
PWCHAR dest = va_arg (arg, PWCHAR);
|
|
wcscpy (dest, cygheap->installation_key_buf);
|
|
res = 0;
|
|
}
|
|
break;
|
|
case CW_INT_SETLOCALE:
|
|
{
|
|
extern void internal_setlocale ();
|
|
internal_setlocale ();
|
|
res = 0;
|
|
}
|
|
break;
|
|
case CW_CVT_MNT_OPTS:
|
|
{
|
|
extern bool fstab_read_flags (char **, unsigned &, bool);
|
|
char **option_string = va_arg (arg, char **);
|
|
if (!option_string || !*option_string)
|
|
set_errno (EINVAL);
|
|
else
|
|
{
|
|
unsigned *pflags = va_arg (arg, unsigned *);
|
|
unsigned flags = pflags ? *pflags : 0;
|
|
if (fstab_read_flags (option_string, flags, true))
|
|
{
|
|
if (pflags)
|
|
*pflags = flags;
|
|
res = 0;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case CW_LST_MNT_OPTS:
|
|
{
|
|
extern char *fstab_list_flags ();
|
|
char **option_string = va_arg (arg, char **);
|
|
if (!option_string)
|
|
set_errno (EINVAL);
|
|
else
|
|
{
|
|
*option_string = fstab_list_flags ();
|
|
if (*option_string)
|
|
res = 0;
|
|
}
|
|
}
|
|
break;
|
|
case CW_STRERROR:
|
|
{
|
|
int err = va_arg (arg, int);
|
|
res = (uintptr_t) strerror (err);
|
|
}
|
|
break;
|
|
|
|
case CW_CVT_ENV_TO_WINENV:
|
|
{
|
|
char **posix_env = va_arg (arg, char **);
|
|
res = (uintptr_t) create_winenv (posix_env);
|
|
}
|
|
break;
|
|
|
|
case CW_ALLOC_DRIVE_MAP:
|
|
{
|
|
dos_drive_mappings *ddm = new dos_drive_mappings ();
|
|
res = (uintptr_t) ddm;
|
|
}
|
|
break;
|
|
|
|
case CW_MAP_DRIVE_MAP:
|
|
{
|
|
dos_drive_mappings *ddm = va_arg (arg, dos_drive_mappings *);
|
|
wchar_t *pathbuf = va_arg (arg, wchar_t *);
|
|
if (ddm && pathbuf)
|
|
res = (uintptr_t) ddm->fixup_if_match (pathbuf);
|
|
}
|
|
break;
|
|
|
|
case CW_FREE_DRIVE_MAP:
|
|
{
|
|
dos_drive_mappings *ddm = va_arg (arg, dos_drive_mappings *);
|
|
if (ddm)
|
|
delete ddm;
|
|
res = 0;
|
|
}
|
|
break;
|
|
|
|
case CW_SETENT:
|
|
{
|
|
int group = va_arg (arg, int);
|
|
int enums = va_arg (arg, int);
|
|
PCWSTR enum_tdoms = va_arg (arg, PCWSTR);
|
|
if (group)
|
|
res = (uintptr_t) setgrent_filtered (enums, enum_tdoms);
|
|
else
|
|
res = (uintptr_t) setpwent_filtered (enums, enum_tdoms);
|
|
}
|
|
break;
|
|
|
|
case CW_GETENT:
|
|
{
|
|
int group = va_arg (arg, int);
|
|
void *obj = va_arg (arg, void *);
|
|
if (obj)
|
|
{
|
|
if (group)
|
|
res = (uintptr_t) getgrent_filtered (obj);
|
|
else
|
|
res = (uintptr_t) getpwent_filtered (obj);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CW_ENDENT:
|
|
{
|
|
int group = va_arg (arg, int);
|
|
void *obj = va_arg (arg, void *);
|
|
if (obj)
|
|
{
|
|
if (group)
|
|
endgrent_filtered (obj);
|
|
else
|
|
endpwent_filtered (obj);
|
|
res = 0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CW_GETNSSSEP:
|
|
res = (uintptr_t) cygheap->pg.nss_separator ();
|
|
break;
|
|
|
|
case CW_GETNSS_PWD_SRC:
|
|
res = (uintptr_t) cygheap->pg.nss_pwd_src ();
|
|
break;
|
|
|
|
case CW_GETNSS_GRP_SRC:
|
|
res = (uintptr_t) cygheap->pg.nss_grp_src ();
|
|
break;
|
|
|
|
case CW_GETPWSID:
|
|
{
|
|
int db_only = va_arg (arg, int);
|
|
PSID psid = va_arg (arg, PSID);
|
|
cygpsid sid (psid);
|
|
res = (uintptr_t) (db_only ? internal_getpwsid_from_db (sid)
|
|
: internal_getpwsid (sid));
|
|
}
|
|
break;
|
|
|
|
case CW_GETGRSID:
|
|
{
|
|
int db_only = va_arg (arg, int);
|
|
PSID psid = va_arg (arg, PSID);
|
|
cygpsid sid (psid);
|
|
res = (uintptr_t) (db_only ? internal_getgrsid_from_db (sid)
|
|
: internal_getgrsid (sid));
|
|
}
|
|
break;
|
|
|
|
case CW_CYGNAME_FROM_WINNAME:
|
|
{
|
|
/* This functionality has been added mainly for sshd. Sshd
|
|
calls getpwnam() with the username of the non-privileged
|
|
user used for privilege separation. This is usually a
|
|
fixed string "sshd". However, when using usernames from
|
|
the Windows DBs, it's no safe bet anymore if the username
|
|
is "sshd", it could also be "DOMAIN+sshd". So what we do
|
|
here is this:
|
|
|
|
Sshd calls cygwin_internal (CW_CYGNAME_FROM_WINNAME,
|
|
"sshd",
|
|
username_buffer,
|
|
sizeof username_buffer);
|
|
|
|
If this call succeeds, sshd expects the correct Cygwin
|
|
username of the unprivileged sshd account in username_buffer.
|
|
|
|
The below code checks for a Windows username matching the
|
|
incoming username, and then fetches the Cygwin username with
|
|
the matching SID. This is our username used for privsep then.
|
|
|
|
Of course, other applications with similar needs can use the
|
|
same method. */
|
|
const char *winname = va_arg (arg, const char *);
|
|
char *buffer = va_arg (arg, char *);
|
|
size_t buflen = va_arg (arg, size_t);
|
|
|
|
if (!winname || !buffer || !buflen)
|
|
break;
|
|
|
|
WCHAR name[UNLEN + 1];
|
|
sys_mbstowcs (name, sizeof name, winname);
|
|
|
|
cygsid sid;
|
|
DWORD slen = SECURITY_MAX_SID_SIZE;
|
|
WCHAR dom[DNLEN + 1];
|
|
DWORD dlen = DNLEN + 1;
|
|
SID_NAME_USE acc_type;
|
|
|
|
if (!LookupAccountNameW (NULL, name, sid, &slen, dom, &dlen,
|
|
&acc_type))
|
|
break;
|
|
|
|
struct passwd *pw = internal_getpwsid (sid);
|
|
if (!pw)
|
|
break;
|
|
|
|
buffer[0] = '\0';
|
|
strncat (buffer, pw->pw_name, buflen - 1);
|
|
res = 0;
|
|
}
|
|
break;
|
|
|
|
case CW_FIXED_ATEXIT:
|
|
res = 0;
|
|
break;
|
|
|
|
case CW_EXCEPTION_RECORD_FROM_SIGINFO_T:
|
|
{
|
|
siginfo_t *si = va_arg(arg, siginfo_t *);
|
|
EXCEPTION_RECORD *er = va_arg(arg, EXCEPTION_RECORD *);
|
|
if (si && si->si_cyg && er)
|
|
{
|
|
memcpy(er, ((cygwin_exception *)si->si_cyg)->exception_record(),
|
|
sizeof(EXCEPTION_RECORD));
|
|
res = 0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CW_CYGHEAP_PROFTHR_ALL:
|
|
{
|
|
typedef void (*func_t) (HANDLE);
|
|
extern void cygheap_profthr_all (func_t);
|
|
|
|
func_t profthr_byhandle = va_arg(arg, func_t);
|
|
cygheap_profthr_all (profthr_byhandle);
|
|
res = 0;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
set_errno (ENOSYS);
|
|
}
|
|
va_end (arg);
|
|
return res;
|
|
}
|