JehanneOS/newlib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

* cygtls.h (_cygtls): Perform minor reformatting.

Browse Source 
* winsup.h (close_all_files): Reflect argument change.
* dtable.cc (close_all_files): Ditto.
* dtable.h: Ditto.
* fhandler.h: Ditto.
* spawn.cc (spawn_guts): Move close_all_files back to its original location in
first P_OVERLAY test but use argument denoting that handles are only supposed
to be closed, not released (more work to be done here).
* syscalls.cc (close_all_files): Take an argument denoting whether to release
closed files or not.
* path.cc (symlink): Change argument names to reflect linux man page.
(symlink_worker): Ditto.  Also appropriately set ENOENT for empty strings.
This commit is contained in:
Christopher Faylor 2005-07-05 02:05:07 +00:00
parent a64b8b2dec
commit 26edeb6a7f
8 changed files with 65 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
winsup/cygwin/ChangeLog
View File

@ -1,3 +1,22 @@
2005-07-04 Christopher Faylor <cgf@timesys.com>
* cygtls.h (_cygtls): Perform minor reformatting.
* winsup.h (close_all_files): Reflect argument change.
* dtable.cc (close_all_files): Ditto.
* dtable.h: Ditto.
* fhandler.h: Ditto.
* spawn.cc (spawn_guts): Move close_all_files back to its original
location in first P_OVERLAY test but use argument denoting that handles
are only supposed to be closed, not released (more work to be done
here).
* syscalls.cc (close_all_files): Take an argument denoting whether to
release closed files or not.
* path.cc (symlink): Change argument names to reflect linux man page.
(symlink_worker): Ditto. Also appropriately set ENOENT for empty strings.
2005-07-04 Pierre Humblet <pierre.humblet@ieee.org> 2005-07-04 Pierre Humblet <pierre.humblet@ieee.org>
* cygheap.h (struct init_cygheap): Delete cygwin_regname member. * cygheap.h (struct init_cygheap): Delete cygwin_regname member.

5
winsup/cygwin/cygtls.h
View File

