+Wed Aug 23 10:51:57 2000 Christopher Faylor <cgf@cygnus.com>
+
+ * include/sys/cygwin.h: Protect class definitions.
+
Tue Aug 22 13:57:36 2000 Christopher Faylor <cgf@cygnus.com>
* path.cc (symlink_info::check): Clear error on each iteration of
// should be blocked.
if (mypid)
- set_myself ((pid_t) mypid);
+ set_myself ((pid_t) mypid, NULL);
(void) SetErrorMode (SEM_FAILCRITICALERRORS);
DuplicateHandle (hMainProc, GetCurrentThread (), hMainProc,
&hMainThread, 0, FALSE, DUPLICATE_SAME_ACCESS);
+ HANDLE h;
GetStartupInfo (&si);
if (si.cbReserved2 >= EXEC_MAGIC_SIZE &&
memcmp (ciresrv->zero, zeros, sizeof (zeros)) == 0)
case PROC_EXEC:
case PROC_SPAWN:
info = si.lpReserved2 + ciresrv->cb;
+ if (child_proc_info->myself_pinfo &&
+ DuplicateHandle (hMainProc, child_proc_info->myself_pinfo,
+ hMainProc, &h, 0, 0,
+ DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE))
+ {
+ set_myself (mypid, h);
+ mypid = 0;
+ }
break;
case PROC_FORK:
case PROC_FORK1:
SIZEOF_PER_PROCESS) to make sure you remember to make the adjustment.
*/
+#ifdef __cplusplus
class ResourceLocks;
class MTinterface;
+#endif
struct per_process
{
This is done once when the dll is first loaded. */
void __stdcall
-set_myself (pid_t pid)
+set_myself (pid_t pid, HANDLE h)
{
DWORD winpid = GetCurrentProcessId ();
if (pid == 1)
pid = cygwin_pid (winpid);
- myself.init (pid, 1);
+ myself.init (pid, 1, h);
myself->dwProcessId = winpid;
myself->process_state |= PID_IN_USE;
myself->start_time = time (NULL); /* Register our starting time. */
pid_t myself_cyg_pid = cygwin_pid (myself->dwProcessId);
- if (pid != myself_cyg_pid)
+ if (pid != myself_cyg_pid && parent_alive)
myself_identity.init (myself_cyg_pid, PID_EXECED);
char buf[30];
{
/* Invent our own pid. */
- set_myself (1);
+ set_myself (1, NULL);
myself->ppid = 1;
myself->pgid = myself->sid = myself->pid;
myself->ctty = -1;
}
void
-pinfo::init (pid_t n, DWORD create)
+pinfo::init (pid_t n, DWORD create, HANDLE in_h)
{
if (n == myself->pid)
{
else
mapsize = sizeof (_pinfo);
- if (!create)
+ if (in_h)
+ {
+ h = in_h;
+ created = 0;
+ }
+ else if (!create)
{
/* CGF FIXME -- deal with inheritance after an exec */
h = OpenFileMappingA (FILE_MAP_READ | FILE_MAP_WRITE, FALSE, mapname);
}
else
{
- h = CreateFileMapping ((HANDLE) 0xffffffff, &sec_none_nih,
+ h = CreateFileMapping ((HANDLE) 0xffffffff, &sec_all_nih,
PAGE_READWRITE, 0, mapsize, mapname);
created = h && GetLastError () != ERROR_ALREADY_EXISTS;
}
return;
}
+ ProtectHandle1 (h, pinfo_shared_handle);
child = (_pinfo *) MapViewOfFile (h, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
if (child->process_state & PID_EXECED)
{
pid_t realpid = child->pid;
+ debug_printf ("execed process windows pid %d, cygwin pid %d", n, realpid);
release ();
if (realpid == n)
api_fatal ("retrieval of execed process info for pid %d failed due to recursion.", n);
_pinfo *child;
int destroy;
public:
- void init (pid_t n, DWORD create = 0);
+ void init (pid_t n, DWORD create = 0, HANDLE h = NULL);
pinfo () {}
pinfo (_pinfo *x): child (x) {}
pinfo (pid_t n) {init (n);}
if (h)
{
UnmapViewOfFile (child);
- CloseHandle (h);
+ ForceCloseHandle1 (h, pinfo_shared_handle);
h = NULL;
}
}
int operator == (char *x) const {return (char *) child == x;}
_pinfo *operator * () const {return child;}
operator _pinfo * () const {return child;}
+ // operator bool () const {return (int) h;}
void remember () {destroy = 0; proc_subproc (PROC_ADDCHILD, (DWORD) this);}
+ HANDLE shared_handle () {return h;}
};
#define ISSTATE(p, f) (!!((p)->process_state & f))
{
return (pid_t) (os_being_run == winNT) ? pid : -(int) pid;
}
-void __stdcall pinfo_init (PBYTE);
+
+void __stdcall pinfo_init (BYTE *);
+void __stdcall set_myself (pid_t pid, HANDLE h = NULL);
extern pinfo myself;
HANDLE shared_h;
HANDLE console_h;
HANDLE parent_alive; // handle of thread used to track children
+ HANDLE myself_pinfo;
};
class child_info_fork: public child_info
}
init_child_info (chtype, ciresrv, (mode == _P_OVERLAY) ? myself->pid : 1, spr);
+ if (mode != _P_OVERLAY ||
+ !DuplicateHandle (hMainProc, myself.shared_handle (), hMainProc, &ciresrv->myself_pinfo, 0,
+ TRUE, DUPLICATE_SAME_ACCESS))
+ ciresrv->myself_pinfo = NULL;
LPBYTE resrv = si.lpReserved2 + sizeof *ciresrv;
# undef ciresrv
int __stdcall lock_pinfo_for_update (DWORD timeout);
#endif
void unlock_pinfo (void);
-void _stdcall set_myself (pid_t pid);
/* Retrieve a security descriptor that allows all access */
SECURITY_DESCRIPTOR *__stdcall get_null_sd (void);