if not found. This data resides in the shared data area (allowing
tasks to store whatever they want here) so it's for informational
purposes only. */
- uid_t uid; /* User ID */
- gid_t gid; /* Group ID */
- pid_t pgid; /* Process group ID */
- pid_t sid; /* Session ID */
- int ctty; /* Control tty */
+ uid_t uid; /* User ID */
+ gid_t gid; /* Group ID */
+ pid_t pgid; /* Process group ID */
+ pid_t sid; /* Session ID */
+ int ctty; /* Control tty */
mode_t umask;
char username[MAX_USER_NAME]; /* user's name */
/* Extendend user information.
The information is derived from the internal_getlogin call
when on a NT system. */
- PSID psid; /* user's SID */
- char sidbuf[MAX_SID_LEN]; /* buffer for user's SID */
+ int use_psid; /* TRUE if psid contains valid data */
+ char psid[MAX_SID_LEN]; /* buffer for user's SID */
char logsrv[MAX_HOST_NAME]; /* Logon server, may be FQDN */
char domain[MAX_COMPUTERNAME_LENGTH+1]; /* Logon domain of the user */
/* select.cc
- Copyright 1996, 1997, 1998, 1999, 2000 Cygnus Solutions.
+ Copyright 1996, 1997, 1998, 1999, 2000 Red Hat, Inc.
Written by Christopher Faylor of Cygnus Solutions
cgf@cygnus.com
#define UNIX_FD_ZERO(p, n) \
bzero ((caddr_t)(p), sizeof_fd_set ((n)))
-#define allocfd_set(n) ((fd_set *) alloca (sizeof_fd_set (n)))
+#define allocfd_set(n) ((fd_set *) memset (alloca (sizeof_fd_set (n)), 0, sizeof_fd_set (n)))
#define copyfd_set(to, from, n) memcpy (to, from, sizeof_fd_set (n));
/* Make a fhandler_foo::ready_for_ready method.
*/
extern "C"
int
-cygwin_select (int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
- struct timeval *to)
+cygwin_select (int maxfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
+ struct timeval *to)
{
select_stuff sel;
- fd_set *dummy_readfds = allocfd_set (n);
- fd_set *dummy_writefds = allocfd_set (n);
- fd_set *dummy_exceptfds = allocfd_set (n);
+ fd_set *dummy_readfds = allocfd_set (maxfds);
+ fd_set *dummy_writefds = allocfd_set (maxfds);
+ fd_set *dummy_exceptfds = allocfd_set (maxfds);
sigframe thisframe (mainthread, 0);
#if 0
}
#endif
- select_printf ("%d, %p, %p, %p, %p", n, readfds, writefds, exceptfds, to);
+ select_printf ("%d, %p, %p, %p, %p", maxfds, readfds, writefds, exceptfds, to);
if (!readfds)
- {
- UNIX_FD_ZERO (dummy_readfds, n);
- readfds = dummy_readfds;
- }
+ readfds = dummy_readfds;
if (!writefds)
- {
- UNIX_FD_ZERO (dummy_writefds, n);
- writefds = dummy_writefds;
- }
+ writefds = dummy_writefds;
if (!exceptfds)
- {
- UNIX_FD_ZERO (dummy_exceptfds, n);
- exceptfds = dummy_exceptfds;
- }
+ exceptfds = dummy_exceptfds;
- for (int i = 0; i < n; i++)
+ for (int i = 0; i < maxfds; i++)
if (!sel.test_and_set (i, readfds, writefds, exceptfds))
{
select_printf ("aborting due to test_and_set error");
return 0;
}
- /* If one of the selected fds is "always ready" just poll everything and return
- the result. There is no need to wait. */
- if (sel.always_ready || ms == 0)
- {
- UNIX_FD_ZERO (readfds, n);
- UNIX_FD_ZERO (writefds, n);
- UNIX_FD_ZERO (exceptfds, n);
- return sel.poll (readfds, writefds, exceptfds);
- }
-
- /* Wait for an fd to come alive */
- return sel.wait (readfds, writefds, exceptfds, ms);
+ /* Allocate some fd_set structures using the number of fds as a guide. */
+ fd_set *r = allocfd_set (maxfds);
+ fd_set *w = allocfd_set (maxfds);
+ fd_set *e = allocfd_set (maxfds);
+
+ /* Don't bother waiting if one of the selected fds is "always ready". */
+ if ((!sel.always_ready || ms != 0) && sel.wait (r, w, e, ms))
+ return -1; /* some kind of error */
+
+ copyfd_set (readfds, r, maxfds);
+ copyfd_set (writefds, w, maxfds);
+ copyfd_set (exceptfds, e, maxfds);
+ return sel.poll (readfds, writefds, exceptfds);
}
/* Cleanup */
continue;
}
- int n = m - 1;
DWORD start_time = GetTickCount (); /* Record the current time for later use. */
- /* Allocate some fd_set structures using the number of fds as a guide. */
- fd_set *r = allocfd_set (n);
- fd_set *w = allocfd_set (n);
- fd_set *e = allocfd_set (n);
- UNIX_FD_ZERO (r, n);
- UNIX_FD_ZERO (w, n);
- UNIX_FD_ZERO (e, n);
- debug_printf ("n %d, ms %u", n, ms);
+ debug_printf ("m %d, ms %u", m, ms);
for (;;)
{
if (!windows_used)
if (s->saw_error)
return -1; /* Somebody detected an error */
else if ((((wait_ret >= m && s->windows_handle) || s->h == w4[wait_ret])) &&
- s->verify (s, r, w, e))
+ s->verify (s, readfds, writefds, exceptfds))
gotone = TRUE;
select_printf ("gotone %d", gotone);
}
out:
- copyfd_set (readfds, r, n);
- copyfd_set (writefds, w, n);
- copyfd_set (exceptfds, e, n);
-
- return poll (readfds, writefds, exceptfds);
+ select_printf ("returning 0");
+ return 0;
}
static int
else if (!GetTokenInformation (ptok, TokenUser, (LPVOID) &tu,
sizeof tu, &siz))
debug_printf ("GetTokenInformation(): %E");
- else if (!(ret = CopySid (MAX_SID_LEN, (PSID) pi->sidbuf,
+ else if (!(ret = CopySid (MAX_SID_LEN, (PSID) pi->psid,
((TOKEN_USER *) &tu)->User.Sid)))
debug_printf ("Couldn't retrieve SID from access token!");
/* Close token only if it's a result from OpenProcessToken(). */
{
/* Concat DOMAIN\USERNAME for the next lookup */
strcat (strcat (strcpy (buf, pi->domain), "\\"), pi->username);
- if (!(ret = lookup_name (buf, NULL, (PSID) pi->sidbuf)))
+ if (!(ret = lookup_name (buf, NULL, (PSID) pi->psid)))
debug_printf ("Couldn't retrieve SID locally!");
}
/* If that failes, too, as a last resort try to get the SID from
the logon server. */
if (!ret && !(ret = lookup_name(pi->username, pi->logsrv,
- (PSID)pi->sidbuf)))
+ (PSID)pi->psid)))
debug_printf ("Couldn't retrieve SID from '%s'!", pi->logsrv);
/* If we have a SID, try to get the corresponding Cygwin user name
char psidbuf[MAX_SID_LEN];
PSID psid = (PSID) psidbuf;
- pi->psid = (PSID) pi->sidbuf;
+ pi->use_psid = 1;
if (!strcasematch (pi->username, "SYSTEM")
&& pi->domain[0] && pi->logsrv[0])
{
OSDN Git Service