@ -252,10 +252,7 @@ class myfault
{ {
jmp_buf buf; jmp_buf buf;
public: public:
~myfault () __attribute__ ((always_inline)) ~myfault () __attribute__ ((always_inline)) { _my_tls.clear_fault (buf); }
{
_my_tls.clear_fault (buf);
}
inline int faulted (int myerrno = 0) __attribute__ ((always_inline)) inline int faulted (int myerrno = 0) __attribute__ ((always_inline))
{ {
return _my_tls.setup_fault (buf, myerrno); return _my_tls.setup_fault (buf, myerrno);

2
winsup/cygwin/dtable.h
View File

@ -84,7 +84,7 @@ public:
fhandler_base **add_archetype (); fhandler_base **add_archetype ();
void delete_archetype (fhandler_base *); void delete_archetype (fhandler_base *);
friend void dtable_init (); friend void dtable_init ();
friend void __stdcall close_all_files (); friend void __stdcall close_all_files (bool);
friend class cygheap_fdmanip; friend class cygheap_fdmanip;
friend class cygheap_fdget; friend class cygheap_fdget;
friend class cygheap_fdnew; friend class cygheap_fdnew;

2
winsup/cygwin/fhandler.h
View File

@ -82,7 +82,7 @@ enum query_state {
class fhandler_base class fhandler_base
{ {
friend class dtable; friend class dtable;
friend void close_all_files (); friend void close_all_files (bool);
struct status_flags struct status_flags
{ {

76
winsup/cygwin/path.cc
View File

@ -2615,48 +2615,48 @@ set_symlink_ea (const char* frompath, const char* topath)
bool allow_winsymlinks = true; bool allow_winsymlinks = true;
extern "C" int extern "C" int
symlink (const char *topath, const char *frompath) symlink (const char *oldpath, const char *newpath)
{ {
return symlink_worker (topath, frompath, allow_winsymlinks, false); return symlink_worker (oldpath, newpath, allow_winsymlinks, false);
} }
int int
symlink_worker (const char *topath, const char *frompath, bool use_winsym, symlink_worker (const char *oldpath, const char *newpath, bool use_winsym,
bool isdevice) bool isdevice)
{ {
HANDLE h; HANDLE h;
int res = -1; int res = -1;
path_conv win32_path, win32_topath; path_conv win32_path, win32_oldpath;
char from[CYG_MAX_PATH + 5]; char from[CYG_MAX_PATH + 5];
char cwd[CYG_MAX_PATH], *cp = NULL, c = 0; char cwd[CYG_MAX_PATH], *cp = NULL, c = 0;
char w32topath[CYG_MAX_PATH]; char w32oldpath[CYG_MAX_PATH];
char reltopath[CYG_MAX_PATH] = { 0 }; char reloldpath[CYG_MAX_PATH] = { 0 };
DWORD written; DWORD written;
SECURITY_ATTRIBUTES sa = sec_none_nih; SECURITY_ATTRIBUTES sa = sec_none_nih;
security_descriptor sd; security_descriptor sd;
/* POSIX says that empty 'frompath' is invalid input while empty /* POSIX says that empty 'newpath' is invalid input while empty
'topath' is valid -- it's symlink resolver job to verify if 'oldpath' is valid -- it's symlink resolver job to verify if
symlink contents point to existing filesystem object */ symlink contents point to existing filesystem object */
myfault efault; myfault efault;
if (efault.faulted (EFAULT)) if (efault.faulted (EFAULT))
goto done; goto done;
if (!*topath || !*frompath) if (!*oldpath || !*newpath)
{ {
set_errno (EINVAL); set_errno (ENOENT);
goto done; goto done;
} }
if (strlen (topath) >= CYG_MAX_PATH) if (strlen (oldpath) >= CYG_MAX_PATH)
{ {
set_errno (ENAMETOOLONG); set_errno (ENAMETOOLONG);
goto done; goto done;
} }
win32_path.check (frompath, PC_SYM_NOFOLLOW); win32_path.check (newpath, PC_SYM_NOFOLLOW);
if (use_winsym && !win32_path.exists ()) if (use_winsym && !win32_path.exists ())
{ {
strcpy (from, frompath); strcpy (from, newpath);
strcat (from, ".lnk"); strcat (from, ".lnk");
win32_path.check (from, PC_SYM_NOFOLLOW); win32_path.check (from, PC_SYM_NOFOLLOW);
} }
@ -2667,7 +2667,7 @@ symlink_worker (const char *topath, const char *frompath, bool use_winsym,
goto done; goto done;
} }
syscall_printf ("symlink (%s, %s)", topath, win32_path.get_win32 ()); syscall_printf ("symlink (%s, %s)", oldpath, win32_path.get_win32 ());
if (win32_path.is_auto_device ()) if (win32_path.is_auto_device ())
{ {
@ -2680,13 +2680,13 @@ symlink_worker (const char *topath, const char *frompath, bool use_winsym,
create_how = CREATE_NEW; create_how = CREATE_NEW;
else if (isdevice) else if (isdevice)
{ {
strcpy (w32topath, topath); strcpy (w32oldpath, oldpath);
create_how = CREATE_ALWAYS; create_how = CREATE_ALWAYS;
(void) SetFileAttributes (win32_path, FILE_ATTRIBUTE_NORMAL); (void) SetFileAttributes (win32_path, FILE_ATTRIBUTE_NORMAL);
} }
else else
{ {
if (!isabspath (topath)) if (!isabspath (oldpath))
{ {
getcwd (cwd, CYG_MAX_PATH); getcwd (cwd, CYG_MAX_PATH);
if ((cp = strrchr (from, '/')) || (cp = strrchr (from, '\\'))) if ((cp = strrchr (from, '/')) || (cp = strrchr (from, '\\')))
@ -2695,23 +2695,23 @@ symlink_worker (const char *topath, const char *frompath, bool use_winsym,
*cp = '\0'; *cp = '\0';
chdir (from); chdir (from);
} }
backslashify (topath, reltopath, 0); backslashify (oldpath, reloldpath, 0);
/* Creating an ITEMIDLIST requires an absolute path. So if we /* Creating an ITEMIDLIST requires an absolute path. So if we
create a shortcut file, we create relative and absolute Win32 create a shortcut file, we create relative and absolute Win32
paths, the first for the relpath field and the latter for the paths, the first for the relpath field and the latter for the
ITEMIDLIST field. */ ITEMIDLIST field. */
if (GetFileAttributes (reltopath) == INVALID_FILE_ATTRIBUTES) if (GetFileAttributes (reloldpath) == INVALID_FILE_ATTRIBUTES)
{ {
win32_topath.check (topath, PC_SYM_NOFOLLOW); win32_oldpath.check (oldpath, PC_SYM_NOFOLLOW);
if (win32_topath.error != ENOENT) if (win32_oldpath.error != ENOENT)
strcpy (use_winsym ? reltopath : w32topath, win32_topath); strcpy (use_winsym ? reloldpath : w32oldpath, win32_oldpath);
} }
else if (!use_winsym) else if (!use_winsym)
strcpy (w32topath, reltopath); strcpy (w32oldpath, reloldpath);
if (use_winsym) if (use_winsym)
{ {
win32_topath.check (topath, PC_SYM_NOFOLLOW); win32_oldpath.check (oldpath, PC_SYM_NOFOLLOW);
strcpy (w32topath, win32_topath); strcpy (w32oldpath, win32_oldpath);
} }
if (cp) if (cp)
{ {
@ -2721,8 +2721,8 @@ symlink_worker (const char *topath, const char *frompath, bool use_winsym,
} }
else else
{ {
win32_topath.check (topath, PC_SYM_NOFOLLOW); win32_oldpath.check (oldpath, PC_SYM_NOFOLLOW);
strcpy (w32topath, win32_topath); strcpy (w32oldpath, win32_oldpath);
} }
create_how = CREATE_NEW; create_how = CREATE_NEW;
} }
@ -2761,7 +2761,7 @@ symlink_worker (const char *topath, const char *frompath, bool use_winsym,
hres = SHGetDesktopFolder (&psl); hres = SHGetDesktopFolder (&psl);
if (SUCCEEDED (hres)) if (SUCCEEDED (hres))
{ {
MultiByteToWideChar (CP_ACP, 0, w32topath, -1, wc_path, MultiByteToWideChar (CP_ACP, 0, w32oldpath, -1, wc_path,
CYG_MAX_PATH); CYG_MAX_PATH);
hres = psl->ParseDisplayName (NULL, NULL, wc_path, NULL, hres = psl->ParseDisplayName (NULL, NULL, wc_path, NULL,
&pidl, NULL); &pidl, NULL);
@ -2780,19 +2780,19 @@ symlink_worker (const char *topath, const char *frompath, bool use_winsym,
psl->Release (); psl->Release ();
} }
/* Creating a description */ /* Creating a description */
*(unsigned short *)cp = len = strlen (topath); *(unsigned short *)cp = len = strlen (oldpath);
memcpy (cp += 2, topath, len); memcpy (cp += 2, oldpath, len);
cp += len; cp += len;
/* Creating a relpath */ /* Creating a relpath */
if (reltopath[0]) if (reloldpath[0])
{ {
*(unsigned short *)cp = len = strlen (reltopath); *(unsigned short *)cp = len = strlen (reloldpath);
memcpy (cp += 2, reltopath, len); memcpy (cp += 2, reloldpath, len);
} }
else else
{ {
*(unsigned short *)cp = len = strlen (w32topath); *(unsigned short *)cp = len = strlen (w32oldpath);
memcpy (cp += 2, w32topath, len); memcpy (cp += 2, w32oldpath, len);
} }
cp += len; cp += len;
success = WriteFile (h, buf, cp - buf, &written, NULL) success = WriteFile (h, buf, cp - buf, &written, NULL)
@ -2803,7 +2803,7 @@ symlink_worker (const char *topath, const char *frompath, bool use_winsym,
/* This is the old technique creating a symlink. */ /* This is the old technique creating a symlink. */
char buf[sizeof (SYMLINK_COOKIE) + CYG_MAX_PATH + 10]; char buf[sizeof (SYMLINK_COOKIE) + CYG_MAX_PATH + 10];
__small_sprintf (buf, "%s%s", SYMLINK_COOKIE, topath); __small_sprintf (buf, "%s%s", SYMLINK_COOKIE, oldpath);
DWORD len = strlen (buf) + 1; DWORD len = strlen (buf) + 1;
/* Note that the terminating nul is written. */ /* Note that the terminating nul is written. */
@ -2828,7 +2828,7 @@ symlink_worker (const char *topath, const char *frompath, bool use_winsym,
SetFileAttributes (win32_path, attr); SetFileAttributes (win32_path, attr);
if (!isdevice && win32_path.fs_has_ea ()) if (!isdevice && win32_path.fs_has_ea ())
set_symlink_ea (win32_path, topath); set_symlink_ea (win32_path, oldpath);
res = 0; res = 0;
} }
else else
@ -2840,8 +2840,8 @@ symlink_worker (const char *topath, const char *frompath, bool use_winsym,
} }
done: done:
syscall_printf ("%d = symlink_worker (%s, %s, %d, %d)", res, topath, syscall_printf ("%d = symlink_worker (%s, %s, %d, %d)", res, oldpath,
frompath, use_winsym, isdevice); newpath, use_winsym, isdevice);
return res; return res;
} }

2
winsup/cygwin/spawn.cc
View File

@ -800,6 +800,7 @@ spawn_guts (const char * prog_arg, const char *const *argv,
strace.execing = 1; strace.execing = 1;
myself.hProcess = hExeced = pi.hProcess; myself.hProcess = hExeced = pi.hProcess;
strcpy (myself->progname, real_path); // FIXME: race? strcpy (myself->progname, real_path); // FIXME: race?
close_all_files (true);
sigproc_printf ("new process name %s", myself->progname); sigproc_printf ("new process name %s", myself->progname);
/* If wr_proc_pipe doesn't exist then this process was not started by a cygwin /* If wr_proc_pipe doesn't exist then this process was not started by a cygwin
process. So, we need to wait around until the process we've just "execed" process. So, we need to wait around until the process we've just "execed"
@ -869,7 +870,6 @@ spawn_guts (const char * prog_arg, const char *const *argv,
switch (mode) switch (mode)
{ {
case _P_OVERLAY: case _P_OVERLAY:
close_all_files ();
if (!synced) if (!synced)
/* let myself.exit handle this */; /* let myself.exit handle this */;
else if (myself->wr_proc_pipe) else if (myself->wr_proc_pipe)

5
winsup/cygwin/syscalls.cc
View File

@ -94,7 +94,7 @@ static int __stdcall stat_worker (const char *name, struct __stat64 *buf,
ensure we don't leave any such files lying around. */ ensure we don't leave any such files lying around. */
void __stdcall void __stdcall
close_all_files () close_all_files (bool norelease)
{ {
cygheap->fdtab.lock (); cygheap->fdtab.lock ();
@ -106,7 +106,8 @@ close_all_files ()
debug_printf ("closing fd %d", i); debug_printf ("closing fd %d", i);
#endif #endif
fh->close (); fh->close ();
cygheap->fdtab.release (i); if (!norelease)
cygheap->fdtab.release (i);
} }
if (cygheap->ctty) if (cygheap->ctty)

2
winsup/cygwin/winsup.h
View File

@ -223,7 +223,7 @@ void uinfo_init (void);
void events_init (void); void events_init (void);
void events_terminate (void); void events_terminate (void);
void __stdcall close_all_files (); void __stdcall close_all_files (bool = false);
/* Globals that handle initialization of winsock in a child process. */ /* Globals that handle initialization of winsock in a child process. */
extern HANDLE wsock32_handle; extern HANDLE wsock32_handle;