2000-02-18 03:38:33 +08:00
|
|
|
/* syscalls.cc: syscalls
|
|
|
|
|
|
|
|
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. */
|
|
|
|
|
2003-03-18 03:08:11 +08:00
|
|
|
#define fstat __FOOfstat__
|
2003-08-13 19:28:42 +08:00
|
|
|
#define lstat __FOOlstat__
|
2013-04-23 17:44:36 +08:00
|
|
|
//#define stat __FOOstat__
|
2002-10-21 09:00:58 +08:00
|
|
|
#define _close __FOO_close__
|
|
|
|
#define _lseek __FOO_lseek__
|
|
|
|
#define _open __FOO_open__
|
|
|
|
#define _read __FOO_read__
|
|
|
|
#define _write __FOO_write__
|
2003-03-10 05:51:00 +08:00
|
|
|
#define _open64 __FOO_open64__
|
|
|
|
#define _lseek64 __FOO_lseek64__
|
|
|
|
#define _fstat64 __FOO_fstat64__
|
2005-07-30 01:04:46 +08:00
|
|
|
#define pread __FOO_pread
|
|
|
|
#define pwrite __FOO_pwrite
|
2002-10-21 09:00:58 +08:00
|
|
|
|
2000-08-03 00:28:18 +08:00
|
|
|
#include "winsup.h"
|
2008-04-08 00:15:45 +08:00
|
|
|
#include "miscfuncs.h"
|
2000-02-18 03:38:33 +08:00
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <sys/vfs.h> /* needed for statfs */
|
2005-02-23 21:12:43 +08:00
|
|
|
#include <sys/statvfs.h> /* needed for statvfs */
|
2000-02-18 03:38:33 +08:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdio.h>
|
2012-02-08 01:15:07 +08:00
|
|
|
#include <process.h>
|
2000-02-18 03:38:33 +08:00
|
|
|
#include <utmp.h>
|
2004-12-16 01:29:01 +08:00
|
|
|
#include <utmpx.h>
|
2000-02-18 03:38:33 +08:00
|
|
|
#include <sys/uio.h>
|
2003-09-09 04:08:53 +08:00
|
|
|
#include <ctype.h>
|
2011-04-02 19:43:43 +08:00
|
|
|
#include <wctype.h>
|
2003-03-18 03:08:11 +08:00
|
|
|
#include <unistd.h>
|
2006-12-12 02:55:29 +08:00
|
|
|
#include <sys/wait.h>
|
2012-02-22 09:58:24 +08:00
|
|
|
#include <dirent.h>
|
2017-11-15 04:28:45 +08:00
|
|
|
#include <ntsecapi.h>
|
2019-02-23 01:27:38 +08:00
|
|
|
#include <iptypes.h>
|
2006-12-08 01:40:24 +08:00
|
|
|
#include "ntdll.h"
|
2003-03-18 03:08:11 +08:00
|
|
|
|
|
|
|
#undef fstat
|
2003-08-13 19:28:42 +08:00
|
|
|
#undef lstat
|
2013-04-23 17:44:36 +08:00
|
|
|
//#undef stat
|
2005-07-30 01:04:46 +08:00
|
|
|
#undef pread
|
|
|
|
#undef pwrite
|
2003-03-18 03:08:11 +08:00
|
|
|
|
2000-09-08 10:56:55 +08:00
|
|
|
#include <cygwin/version.h>
|
2000-08-22 13:10:20 +08:00
|
|
|
#include "cygerrno.h"
|
2001-03-05 14:28:25 +08:00
|
|
|
#include "perprocess.h"
|
2001-07-27 03:22:24 +08:00
|
|
|
#include "security.h"
|
2000-08-22 13:10:20 +08:00
|
|
|
#include "path.h"
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
#include "fhandler.h"
|
2000-08-12 13:35:42 +08:00
|
|
|
#include "dtable.h"
|
2000-08-22 13:10:20 +08:00
|
|
|
#include "sigproc.h"
|
2000-08-12 13:35:42 +08:00
|
|
|
#include "pinfo.h"
|
2000-09-08 00:23:51 +08:00
|
|
|
#include "shared_info.h"
|
2000-11-14 13:53:32 +08:00
|
|
|
#include "cygheap.h"
|
2003-04-16 11:03:45 +08:00
|
|
|
#include "registry.h"
|
2004-05-08 10:55:38 +08:00
|
|
|
#include "environ.h"
|
2008-04-23 19:13:52 +08:00
|
|
|
#include "tls_pbuf.h"
|
2011-11-14 09:29:49 +08:00
|
|
|
#include "sync.h"
|
|
|
|
#include "child_info.h"
|
2017-08-17 21:12:15 +08:00
|
|
|
#include <cygwin/fs.h> /* needed for RENAME_NOREPLACE */
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2002-10-21 09:00:58 +08:00
|
|
|
#undef _close
|
|
|
|
#undef _lseek
|
|
|
|
#undef _open
|
|
|
|
#undef _read
|
|
|
|
#undef _write
|
2003-03-10 05:51:00 +08:00
|
|
|
#undef _open64
|
|
|
|
#undef _lseek64
|
|
|
|
#undef _fstat64
|
2002-10-21 09:00:58 +08:00
|
|
|
|
2020-01-29 00:57:50 +08:00
|
|
|
static int mknod_worker (path_conv &, mode_t, _major_t, _minor_t);
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
/* Close all files and process any queued deletions.
|
|
|
|
Lots of unix style applications will open a tmp file, unlink it,
|
|
|
|
but never call close. This function is called by _exit to
|
|
|
|
ensure we don't leave any such files lying around. */
|
|
|
|
|
2020-01-28 22:33:53 +08:00
|
|
|
void
|
2005-07-05 10:05:07 +08:00
|
|
|
close_all_files (bool norelease)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2004-01-14 23:45:37 +08:00
|
|
|
cygheap->fdtab.lock ();
|
2000-10-15 09:37:07 +08:00
|
|
|
|
2007-02-20 23:48:04 +08:00
|
|
|
semaphore::terminate ();
|
|
|
|
|
2008-03-27 09:50:40 +08:00
|
|
|
HANDLE h = NULL;
|
|
|
|
|
2001-04-19 05:10:15 +08:00
|
|
|
for (int i = 0; i < (int) cygheap->fdtab.size; i++)
|
2012-02-03 00:58:13 +08:00
|
|
|
{
|
2012-02-08 00:54:14 +08:00
|
|
|
cygheap_fdget cfd (i, false, false);
|
2012-02-03 00:58:13 +08:00
|
|
|
if (cfd >= 0)
|
|
|
|
{
|
|
|
|
debug_only_printf ("closing fd %d", i);
|
|
|
|
if (i == 2)
|
|
|
|
DuplicateHandle (GetCurrentProcess (), cfd->get_output_handle (),
|
|
|
|
GetCurrentProcess (), &h,
|
|
|
|
0, false, DUPLICATE_SAME_ACCESS);
|
|
|
|
cfd->close_with_arch ();
|
|
|
|
if (!norelease)
|
|
|
|
cfd.release ();
|
|
|
|
}
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2011-11-14 09:29:49 +08:00
|
|
|
if (!have_execed && cygheap->ctty)
|
2004-01-14 23:45:37 +08:00
|
|
|
cygheap->close_ctty ();
|
2003-12-27 10:41:07 +08:00
|
|
|
|
2011-11-29 23:34:49 +08:00
|
|
|
fhandler_base_overlapped::flush_all_async_io ();
|
2008-03-27 09:50:40 +08:00
|
|
|
if (h)
|
|
|
|
SetStdHandle (STD_ERROR_HANDLE, h);
|
2004-01-14 23:45:37 +08:00
|
|
|
cygheap->fdtab.unlock ();
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2010-01-15 02:46:02 +08:00
|
|
|
extern "C" int
|
2001-09-25 05:50:44 +08:00
|
|
|
dup (int fd)
|
|
|
|
{
|
2013-12-06 03:43:34 +08:00
|
|
|
int res;
|
2013-12-06 23:38:21 +08:00
|
|
|
cygheap_fdnew newfd;
|
2013-12-06 03:43:34 +08:00
|
|
|
if (newfd < 0)
|
|
|
|
res = -1;
|
|
|
|
else
|
|
|
|
res = cygheap->fdtab.dup3 (fd, newfd, 0);
|
2011-12-17 08:03:31 +08:00
|
|
|
syscall_printf ("%R = dup(%d)", res, fd);
|
|
|
|
return res;
|
2001-09-25 05:50:44 +08:00
|
|
|
}
|
|
|
|
|
2012-06-04 02:02:45 +08:00
|
|
|
inline int
|
|
|
|
dup_finish (int oldfd, int newfd, int flags)
|
|
|
|
{
|
|
|
|
int res;
|
2012-06-04 09:26:05 +08:00
|
|
|
if ((res = cygheap->fdtab.dup3 (oldfd, newfd, flags | O_EXCL)) == newfd)
|
2012-06-04 02:02:45 +08:00
|
|
|
{
|
|
|
|
cygheap_fdget (newfd)->inc_refcnt ();
|
|
|
|
cygheap->fdtab.unlock (); /* dup3 exits with lock set on success */
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2010-01-15 02:46:02 +08:00
|
|
|
extern "C" int
|
2001-09-25 05:50:44 +08:00
|
|
|
dup2 (int oldfd, int newfd)
|
|
|
|
{
|
2011-12-17 08:03:31 +08:00
|
|
|
int res;
|
2021-01-29 22:14:35 +08:00
|
|
|
if (newfd >= OPEN_MAX || newfd < 0)
|
2009-09-22 12:09:03 +08:00
|
|
|
{
|
|
|
|
set_errno (EBADF);
|
2011-12-17 08:03:31 +08:00
|
|
|
res = -1;
|
2009-09-22 12:09:03 +08:00
|
|
|
}
|
2011-12-17 08:03:31 +08:00
|
|
|
else if (newfd == oldfd)
|
2010-01-15 02:46:02 +08:00
|
|
|
{
|
|
|
|
cygheap_fdget cfd (oldfd);
|
2011-12-17 08:03:31 +08:00
|
|
|
res = (cfd >= 0) ? oldfd : -1;
|
2010-01-15 02:46:02 +08:00
|
|
|
}
|
2012-06-04 02:02:45 +08:00
|
|
|
else
|
|
|
|
res = dup_finish (oldfd, newfd, 0);
|
2011-12-17 08:03:31 +08:00
|
|
|
|
|
|
|
syscall_printf ("%R = dup2(%d, %d)", res, oldfd, newfd);
|
|
|
|
return res;
|
2010-01-15 02:46:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
dup3 (int oldfd, int newfd, int flags)
|
|
|
|
{
|
2011-12-17 08:03:31 +08:00
|
|
|
int res;
|
2021-01-29 22:14:35 +08:00
|
|
|
if (newfd >= OPEN_MAX)
|
2010-01-15 02:46:02 +08:00
|
|
|
{
|
|
|
|
set_errno (EBADF);
|
2011-12-17 08:03:31 +08:00
|
|
|
res = -1;
|
2010-01-15 02:46:02 +08:00
|
|
|
}
|
2011-12-17 08:03:31 +08:00
|
|
|
else if (newfd == oldfd)
|
2010-01-15 02:46:02 +08:00
|
|
|
{
|
|
|
|
cygheap_fdget cfd (oldfd, false, false);
|
|
|
|
set_errno (cfd < 0 ? EBADF : EINVAL);
|
2011-12-17 08:03:31 +08:00
|
|
|
res = -1;
|
2010-01-15 02:46:02 +08:00
|
|
|
}
|
2012-06-04 02:02:45 +08:00
|
|
|
else
|
|
|
|
res = dup_finish (oldfd, newfd, flags);
|
2012-02-02 01:20:02 +08:00
|
|
|
|
2013-04-23 17:44:36 +08:00
|
|
|
syscall_printf ("%R = dup3(%d, %d, %y)", res, oldfd, newfd, flags);
|
2011-12-17 08:03:31 +08:00
|
|
|
return res;
|
2001-09-25 05:50:44 +08:00
|
|
|
}
|
|
|
|
|
2015-12-16 04:50:14 +08:00
|
|
|
static const char desktop_ini[] =
|
2012-06-04 00:46:53 +08:00
|
|
|
"[.ShellClassInfo]\r\n"
|
2015-12-16 04:50:14 +08:00
|
|
|
"CLSID={645FF040-5081-101B-9F08-00AA002F954E}\r\n"
|
2012-06-04 00:46:53 +08:00
|
|
|
"LocalizedResourceName=@%SystemRoot%\\system32\\shell32.dll,-8964\r\n";
|
|
|
|
|
2009-01-12 23:51:23 +08:00
|
|
|
enum bin_status
|
2006-12-11 00:43:30 +08:00
|
|
|
{
|
2009-01-12 23:51:23 +08:00
|
|
|
dont_move,
|
|
|
|
move_to_bin,
|
2012-07-25 20:32:37 +08:00
|
|
|
has_been_moved,
|
|
|
|
dir_not_empty
|
2009-01-12 23:51:23 +08:00
|
|
|
};
|
|
|
|
|
2019-01-10 04:14:58 +08:00
|
|
|
/* Typically the recycler on drive C has been created at installation
|
|
|
|
time. The name is then written in camel back. On any other drive,
|
|
|
|
the recycler is created on first usage. shell32.dll then creates
|
|
|
|
the recycler in all upper case. That's only important if the entire
|
|
|
|
operation is running case sensitive. */
|
|
|
|
static WCHAR recycler_basename_drive_c[] = L"\\$Recycle.Bin\\";
|
|
|
|
static WCHAR recycler_basename_other[] = L"\\$RECYCLE.BIN\\";
|
|
|
|
|
2009-01-12 23:51:23 +08:00
|
|
|
static bin_status
|
2013-11-27 22:27:34 +08:00
|
|
|
try_to_bin (path_conv &pc, HANDLE &fh, ACCESS_MASK access, ULONG flags)
|
2009-01-12 23:51:23 +08:00
|
|
|
{
|
|
|
|
bin_status bin_stat = move_to_bin;
|
2006-12-11 00:43:30 +08:00
|
|
|
NTSTATUS status;
|
2007-08-12 20:48:02 +08:00
|
|
|
OBJECT_ATTRIBUTES attr;
|
2006-12-11 00:43:30 +08:00
|
|
|
IO_STATUS_BLOCK io;
|
2009-01-12 23:51:23 +08:00
|
|
|
HANDLE rootdir = NULL, recyclerdir = NULL, tmp_fh = NULL;
|
2007-08-12 20:48:02 +08:00
|
|
|
USHORT recycler_base_len = 0, recycler_user_len = 0;
|
|
|
|
UNICODE_STRING root, recycler, fname;
|
2019-01-10 04:14:58 +08:00
|
|
|
PWCHAR recycler_basename = NULL;
|
2007-08-12 20:48:02 +08:00
|
|
|
WCHAR recyclerbuf[NAME_MAX + 1]; /* Enough for recycler + SID + filename */
|
|
|
|
PFILE_NAME_INFORMATION pfni;
|
|
|
|
PFILE_INTERNAL_INFORMATION pfii;
|
|
|
|
PFILE_RENAME_INFORMATION pfri;
|
2012-07-25 20:32:37 +08:00
|
|
|
ULONG frisiz;
|
2009-01-12 23:51:23 +08:00
|
|
|
FILE_DISPOSITION_INFORMATION disp = { TRUE };
|
2012-06-04 00:46:53 +08:00
|
|
|
bool fs_has_per_user_recycler = pc.fs_is_ntfs () || pc.fs_is_refs ();
|
2006-12-11 00:43:30 +08:00
|
|
|
|
2009-04-10 01:55:01 +08:00
|
|
|
tmp_pathbuf tp;
|
|
|
|
PBYTE infobuf = (PBYTE) tp.w_get ();
|
|
|
|
|
2007-08-12 20:48:02 +08:00
|
|
|
pfni = (PFILE_NAME_INFORMATION) infobuf;
|
2019-01-10 04:14:58 +08:00
|
|
|
status = NtQueryInformationFile (fh, &io, pfni, NT_MAX_PATH * sizeof (WCHAR),
|
|
|
|
FileNameInformation);
|
2007-08-12 20:48:02 +08:00
|
|
|
if (!NT_SUCCESS (status))
|
2006-12-11 00:43:30 +08:00
|
|
|
{
|
2011-10-20 18:59:01 +08:00
|
|
|
debug_printf ("NtQueryInformationFile (%S, FileNameInformation) "
|
2013-04-23 17:44:36 +08:00
|
|
|
"failed, status = %y", pc.get_nt_native_path (), status);
|
2007-08-12 20:48:02 +08:00
|
|
|
goto out;
|
2006-12-11 00:43:30 +08:00
|
|
|
}
|
2007-08-12 20:48:02 +08:00
|
|
|
/* The filename could change, the parent dir not. So we split both paths
|
|
|
|
and take the prefix. However, there are two special cases:
|
|
|
|
- The handle refers to the root dir of the volume.
|
|
|
|
- The handle refers to the recycler or a subdir.
|
|
|
|
Both cases are handled by just returning and not even trying to move
|
|
|
|
them into the recycler. */
|
|
|
|
if (pfni->FileNameLength == 2) /* root dir. */
|
|
|
|
goto out;
|
|
|
|
/* Initialize recycler path. */
|
|
|
|
RtlInitEmptyUnicodeString (&recycler, recyclerbuf, sizeof recyclerbuf);
|
2009-12-18 02:33:05 +08:00
|
|
|
if (!pc.isremote ())
|
2006-12-11 00:43:30 +08:00
|
|
|
{
|
2019-01-10 04:14:58 +08:00
|
|
|
recycler_basename = wcsncmp (pc.get_nt_native_path ()->Buffer,
|
|
|
|
L"\\??\\C:\\", 7)
|
|
|
|
? recycler_basename_other
|
|
|
|
: recycler_basename_drive_c;
|
|
|
|
RtlAppendUnicodeToString (&recycler, recycler_basename);
|
2009-12-18 02:33:05 +08:00
|
|
|
RtlInitCountedUnicodeString(&fname, pfni->FileName, pfni->FileNameLength);
|
2015-04-23 21:02:32 +08:00
|
|
|
/* Is the file a subdir of the recycler? */
|
2009-12-18 02:33:05 +08:00
|
|
|
if (RtlEqualUnicodePathPrefix (&fname, &recycler, TRUE))
|
|
|
|
goto out;
|
|
|
|
/* Is fname the recycler? Temporarily hide trailing backslash. */
|
|
|
|
recycler.Length -= sizeof (WCHAR);
|
|
|
|
if (RtlEqualUnicodeString (&fname, &recycler, TRUE))
|
|
|
|
goto out;
|
2015-04-23 21:02:32 +08:00
|
|
|
/* Is fname really a subcomponent of the full path? If not, there's
|
2019-01-05 18:32:23 +08:00
|
|
|
a high probability we're accessing the file via a virtual drive
|
2015-04-23 21:02:32 +08:00
|
|
|
created with "subst". Check and accommodate it. Note that we
|
2017-10-18 22:12:42 +08:00
|
|
|
only get here if the virtual drive is really pointing to a local
|
2015-04-23 21:02:32 +08:00
|
|
|
drive. Otherwise pc.isremote () returns "true". */
|
|
|
|
if (!RtlEqualUnicodePathSuffix (pc.get_nt_native_path (), &fname, TRUE))
|
|
|
|
{
|
|
|
|
WCHAR drive[3] = { pc.get_nt_native_path ()->Buffer[4], ':', '\0' };
|
|
|
|
PWCHAR tgt = tp.w_get ();
|
|
|
|
|
|
|
|
if (QueryDosDeviceW (drive, tgt, NT_MAX_PATH)
|
|
|
|
&& !wcsncmp (tgt, L"\\??\\", 4))
|
|
|
|
{
|
|
|
|
UNICODE_STRING new_path;
|
|
|
|
|
|
|
|
wcsncpy (tgt + 6, fname.Buffer, fname.Length / sizeof (WCHAR));
|
|
|
|
RtlInitCountedUnicodeString(&new_path, tgt,
|
|
|
|
6 * sizeof (WCHAR) + fname.Length);
|
|
|
|
pc.set_nt_native_path (&new_path);
|
|
|
|
}
|
|
|
|
}
|
2009-12-18 02:33:05 +08:00
|
|
|
/* Create root dir path from file name information. */
|
|
|
|
RtlSplitUnicodePath (&fname, &fname, NULL);
|
|
|
|
RtlSplitUnicodePath (pc.get_nt_native_path (), &root, NULL);
|
|
|
|
root.Length -= fname.Length - sizeof (WCHAR);
|
|
|
|
|
|
|
|
/* Open root directory. All recycler bin ops are caseinsensitive. */
|
|
|
|
InitializeObjectAttributes (&attr, &root, OBJ_CASE_INSENSITIVE,
|
|
|
|
NULL, NULL);
|
|
|
|
status = NtOpenFile (&rootdir, FILE_TRAVERSE, &attr, &io,
|
|
|
|
FILE_SHARE_VALID_FLAGS, FILE_OPEN_FOR_BACKUP_INTENT);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("NtOpenFile (%S) failed, status = %y", &root, status);
|
2009-12-18 02:33:05 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2006-12-11 00:43:30 +08:00
|
|
|
|
2009-12-18 02:33:05 +08:00
|
|
|
/* Strip leading backslash */
|
|
|
|
++recycler.Buffer;
|
|
|
|
recycler.Length -= sizeof (WCHAR);
|
|
|
|
/* Store length of recycler base dir, if it's necessary to create it. */
|
|
|
|
recycler_base_len = recycler.Length;
|
2012-06-04 00:46:53 +08:00
|
|
|
/* On NTFS or ReFS the recycler dir contains user specific subdirs, which
|
2019-01-05 18:32:23 +08:00
|
|
|
are the actual recycle bins per user. The name of this dir is the
|
2012-06-04 00:46:53 +08:00
|
|
|
string representation of the user SID. */
|
|
|
|
if (fs_has_per_user_recycler)
|
2009-12-18 02:33:05 +08:00
|
|
|
{
|
|
|
|
UNICODE_STRING sid;
|
|
|
|
WCHAR sidbuf[128];
|
|
|
|
/* Unhide trailing backslash. */
|
|
|
|
recycler.Length += sizeof (WCHAR);
|
|
|
|
RtlInitEmptyUnicodeString (&sid, sidbuf, sizeof sidbuf);
|
|
|
|
RtlConvertSidToUnicodeString (&sid, cygheap->user.sid (), FALSE);
|
|
|
|
RtlAppendUnicodeStringToString (&recycler, &sid);
|
|
|
|
recycler_user_len = recycler.Length;
|
|
|
|
}
|
|
|
|
RtlAppendUnicodeToString (&recycler, L"\\");
|
2007-08-12 20:48:02 +08:00
|
|
|
}
|
2019-01-06 04:44:12 +08:00
|
|
|
if (pc.file_attributes () & FILE_ATTRIBUTE_TEMPORARY)
|
2007-08-12 20:48:02 +08:00
|
|
|
{
|
2019-01-06 04:44:12 +08:00
|
|
|
UNICODE_STRING basename;
|
|
|
|
|
|
|
|
RtlSplitUnicodePath (pc.get_nt_native_path (), NULL, &basename);
|
|
|
|
RtlAppendUnicodeToString (&recycler, basename.Buffer);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Create unique filename. Start with a dot, followed by "cyg"
|
|
|
|
transposed into the Unicode low surrogate area (U+dc00) on file
|
|
|
|
systems supporting Unicode (except Samba), followed by the inode
|
|
|
|
number in hex, followed by a path hash in hex. The combination
|
|
|
|
allows to remove multiple hardlinks to the same file. */
|
|
|
|
RtlAppendUnicodeToString (&recycler,
|
|
|
|
(pc.fs_flags () & FILE_UNICODE_ON_DISK
|
|
|
|
&& !pc.fs_is_samba ())
|
|
|
|
? L".\xdc63\xdc79\xdc67" : L".cyg");
|
|
|
|
pfii = (PFILE_INTERNAL_INFORMATION) infobuf;
|
|
|
|
status = NtQueryInformationFile (fh, &io, pfii, sizeof *pfii,
|
|
|
|
FileInternalInformation);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
debug_printf ("NtQueryInformationFile (%S, FileInternalInformation) "
|
|
|
|
"failed, status = %y",
|
|
|
|
pc.get_nt_native_path (), status);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
RtlInt64ToHexUnicodeString (pfii->IndexNumber.QuadPart, &recycler, TRUE);
|
|
|
|
RtlInt64ToHexUnicodeString (hash_path_name (0, pc.get_nt_native_path ()),
|
|
|
|
&recycler, TRUE);
|
2007-08-12 20:48:02 +08:00
|
|
|
}
|
|
|
|
/* Shoot. */
|
|
|
|
pfri = (PFILE_RENAME_INFORMATION) infobuf;
|
|
|
|
pfri->ReplaceIfExists = TRUE;
|
2017-10-18 22:15:08 +08:00
|
|
|
pfri->RootDirectory = rootdir;
|
2007-08-12 20:48:02 +08:00
|
|
|
pfri->FileNameLength = recycler.Length;
|
|
|
|
memcpy (pfri->FileName, recycler.Buffer, recycler.Length);
|
2012-07-25 20:32:37 +08:00
|
|
|
frisiz = sizeof *pfri + pfri->FileNameLength - sizeof (WCHAR);
|
2013-11-27 22:27:34 +08:00
|
|
|
|
2012-07-25 20:32:37 +08:00
|
|
|
status = NtSetInformationFile (fh, &io, pfri, frisiz, FileRenameInformation);
|
2009-12-18 02:33:05 +08:00
|
|
|
if (status == STATUS_OBJECT_PATH_NOT_FOUND && !pc.isremote ())
|
2007-08-12 20:48:02 +08:00
|
|
|
{
|
2019-01-10 04:14:58 +08:00
|
|
|
/* The recycler and/or the recycler/SID directory don't exist, or the
|
|
|
|
case of recycler dir has changed and the rename op is case sensitive.
|
2007-08-12 20:48:02 +08:00
|
|
|
First reopen root dir with permission to create subdirs. */
|
|
|
|
NtClose (rootdir);
|
2012-06-04 00:46:53 +08:00
|
|
|
InitializeObjectAttributes (&attr, &root, OBJ_CASE_INSENSITIVE,
|
|
|
|
NULL, NULL);
|
2007-08-12 20:48:02 +08:00
|
|
|
status = NtOpenFile (&rootdir, FILE_ADD_SUBDIRECTORY, &attr, &io,
|
|
|
|
FILE_SHARE_VALID_FLAGS, FILE_OPEN_FOR_BACKUP_INTENT);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("NtOpenFile (%S) failed, status = %y",
|
2019-01-26 03:02:03 +08:00
|
|
|
&recycler, status);
|
2007-08-12 20:48:02 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2019-01-10 04:41:48 +08:00
|
|
|
/* Correct the rootdir HANDLE in pfri after reopening the dir. */
|
|
|
|
pfri->RootDirectory = rootdir;
|
2007-08-12 20:48:02 +08:00
|
|
|
/* Then check if recycler exists by opening and potentially creating it.
|
|
|
|
Yes, we can really do that. Typically the recycle bin is created
|
2015-12-15 21:30:03 +08:00
|
|
|
by the first user actually using the bin. */
|
2007-08-12 20:48:02 +08:00
|
|
|
InitializeObjectAttributes (&attr, &recycler, OBJ_CASE_INSENSITIVE,
|
2015-12-15 21:30:03 +08:00
|
|
|
rootdir, recycler_sd (true, true));
|
2007-08-12 20:48:02 +08:00
|
|
|
recycler.Length = recycler_base_len;
|
|
|
|
status = NtCreateFile (&recyclerdir,
|
|
|
|
READ_CONTROL
|
2012-06-04 00:46:53 +08:00
|
|
|
| (fs_has_per_user_recycler ? 0 : FILE_ADD_FILE),
|
2007-08-12 20:48:02 +08:00
|
|
|
&attr, &io, NULL,
|
|
|
|
FILE_ATTRIBUTE_DIRECTORY
|
|
|
|
| FILE_ATTRIBUTE_SYSTEM
|
|
|
|
| FILE_ATTRIBUTE_HIDDEN,
|
|
|
|
FILE_SHARE_VALID_FLAGS, FILE_OPEN_IF,
|
|
|
|
FILE_DIRECTORY_FILE, NULL, 0);
|
|
|
|
if (!NT_SUCCESS (status))
|
2006-12-12 23:58:08 +08:00
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("NtCreateFile (%S) failed, status = %y",
|
2019-01-26 03:02:03 +08:00
|
|
|
&recycler, status);
|
2007-08-12 20:48:02 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2019-01-10 04:14:58 +08:00
|
|
|
/* If we opened the recycler (in contrast to creating it) and our
|
|
|
|
rename op is case sensitive, fetch the actual case of the recycler
|
|
|
|
and store the name in recycler_basename, as well as in pfri->FileName
|
|
|
|
for the below 2nd try to rename the file. */
|
|
|
|
if (io.Information == FILE_OPENED && !pc.objcaseinsensitive ())
|
|
|
|
{
|
|
|
|
pfni = (PFILE_NAME_INFORMATION) tp.w_get ();
|
|
|
|
status = NtQueryInformationFile (recyclerdir, &io, pfni,
|
|
|
|
NT_MAX_PATH * sizeof (WCHAR),
|
|
|
|
FileNameInformation);
|
|
|
|
if (NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
size_t len = pfni->FileNameLength / sizeof (WCHAR) - 1;
|
|
|
|
PWCHAR p = pfni->FileName + 1;
|
|
|
|
p[len] = L'\0';
|
|
|
|
wcpncpy (pfri->FileName, p, len);
|
|
|
|
wcpncpy (recycler_basename + 1, p, len);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-08-12 20:48:02 +08:00
|
|
|
/* Next, if necessary, check if the recycler/SID dir exists and
|
2008-02-16 01:53:11 +08:00
|
|
|
create it if not. */
|
2012-06-04 00:46:53 +08:00
|
|
|
if (fs_has_per_user_recycler)
|
2008-02-16 01:53:11 +08:00
|
|
|
{
|
2007-08-12 20:48:02 +08:00
|
|
|
NtClose (recyclerdir);
|
|
|
|
recycler.Length = recycler_user_len;
|
2012-06-04 00:46:53 +08:00
|
|
|
InitializeObjectAttributes (&attr, &recycler, OBJ_CASE_INSENSITIVE,
|
|
|
|
rootdir, recycler_sd (false, true));
|
2007-08-12 20:48:02 +08:00
|
|
|
status = NtCreateFile (&recyclerdir, READ_CONTROL | FILE_ADD_FILE,
|
|
|
|
&attr, &io, NULL, FILE_ATTRIBUTE_DIRECTORY
|
|
|
|
| FILE_ATTRIBUTE_SYSTEM
|
|
|
|
| FILE_ATTRIBUTE_HIDDEN,
|
|
|
|
FILE_SHARE_VALID_FLAGS, FILE_OPEN_IF,
|
|
|
|
FILE_DIRECTORY_FILE, NULL, 0);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("NtCreateFile (%S) failed, status = %y",
|
2007-08-12 20:48:02 +08:00
|
|
|
&recycler, status);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2015-12-15 21:30:03 +08:00
|
|
|
/* The desktop.ini file is expected by Windows Explorer. Otherwise,
|
|
|
|
the created bin is treated as corrupted */
|
2007-08-12 20:48:02 +08:00
|
|
|
if (io.Information == FILE_CREATED)
|
2008-02-16 01:53:11 +08:00
|
|
|
{
|
2007-08-12 20:48:02 +08:00
|
|
|
RtlInitUnicodeString (&fname, L"desktop.ini");
|
|
|
|
InitializeObjectAttributes (&attr, &fname, OBJ_CASE_INSENSITIVE,
|
2012-06-04 00:46:53 +08:00
|
|
|
recyclerdir, recycler_sd (false, false));
|
2009-01-12 23:51:23 +08:00
|
|
|
status = NtCreateFile (&tmp_fh, FILE_GENERIC_WRITE, &attr, &io, NULL,
|
2007-08-12 20:48:02 +08:00
|
|
|
FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN,
|
|
|
|
FILE_SHARE_VALID_FLAGS, FILE_CREATE,
|
|
|
|
FILE_SYNCHRONOUS_IO_NONALERT
|
|
|
|
| FILE_NON_DIRECTORY_FILE, NULL, 0);
|
|
|
|
if (!NT_SUCCESS (status))
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("NtCreateFile (%S) failed, status = %y",
|
2011-10-20 18:59:01 +08:00
|
|
|
&recycler, status);
|
2007-08-12 20:48:02 +08:00
|
|
|
else
|
|
|
|
{
|
2015-12-16 04:50:14 +08:00
|
|
|
status = NtWriteFile (tmp_fh, NULL, NULL, NULL, &io,
|
|
|
|
(PVOID) desktop_ini, sizeof desktop_ini - 1,
|
|
|
|
NULL, NULL);
|
2007-08-12 20:48:02 +08:00
|
|
|
if (!NT_SUCCESS (status))
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("NtWriteFile (%S) failed, status = %y",
|
2011-10-20 18:59:01 +08:00
|
|
|
&fname, status);
|
2009-01-12 23:51:23 +08:00
|
|
|
NtClose (tmp_fh);
|
2007-08-12 20:48:02 +08:00
|
|
|
}
|
2006-12-11 00:43:30 +08:00
|
|
|
}
|
2007-08-12 20:48:02 +08:00
|
|
|
NtClose (recyclerdir);
|
|
|
|
/* Shoot again. */
|
2012-07-25 20:32:37 +08:00
|
|
|
status = NtSetInformationFile (fh, &io, pfri, frisiz,
|
2007-08-12 20:48:02 +08:00
|
|
|
FileRenameInformation);
|
2006-12-11 00:43:30 +08:00
|
|
|
}
|
|
|
|
if (!NT_SUCCESS (status))
|
2009-01-12 23:51:23 +08:00
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("Move %S to %S failed, status = %y",
|
2009-01-12 23:51:23 +08:00
|
|
|
pc.get_nt_native_path (), &recycler, status);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
/* Moving to the bin worked. */
|
|
|
|
bin_stat = has_been_moved;
|
2019-01-06 04:44:12 +08:00
|
|
|
/* If we're only moving a just created O_TMPFILE, we're done here. */
|
|
|
|
if (pc.file_attributes () & FILE_ATTRIBUTE_TEMPORARY)
|
|
|
|
goto out;
|
2009-01-12 23:51:23 +08:00
|
|
|
/* Now we try to set the delete disposition. If that worked, we're done.
|
|
|
|
We try this here first, as long as we still have the open handle.
|
|
|
|
Otherwise the below code closes the handle to allow replacing the file. */
|
|
|
|
status = NtSetInformationFile (fh, &io, &disp, sizeof disp,
|
|
|
|
FileDispositionInformation);
|
2017-10-18 22:27:17 +08:00
|
|
|
switch (status)
|
2012-07-25 20:32:37 +08:00
|
|
|
{
|
2017-10-18 22:27:17 +08:00
|
|
|
case STATUS_SUCCESS:
|
|
|
|
break;
|
|
|
|
case STATUS_DIRECTORY_NOT_EMPTY:
|
2012-07-25 20:32:37 +08:00
|
|
|
/* Uh oh! This was supposed to be avoided by the check_dir_not_empty
|
|
|
|
test in unlink_nt, but given that the test isn't atomic, this *can*
|
|
|
|
happen. Try to move the dir back ASAP. */
|
|
|
|
pfri->RootDirectory = NULL;
|
|
|
|
pfri->FileNameLength = pc.get_nt_native_path ()->Length;
|
|
|
|
memcpy (pfri->FileName, pc.get_nt_native_path ()->Buffer,
|
|
|
|
pc.get_nt_native_path ()->Length);
|
|
|
|
frisiz = sizeof *pfri + pfri->FileNameLength - sizeof (WCHAR);
|
|
|
|
if (NT_SUCCESS (NtSetInformationFile (fh, &io, pfri, frisiz,
|
|
|
|
FileRenameInformation)))
|
|
|
|
{
|
|
|
|
/* Give notice to unlink_nt and leave immediately. This avoids
|
|
|
|
closing the handle, which might still be used if called from
|
|
|
|
the rm -r workaround code. */
|
|
|
|
bin_stat = dir_not_empty;
|
|
|
|
goto out;
|
|
|
|
}
|
2017-10-18 22:18:12 +08:00
|
|
|
debug_printf ("Renaming dir %S back to %S failed, status = %y",
|
|
|
|
&recycler, pc.get_nt_native_path (), status);
|
2017-10-18 22:27:17 +08:00
|
|
|
break;
|
|
|
|
case STATUS_FILE_RENAMED:
|
|
|
|
/* On NFS, the subsequent request to set the delete disposition fails
|
|
|
|
with STATUS_FILE_RENAMED. We have to reopen the file, close the
|
|
|
|
original handle, and set the delete disposition on the reopened
|
|
|
|
handle to make sure setting delete disposition works. */
|
|
|
|
InitializeObjectAttributes (&attr, &ro_u_empty, 0, fh, NULL);
|
|
|
|
status = NtOpenFile (&tmp_fh, access, &attr, &io,
|
|
|
|
FILE_SHARE_VALID_FLAGS, flags);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
debug_printf ("NtOpenFile (%S) for reopening in renamed case failed, "
|
|
|
|
"status = %y", pc.get_nt_native_path (), status);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
NtClose (fh);
|
|
|
|
fh = tmp_fh;
|
|
|
|
status = NtSetInformationFile (fh, &io, &disp, sizeof disp,
|
|
|
|
FileDispositionInformation);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
debug_printf ("Setting delete disposition %S (%S) in renamed "
|
|
|
|
"case failed, status = %y",
|
|
|
|
&recycler, pc.get_nt_native_path (), status);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
debug_printf ("Setting delete disposition on %S (%S) failed, status = %y",
|
|
|
|
&recycler, pc.get_nt_native_path (), status);
|
|
|
|
break;
|
2012-07-25 20:32:37 +08:00
|
|
|
}
|
2009-01-12 23:51:23 +08:00
|
|
|
/* In case of success, restore R/O attribute to accommodate hardlinks.
|
|
|
|
That leaves potentially hardlinks around with the R/O bit suddenly
|
|
|
|
off if setting the delete disposition failed, but please, keep in
|
|
|
|
mind this is really a border case only. */
|
|
|
|
if ((access & FILE_WRITE_ATTRIBUTES) && NT_SUCCESS (status) && !pc.isdir ())
|
|
|
|
NtSetAttributesFile (fh, pc.file_attributes ());
|
|
|
|
NtClose (fh);
|
|
|
|
fh = NULL; /* So unlink_nt doesn't close the handle twice. */
|
|
|
|
/* On success or when trying to unlink a directory we just return here.
|
2017-10-18 22:22:14 +08:00
|
|
|
The below code only works for files. It also fails on NFS. */
|
|
|
|
if (NT_SUCCESS (status) || pc.isdir () || pc.fs_is_nfs ())
|
2009-01-12 23:51:23 +08:00
|
|
|
goto out;
|
|
|
|
/* The final trick. We create a temporary file with delete-on-close
|
|
|
|
semantic and rename that file to the file just moved to the bin.
|
|
|
|
This typically overwrites the original file and we get rid of it,
|
|
|
|
even if neither setting the delete dispostion, nor setting
|
|
|
|
delete-on-close on the original file succeeds. There are still
|
|
|
|
cases in which this fails, for instance, when trying to delete a
|
|
|
|
hardlink to a DLL used by the unlinking application itself. */
|
2017-10-18 22:21:12 +08:00
|
|
|
if (pc.isremote ())
|
|
|
|
{
|
|
|
|
/* In the remote case we need the full path, but recycler is only
|
|
|
|
a relative path. Convert to absolute path. */
|
|
|
|
RtlInitEmptyUnicodeString (&fname, (PCWSTR) tp.w_get (),
|
|
|
|
(NT_MAX_PATH - 1) * sizeof (WCHAR));
|
|
|
|
RtlCopyUnicodeString (&fname, pc.get_nt_native_path ());
|
|
|
|
RtlSplitUnicodePath (&fname, &fname, NULL);
|
|
|
|
/* Reset max length, overwritten by RtlSplitUnicodePath. */
|
|
|
|
fname.MaximumLength = (NT_MAX_PATH - 1) * sizeof (WCHAR); /* reset */
|
|
|
|
RtlAppendUnicodeStringToString (&fname, &recycler);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
fname = recycler;
|
|
|
|
RtlAppendUnicodeToString (&fname, L"X");
|
|
|
|
InitializeObjectAttributes (&attr, &fname, 0, rootdir, NULL);
|
2009-01-12 23:51:23 +08:00
|
|
|
status = NtCreateFile (&tmp_fh, DELETE, &attr, &io, NULL,
|
|
|
|
FILE_ATTRIBUTE_NORMAL, 0, FILE_SUPERSEDE,
|
|
|
|
FILE_NON_DIRECTORY_FILE | FILE_DELETE_ON_CLOSE,
|
|
|
|
NULL, 0);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
2017-10-18 22:18:12 +08:00
|
|
|
debug_printf ("Creating file %S for overwriting %S (%S) failed, "
|
|
|
|
"status = %y", &fname, &recycler, pc.get_nt_native_path (),
|
2009-01-12 23:51:23 +08:00
|
|
|
status);
|
|
|
|
goto out;
|
|
|
|
}
|
2012-07-25 20:32:37 +08:00
|
|
|
status = NtSetInformationFile (tmp_fh, &io, pfri, frisiz,
|
2009-01-12 23:51:23 +08:00
|
|
|
FileRenameInformation);
|
|
|
|
NtClose (tmp_fh);
|
|
|
|
if (!NT_SUCCESS (status))
|
2017-10-18 22:18:12 +08:00
|
|
|
debug_printf ("Overwriting %S (%S) with %S failed, status = %y",
|
|
|
|
&recycler, pc.get_nt_native_path (), &fname, status);
|
2009-01-12 23:51:23 +08:00
|
|
|
|
2007-08-12 20:48:02 +08:00
|
|
|
out:
|
|
|
|
if (rootdir)
|
|
|
|
NtClose (rootdir);
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("%S, return bin_status %d", pc.get_nt_native_path (), bin_stat);
|
2009-01-12 23:51:23 +08:00
|
|
|
return bin_stat;
|
2006-12-07 19:53:46 +08:00
|
|
|
}
|
|
|
|
|
2007-08-01 22:46:09 +08:00
|
|
|
static NTSTATUS
|
2011-10-20 18:59:01 +08:00
|
|
|
check_dir_not_empty (HANDLE dir, path_conv &pc)
|
2007-08-01 22:46:09 +08:00
|
|
|
{
|
|
|
|
IO_STATUS_BLOCK io;
|
|
|
|
const ULONG bufsiz = 3 * sizeof (FILE_NAMES_INFORMATION)
|
|
|
|
+ 3 * NAME_MAX * sizeof (WCHAR);
|
|
|
|
PFILE_NAMES_INFORMATION pfni = (PFILE_NAMES_INFORMATION)
|
|
|
|
alloca (bufsiz);
|
|
|
|
NTSTATUS status = NtQueryDirectoryFile (dir, NULL, NULL, 0, &io, pfni,
|
|
|
|
bufsiz, FileNamesInformation,
|
|
|
|
FALSE, NULL, TRUE);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("Checking if directory %S is empty failed, status = %y",
|
2011-10-20 18:59:01 +08:00
|
|
|
pc.get_nt_native_path (), status);
|
2007-08-01 22:46:09 +08:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
int cnt = 1;
|
2011-11-07 18:03:30 +08:00
|
|
|
do
|
2007-08-01 22:46:09 +08:00
|
|
|
{
|
2011-11-07 18:03:30 +08:00
|
|
|
while (pfni->NextEntryOffset)
|
2010-12-12 23:32:45 +08:00
|
|
|
{
|
2011-11-07 18:03:30 +08:00
|
|
|
if (++cnt > 2)
|
2011-10-20 18:59:01 +08:00
|
|
|
{
|
|
|
|
UNICODE_STRING fname;
|
2011-11-07 18:03:30 +08:00
|
|
|
OBJECT_ATTRIBUTES attr;
|
|
|
|
FILE_BASIC_INFORMATION fbi;
|
2011-10-20 18:59:01 +08:00
|
|
|
|
|
|
|
pfni = (PFILE_NAMES_INFORMATION)
|
|
|
|
((caddr_t) pfni + pfni->NextEntryOffset);
|
|
|
|
RtlInitCountedUnicodeString(&fname, pfni->FileName,
|
|
|
|
pfni->FileNameLength);
|
2011-11-07 18:03:30 +08:00
|
|
|
InitializeObjectAttributes (&attr, &fname, 0, dir, NULL);
|
|
|
|
status = NtQueryAttributesFile (&attr, &fbi);
|
|
|
|
/* Intensive testing shows that sometimes directories, for which
|
|
|
|
the delete disposition has already been set, and the deleting
|
|
|
|
handle is already closed, can linger in the parent dir for a
|
|
|
|
couple of ms for no apparent reason (Windows Defender or other
|
|
|
|
real-time scanners are suspect).
|
|
|
|
|
|
|
|
A fast rm -r is capable to exploit this problem. Setting the
|
|
|
|
delete disposition of the parent dir then fails with
|
|
|
|
STATUS_DIRECTORY_NOT_EMPTY. Examining the content of the
|
|
|
|
affected dir can then show either that the dir is empty, or it
|
|
|
|
can contain a lingering subdir. Calling NtQueryAttributesFile
|
|
|
|
on that subdir returns with STATUS_DELETE_PENDING, or it
|
|
|
|
disappeared before that call.
|
|
|
|
|
|
|
|
That's what we do here. If NtQueryAttributesFile succeeded,
|
|
|
|
or if the error code does not indicate an already deleted
|
|
|
|
entry, STATUS_DIRECTORY_NOT_EMPTY is returned.
|
|
|
|
|
|
|
|
Otherwise STATUS_SUCCESS is returned. Read on in unlink_nt. */
|
|
|
|
if (status != STATUS_DELETE_PENDING
|
|
|
|
&& status != STATUS_OBJECT_NAME_NOT_FOUND
|
|
|
|
&& status != STATUS_OBJECT_PATH_NOT_FOUND)
|
|
|
|
{
|
|
|
|
debug_printf ("Directory %S not empty, found file <%S>, "
|
2013-04-23 17:44:36 +08:00
|
|
|
"query status = %y",
|
2011-11-07 18:03:30 +08:00
|
|
|
pc.get_nt_native_path (), &fname, status);
|
|
|
|
return STATUS_DIRECTORY_NOT_EMPTY;
|
|
|
|
}
|
2011-10-20 18:59:01 +08:00
|
|
|
}
|
2011-11-07 18:03:30 +08:00
|
|
|
pfni = (PFILE_NAMES_INFORMATION) ((caddr_t) pfni + pfni->NextEntryOffset);
|
2010-12-12 23:32:45 +08:00
|
|
|
}
|
2007-08-01 22:46:09 +08:00
|
|
|
}
|
2011-11-07 18:03:30 +08:00
|
|
|
while (NT_SUCCESS (NtQueryDirectoryFile (dir, NULL, NULL, 0, &io, pfni,
|
|
|
|
bufsiz, FileNamesInformation,
|
|
|
|
FALSE, NULL, FALSE)));
|
2007-08-01 22:46:09 +08:00
|
|
|
return STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2021-01-21 00:10:51 +08:00
|
|
|
static inline NTSTATUS
|
|
|
|
_unlink_nt_post_dir_check (NTSTATUS status, POBJECT_ATTRIBUTES attr, const path_conv &pc)
|
|
|
|
{
|
|
|
|
/* Check for existence of remote dirs after trying to delete them.
|
|
|
|
Two reasons:
|
|
|
|
- Sometimes SMB indicates failure when it really succeeds.
|
|
|
|
- Removing a directory on a Samba drive using an old Samba version
|
|
|
|
sometimes doesn't return an error, if the directory can't be removed
|
|
|
|
because it's not empty. */
|
|
|
|
if (pc.isremote ())
|
|
|
|
{
|
|
|
|
FILE_BASIC_INFORMATION fbi;
|
|
|
|
NTSTATUS q_status;
|
|
|
|
|
|
|
|
q_status = NtQueryAttributesFile (attr, &fbi);
|
|
|
|
if (!NT_SUCCESS (status) && q_status == STATUS_OBJECT_NAME_NOT_FOUND)
|
|
|
|
status = STATUS_SUCCESS;
|
|
|
|
else if (pc.fs_is_samba ()
|
|
|
|
&& NT_SUCCESS (status) && NT_SUCCESS (q_status))
|
|
|
|
status = STATUS_DIRECTORY_NOT_EMPTY;
|
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
forkables: Create forkable hardlinks, yet unused.
In preparation to protect fork() against dll- and exe-updates, create
hardlinks to the main executable and each loaded dll in subdirectories
of /var/run/cygfork/, if that one exists on the NTFS file system.
The directory names consist of the user sid, the main executable's NTFS
IndexNumber, and the most recent LastWriteTime of all involved binaries
(dlls and main executable). Next to the main.exe hardlink we create the
empty file main.exe.local to enable dll redirection.
The name of the mutex to synchronize hardlink creation/cleanup also is
assembled from these directory names, to allow for synchronized cleanup
of even orphaned hardlink directories.
The hardlink to each dynamically loaded dll goes into another directory,
named using the NTFS IndexNumber of the dll's original directory.
* Makefile.in (DLL_OFILES): Add forkable.o.
* dll_init.h (struct dll): Declare member variables fbi, fii,
forkable_ntname. Declare methods nominate_forkable,
create_forkable.
(struct dll_list): Declare enum forkables_needs. Declare member
variables forkables_dirx_size, forkables_dirx_ntname,
forkables_mutex_name, forkables_mutex. Declare private methods
forkable_ntnamesize, prepare_forkables_nomination,
update_forkables_needs, update_forkables, create_forkables,
denominate_forkables, close_mutex, try_remove_forkables,
set_forkables_inheritance, request_forkables. Declare public
static methods ntopenfile, read_fii, read_fbi. Declare public
methods release_forkables, cleanup_forkables. Define public
inline method setup_forkables.
* dll_init.cc (dll_list::alloc): Allocate memory to hold the
name of the hardlink in struct dll member forkable_ntname.
Initialize struct dll members fbi, fii.
(dll_list::load_after_fork): Call release_forkables method.
* fork.cc: Rename public fork function to static dofork, add
with_forkables as bool pointer parameter. Add new fork function
calling dofork. (struct frok): Add bool pointer member
with_forkables, add as constructor parameter.
(frok::parent): Call dlls.setup_forkables before CreateProcessW,
dlls.release_forkables afterwards.
* pinfo.cc (pinfo::exit): Call dlls.cleanup_forkables.
* syscalls.cc (_unlink_nt): Rename public unlink_nt function to
static _unlink_nt, with 'shareable' as additional argument.
(unlink_nt): New, wrap _unlink_nt for original behaviour.
(unlink_nt_shareable): New, wrap _unlink_nt to keep a binary
file still loadable while removing one of its hardlinks.
* forkable.cc: New file.
Implement static functions mkdirs, rmdirs, rmdirs_synchronized,
stat_real_file_once, format_IndexNumber, rootname, sidname,
exename, lwtimename. Define static array forkable_nameparts.
(struct dll): Implement nominate_forkable, create_forkable.
(struct dll_list): Implement static methods ntopenfile,
read_fii, read_fbi. Implement forkable_ntnamesize,
2016-12-07 18:58:27 +08:00
|
|
|
static NTSTATUS
|
|
|
|
_unlink_nt (path_conv &pc, bool shareable)
|
2006-12-08 01:40:24 +08:00
|
|
|
{
|
2007-07-29 20:27:22 +08:00
|
|
|
NTSTATUS status;
|
2009-07-17 00:55:25 +08:00
|
|
|
HANDLE fh, fh_ro = NULL;
|
2006-12-08 01:40:24 +08:00
|
|
|
OBJECT_ATTRIBUTES attr;
|
|
|
|
IO_STATUS_BLOCK io;
|
2018-12-24 04:36:42 +08:00
|
|
|
ACCESS_MASK access = DELETE;
|
|
|
|
ULONG flags = FILE_OPEN_FOR_BACKUP_INTENT;
|
2010-09-12 19:41:56 +08:00
|
|
|
HANDLE old_trans = NULL, trans = NULL;
|
|
|
|
ULONG num_links = 1;
|
|
|
|
FILE_DISPOSITION_INFORMATION disp = { TRUE };
|
2011-11-07 18:03:30 +08:00
|
|
|
int reopened = 0;
|
2009-07-17 00:55:25 +08:00
|
|
|
bin_status bin_stat = dont_move;
|
2006-12-08 01:40:24 +08:00
|
|
|
|
2011-10-20 18:59:01 +08:00
|
|
|
syscall_printf ("Trying to delete %S, isdir = %d",
|
|
|
|
pc.get_nt_native_path (), pc.isdir ());
|
2018-12-24 04:36:42 +08:00
|
|
|
|
2018-03-01 23:41:45 +08:00
|
|
|
/* Add the reparse point flag to known reparse points, otherwise we remove
|
|
|
|
the target, not the reparse point. */
|
|
|
|
if (pc.is_known_reparse_point ())
|
2006-12-08 01:53:05 +08:00
|
|
|
flags |= FILE_OPEN_REPARSE_POINT;
|
2006-12-08 01:40:24 +08:00
|
|
|
|
2007-07-29 20:27:22 +08:00
|
|
|
pc.get_object_attr (attr, sec_none_nih);
|
2018-12-24 04:36:42 +08:00
|
|
|
|
2021-01-22 23:47:11 +08:00
|
|
|
/* First check if we can use POSIX unlink semantics: W10 1709+, local NTFS.
|
2018-12-24 04:36:42 +08:00
|
|
|
With POSIX unlink semantics the entire job gets MUCH easier and faster.
|
|
|
|
Just try to do it and if it fails, it fails. */
|
2019-01-15 03:38:24 +08:00
|
|
|
if (wincap.has_posix_unlink_semantics ()
|
|
|
|
&& !pc.isremote () && pc.fs_is_ntfs ())
|
2018-12-24 04:36:42 +08:00
|
|
|
{
|
|
|
|
FILE_DISPOSITION_INFORMATION_EX fdie;
|
|
|
|
|
2021-01-22 23:47:11 +08:00
|
|
|
/* POSIX unlink semantics are nice, but they still fail if the file has
|
|
|
|
the R/O attribute set. If so, ignoring might be an option: W10 1809+
|
|
|
|
Removing the file is very much a safe bet afterwards, so, no
|
|
|
|
transaction. */
|
|
|
|
if ((pc.file_attributes () & FILE_ATTRIBUTE_READONLY)
|
|
|
|
&& !wincap.has_posix_unlink_semantics_with_ignore_readonly ())
|
2018-12-24 04:36:42 +08:00
|
|
|
access |= FILE_WRITE_ATTRIBUTES;
|
|
|
|
status = NtOpenFile (&fh, access, &attr, &io, FILE_SHARE_VALID_FLAGS,
|
|
|
|
flags);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
goto out;
|
2021-01-22 23:47:11 +08:00
|
|
|
if (access & FILE_WRITE_ATTRIBUTES)
|
2018-12-24 04:36:42 +08:00
|
|
|
{
|
|
|
|
status = NtSetAttributesFile (fh, pc.file_attributes ()
|
|
|
|
& ~FILE_ATTRIBUTE_READONLY);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
NtClose (fh);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fdie.Flags = FILE_DISPOSITION_DELETE | FILE_DISPOSITION_POSIX_SEMANTICS;
|
2021-01-22 23:47:11 +08:00
|
|
|
if (wincap.has_posix_unlink_semantics_with_ignore_readonly ())
|
|
|
|
fdie.Flags |= FILE_DISPOSITION_IGNORE_READONLY_ATTRIBUTE;
|
2018-12-24 04:36:42 +08:00
|
|
|
status = NtSetInformationFile (fh, &io, &fdie, sizeof fdie,
|
|
|
|
FileDispositionInformationEx);
|
|
|
|
/* Restore R/O attribute in case we have multiple hardlinks. */
|
2021-01-22 23:47:11 +08:00
|
|
|
if (access & FILE_WRITE_ATTRIBUTES)
|
2018-12-24 04:36:42 +08:00
|
|
|
NtSetAttributesFile (fh, pc.file_attributes ());
|
|
|
|
NtClose (fh);
|
2019-02-07 04:17:35 +08:00
|
|
|
/* Trying to delete in-use executables and DLLs using
|
|
|
|
FILE_DISPOSITION_POSIX_SEMANTICS returns STATUS_CANNOT_DELETE.
|
|
|
|
Fall back to the default method. */
|
|
|
|
if (status != STATUS_CANNOT_DELETE)
|
|
|
|
goto out;
|
2018-12-24 04:36:42 +08:00
|
|
|
}
|
|
|
|
|
2009-07-17 00:55:25 +08:00
|
|
|
/* If the R/O attribute is set, we have to open the file with
|
|
|
|
FILE_WRITE_ATTRIBUTES to be able to remove this flags before trying
|
|
|
|
to delete it. We do this separately because there are filesystems
|
|
|
|
out there (MVFS), which refuse a request to open a file for DELETE
|
|
|
|
if the DOS R/O attribute is set for the file. After removing the R/O
|
|
|
|
attribute, just re-open the file for DELETE and go ahead. */
|
|
|
|
if (pc.file_attributes () & FILE_ATTRIBUTE_READONLY)
|
|
|
|
{
|
2010-09-12 19:41:56 +08:00
|
|
|
FILE_STANDARD_INFORMATION fsi;
|
|
|
|
|
|
|
|
/* If possible, hide the non-atomicity of the "remove R/O flag, remove
|
2011-06-06 13:02:13 +08:00
|
|
|
link to file" operation behind a transaction. */
|
2015-12-15 22:19:05 +08:00
|
|
|
if ((pc.fs_flags () & FILE_SUPPORTS_TRANSACTIONS))
|
2010-09-12 19:41:56 +08:00
|
|
|
start_transaction (old_trans, trans);
|
2013-12-11 20:12:12 +08:00
|
|
|
retry_open:
|
2021-01-15 21:45:26 +08:00
|
|
|
status = NtOpenFile (&fh_ro,
|
|
|
|
FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES,
|
|
|
|
&attr, &io, FILE_SHARE_VALID_FLAGS, flags);
|
2009-07-17 00:55:25 +08:00
|
|
|
if (NT_SUCCESS (status))
|
|
|
|
{
|
2011-10-20 18:59:01 +08:00
|
|
|
debug_printf ("Opening %S for removing R/O succeeded",
|
|
|
|
pc.get_nt_native_path ());
|
|
|
|
NTSTATUS status2 = NtSetAttributesFile (fh_ro,
|
|
|
|
pc.file_attributes ()
|
|
|
|
& ~FILE_ATTRIBUTE_READONLY);
|
|
|
|
if (!NT_SUCCESS (status2))
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("Removing R/O on %S failed, status = %y",
|
2011-10-20 18:59:01 +08:00
|
|
|
pc.get_nt_native_path (), status2);
|
2014-08-27 04:47:46 +08:00
|
|
|
pc.init_reopen_attr (attr, fh_ro);
|
2011-06-06 13:02:13 +08:00
|
|
|
}
|
2011-10-20 18:59:01 +08:00
|
|
|
else
|
2013-12-11 20:12:12 +08:00
|
|
|
{
|
|
|
|
debug_printf ("Opening %S for removing R/O failed, status = %y",
|
|
|
|
pc.get_nt_native_path (), status);
|
|
|
|
if (NT_TRANSACTIONAL_ERROR (status) && trans)
|
|
|
|
{
|
|
|
|
/* If NtOpenFile fails due to transactional problems, stop
|
|
|
|
transaction and go ahead without. */
|
|
|
|
stop_transaction (status, old_trans, trans);
|
|
|
|
debug_printf ("Transaction failure. Retry open.");
|
|
|
|
goto retry_open;
|
|
|
|
}
|
|
|
|
}
|
2010-09-12 19:41:56 +08:00
|
|
|
if (pc.is_lnk_symlink ())
|
|
|
|
{
|
|
|
|
status = NtQueryInformationFile (fh_ro, &io, &fsi, sizeof fsi,
|
|
|
|
FileStandardInformation);
|
|
|
|
if (NT_SUCCESS (status))
|
|
|
|
num_links = fsi.NumberOfLinks;
|
|
|
|
}
|
|
|
|
access |= FILE_WRITE_ATTRIBUTES;
|
2009-07-17 00:55:25 +08:00
|
|
|
}
|
2009-01-08 02:18:23 +08:00
|
|
|
/* First try to open the file with only allowing sharing for delete. If
|
|
|
|
the file has an open handle on it, other than just for deletion, this
|
|
|
|
will fail. That indicates that the file has to be moved to the recycle
|
|
|
|
bin so that it actually disappears from its directory even though its
|
|
|
|
in use. Otherwise, if opening doesn't fail, the file is not in use and
|
2011-11-07 18:03:30 +08:00
|
|
|
we can go straight to setting the delete disposition flag.
|
forkables: Create forkable hardlinks, yet unused.
In preparation to protect fork() against dll- and exe-updates, create
hardlinks to the main executable and each loaded dll in subdirectories
of /var/run/cygfork/, if that one exists on the NTFS file system.
The directory names consist of the user sid, the main executable's NTFS
IndexNumber, and the most recent LastWriteTime of all involved binaries
(dlls and main executable). Next to the main.exe hardlink we create the
empty file main.exe.local to enable dll redirection.
The name of the mutex to synchronize hardlink creation/cleanup also is
assembled from these directory names, to allow for synchronized cleanup
of even orphaned hardlink directories.
The hardlink to each dynamically loaded dll goes into another directory,
named using the NTFS IndexNumber of the dll's original directory.
* Makefile.in (DLL_OFILES): Add forkable.o.
* dll_init.h (struct dll): Declare member variables fbi, fii,
forkable_ntname. Declare methods nominate_forkable,
create_forkable.
(struct dll_list): Declare enum forkables_needs. Declare member
variables forkables_dirx_size, forkables_dirx_ntname,
forkables_mutex_name, forkables_mutex. Declare private methods
forkable_ntnamesize, prepare_forkables_nomination,
update_forkables_needs, update_forkables, create_forkables,
denominate_forkables, close_mutex, try_remove_forkables,
set_forkables_inheritance, request_forkables. Declare public
static methods ntopenfile, read_fii, read_fbi. Declare public
methods release_forkables, cleanup_forkables. Define public
inline method setup_forkables.
* dll_init.cc (dll_list::alloc): Allocate memory to hold the
name of the hardlink in struct dll member forkable_ntname.
Initialize struct dll members fbi, fii.
(dll_list::load_after_fork): Call release_forkables method.
* fork.cc: Rename public fork function to static dofork, add
with_forkables as bool pointer parameter. Add new fork function
calling dofork. (struct frok): Add bool pointer member
with_forkables, add as constructor parameter.
(frok::parent): Call dlls.setup_forkables before CreateProcessW,
dlls.release_forkables afterwards.
* pinfo.cc (pinfo::exit): Call dlls.cleanup_forkables.
* syscalls.cc (_unlink_nt): Rename public unlink_nt function to
static _unlink_nt, with 'shareable' as additional argument.
(unlink_nt): New, wrap _unlink_nt for original behaviour.
(unlink_nt_shareable): New, wrap _unlink_nt to keep a binary
file still loadable while removing one of its hardlinks.
* forkable.cc: New file.
Implement static functions mkdirs, rmdirs, rmdirs_synchronized,
stat_real_file_once, format_IndexNumber, rootname, sidname,
exename, lwtimename. Define static array forkable_nameparts.
(struct dll): Implement nominate_forkable, create_forkable.
(struct dll_list): Implement static methods ntopenfile,
read_fii, read_fbi. Implement forkable_ntnamesize,
2016-12-07 18:58:27 +08:00
|
|
|
However, while we have the file open with FILE_SHARE_DELETE, using
|
|
|
|
this file via another hardlink for anything other than DELETE by
|
|
|
|
concurrent processes fails. The 'shareable' argument is to prevent this.
|
2011-12-18 07:39:47 +08:00
|
|
|
|
2011-11-07 18:03:30 +08:00
|
|
|
NOTE: The missing sharing modes FILE_SHARE_READ and FILE_SHARE_WRITE do
|
|
|
|
NOT result in a STATUS_SHARING_VIOLATION, if another handle is
|
|
|
|
opened for reading/writing metadata only. In other words, if
|
|
|
|
another handle is open, but does not have the file open with
|
|
|
|
FILE_READ_DATA or FILE_WRITE_DATA, the following NtOpenFile call
|
|
|
|
will succeed. So, apparently there is no reliable way to find out
|
|
|
|
if a file is already open elsewhere for other purposes than
|
|
|
|
reading and writing data. */
|
forkables: Create forkable hardlinks, yet unused.
In preparation to protect fork() against dll- and exe-updates, create
hardlinks to the main executable and each loaded dll in subdirectories
of /var/run/cygfork/, if that one exists on the NTFS file system.
The directory names consist of the user sid, the main executable's NTFS
IndexNumber, and the most recent LastWriteTime of all involved binaries
(dlls and main executable). Next to the main.exe hardlink we create the
empty file main.exe.local to enable dll redirection.
The name of the mutex to synchronize hardlink creation/cleanup also is
assembled from these directory names, to allow for synchronized cleanup
of even orphaned hardlink directories.
The hardlink to each dynamically loaded dll goes into another directory,
named using the NTFS IndexNumber of the dll's original directory.
* Makefile.in (DLL_OFILES): Add forkable.o.
* dll_init.h (struct dll): Declare member variables fbi, fii,
forkable_ntname. Declare methods nominate_forkable,
create_forkable.
(struct dll_list): Declare enum forkables_needs. Declare member
variables forkables_dirx_size, forkables_dirx_ntname,
forkables_mutex_name, forkables_mutex. Declare private methods
forkable_ntnamesize, prepare_forkables_nomination,
update_forkables_needs, update_forkables, create_forkables,
denominate_forkables, close_mutex, try_remove_forkables,
set_forkables_inheritance, request_forkables. Declare public
static methods ntopenfile, read_fii, read_fbi. Declare public
methods release_forkables, cleanup_forkables. Define public
inline method setup_forkables.
* dll_init.cc (dll_list::alloc): Allocate memory to hold the
name of the hardlink in struct dll member forkable_ntname.
Initialize struct dll members fbi, fii.
(dll_list::load_after_fork): Call release_forkables method.
* fork.cc: Rename public fork function to static dofork, add
with_forkables as bool pointer parameter. Add new fork function
calling dofork. (struct frok): Add bool pointer member
with_forkables, add as constructor parameter.
(frok::parent): Call dlls.setup_forkables before CreateProcessW,
dlls.release_forkables afterwards.
* pinfo.cc (pinfo::exit): Call dlls.cleanup_forkables.
* syscalls.cc (_unlink_nt): Rename public unlink_nt function to
static _unlink_nt, with 'shareable' as additional argument.
(unlink_nt): New, wrap _unlink_nt for original behaviour.
(unlink_nt_shareable): New, wrap _unlink_nt to keep a binary
file still loadable while removing one of its hardlinks.
* forkable.cc: New file.
Implement static functions mkdirs, rmdirs, rmdirs_synchronized,
stat_real_file_once, format_IndexNumber, rootname, sidname,
exename, lwtimename. Define static array forkable_nameparts.
(struct dll): Implement nominate_forkable, create_forkable.
(struct dll_list): Implement static methods ntopenfile,
read_fii, read_fbi. Implement forkable_ntnamesize,
2016-12-07 18:58:27 +08:00
|
|
|
if (shareable)
|
|
|
|
status = STATUS_SHARING_VIOLATION;
|
|
|
|
else
|
|
|
|
status = NtOpenFile (&fh, access, &attr, &io, FILE_SHARE_DELETE, flags);
|
2012-07-25 20:32:37 +08:00
|
|
|
/* STATUS_SHARING_VIOLATION is what we expect. STATUS_LOCK_NOT_GRANTED can
|
|
|
|
be generated under not quite clear circumstances when trying to open a
|
|
|
|
file on NFS with FILE_SHARE_DELETE only. This has been observed with
|
|
|
|
SFU 3.5 if the NFS share has been mounted under a drive letter. It's
|
|
|
|
not generated for all files, but only for some. If it's generated once
|
|
|
|
for a file, it will be generated all the time. It looks as if wrong file
|
|
|
|
state information is stored within the NFS client which never times out.
|
|
|
|
Opening the file with FILE_SHARE_VALID_FLAGS will work, though, and it
|
|
|
|
is then possible to delete the file quite normally. */
|
2009-04-16 20:16:35 +08:00
|
|
|
if (status == STATUS_SHARING_VIOLATION || status == STATUS_LOCK_NOT_GRANTED)
|
2007-01-14 04:56:01 +08:00
|
|
|
{
|
2012-07-25 20:32:37 +08:00
|
|
|
debug_printf ("Sharing violation when opening %S",
|
|
|
|
pc.get_nt_native_path ());
|
2017-10-18 22:27:17 +08:00
|
|
|
/* We never call try_to_bin on NetApp. Netapp filesystems don't
|
|
|
|
understand the "move and delete" method at all and have all kinds
|
|
|
|
of weird effects. Just setting the delete dispositon usually
|
|
|
|
works fine, though.
|
2012-08-17 07:34:45 +08:00
|
|
|
|
|
|
|
NFS implements its own mechanism to remove in-use files, which looks
|
2017-10-18 22:27:17 +08:00
|
|
|
quite similar to what we do in try_to_bin for remote files. However,
|
|
|
|
apparently it doesn't work as desired in all cases. This has been
|
|
|
|
observed when running the gawk 4.1.62++ testcase "testext.awk" under
|
|
|
|
Windows 10. So for NFS we still call try_to_bin to rename the file,
|
|
|
|
at least to make room for subsequent creation of a file with the
|
|
|
|
same filename. */
|
|
|
|
if (!pc.fs_is_netapp ())
|
2009-01-12 23:51:23 +08:00
|
|
|
bin_stat = move_to_bin;
|
2012-07-25 20:32:37 +08:00
|
|
|
/* If the file is not a directory, of if we didn't set the move_to_bin
|
|
|
|
flag, just proceed with the FILE_SHARE_VALID_FLAGS set. */
|
|
|
|
if (!pc.isdir () || bin_stat == dont_move)
|
2007-07-29 20:27:22 +08:00
|
|
|
status = NtOpenFile (&fh, access, &attr, &io,
|
|
|
|
FILE_SHARE_VALID_FLAGS, flags);
|
2007-03-03 04:04:26 +08:00
|
|
|
else
|
|
|
|
{
|
2012-07-25 20:32:37 +08:00
|
|
|
/* Otherwise it's getting tricky. The directory is opened in some
|
|
|
|
process, so we're supposed to move it to the recycler and mark it
|
|
|
|
for deletion. But what if the directory is not empty? The move
|
2007-03-03 04:04:26 +08:00
|
|
|
will work, but the subsequent delete will fail. So we would
|
2012-07-25 20:32:37 +08:00
|
|
|
have to move it back. While we do that in try_to_bin, it's bad,
|
|
|
|
because the move results in a temporary inconsistent state.
|
|
|
|
So, we test first if the directory is empty. If not, we bail
|
|
|
|
out with STATUS_DIRECTORY_NOT_EMPTY. This avoids most of the
|
|
|
|
problems. */
|
2007-07-29 20:27:22 +08:00
|
|
|
status = NtOpenFile (&fh, access | FILE_LIST_DIRECTORY | SYNCHRONIZE,
|
2007-03-03 04:04:26 +08:00
|
|
|
&attr, &io, FILE_SHARE_VALID_FLAGS,
|
|
|
|
flags | FILE_SYNCHRONOUS_IO_NONALERT);
|
|
|
|
if (NT_SUCCESS (status))
|
|
|
|
{
|
2011-10-20 18:59:01 +08:00
|
|
|
status = check_dir_not_empty (fh, pc);
|
2007-03-03 04:04:26 +08:00
|
|
|
if (!NT_SUCCESS (status))
|
2008-02-16 01:53:11 +08:00
|
|
|
{
|
2007-07-29 20:27:22 +08:00
|
|
|
NtClose (fh);
|
2009-07-17 00:55:25 +08:00
|
|
|
if (fh_ro)
|
|
|
|
NtClose (fh_ro);
|
2010-09-12 19:41:56 +08:00
|
|
|
goto out;
|
2007-03-03 04:04:26 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-01-14 04:56:01 +08:00
|
|
|
}
|
2009-07-17 00:55:25 +08:00
|
|
|
if (fh_ro)
|
|
|
|
NtClose (fh_ro);
|
2006-12-08 01:40:24 +08:00
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
if (status == STATUS_DELETE_PENDING)
|
|
|
|
{
|
2011-10-20 18:59:01 +08:00
|
|
|
debug_printf ("Delete %S already pending", pc.get_nt_native_path ());
|
2011-11-07 18:03:30 +08:00
|
|
|
status = STATUS_SUCCESS;
|
2010-09-12 19:41:56 +08:00
|
|
|
goto out;
|
2006-12-08 01:40:24 +08:00
|
|
|
}
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("Opening %S for delete failed, status = %y",
|
2011-10-20 18:59:01 +08:00
|
|
|
pc.get_nt_native_path (), status);
|
2010-09-12 19:41:56 +08:00
|
|
|
goto out;
|
2006-12-08 01:40:24 +08:00
|
|
|
}
|
2009-01-12 23:51:23 +08:00
|
|
|
/* Try to move to bin if a sharing violation occured. If that worked,
|
|
|
|
we're done. */
|
|
|
|
if (bin_stat == move_to_bin
|
2013-11-27 22:27:34 +08:00
|
|
|
&& (bin_stat = try_to_bin (pc, fh, access, flags)) >= has_been_moved)
|
2010-09-12 19:41:56 +08:00
|
|
|
{
|
2012-07-25 20:32:37 +08:00
|
|
|
if (bin_stat == has_been_moved)
|
|
|
|
status = STATUS_SUCCESS;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
status = STATUS_DIRECTORY_NOT_EMPTY;
|
|
|
|
NtClose (fh);
|
|
|
|
}
|
2010-09-12 19:41:56 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2011-11-07 18:03:30 +08:00
|
|
|
|
|
|
|
try_again:
|
2009-01-12 23:51:23 +08:00
|
|
|
/* Try to set delete disposition. */
|
2007-07-29 20:27:22 +08:00
|
|
|
status = NtSetInformationFile (fh, &io, &disp, sizeof disp,
|
|
|
|
FileDispositionInformation);
|
2006-12-08 01:40:24 +08:00
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("Setting delete disposition on %S failed, status = %y",
|
2011-10-20 18:59:01 +08:00
|
|
|
pc.get_nt_native_path (), status);
|
2011-11-07 18:03:30 +08:00
|
|
|
if (status == STATUS_DIRECTORY_NOT_EMPTY)
|
2011-10-20 18:59:01 +08:00
|
|
|
{
|
2011-11-07 18:03:30 +08:00
|
|
|
NTSTATUS status2 = STATUS_SUCCESS;
|
|
|
|
|
|
|
|
if (!reopened)
|
|
|
|
{
|
|
|
|
/* Have to close and reopen the file from scratch, otherwise
|
|
|
|
we collide with the delete-only sharing mode. */
|
|
|
|
pc.get_object_attr (attr, sec_none_nih);
|
|
|
|
NtClose (fh);
|
|
|
|
status2 = NtOpenFile (&fh, access | FILE_LIST_DIRECTORY
|
|
|
|
| SYNCHRONIZE,
|
|
|
|
&attr, &io, FILE_SHARE_VALID_FLAGS,
|
|
|
|
flags | FILE_SYNCHRONOUS_IO_NONALERT);
|
|
|
|
}
|
|
|
|
if (NT_SUCCESS (status2) && reopened < 20)
|
|
|
|
{
|
|
|
|
/* Workaround rm -r problem:
|
2011-12-18 07:39:47 +08:00
|
|
|
|
2011-11-07 18:03:30 +08:00
|
|
|
Sometimes a deleted directory lingers in its parent dir
|
|
|
|
after the deleting handle has already been closed. This
|
|
|
|
can break deleting the parent dir. See the comment in
|
|
|
|
check_dir_not_empty for more information.
|
|
|
|
|
|
|
|
What we do here is this: If check_dir_not_empty returns
|
|
|
|
STATUS_SUCCESS, the dir is either empty, or only inhabited
|
|
|
|
by already deleted entries. If so, we try to move the dir
|
|
|
|
into the bin. This usually works.
|
2011-12-18 07:39:47 +08:00
|
|
|
|
2011-11-07 18:03:30 +08:00
|
|
|
However, if we're on a filesystem which doesn't support
|
|
|
|
the try_to_bin method, or if moving to the bin doesn't work
|
|
|
|
for some reason, just try to delete the directory again,
|
|
|
|
with a very short grace period to free the CPU for a while.
|
|
|
|
This gives the OS time to clean up. 5ms is enough in my
|
|
|
|
testing to make sure that we don't have to try more than
|
|
|
|
once in practically all cases.
|
|
|
|
While this is an extrem bordercase, we don't want to hang
|
|
|
|
infinitely in case a file in the directory is in the "delete
|
|
|
|
pending" state but an application holds an open handle to it
|
|
|
|
for a longer time. So we don't try this more than 20 times,
|
|
|
|
which means a process time of 100-120ms. */
|
|
|
|
if (check_dir_not_empty (fh, pc) == STATUS_SUCCESS)
|
|
|
|
{
|
|
|
|
if (bin_stat == dont_move)
|
|
|
|
{
|
|
|
|
bin_stat = move_to_bin;
|
|
|
|
if (!pc.fs_is_nfs () && !pc.fs_is_netapp ())
|
|
|
|
{
|
|
|
|
debug_printf ("Try-to-bin %S",
|
|
|
|
pc.get_nt_native_path ());
|
2013-11-27 22:27:34 +08:00
|
|
|
bin_stat = try_to_bin (pc, fh, access, flags);
|
2011-11-07 18:03:30 +08:00
|
|
|
}
|
|
|
|
}
|
2012-07-25 20:32:37 +08:00
|
|
|
/* Do NOT handle bin_stat == dir_not_empty here! */
|
2011-11-07 18:03:30 +08:00
|
|
|
if (bin_stat == has_been_moved)
|
|
|
|
status = STATUS_SUCCESS;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
debug_printf ("Try %S again", pc.get_nt_native_path ());
|
|
|
|
++reopened;
|
|
|
|
Sleep (5L);
|
|
|
|
goto try_again;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-07-25 20:32:37 +08:00
|
|
|
else if (status2 != STATUS_OBJECT_PATH_NOT_FOUND
|
|
|
|
&& status2 != STATUS_OBJECT_NAME_NOT_FOUND)
|
2011-10-20 18:59:01 +08:00
|
|
|
{
|
|
|
|
fh = NULL;
|
|
|
|
debug_printf ("Opening dir %S for check_dir_not_empty failed, "
|
2013-04-23 17:44:36 +08:00
|
|
|
"status = %y", pc.get_nt_native_path (), status2);
|
2011-10-20 18:59:01 +08:00
|
|
|
}
|
2012-07-25 20:32:37 +08:00
|
|
|
else /* Directory disappeared between NtClose and NtOpenFile. */
|
|
|
|
status = STATUS_SUCCESS;
|
2011-10-20 18:59:01 +08:00
|
|
|
}
|
2009-01-08 02:18:23 +08:00
|
|
|
/* Trying to delete a hardlink to a file in use by the system in some
|
|
|
|
way (for instance, font files) by setting the delete disposition fails
|
|
|
|
with STATUS_CANNOT_DELETE. Strange enough, deleting these hardlinks
|
2009-01-12 23:51:23 +08:00
|
|
|
using delete-on-close semantic works... most of the time.
|
2009-07-01 05:18:44 +08:00
|
|
|
|
2009-01-08 02:18:23 +08:00
|
|
|
Don't use delete-on-close on remote shares. If two processes
|
|
|
|
have open handles on a file and one of them calls unlink, the
|
|
|
|
file is removed from the remote share even though the other
|
|
|
|
process still has an open handle. That process than gets Win32
|
|
|
|
error 59, ERROR_UNEXP_NET_ERR when trying to access the file.
|
|
|
|
Microsoft KB 837665 describes this problem as a bug in 2K3, but
|
|
|
|
I have reproduced it on other systems. */
|
2011-11-07 18:03:30 +08:00
|
|
|
else if (status == STATUS_CANNOT_DELETE
|
|
|
|
&& (!pc.isremote () || pc.fs_is_ncfsd ()))
|
2009-07-01 05:18:44 +08:00
|
|
|
{
|
2009-01-08 02:18:23 +08:00
|
|
|
HANDLE fh2;
|
|
|
|
|
2011-10-20 18:59:01 +08:00
|
|
|
debug_printf ("Cannot delete %S, try delete-on-close",
|
|
|
|
pc.get_nt_native_path ());
|
2009-01-08 02:18:23 +08:00
|
|
|
/* Re-open from handle so we open the correct file no matter if it
|
|
|
|
has been moved to the bin or not. */
|
2014-08-27 04:47:46 +08:00
|
|
|
status = NtOpenFile (&fh2, DELETE,
|
|
|
|
pc.init_reopen_attr (attr, fh), &io,
|
2009-01-12 23:51:23 +08:00
|
|
|
bin_stat == move_to_bin ? FILE_SHARE_VALID_FLAGS
|
|
|
|
: FILE_SHARE_DELETE,
|
2009-01-08 02:18:23 +08:00
|
|
|
flags | FILE_DELETE_ON_CLOSE);
|
|
|
|
if (!NT_SUCCESS (status))
|
2009-01-12 23:51:23 +08:00
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("Setting delete-on-close on %S failed, status = %y",
|
2011-10-20 18:59:01 +08:00
|
|
|
pc.get_nt_native_path (), status);
|
2009-01-12 23:51:23 +08:00
|
|
|
/* This is really the last chance. If it hasn't been moved
|
2009-07-01 05:18:44 +08:00
|
|
|
to the bin already, try it now. If moving to the bin
|
2009-01-12 23:51:23 +08:00
|
|
|
succeeds, we got rid of the file in some way, even if
|
|
|
|
unlinking didn't work. */
|
|
|
|
if (bin_stat == dont_move)
|
2013-11-27 22:27:34 +08:00
|
|
|
bin_stat = try_to_bin (pc, fh, access, flags);
|
2012-07-25 20:32:37 +08:00
|
|
|
if (bin_stat >= has_been_moved)
|
|
|
|
status = bin_stat == has_been_moved
|
|
|
|
? STATUS_SUCCESS
|
|
|
|
: STATUS_DIRECTORY_NOT_EMPTY;
|
2009-01-12 23:51:23 +08:00
|
|
|
}
|
2009-01-08 02:18:23 +08:00
|
|
|
else
|
|
|
|
NtClose (fh2);
|
|
|
|
}
|
2006-12-08 01:40:24 +08:00
|
|
|
}
|
2009-01-12 23:51:23 +08:00
|
|
|
if (fh)
|
2007-07-29 23:57:41 +08:00
|
|
|
{
|
2010-09-12 19:41:56 +08:00
|
|
|
if (access & FILE_WRITE_ATTRIBUTES)
|
2011-06-06 13:02:13 +08:00
|
|
|
{
|
2012-07-25 20:32:37 +08:00
|
|
|
/* Restore R/O attribute if setting the delete disposition failed. */
|
2010-09-12 19:41:56 +08:00
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
NtSetAttributesFile (fh, pc.file_attributes ());
|
|
|
|
/* If we succeeded, restore R/O attribute to accommodate hardlinks.
|
|
|
|
Only ever try to do this for our own winsymlinks, because there's
|
|
|
|
a problem with setting the delete disposition:
|
|
|
|
http://msdn.microsoft.com/en-us/library/ff545765%28VS.85%29.aspx
|
|
|
|
"Subsequently, the only legal operation by such a caller is
|
|
|
|
to close the open file handle."
|
2011-05-06 06:30:53 +08:00
|
|
|
|
2015-12-16 04:43:33 +08:00
|
|
|
FIXME? We could use FILE_HARD_LINK_INFORMATION to find all
|
|
|
|
hardlinks and use one of them to restore the R/O bit, after the
|
|
|
|
NtClose, but before we stop the transaction. This avoids the
|
|
|
|
aforementioned problem entirely . */
|
2010-09-12 19:41:56 +08:00
|
|
|
else if (pc.is_lnk_symlink () && num_links > 1)
|
|
|
|
NtSetAttributesFile (fh, pc.file_attributes ());
|
|
|
|
}
|
|
|
|
|
2009-01-12 23:51:23 +08:00
|
|
|
NtClose (fh);
|
2010-09-12 19:41:56 +08:00
|
|
|
|
2007-07-29 23:57:41 +08:00
|
|
|
}
|
2010-09-12 19:41:56 +08:00
|
|
|
out:
|
|
|
|
/* Stop transaction if we started one. */
|
2013-12-11 20:12:12 +08:00
|
|
|
if (trans)
|
2010-09-12 19:41:56 +08:00
|
|
|
stop_transaction (status, old_trans, trans);
|
2021-01-21 00:10:51 +08:00
|
|
|
|
|
|
|
if (pc.isdir ())
|
|
|
|
status = _unlink_nt_post_dir_check (status, &attr, pc);
|
|
|
|
|
2013-04-23 17:44:36 +08:00
|
|
|
syscall_printf ("%S, return status = %y", pc.get_nt_native_path (), status);
|
2007-07-29 20:27:22 +08:00
|
|
|
return status;
|
2006-12-08 01:40:24 +08:00
|
|
|
}
|
|
|
|
|
forkables: Create forkable hardlinks, yet unused.
In preparation to protect fork() against dll- and exe-updates, create
hardlinks to the main executable and each loaded dll in subdirectories
of /var/run/cygfork/, if that one exists on the NTFS file system.
The directory names consist of the user sid, the main executable's NTFS
IndexNumber, and the most recent LastWriteTime of all involved binaries
(dlls and main executable). Next to the main.exe hardlink we create the
empty file main.exe.local to enable dll redirection.
The name of the mutex to synchronize hardlink creation/cleanup also is
assembled from these directory names, to allow for synchronized cleanup
of even orphaned hardlink directories.
The hardlink to each dynamically loaded dll goes into another directory,
named using the NTFS IndexNumber of the dll's original directory.
* Makefile.in (DLL_OFILES): Add forkable.o.
* dll_init.h (struct dll): Declare member variables fbi, fii,
forkable_ntname. Declare methods nominate_forkable,
create_forkable.
(struct dll_list): Declare enum forkables_needs. Declare member
variables forkables_dirx_size, forkables_dirx_ntname,
forkables_mutex_name, forkables_mutex. Declare private methods
forkable_ntnamesize, prepare_forkables_nomination,
update_forkables_needs, update_forkables, create_forkables,
denominate_forkables, close_mutex, try_remove_forkables,
set_forkables_inheritance, request_forkables. Declare public
static methods ntopenfile, read_fii, read_fbi. Declare public
methods release_forkables, cleanup_forkables. Define public
inline method setup_forkables.
* dll_init.cc (dll_list::alloc): Allocate memory to hold the
name of the hardlink in struct dll member forkable_ntname.
Initialize struct dll members fbi, fii.
(dll_list::load_after_fork): Call release_forkables method.
* fork.cc: Rename public fork function to static dofork, add
with_forkables as bool pointer parameter. Add new fork function
calling dofork. (struct frok): Add bool pointer member
with_forkables, add as constructor parameter.
(frok::parent): Call dlls.setup_forkables before CreateProcessW,
dlls.release_forkables afterwards.
* pinfo.cc (pinfo::exit): Call dlls.cleanup_forkables.
* syscalls.cc (_unlink_nt): Rename public unlink_nt function to
static _unlink_nt, with 'shareable' as additional argument.
(unlink_nt): New, wrap _unlink_nt for original behaviour.
(unlink_nt_shareable): New, wrap _unlink_nt to keep a binary
file still loadable while removing one of its hardlinks.
* forkable.cc: New file.
Implement static functions mkdirs, rmdirs, rmdirs_synchronized,
stat_real_file_once, format_IndexNumber, rootname, sidname,
exename, lwtimename. Define static array forkable_nameparts.
(struct dll): Implement nominate_forkable, create_forkable.
(struct dll_list): Implement static methods ntopenfile,
read_fii, read_fbi. Implement forkable_ntnamesize,
2016-12-07 18:58:27 +08:00
|
|
|
NTSTATUS
|
|
|
|
unlink_nt (path_conv &pc)
|
|
|
|
{
|
|
|
|
return _unlink_nt (pc, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
NTSTATUS
|
|
|
|
unlink_nt_shareable (path_conv &pc)
|
|
|
|
{
|
|
|
|
return _unlink_nt (pc, true);
|
|
|
|
}
|
|
|
|
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2002-10-21 09:00:58 +08:00
|
|
|
unlink (const char *ourname)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
int res = -1;
|
2013-04-23 17:44:36 +08:00
|
|
|
dev_t devn;
|
2007-07-29 20:27:22 +08:00
|
|
|
NTSTATUS status;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-04-14 00:47:21 +08:00
|
|
|
path_conv win32_name (ourname, PC_SYM_NOFOLLOW, stat_suffixes);
|
2000-02-18 03:38:33 +08:00
|
|
|
|
|
|
|
if (win32_name.error)
|
|
|
|
{
|
|
|
|
set_errno (win32_name.error);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2013-04-23 17:44:36 +08:00
|
|
|
devn = win32_name.get_device ();
|
2007-01-18 03:26:58 +08:00
|
|
|
if (isproc_dev (devn))
|
2002-06-06 00:01:55 +08:00
|
|
|
{
|
|
|
|
set_errno (EROFS);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2001-10-01 12:10:07 +08:00
|
|
|
if (!win32_name.exists ())
|
2001-07-18 19:00:05 +08:00
|
|
|
{
|
2011-10-20 18:59:01 +08:00
|
|
|
debug_printf ("unlinking a nonexistent file");
|
2001-07-18 19:00:05 +08:00
|
|
|
set_errno (ENOENT);
|
|
|
|
goto done;
|
|
|
|
}
|
2001-10-01 12:10:07 +08:00
|
|
|
else if (win32_name.isdir ())
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2011-10-20 18:59:01 +08:00
|
|
|
debug_printf ("unlinking a directory");
|
2021-01-15 21:45:27 +08:00
|
|
|
set_errno (EISDIR);
|
2000-02-18 03:38:33 +08:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2007-07-29 20:27:22 +08:00
|
|
|
status = unlink_nt (win32_name);
|
|
|
|
if (NT_SUCCESS (status))
|
2006-12-08 01:40:24 +08:00
|
|
|
res = 0;
|
|
|
|
else
|
2007-08-14 01:16:05 +08:00
|
|
|
__seterrno_from_nt_status (status);
|
2000-05-05 03:46:32 +08:00
|
|
|
|
2001-06-19 05:18:59 +08:00
|
|
|
done:
|
2011-12-04 05:43:27 +08:00
|
|
|
syscall_printf ("%R = unlink(%s)", res, ourname);
|
2000-02-18 03:38:33 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2003-08-24 02:03:16 +08:00
|
|
|
extern "C" int
|
|
|
|
_remove_r (struct _reent *, const char *ourname)
|
|
|
|
{
|
2005-05-13 23:46:07 +08:00
|
|
|
path_conv win32_name (ourname, PC_SYM_NOFOLLOW);
|
2003-08-24 02:03:16 +08:00
|
|
|
|
|
|
|
if (win32_name.error)
|
|
|
|
{
|
|
|
|
set_errno (win32_name.error);
|
2011-12-04 05:43:27 +08:00
|
|
|
syscall_printf ("%R = remove(%s)",-1, ourname);
|
2003-08-24 02:03:16 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2021-01-22 23:47:12 +08:00
|
|
|
int res = win32_name.isdir () ? rmdir (ourname) : unlink (ourname);
|
|
|
|
syscall_printf ("%R = remove(%s)", res, ourname);
|
|
|
|
return res;
|
2003-08-24 02:03:16 +08:00
|
|
|
}
|
|
|
|
|
2000-12-20 04:43:41 +08:00
|
|
|
extern "C" int
|
|
|
|
remove (const char *ourname)
|
|
|
|
{
|
2021-01-22 23:47:12 +08:00
|
|
|
return _remove_r (_REENT, ourname);
|
2000-12-20 04:43:41 +08:00
|
|
|
}
|
|
|
|
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" pid_t
|
2002-10-20 12:15:50 +08:00
|
|
|
getpid ()
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2011-12-17 08:03:31 +08:00
|
|
|
syscall_printf ("%d = getpid()", myself->pid);
|
2000-02-18 03:38:33 +08:00
|
|
|
return myself->pid;
|
|
|
|
}
|
|
|
|
|
2002-10-20 12:15:50 +08:00
|
|
|
extern "C" pid_t
|
|
|
|
_getpid_r (struct _reent *)
|
|
|
|
{
|
|
|
|
return getpid ();
|
|
|
|
}
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
/* getppid: POSIX 4.1.1.1 */
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" pid_t
|
2000-02-18 03:38:33 +08:00
|
|
|
getppid ()
|
|
|
|
{
|
2011-12-17 08:03:31 +08:00
|
|
|
syscall_printf ("%d = getppid()", myself->ppid);
|
2000-02-18 03:38:33 +08:00
|
|
|
return myself->ppid;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* setsid: POSIX 4.3.2.1 */
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" pid_t
|
2000-02-18 03:38:33 +08:00
|
|
|
setsid (void)
|
|
|
|
{
|
2003-12-24 00:26:31 +08:00
|
|
|
if (myself->pgid == myself->pid)
|
|
|
|
syscall_printf ("hmm. pgid %d pid %d", myself->pgid, myself->pid);
|
|
|
|
else
|
2002-08-18 13:49:26 +08:00
|
|
|
{
|
2012-02-11 00:43:36 +08:00
|
|
|
myself->ctty = -2;
|
2012-02-15 03:08:20 +08:00
|
|
|
myself->sid = myself->pid;
|
|
|
|
myself->pgid = myself->pid;
|
2003-12-11 14:12:41 +08:00
|
|
|
if (cygheap->ctty)
|
2004-01-14 23:45:37 +08:00
|
|
|
cygheap->close_ctty ();
|
2005-11-14 13:36:16 +08:00
|
|
|
syscall_printf ("sid %d, pgid %d, %s", myself->sid, myself->pgid, myctty ());
|
2000-02-18 03:38:33 +08:00
|
|
|
return myself->sid;
|
|
|
|
}
|
2002-08-18 13:49:26 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
set_errno (EPERM);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2002-08-18 13:49:26 +08:00
|
|
|
extern "C" pid_t
|
|
|
|
getsid (pid_t pid)
|
|
|
|
{
|
|
|
|
pid_t res;
|
|
|
|
if (!pid)
|
|
|
|
res = myself->sid;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
pinfo p (pid);
|
|
|
|
if (p)
|
|
|
|
res = p->sid;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
set_errno (ESRCH);
|
|
|
|
res = -1;
|
|
|
|
}
|
|
|
|
}
|
2011-12-17 08:03:31 +08:00
|
|
|
syscall_printf ("%R = getsid(%d)", pid);
|
2002-08-18 13:49:26 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2001-03-08 04:52:33 +08:00
|
|
|
extern "C" ssize_t
|
2002-10-21 09:00:58 +08:00
|
|
|
read (int fd, void *ptr, size_t len)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2011-05-06 18:56:37 +08:00
|
|
|
size_t res = (size_t) -1;
|
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
pthread_testcancel ();
|
2011-05-06 18:56:37 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2002-08-30 23:47:10 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd < 0)
|
|
|
|
__leave;
|
2002-08-30 23:47:10 +08:00
|
|
|
|
2019-01-08 02:33:11 +08:00
|
|
|
if ((cfd->get_flags () & O_PATH)
|
|
|
|
|| (cfd->get_flags () & O_ACCMODE) == O_WRONLY)
|
2014-08-22 17:21:33 +08:00
|
|
|
{
|
|
|
|
set_errno (EBADF);
|
|
|
|
__leave;
|
|
|
|
}
|
2011-05-06 18:56:37 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
/* Could block, so let user know we at least got here. */
|
|
|
|
syscall_printf ("read(%d, %p, %d) %sblocking",
|
|
|
|
fd, ptr, len, cfd->is_nonblocking () ? "non" : "");
|
2011-05-06 18:56:37 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
cfd->read (ptr, len);
|
|
|
|
res = len;
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
2013-04-23 17:44:36 +08:00
|
|
|
syscall_printf ("%lR = read(%d, %p, %d)", res, fd, ptr, len);
|
2011-05-06 18:56:37 +08:00
|
|
|
return (ssize_t) res;
|
2002-08-30 23:47:10 +08:00
|
|
|
}
|
2001-10-24 12:16:45 +08:00
|
|
|
|
2011-02-22 17:17:57 +08:00
|
|
|
EXPORT_ALIAS (read, _read)
|
|
|
|
|
2005-07-30 01:04:46 +08:00
|
|
|
extern "C" ssize_t
|
2011-05-06 18:56:37 +08:00
|
|
|
readv (int fd, const struct iovec *const iov, const int iovcnt)
|
2005-07-30 01:04:46 +08:00
|
|
|
{
|
2011-05-06 18:56:37 +08:00
|
|
|
ssize_t res = -1;
|
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
pthread_testcancel ();
|
2005-07-30 01:04:46 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2011-05-06 18:56:37 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
const ssize_t tot = check_iovec_for_read (iov, iovcnt);
|
2011-05-06 18:56:37 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd < 0)
|
|
|
|
__leave;
|
2011-05-06 18:56:37 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
if (tot <= 0)
|
|
|
|
{
|
|
|
|
res = tot;
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
|
2019-01-08 02:33:11 +08:00
|
|
|
if ((cfd->get_flags () & O_PATH)
|
|
|
|
|| (cfd->get_flags () & O_ACCMODE) == O_WRONLY)
|
2014-08-22 17:21:33 +08:00
|
|
|
{
|
|
|
|
set_errno (EBADF);
|
|
|
|
__leave;
|
|
|
|
}
|
2011-05-06 18:56:37 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
/* Could block, so let user know we at least got here. */
|
|
|
|
syscall_printf ("readv(%d, %p, %d) %sblocking",
|
|
|
|
fd, iov, iovcnt, cfd->is_nonblocking () ? "non" : "");
|
2011-05-06 18:56:37 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
res = cfd->readv (iov, iovcnt, tot);
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
2013-04-23 17:44:36 +08:00
|
|
|
syscall_printf ("%lR = readv(%d, %p, %d)", res, fd, iov, iovcnt);
|
2005-07-30 01:04:46 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" ssize_t
|
2013-04-23 17:44:36 +08:00
|
|
|
pread (int fd, void *ptr, size_t len, off_t off)
|
2005-07-30 01:04:46 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
ssize_t res;
|
|
|
|
|
2011-05-01 00:34:48 +08:00
|
|
|
pthread_testcancel ();
|
|
|
|
|
2005-07-30 01:04:46 +08:00
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd < 0)
|
|
|
|
res = -1;
|
2019-01-08 02:33:11 +08:00
|
|
|
else if (cfd->get_flags () & O_PATH)
|
|
|
|
{
|
|
|
|
set_errno (EBADF);
|
|
|
|
res = -1;
|
|
|
|
}
|
2005-07-30 01:04:46 +08:00
|
|
|
else
|
2011-05-06 18:56:37 +08:00
|
|
|
res = cfd->pread (ptr, len, off);
|
2005-07-30 01:04:46 +08:00
|
|
|
|
2013-04-23 17:44:36 +08:00
|
|
|
syscall_printf ("%lR = pread(%d, %p, %d, %d)", res, fd, ptr, len, off);
|
2005-07-30 01:04:46 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2002-08-30 23:47:10 +08:00
|
|
|
extern "C" ssize_t
|
2002-10-21 09:00:58 +08:00
|
|
|
write (int fd, const void *ptr, size_t len)
|
2002-08-30 23:47:10 +08:00
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
ssize_t res = -1;
|
2002-08-30 23:47:10 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
pthread_testcancel ();
|
2011-05-06 02:46:38 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd < 0)
|
|
|
|
__leave;
|
2001-04-01 08:06:17 +08:00
|
|
|
|
2019-01-08 02:33:11 +08:00
|
|
|
if ((cfd->get_flags () & O_PATH)
|
|
|
|
|| (cfd->get_flags () & O_ACCMODE) == O_RDONLY)
|
2014-08-22 17:21:33 +08:00
|
|
|
{
|
|
|
|
set_errno (EBADF);
|
|
|
|
__leave;
|
|
|
|
}
|
2001-10-31 08:55:32 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
/* Could block, so let user know we at least got here. */
|
|
|
|
if (fd == 1 || fd == 2)
|
|
|
|
paranoid_printf ("write(%d, %p, %d)", fd, ptr, len);
|
|
|
|
else
|
|
|
|
syscall_printf ("write(%d, %p, %d)", fd, ptr, len);
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
res = cfd->write (ptr, len);
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
2013-04-23 17:44:36 +08:00
|
|
|
syscall_printf ("%lR = write(%d, %p, %d)", res, fd, ptr, len);
|
2000-09-26 00:36:12 +08:00
|
|
|
return res;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2011-05-06 18:56:37 +08:00
|
|
|
EXPORT_ALIAS (write, _write)
|
|
|
|
|
2001-03-08 04:52:33 +08:00
|
|
|
extern "C" ssize_t
|
2002-08-30 23:47:10 +08:00
|
|
|
writev (const int fd, const struct iovec *const iov, const int iovcnt)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
ssize_t res = -1;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
pthread_testcancel ();
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2001-11-15 11:25:52 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
const ssize_t tot = check_iovec_for_write (iov, iovcnt);
|
2001-11-15 11:25:52 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd < 0)
|
|
|
|
__leave;
|
2001-11-15 11:25:52 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
if (tot <= 0)
|
|
|
|
{
|
|
|
|
res = tot;
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
|
2019-01-08 02:33:11 +08:00
|
|
|
if ((cfd->get_flags () & O_PATH)
|
|
|
|
|| (cfd->get_flags () & O_ACCMODE) == O_RDONLY)
|
2014-08-22 17:21:33 +08:00
|
|
|
{
|
|
|
|
set_errno (EBADF);
|
|
|
|
__leave;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
/* Could block, so let user know we at least got here. */
|
|
|
|
if (fd == 1 || fd == 2)
|
|
|
|
paranoid_printf ("writev(%d, %p, %d)", fd, iov, iovcnt);
|
|
|
|
else
|
|
|
|
syscall_printf ("writev(%d, %p, %d)", fd, iov, iovcnt);
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
res = cfd->writev (iov, iovcnt, tot);
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
2000-02-18 03:38:33 +08:00
|
|
|
if (fd == 1 || fd == 2)
|
2013-04-23 17:44:36 +08:00
|
|
|
paranoid_printf ("%lR = writev(%d, %p, %d)", res, fd, iov, iovcnt);
|
2000-02-18 03:38:33 +08:00
|
|
|
else
|
2013-04-23 17:44:36 +08:00
|
|
|
syscall_printf ("%lR = writev(%d, %p, %d)", res, fd, iov, iovcnt);
|
2002-08-30 23:47:10 +08:00
|
|
|
return res;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2011-05-06 18:56:37 +08:00
|
|
|
extern "C" ssize_t
|
2013-04-23 17:44:36 +08:00
|
|
|
pwrite (int fd, void *ptr, size_t len, off_t off)
|
2011-05-06 18:56:37 +08:00
|
|
|
{
|
|
|
|
pthread_testcancel ();
|
|
|
|
|
|
|
|
ssize_t res;
|
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd < 0)
|
|
|
|
res = -1;
|
2019-01-08 02:33:11 +08:00
|
|
|
else if (cfd->get_flags () & O_PATH)
|
|
|
|
{
|
|
|
|
set_errno (EBADF);
|
|
|
|
res = -1;
|
|
|
|
}
|
2011-05-06 18:56:37 +08:00
|
|
|
else
|
|
|
|
res = cfd->pwrite (ptr, len, off);
|
|
|
|
|
2013-04-23 17:44:36 +08:00
|
|
|
syscall_printf ("%lR = pwrite(%d, %p, %d, %d)", res, fd, ptr, len, off);
|
2011-05-06 18:56:37 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
/* _open */
|
|
|
|
/* newlib's fcntl.h defines _open as taking variable args so we must
|
|
|
|
correspond. The third arg if it exists is: mode_t mode. */
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2002-10-21 09:00:58 +08:00
|
|
|
open (const char *unix_path, int flags, ...)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
int res = -1;
|
|
|
|
va_list ap;
|
|
|
|
mode_t mode = 0;
|
2017-11-14 23:28:44 +08:00
|
|
|
fhandler_base *fh = NULL;
|
2019-01-06 05:13:42 +08:00
|
|
|
fhandler_base *fh_file = NULL;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2011-05-01 00:34:48 +08:00
|
|
|
pthread_testcancel ();
|
2014-08-22 17:21:33 +08:00
|
|
|
|
|
|
|
__try
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
syscall_printf ("open(%s, %y)", unix_path, flags);
|
|
|
|
if (!*unix_path)
|
|
|
|
{
|
2017-11-14 23:28:44 +08:00
|
|
|
set_errno (ENOENT);
|
|
|
|
__leave;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2017-11-14 23:28:44 +08:00
|
|
|
/* check for optional mode argument */
|
|
|
|
va_start (ap, flags);
|
|
|
|
mode = va_arg (ap, mode_t);
|
|
|
|
va_end (ap);
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2017-11-14 23:28:44 +08:00
|
|
|
cygheap_fdnew fd;
|
|
|
|
|
|
|
|
if (fd < 0)
|
|
|
|
__leave; /* errno already set */
|
|
|
|
|
2019-01-08 02:33:11 +08:00
|
|
|
/* When O_PATH is specified in flags, flag bits other than O_CLOEXEC,
|
|
|
|
O_DIRECTORY, and O_NOFOLLOW are ignored. */
|
|
|
|
if (flags & O_PATH)
|
|
|
|
flags &= (O_PATH | O_CLOEXEC | O_DIRECTORY | O_NOFOLLOW);
|
|
|
|
|
2019-01-07 03:13:52 +08:00
|
|
|
int opt = PC_OPEN | PC_SYM_NOFOLLOW_PROCFD;
|
|
|
|
opt |= (flags & (O_NOFOLLOW | O_EXCL)) ? PC_SYM_NOFOLLOW
|
|
|
|
: PC_SYM_FOLLOW;
|
2017-11-14 23:28:44 +08:00
|
|
|
/* This is a temporary kludge until all utilities can catch up
|
|
|
|
with a change in behavior that implements linux functionality:
|
|
|
|
opening a tty should not automatically cause it to become the
|
|
|
|
controlling tty for the process. */
|
|
|
|
if (!(flags & O_NOCTTY) && fd > 2 && myself->ctty != -2)
|
|
|
|
{
|
|
|
|
flags |= O_NOCTTY;
|
|
|
|
/* flag that, if opened, this fhandler could later be capable
|
|
|
|
of being a controlling terminal if /dev/tty is opened. */
|
|
|
|
opt |= PC_CTTY;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2017-11-14 23:28:44 +08:00
|
|
|
if (!(fh = build_fh_name (unix_path, opt, stat_suffixes)))
|
|
|
|
__leave; /* errno already set */
|
2019-12-28 00:43:58 +08:00
|
|
|
if ((flags & O_NOFOLLOW) && fh->issymlink () && !(flags & O_PATH))
|
2017-11-14 23:28:44 +08:00
|
|
|
{
|
|
|
|
set_errno (ELOOP);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
if ((flags & O_DIRECTORY) && fh->exists () && !fh->pc.isdir ())
|
|
|
|
{
|
|
|
|
set_errno (ENOTDIR);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
if (((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)) && fh->exists ())
|
|
|
|
{
|
|
|
|
set_errno (EEXIST);
|
|
|
|
__leave;
|
|
|
|
}
|
2017-11-15 04:28:45 +08:00
|
|
|
if (flags & O_TMPFILE)
|
|
|
|
{
|
|
|
|
if ((flags & O_ACCMODE) != O_WRONLY && (flags & O_ACCMODE) != O_RDWR)
|
|
|
|
{
|
|
|
|
set_errno (EINVAL);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
if (!fh->pc.isdir ())
|
|
|
|
{
|
|
|
|
set_errno (fh->exists () ? ENOTDIR : ENOENT);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
/* Unfortunately Windows does not allow to create a nameless file.
|
|
|
|
So create unique filename instead. It starts with ".cyg_tmp_",
|
|
|
|
followed by an 8 byte unique hex number, followed by an 8 byte
|
|
|
|
random hex number. */
|
|
|
|
int64_t rnd;
|
|
|
|
char *new_path;
|
|
|
|
|
|
|
|
new_path = (char *) malloc (strlen (fh->get_name ())
|
|
|
|
+ 1 /* slash */
|
|
|
|
+ 10 /* prefix */
|
|
|
|
+ 16 /* 64 bit unique id as hex*/
|
|
|
|
+ 16 /* 64 bit random number as hex */
|
|
|
|
+ 1 /* trailing NUL */);
|
|
|
|
if (!new_path)
|
|
|
|
__leave;
|
|
|
|
fh->set_unique_id ();
|
|
|
|
RtlGenRandom (&rnd, sizeof rnd);
|
|
|
|
__small_sprintf (new_path, "%s/%s%016X%016X",
|
|
|
|
fh->get_name (), ".cyg_tmp_",
|
|
|
|
fh->get_unique_id (), rnd);
|
|
|
|
|
|
|
|
if (!(fh_file = build_fh_name (new_path, opt, NULL)))
|
|
|
|
{
|
|
|
|
free (new_path);
|
|
|
|
__leave; /* errno already set */
|
|
|
|
}
|
|
|
|
delete fh;
|
|
|
|
fh = fh_file;
|
|
|
|
}
|
|
|
|
|
2019-01-07 03:13:52 +08:00
|
|
|
if (fh->dev () == FH_PROCESSFD && fh->pc.follow_fd_symlink ())
|
2019-01-06 05:13:42 +08:00
|
|
|
{
|
|
|
|
/* Reopen file by descriptor */
|
2019-02-05 22:20:13 +08:00
|
|
|
fh_file = fh->fd_reopen (flags, mode & 07777);
|
2019-01-06 05:13:42 +08:00
|
|
|
if (!fh_file)
|
|
|
|
__leave;
|
|
|
|
delete fh;
|
|
|
|
fh = fh_file;
|
|
|
|
}
|
|
|
|
else if ((fh->is_fs_special () && fh->device_access_denied (flags))
|
|
|
|
|| !fh->open_with_arch (flags, mode & 07777))
|
2017-11-14 23:28:44 +08:00
|
|
|
__leave; /* errno already set */
|
2019-01-06 05:15:58 +08:00
|
|
|
/* Move O_TMPFILEs to the bin to avoid blocking the parent dir. */
|
|
|
|
if ((flags & O_TMPFILE) && !fh->pc.isremote ())
|
|
|
|
try_to_bin (fh->pc, fh->get_handle (), DELETE,
|
|
|
|
FILE_OPEN_FOR_BACKUP_INTENT);
|
2017-11-14 23:28:44 +08:00
|
|
|
fd = fh;
|
|
|
|
if (fd <= 2)
|
|
|
|
set_std_handle (fd);
|
|
|
|
res = fd;
|
2014-08-22 17:21:33 +08:00
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
2017-11-14 23:28:44 +08:00
|
|
|
if (res < 0 && fh)
|
|
|
|
delete fh;
|
|
|
|
syscall_printf ("%R = open(%s, %y)", res, unix_path, flags);
|
2000-02-18 03:38:33 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2004-09-10 16:30:51 +08:00
|
|
|
EXPORT_ALIAS (open, _open )
|
|
|
|
EXPORT_ALIAS (open, _open64 )
|
2003-03-10 05:51:00 +08:00
|
|
|
|
2013-04-23 17:44:36 +08:00
|
|
|
extern "C" off_t
|
|
|
|
lseek64 (int fd, off_t pos, int dir)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
off_t res;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2001-03-03 11:56:34 +08:00
|
|
|
if (dir != SEEK_SET && dir != SEEK_CUR && dir != SEEK_END)
|
2001-02-17 02:49:20 +08:00
|
|
|
{
|
2001-03-03 11:56:34 +08:00
|
|
|
set_errno (EINVAL);
|
2001-02-17 02:49:20 +08:00
|
|
|
res = -1;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
else
|
|
|
|
{
|
2001-10-16 07:39:33 +08:00
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd >= 0)
|
|
|
|
res = cfd->lseek (pos, dir);
|
|
|
|
else
|
|
|
|
res = -1;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
2013-04-23 17:44:36 +08:00
|
|
|
/* Can't use %R/%lR here since res is always 8 bytes */
|
2012-03-21 04:39:32 +08:00
|
|
|
syscall_printf (res == -1 ? "%D = lseek(%d, %D, %d), errno %d"
|
|
|
|
: "%D = lseek(%d, %D, %d)",
|
|
|
|
res, fd, pos, dir, get_errno ());
|
2000-02-18 03:38:33 +08:00
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2004-09-10 16:30:51 +08:00
|
|
|
EXPORT_ALIAS (lseek64, _lseek64)
|
2003-03-10 05:51:00 +08:00
|
|
|
|
2017-11-27 21:36:06 +08:00
|
|
|
#ifdef __i386__
|
2003-04-02 00:11:41 +08:00
|
|
|
extern "C" _off_t
|
|
|
|
lseek (int fd, _off_t pos, int dir)
|
2002-02-26 01:47:51 +08:00
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
return lseek64 (fd, (off_t) pos, dir);
|
2002-02-26 01:47:51 +08:00
|
|
|
}
|
2004-09-10 16:30:51 +08:00
|
|
|
EXPORT_ALIAS (lseek, _lseek)
|
2017-11-27 21:36:06 +08:00
|
|
|
#else
|
|
|
|
EXPORT_ALIAS (lseek64, lseek)
|
|
|
|
EXPORT_ALIAS (lseek64, _lseek)
|
2013-04-23 17:44:36 +08:00
|
|
|
#endif
|
|
|
|
|
2002-10-21 09:00:58 +08:00
|
|
|
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2002-10-21 09:00:58 +08:00
|
|
|
close (int fd)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
int res;
|
|
|
|
|
2011-12-17 08:03:31 +08:00
|
|
|
syscall_printf ("close(%d)", fd);
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2011-05-01 00:34:48 +08:00
|
|
|
pthread_testcancel ();
|
|
|
|
|
2001-10-16 07:39:33 +08:00
|
|
|
cygheap_fdget cfd (fd, true);
|
|
|
|
if (cfd < 0)
|
|
|
|
res = -1;
|
2000-02-18 03:38:33 +08:00
|
|
|
else
|
|
|
|
{
|
2011-12-18 12:07:47 +08:00
|
|
|
cfd->isclosed (true);
|
2011-05-06 06:30:53 +08:00
|
|
|
res = cfd->close_with_arch ();
|
2001-10-16 07:39:33 +08:00
|
|
|
cfd.release ();
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2011-12-04 05:43:27 +08:00
|
|
|
syscall_printf ("%R = close(%d)", res, fd);
|
2000-02-18 03:38:33 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2004-09-10 16:30:51 +08:00
|
|
|
EXPORT_ALIAS (close, _close)
|
2002-10-21 09:00:58 +08:00
|
|
|
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2000-02-18 03:38:33 +08:00
|
|
|
isatty (int fd)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
|
2001-10-16 07:39:33 +08:00
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd < 0)
|
|
|
|
res = 0;
|
2001-11-05 14:09:15 +08:00
|
|
|
else
|
2001-10-16 07:39:33 +08:00
|
|
|
res = cfd->is_tty ();
|
2011-12-04 05:43:27 +08:00
|
|
|
syscall_printf ("%R = isatty(%d)", res, fd);
|
2000-02-18 03:38:33 +08:00
|
|
|
return res;
|
|
|
|
}
|
2008-02-14 01:21:05 +08:00
|
|
|
EXPORT_ALIAS (isatty, _isatty)
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2005-02-20 05:53:36 +08:00
|
|
|
link (const char *oldpath, const char *newpath)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
int res = -1;
|
2005-02-20 05:53:36 +08:00
|
|
|
fhandler_base *fh;
|
2002-06-26 12:21:01 +08:00
|
|
|
|
2010-06-15 20:05:15 +08:00
|
|
|
if (!(fh = build_fh_name (oldpath, PC_SYM_NOFOLLOW | PC_KEEP_HANDLE,
|
|
|
|
stat_suffixes)))
|
2005-02-20 05:53:36 +08:00
|
|
|
goto error;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2005-02-20 05:53:36 +08:00
|
|
|
if (fh->error ())
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2005-02-20 05:53:36 +08:00
|
|
|
debug_printf ("got %d error from build_fh_name", fh->error ());
|
|
|
|
set_errno (fh->error ());
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
2009-09-26 23:51:53 +08:00
|
|
|
else if (fh->pc.isdir ())
|
|
|
|
set_errno (EPERM); /* We do not permit linking directories. */
|
|
|
|
else if (!fh->pc.exists ())
|
|
|
|
set_errno (ENOENT);
|
2000-02-18 03:38:33 +08:00
|
|
|
else
|
2005-02-20 05:53:36 +08:00
|
|
|
res = fh->link (newpath);
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2005-02-20 05:53:36 +08:00
|
|
|
delete fh;
|
|
|
|
error:
|
2011-12-04 05:43:27 +08:00
|
|
|
syscall_printf ("%R = link(%s, %s)", res, oldpath, newpath);
|
2000-02-18 03:38:33 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* chown: POSIX 5.6.5.1 */
|
|
|
|
/*
|
2001-03-03 11:56:34 +08:00
|
|
|
* chown () is only implemented for Windows NT. Under other operating
|
2000-02-18 03:38:33 +08:00
|
|
|
* systems, it is only a stub that always returns zero.
|
|
|
|
*/
|
2000-04-03 04:42:42 +08:00
|
|
|
static int
|
2013-04-23 17:44:36 +08:00
|
|
|
chown_worker (const char *name, unsigned fmode, uid_t uid, gid_t gid)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2004-04-15 00:36:26 +08:00
|
|
|
int res = -1;
|
2004-04-20 23:51:24 +08:00
|
|
|
fhandler_base *fh;
|
|
|
|
|
2010-01-12 18:14:59 +08:00
|
|
|
if (!(fh = build_fh_name (name, fmode, stat_suffixes)))
|
2004-04-20 23:51:24 +08:00
|
|
|
goto error;
|
|
|
|
|
2004-04-15 00:36:26 +08:00
|
|
|
if (fh->error ())
|
|
|
|
{
|
|
|
|
debug_printf ("got %d error from build_fh_name", fh->error ());
|
|
|
|
set_errno (fh->error ());
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
2004-04-15 00:36:26 +08:00
|
|
|
else
|
|
|
|
res = fh->fchown (uid, gid);
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2004-04-15 05:11:45 +08:00
|
|
|
delete fh;
|
2004-04-20 23:51:24 +08:00
|
|
|
error:
|
2011-12-04 05:43:27 +08:00
|
|
|
syscall_printf ("%R = %schown(%s,...)",
|
2001-03-14 19:13:46 +08:00
|
|
|
res, (fmode & PC_SYM_NOFOLLOW) ? "l" : "", name);
|
2000-02-18 03:38:33 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
chown32 (const char * name, uid_t uid, gid_t gid)
|
2000-04-03 04:42:42 +08:00
|
|
|
{
|
2000-07-18 03:18:21 +08:00
|
|
|
return chown_worker (name, PC_SYM_FOLLOW, uid, gid);
|
2000-04-03 04:42:42 +08:00
|
|
|
}
|
|
|
|
|
2017-11-27 21:36:06 +08:00
|
|
|
#ifdef __i386__
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
Change internal gid datatype from __gid16_t to __gid32_t
throughout.
* cygwin.din: Export new symbols chown32, fchown32, getegid32,
getgid32, getgrgid32, getgrnam32, getgroups32, initgroups32, lchown32,
setgid32, setegid32, getgrent32.
* grp.cc (grp32togrp16): New static function.
(getgrgid32): New function.
(getgrnam32): Ditto.
(getgrent32): Ditto.
(getgroups32): Change name of internal function from getgroups.
(getgroups32): New function.
(initgroups32): Ditto.
* syscalls.cc (chown32): Ditto.
(lchown32): Ditto.
(fchown32): Ditto.
(setegid32): Ditto.
(setgid32): Ditto.
* uinfo.cc (getgid32): Ditto.
(getegid32): Ditto.
* include/cygwin/grp.h: Remove declaration of getgrgid() and getgrnam().
Declare getgrgid32() and getgrnam32() instead. Declare getgid32().
2002-05-28 22:10:55 +08:00
|
|
|
chown (const char * name, __uid16_t uid, __gid16_t gid)
|
|
|
|
{
|
2002-06-25 16:06:29 +08:00
|
|
|
return chown_worker (name, PC_SYM_FOLLOW,
|
|
|
|
uid16touid32 (uid), gid16togid32 (gid));
|
Change internal gid datatype from __gid16_t to __gid32_t
throughout.
* cygwin.din: Export new symbols chown32, fchown32, getegid32,
getgid32, getgrgid32, getgrnam32, getgroups32, initgroups32, lchown32,
setgid32, setegid32, getgrent32.
* grp.cc (grp32togrp16): New static function.
(getgrgid32): New function.
(getgrnam32): Ditto.
(getgrent32): Ditto.
(getgroups32): Change name of internal function from getgroups.
(getgroups32): New function.
(initgroups32): Ditto.
* syscalls.cc (chown32): Ditto.
(lchown32): Ditto.
(fchown32): Ditto.
(setegid32): Ditto.
(setgid32): Ditto.
* uinfo.cc (getgid32): Ditto.
(getegid32): Ditto.
* include/cygwin/grp.h: Remove declaration of getgrgid() and getgrnam().
Declare getgrgid32() and getgrnam32() instead. Declare getgid32().
2002-05-28 22:10:55 +08:00
|
|
|
}
|
2017-11-27 21:36:06 +08:00
|
|
|
#else
|
|
|
|
EXPORT_ALIAS (chown32, chown)
|
2013-04-23 17:44:36 +08:00
|
|
|
#endif
|
Change internal gid datatype from __gid16_t to __gid32_t
throughout.
* cygwin.din: Export new symbols chown32, fchown32, getegid32,
getgid32, getgrgid32, getgrnam32, getgroups32, initgroups32, lchown32,
setgid32, setegid32, getgrent32.
* grp.cc (grp32togrp16): New static function.
(getgrgid32): New function.
(getgrnam32): Ditto.
(getgrent32): Ditto.
(getgroups32): Change name of internal function from getgroups.
(getgroups32): New function.
(initgroups32): Ditto.
* syscalls.cc (chown32): Ditto.
(lchown32): Ditto.
(fchown32): Ditto.
(setegid32): Ditto.
(setgid32): Ditto.
* uinfo.cc (getgid32): Ditto.
(getegid32): Ditto.
* include/cygwin/grp.h: Remove declaration of getgrgid() and getgrnam().
Declare getgrgid32() and getgrnam32() instead. Declare getgid32().
2002-05-28 22:10:55 +08:00
|
|
|
|
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
lchown32 (const char * name, uid_t uid, gid_t gid)
|
2000-04-03 04:42:42 +08:00
|
|
|
{
|
2001-03-14 19:13:46 +08:00
|
|
|
return chown_worker (name, PC_SYM_NOFOLLOW, uid, gid);
|
2000-04-03 04:42:42 +08:00
|
|
|
}
|
|
|
|
|
2017-11-27 21:36:06 +08:00
|
|
|
#ifdef __i386__
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
Change internal gid datatype from __gid16_t to __gid32_t
throughout.
* cygwin.din: Export new symbols chown32, fchown32, getegid32,
getgid32, getgrgid32, getgrnam32, getgroups32, initgroups32, lchown32,
setgid32, setegid32, getgrent32.
* grp.cc (grp32togrp16): New static function.
(getgrgid32): New function.
(getgrnam32): Ditto.
(getgrent32): Ditto.
(getgroups32): Change name of internal function from getgroups.
(getgroups32): New function.
(initgroups32): Ditto.
* syscalls.cc (chown32): Ditto.
(lchown32): Ditto.
(fchown32): Ditto.
(setegid32): Ditto.
(setgid32): Ditto.
* uinfo.cc (getgid32): Ditto.
(getegid32): Ditto.
* include/cygwin/grp.h: Remove declaration of getgrgid() and getgrnam().
Declare getgrgid32() and getgrnam32() instead. Declare getgid32().
2002-05-28 22:10:55 +08:00
|
|
|
lchown (const char * name, __uid16_t uid, __gid16_t gid)
|
|
|
|
{
|
2002-06-25 16:06:29 +08:00
|
|
|
return chown_worker (name, PC_SYM_NOFOLLOW,
|
|
|
|
uid16touid32 (uid), gid16togid32 (gid));
|
Change internal gid datatype from __gid16_t to __gid32_t
throughout.
* cygwin.din: Export new symbols chown32, fchown32, getegid32,
getgid32, getgrgid32, getgrnam32, getgroups32, initgroups32, lchown32,
setgid32, setegid32, getgrent32.
* grp.cc (grp32togrp16): New static function.
(getgrgid32): New function.
(getgrnam32): Ditto.
(getgrent32): Ditto.
(getgroups32): Change name of internal function from getgroups.
(getgroups32): New function.
(initgroups32): Ditto.
* syscalls.cc (chown32): Ditto.
(lchown32): Ditto.
(fchown32): Ditto.
(setegid32): Ditto.
(setgid32): Ditto.
* uinfo.cc (getgid32): Ditto.
(getegid32): Ditto.
* include/cygwin/grp.h: Remove declaration of getgrgid() and getgrnam().
Declare getgrgid32() and getgrnam32() instead. Declare getgid32().
2002-05-28 22:10:55 +08:00
|
|
|
}
|
2017-11-27 21:36:06 +08:00
|
|
|
#else
|
|
|
|
EXPORT_ALIAS (lchown32, lchown)
|
2013-04-23 17:44:36 +08:00
|
|
|
#endif
|
Change internal gid datatype from __gid16_t to __gid32_t
throughout.
* cygwin.din: Export new symbols chown32, fchown32, getegid32,
getgid32, getgrgid32, getgrnam32, getgroups32, initgroups32, lchown32,
setgid32, setegid32, getgrent32.
* grp.cc (grp32togrp16): New static function.
(getgrgid32): New function.
(getgrnam32): Ditto.
(getgrent32): Ditto.
(getgroups32): Change name of internal function from getgroups.
(getgroups32): New function.
(initgroups32): Ditto.
* syscalls.cc (chown32): Ditto.
(lchown32): Ditto.
(fchown32): Ditto.
(setegid32): Ditto.
(setgid32): Ditto.
* uinfo.cc (getgid32): Ditto.
(getegid32): Ditto.
* include/cygwin/grp.h: Remove declaration of getgrgid() and getgrnam().
Declare getgrgid32() and getgrnam32() instead. Declare getgid32().
2002-05-28 22:10:55 +08:00
|
|
|
|
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
fchown32 (int fd, uid_t uid, gid_t gid)
|
2000-04-03 04:42:42 +08:00
|
|
|
{
|
2001-10-16 07:39:33 +08:00
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd < 0)
|
2000-04-03 04:42:42 +08:00
|
|
|
{
|
|
|
|
syscall_printf ("-1 = fchown (%d,...)", fd);
|
|
|
|
return -1;
|
|
|
|
}
|
2019-01-08 02:33:11 +08:00
|
|
|
else if (cfd->get_flags () & O_PATH)
|
|
|
|
{
|
|
|
|
set_errno (EBADF);
|
|
|
|
return -1;
|
|
|
|
}
|
2000-04-03 04:42:42 +08:00
|
|
|
|
2004-04-15 00:36:26 +08:00
|
|
|
int res = cfd->fchown (uid, gid);
|
2000-04-03 04:42:42 +08:00
|
|
|
|
2011-12-04 05:43:27 +08:00
|
|
|
syscall_printf ("%R = fchown(%s,...)", res, cfd->get_name ());
|
2004-04-15 00:36:26 +08:00
|
|
|
return res;
|
2000-04-03 04:42:42 +08:00
|
|
|
}
|
|
|
|
|
2017-11-27 21:36:06 +08:00
|
|
|
#ifdef __i386__
|
Change internal gid datatype from __gid16_t to __gid32_t
throughout.
* cygwin.din: Export new symbols chown32, fchown32, getegid32,
getgid32, getgrgid32, getgrnam32, getgroups32, initgroups32, lchown32,
setgid32, setegid32, getgrent32.
* grp.cc (grp32togrp16): New static function.
(getgrgid32): New function.
(getgrnam32): Ditto.
(getgrent32): Ditto.
(getgroups32): Change name of internal function from getgroups.
(getgroups32): New function.
(initgroups32): Ditto.
* syscalls.cc (chown32): Ditto.
(lchown32): Ditto.
(fchown32): Ditto.
(setegid32): Ditto.
(setgid32): Ditto.
* uinfo.cc (getgid32): Ditto.
(getegid32): Ditto.
* include/cygwin/grp.h: Remove declaration of getgrgid() and getgrnam().
Declare getgrgid32() and getgrnam32() instead. Declare getgid32().
2002-05-28 22:10:55 +08:00
|
|
|
extern "C" int
|
|
|
|
fchown (int fd, __uid16_t uid, __gid16_t gid)
|
|
|
|
{
|
2002-06-25 16:06:29 +08:00
|
|
|
return fchown32 (fd, uid16touid32 (uid), gid16togid32 (gid));
|
Change internal gid datatype from __gid16_t to __gid32_t
throughout.
* cygwin.din: Export new symbols chown32, fchown32, getegid32,
getgid32, getgrgid32, getgrnam32, getgroups32, initgroups32, lchown32,
setgid32, setegid32, getgrent32.
* grp.cc (grp32togrp16): New static function.
(getgrgid32): New function.
(getgrnam32): Ditto.
(getgrent32): Ditto.
(getgroups32): Change name of internal function from getgroups.
(getgroups32): New function.
(initgroups32): Ditto.
* syscalls.cc (chown32): Ditto.
(lchown32): Ditto.
(fchown32): Ditto.
(setegid32): Ditto.
(setgid32): Ditto.
* uinfo.cc (getgid32): Ditto.
(getegid32): Ditto.
* include/cygwin/grp.h: Remove declaration of getgrgid() and getgrnam().
Declare getgrgid32() and getgrnam32() instead. Declare getgid32().
2002-05-28 22:10:55 +08:00
|
|
|
}
|
2017-11-27 21:36:06 +08:00
|
|
|
#else
|
|
|
|
EXPORT_ALIAS (fchown32, fchown)
|
2013-04-23 17:44:36 +08:00
|
|
|
#endif
|
Change internal gid datatype from __gid16_t to __gid32_t
throughout.
* cygwin.din: Export new symbols chown32, fchown32, getegid32,
getgid32, getgrgid32, getgrnam32, getgroups32, initgroups32, lchown32,
setgid32, setegid32, getgrent32.
* grp.cc (grp32togrp16): New static function.
(getgrgid32): New function.
(getgrnam32): Ditto.
(getgrent32): Ditto.
(getgroups32): Change name of internal function from getgroups.
(getgroups32): New function.
(initgroups32): Ditto.
* syscalls.cc (chown32): Ditto.
(lchown32): Ditto.
(fchown32): Ditto.
(setegid32): Ditto.
(setgid32): Ditto.
* uinfo.cc (getgid32): Ditto.
(getegid32): Ditto.
* include/cygwin/grp.h: Remove declaration of getgrgid() and getgrnam().
Declare getgrgid32() and getgrnam32() instead. Declare getgid32().
2002-05-28 22:10:55 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
/* umask: POSIX 5.3.3.1 */
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" mode_t
|
2000-02-18 03:38:33 +08:00
|
|
|
umask (mode_t mask)
|
|
|
|
{
|
|
|
|
mode_t oldmask;
|
|
|
|
|
2000-11-14 13:53:32 +08:00
|
|
|
oldmask = cygheap->umask;
|
|
|
|
cygheap->umask = mask & 0777;
|
2000-02-18 03:38:33 +08:00
|
|
|
return oldmask;
|
|
|
|
}
|
|
|
|
|
2020-01-29 00:57:50 +08:00
|
|
|
#define FILTERED_MODE(m) ((m) & (S_ISUID | S_ISGID | S_ISVTX \
|
|
|
|
| S_IRWXU | S_IRWXG | S_IRWXO))
|
|
|
|
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
int
|
|
|
|
chmod_device (path_conv& pc, mode_t mode)
|
|
|
|
{
|
2020-01-29 00:57:50 +08:00
|
|
|
return mknod_worker (pc, (pc.dev.mode () & S_IFMT) | FILTERED_MODE (mode),
|
|
|
|
pc.dev.get_major (), pc.dev.get_minor ());
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
}
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
/* chmod: POSIX 5.6.4.1 */
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2000-02-18 03:38:33 +08:00
|
|
|
chmod (const char *path, mode_t mode)
|
|
|
|
{
|
|
|
|
int res = -1;
|
2004-04-20 23:51:24 +08:00
|
|
|
fhandler_base *fh;
|
2010-01-12 18:14:59 +08:00
|
|
|
if (!(fh = build_fh_name (path, PC_SYM_FOLLOW, stat_suffixes)))
|
2004-04-20 23:51:24 +08:00
|
|
|
goto error;
|
2004-05-29 03:50:07 +08:00
|
|
|
|
2004-04-14 04:36:58 +08:00
|
|
|
if (fh->error ())
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2004-04-14 04:36:58 +08:00
|
|
|
debug_printf ("got %d error from build_fh_name", fh->error ());
|
|
|
|
set_errno (fh->error ());
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
else
|
2008-05-21 16:05:53 +08:00
|
|
|
res = fh->fchmod (FILTERED_MODE (mode));
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2004-04-15 05:11:45 +08:00
|
|
|
delete fh;
|
2004-04-20 23:51:24 +08:00
|
|
|
error:
|
2013-04-23 17:44:36 +08:00
|
|
|
syscall_printf ("%R = chmod(%s, 0%o)", res, path, mode);
|
2000-02-18 03:38:33 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fchmod: P96 5.6.4.1 */
|
|
|
|
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2000-02-18 03:38:33 +08:00
|
|
|
fchmod (int fd, mode_t mode)
|
|
|
|
{
|
2001-10-16 07:39:33 +08:00
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd < 0)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
syscall_printf ("-1 = fchmod (%d, 0%o)", fd, mode);
|
|
|
|
return -1;
|
|
|
|
}
|
2019-01-08 02:33:11 +08:00
|
|
|
else if (cfd->get_flags () & O_PATH)
|
|
|
|
{
|
|
|
|
set_errno (EBADF);
|
|
|
|
return -1;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-05-21 16:05:53 +08:00
|
|
|
return cfd->fchmod (FILTERED_MODE (mode));
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2017-11-27 21:36:06 +08:00
|
|
|
#ifdef __i386__
|
2002-02-26 01:47:51 +08:00
|
|
|
static void
|
2013-04-23 17:44:36 +08:00
|
|
|
stat64_to_stat32 (struct stat *src, struct __stat32 *dst)
|
2002-02-26 01:47:51 +08:00
|
|
|
{
|
2002-06-04 01:44:09 +08:00
|
|
|
dst->st_dev = ((src->st_dev >> 8) & 0xff00) | (src->st_dev & 0xff);
|
2003-05-11 08:10:11 +08:00
|
|
|
dst->st_ino = ((unsigned) (src->st_ino >> 32)) | (unsigned) src->st_ino;
|
2002-02-26 01:47:51 +08:00
|
|
|
dst->st_mode = src->st_mode;
|
|
|
|
dst->st_nlink = src->st_nlink;
|
|
|
|
dst->st_uid = src->st_uid;
|
|
|
|
dst->st_gid = src->st_gid;
|
2002-06-21 23:01:19 +08:00
|
|
|
dst->st_rdev = ((src->st_rdev >> 8) & 0xff00) | (src->st_rdev & 0xff);
|
2002-02-26 01:47:51 +08:00
|
|
|
dst->st_size = src->st_size;
|
2002-06-06 23:35:09 +08:00
|
|
|
dst->st_atim = src->st_atim;
|
|
|
|
dst->st_mtim = src->st_mtim;
|
|
|
|
dst->st_ctim = src->st_ctim;
|
2002-02-26 01:47:51 +08:00
|
|
|
dst->st_blksize = src->st_blksize;
|
|
|
|
dst->st_blocks = src->st_blocks;
|
|
|
|
}
|
2013-04-23 17:44:36 +08:00
|
|
|
#endif
|
2002-02-26 01:47:51 +08:00
|
|
|
|
2013-04-23 17:44:36 +08:00
|
|
|
static struct stat dev_st;
|
2012-04-02 19:18:45 +08:00
|
|
|
static bool dev_st_inited;
|
|
|
|
|
|
|
|
void
|
2013-04-23 17:44:36 +08:00
|
|
|
fhandler_base::stat_fixup (struct stat *buf)
|
2012-04-02 19:18:45 +08:00
|
|
|
{
|
2012-04-11 16:49:52 +08:00
|
|
|
/* For devices, set inode number to device number. This gives us a valid,
|
2015-02-11 04:41:16 +08:00
|
|
|
unique inode number without having to call hash_path_name. /dev/tty needs
|
|
|
|
a bit of persuasion to get the same st_ino value in stat and fstat. */
|
2012-04-02 19:18:45 +08:00
|
|
|
if (!buf->st_ino)
|
2015-02-11 04:41:16 +08:00
|
|
|
{
|
|
|
|
if (get_major () == DEV_VIRTFS_MAJOR)
|
|
|
|
buf->st_ino = get_ino ();
|
|
|
|
else if (dev () == FH_TTY ||
|
|
|
|
((get_major () == DEV_PTYS_MAJOR
|
|
|
|
|| get_major () == DEV_CONS_MAJOR)
|
|
|
|
&& !strcmp (get_name (), "/dev/tty")))
|
|
|
|
buf->st_ino = FH_TTY;
|
|
|
|
else
|
|
|
|
buf->st_ino = get_device ();
|
|
|
|
}
|
2012-04-02 19:18:45 +08:00
|
|
|
/* For /dev-based devices, st_dev must be set to the device number of /dev,
|
|
|
|
not it's own device major/minor numbers. What we do here to speed up
|
|
|
|
the process is to fetch the device number of /dev only once, liberally
|
|
|
|
assuming that /dev doesn't change over the lifetime of a process. */
|
|
|
|
if (!buf->st_dev)
|
|
|
|
{
|
2012-04-03 15:28:48 +08:00
|
|
|
if (dev ().is_dev_resident ())
|
2012-04-02 19:18:45 +08:00
|
|
|
{
|
|
|
|
if (!dev_st_inited)
|
|
|
|
{
|
|
|
|
stat64 ("/dev", &dev_st);
|
|
|
|
dev_st_inited = true;
|
|
|
|
}
|
|
|
|
buf->st_dev = dev_st.st_dev;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
buf->st_dev = get_device ();
|
|
|
|
}
|
|
|
|
/* Only set st_rdev if it's a device. */
|
2012-04-02 23:56:43 +08:00
|
|
|
if (!buf->st_rdev && get_major () != DEV_VIRTFS_MAJOR)
|
2012-04-03 00:19:29 +08:00
|
|
|
{
|
|
|
|
buf->st_rdev = get_device ();
|
|
|
|
/* consX, console, conin, and conout point to the same device.
|
2012-04-03 03:25:58 +08:00
|
|
|
Make sure the link count is correct. */
|
2012-04-03 00:19:29 +08:00
|
|
|
if (buf->st_rdev == (dev_t) myself->ctty && iscons_dev (myself->ctty))
|
|
|
|
buf->st_nlink = 4;
|
2012-04-03 03:25:58 +08:00
|
|
|
/* CD-ROM drives have two links, /dev/srX and /dev/scdX. */
|
|
|
|
else if (gnu_dev_major (buf->st_rdev) == DEV_CDROM_MAJOR)
|
|
|
|
buf->st_nlink = 2;
|
2012-04-03 00:19:29 +08:00
|
|
|
}
|
2012-04-02 19:18:45 +08:00
|
|
|
}
|
|
|
|
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
fstat64 (int fd, struct stat *buf)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2001-10-16 07:39:33 +08:00
|
|
|
int res;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2001-10-16 07:39:33 +08:00
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd < 0)
|
|
|
|
res = -1;
|
2000-02-18 03:38:33 +08:00
|
|
|
else
|
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
memset (buf, 0, sizeof (struct stat));
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
res = cfd->fstat (buf);
|
|
|
|
if (!res)
|
2012-04-03 00:19:29 +08:00
|
|
|
cfd->stat_fixup (buf);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2011-12-04 05:43:27 +08:00
|
|
|
syscall_printf ("%R = fstat(%d, %p)", res, fd, buf);
|
2001-10-16 07:39:33 +08:00
|
|
|
return res;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2003-05-12 19:06:27 +08:00
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
_fstat64_r (struct _reent *ptr, int fd, struct stat *buf)
|
2003-05-12 19:06:27 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2005-03-01 19:51:29 +08:00
|
|
|
if ((ret = fstat64 (fd, buf)) == -1)
|
2003-05-12 19:06:27 +08:00
|
|
|
ptr->_errno = get_errno ();
|
|
|
|
return ret;
|
|
|
|
}
|
2003-03-10 05:51:00 +08:00
|
|
|
|
2017-11-27 21:36:06 +08:00
|
|
|
#ifdef __i386__
|
2021-01-13 03:18:28 +08:00
|
|
|
/* This entry point is retained only to serve old 32 bit applications
|
|
|
|
built under Cygwin 1.3.x or earlier. Newer 32 bit apps are redirected
|
|
|
|
to fstat64; see NEW_FUNCTIONS in Makefile.in. */
|
2002-02-26 01:47:51 +08:00
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
fstat (int fd, struct stat *buf)
|
2002-02-26 01:47:51 +08:00
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
struct stat buf64;
|
2002-02-26 01:47:51 +08:00
|
|
|
int ret = fstat64 (fd, &buf64);
|
|
|
|
if (!ret)
|
2013-04-23 17:44:36 +08:00
|
|
|
stat64_to_stat32 (&buf64, (struct __stat32 *) buf);
|
2002-02-26 01:47:51 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2003-05-12 19:06:27 +08:00
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
_fstat_r (struct _reent *ptr, int fd, struct stat *buf)
|
2003-05-12 19:06:27 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2005-03-01 19:51:29 +08:00
|
|
|
if ((ret = fstat (fd, buf)) == -1)
|
2003-05-12 19:06:27 +08:00
|
|
|
ptr->_errno = get_errno ();
|
|
|
|
return ret;
|
|
|
|
}
|
2017-11-27 21:36:06 +08:00
|
|
|
#else
|
|
|
|
EXPORT_ALIAS (fstat64, fstat)
|
|
|
|
EXPORT_ALIAS (_fstat64_r, _fstat_r)
|
2013-04-23 17:44:36 +08:00
|
|
|
#endif
|
2003-03-18 03:08:11 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
/* fsync: P96 6.6.1.1 */
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2000-02-18 03:38:33 +08:00
|
|
|
fsync (int fd)
|
|
|
|
{
|
2011-05-01 00:34:48 +08:00
|
|
|
pthread_testcancel ();
|
2001-10-16 07:39:33 +08:00
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd < 0)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
syscall_printf ("-1 = fsync (%d)", fd);
|
|
|
|
return -1;
|
|
|
|
}
|
2005-02-20 21:28:23 +08:00
|
|
|
return cfd->fsync ();
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2005-02-22 23:30:09 +08:00
|
|
|
EXPORT_ALIAS (fsync, fdatasync)
|
|
|
|
|
2005-05-02 11:50:11 +08:00
|
|
|
static void
|
2011-04-02 19:43:43 +08:00
|
|
|
sync_worker (HANDLE dir, USHORT len, LPCWSTR vol)
|
2005-02-20 21:28:23 +08:00
|
|
|
{
|
2011-04-02 19:43:43 +08:00
|
|
|
NTSTATUS status;
|
|
|
|
HANDLE fh;
|
|
|
|
IO_STATUS_BLOCK io;
|
|
|
|
OBJECT_ATTRIBUTES attr;
|
|
|
|
UNICODE_STRING uvol = { len, len, (WCHAR *) vol };
|
|
|
|
|
|
|
|
InitializeObjectAttributes (&attr, &uvol, OBJ_CASE_INSENSITIVE, dir, NULL);
|
|
|
|
status = NtOpenFile (&fh, GENERIC_WRITE, &attr, &io,
|
|
|
|
FILE_SHARE_VALID_FLAGS, 0);
|
|
|
|
if (!NT_SUCCESS (status))
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("NtOpenFile (%S), status %y", &uvol, status);
|
2011-04-02 19:43:43 +08:00
|
|
|
else
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2011-04-02 19:43:43 +08:00
|
|
|
status = NtFlushBuffersFile (fh, &io);
|
|
|
|
if (!NT_SUCCESS (status))
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("NtFlushBuffersFile (%S), status %y", &uvol, status);
|
2011-04-02 19:43:43 +08:00
|
|
|
NtClose (fh);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-04-11 04:40:41 +08:00
|
|
|
/* sync: SUSv3 */
|
|
|
|
extern "C" void
|
2000-02-18 03:38:33 +08:00
|
|
|
sync ()
|
|
|
|
{
|
2011-04-02 19:43:43 +08:00
|
|
|
OBJECT_ATTRIBUTES attr;
|
|
|
|
NTSTATUS status;
|
|
|
|
HANDLE devhdl;
|
|
|
|
UNICODE_STRING device;
|
2005-05-02 11:50:11 +08:00
|
|
|
|
2011-04-02 19:43:43 +08:00
|
|
|
/* Open \Device object directory. */
|
|
|
|
RtlInitUnicodeString (&device, L"\\Device");
|
|
|
|
InitializeObjectAttributes (&attr, &device, OBJ_CASE_INSENSITIVE, NULL, NULL);
|
|
|
|
status = NtOpenDirectoryObject (&devhdl, DIRECTORY_QUERY, &attr);
|
|
|
|
if (!NT_SUCCESS (status))
|
2005-02-20 21:28:23 +08:00
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("NtOpenDirectoryObject, status %y", status);
|
2011-04-02 19:43:43 +08:00
|
|
|
return;
|
2005-02-20 21:28:23 +08:00
|
|
|
}
|
2011-04-02 19:43:43 +08:00
|
|
|
/* Traverse \Device directory ... */
|
|
|
|
PDIRECTORY_BASIC_INFORMATION dbi = (PDIRECTORY_BASIC_INFORMATION)
|
2011-06-06 13:02:13 +08:00
|
|
|
alloca (640);
|
2011-04-02 19:43:43 +08:00
|
|
|
BOOLEAN restart = TRUE;
|
|
|
|
ULONG context = 0;
|
|
|
|
while (NT_SUCCESS (NtQueryDirectoryObject (devhdl, dbi, 640, TRUE, restart,
|
2011-06-06 13:02:13 +08:00
|
|
|
&context, NULL)))
|
2005-02-20 21:28:23 +08:00
|
|
|
{
|
2011-04-02 19:43:43 +08:00
|
|
|
restart = FALSE;
|
|
|
|
/* ... and call sync_worker for each HarddiskVolumeX entry. */
|
|
|
|
if (dbi->ObjectName.Length >= 15 * sizeof (WCHAR)
|
|
|
|
&& !wcsncasecmp (dbi->ObjectName.Buffer, L"HarddiskVolume", 14)
|
|
|
|
&& iswdigit (dbi->ObjectName.Buffer[14]))
|
|
|
|
sync_worker (devhdl, dbi->ObjectName.Length, dbi->ObjectName.Buffer);
|
2005-02-20 21:28:23 +08:00
|
|
|
}
|
2011-04-02 19:43:43 +08:00
|
|
|
NtClose (devhdl);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Cygwin internal */
|
2013-05-01 09:20:37 +08:00
|
|
|
int __reg2
|
2013-04-23 17:44:36 +08:00
|
|
|
stat_worker (path_conv &pc, struct stat *buf)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
int res = -1;
|
2000-04-26 00:31:14 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
if (pc.error)
|
|
|
|
{
|
|
|
|
debug_printf ("got %d error from path_conv", pc.error);
|
|
|
|
set_errno (pc.error);
|
|
|
|
}
|
|
|
|
else if (pc.exists ())
|
|
|
|
{
|
|
|
|
fhandler_base *fh;
|
2007-07-30 18:05:27 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
if (!(fh = build_fh_pc (pc)))
|
|
|
|
__leave;
|
2007-07-30 18:05:27 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
debug_printf ("(%S, %p, %p), file_attributes %d",
|
|
|
|
pc.get_nt_native_path (), buf, fh, (DWORD) *fh);
|
|
|
|
memset (buf, 0, sizeof (*buf));
|
|
|
|
res = fh->fstat (buf);
|
|
|
|
if (!res)
|
|
|
|
fh->stat_fixup (buf);
|
|
|
|
delete fh;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
set_errno (ENOENT);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
2011-12-04 05:43:27 +08:00
|
|
|
syscall_printf ("%d = (%S,%p)", res, pc.get_nt_native_path (), buf);
|
2000-02-18 03:38:33 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2013-11-25 19:38:08 +08:00
|
|
|
stat64 (const char *__restrict name, struct stat *__restrict buf)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2001-10-05 08:17:57 +08:00
|
|
|
syscall_printf ("entering");
|
2019-01-07 03:18:14 +08:00
|
|
|
path_conv pc (name, PC_SYM_FOLLOW | PC_POSIX | PC_KEEP_HANDLE
|
|
|
|
| PC_SYM_NOFOLLOW_PROCFD,
|
2011-10-16 06:37:30 +08:00
|
|
|
stat_suffixes);
|
2007-07-27 01:30:54 +08:00
|
|
|
return stat_worker (pc, buf);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2003-05-12 19:06:27 +08:00
|
|
|
extern "C" int
|
2013-11-25 19:38:08 +08:00
|
|
|
_stat64_r (struct _reent *__restrict ptr, const char *__restrict name,
|
|
|
|
struct stat *buf)
|
2003-05-12 19:06:27 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2005-03-01 19:51:29 +08:00
|
|
|
if ((ret = stat64 (name, buf)) == -1)
|
2003-05-12 19:06:27 +08:00
|
|
|
ptr->_errno = get_errno ();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-11-27 21:36:06 +08:00
|
|
|
#ifdef __i386__
|
2002-02-26 01:47:51 +08:00
|
|
|
extern "C" int
|
2013-11-25 19:38:08 +08:00
|
|
|
stat (const char *__restrict name, struct stat *__restrict buf)
|
2002-02-26 01:47:51 +08:00
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
struct stat buf64;
|
2002-02-26 01:47:51 +08:00
|
|
|
int ret = stat64 (name, &buf64);
|
|
|
|
if (!ret)
|
2013-04-23 17:44:36 +08:00
|
|
|
stat64_to_stat32 (&buf64, (struct __stat32 *) buf);
|
2002-02-26 01:47:51 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2003-05-12 19:06:27 +08:00
|
|
|
extern "C" int
|
2013-11-25 19:38:08 +08:00
|
|
|
_stat_r (struct _reent *__restrict ptr, const char *__restrict name,
|
|
|
|
struct stat *__restrict buf)
|
2003-05-12 19:06:27 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2005-03-01 19:51:29 +08:00
|
|
|
if ((ret = stat (name, buf)) == -1)
|
2003-05-12 19:06:27 +08:00
|
|
|
ptr->_errno = get_errno ();
|
|
|
|
return ret;
|
|
|
|
}
|
2017-11-27 21:36:06 +08:00
|
|
|
#else
|
|
|
|
EXPORT_ALIAS (stat64, stat)
|
|
|
|
EXPORT_ALIAS (_stat64_r, _stat_r)
|
2013-04-23 17:44:36 +08:00
|
|
|
#endif
|
2003-05-12 19:06:27 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
/* lstat: Provided by SVR4 and 4.3+BSD, POSIX? */
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2013-11-25 19:38:08 +08:00
|
|
|
lstat64 (const char *__restrict name, struct stat *__restrict buf)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2001-10-05 08:17:57 +08:00
|
|
|
syscall_printf ("entering");
|
2010-06-15 20:05:15 +08:00
|
|
|
path_conv pc (name, PC_SYM_NOFOLLOW | PC_POSIX | PC_KEEP_HANDLE,
|
|
|
|
stat_suffixes);
|
2007-07-27 01:30:54 +08:00
|
|
|
return stat_worker (pc, buf);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2017-11-27 21:36:06 +08:00
|
|
|
#ifdef __i386__
|
2002-02-26 01:47:51 +08:00
|
|
|
/* lstat: Provided by SVR4 and 4.3+BSD, POSIX? */
|
|
|
|
extern "C" int
|
2013-11-25 19:38:08 +08:00
|
|
|
lstat (const char *__restrict name, struct stat *__restrict buf)
|
2002-02-26 01:47:51 +08:00
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
struct stat buf64;
|
2002-02-26 01:47:51 +08:00
|
|
|
int ret = lstat64 (name, &buf64);
|
|
|
|
if (!ret)
|
2013-04-23 17:44:36 +08:00
|
|
|
stat64_to_stat32 (&buf64, (struct __stat32 *) buf);
|
2002-02-26 01:47:51 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2017-11-27 21:36:06 +08:00
|
|
|
#else
|
|
|
|
EXPORT_ALIAS (lstat64, lstat)
|
2013-04-23 17:44:36 +08:00
|
|
|
#endif
|
2002-02-26 01:47:51 +08:00
|
|
|
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
extern "C" int
|
|
|
|
access (const char *fn, int flags)
|
|
|
|
{
|
|
|
|
// flags were incorrectly specified
|
2004-01-24 11:40:33 +08:00
|
|
|
int res = -1;
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
if (flags & ~(F_OK|R_OK|W_OK|X_OK))
|
2004-01-24 11:40:33 +08:00
|
|
|
set_errno (EINVAL);
|
|
|
|
else
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
{
|
2011-07-26 21:30:41 +08:00
|
|
|
fhandler_base *fh = build_fh_name (fn, PC_SYM_FOLLOW | PC_KEEP_HANDLE,
|
|
|
|
stat_suffixes);
|
2004-04-20 23:51:24 +08:00
|
|
|
if (fh)
|
2004-05-29 03:50:07 +08:00
|
|
|
{
|
2009-09-25 21:44:45 +08:00
|
|
|
res = fh->fhaccess (flags, false);
|
2004-04-20 23:51:24 +08:00
|
|
|
delete fh;
|
|
|
|
}
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
}
|
2004-01-24 11:40:33 +08:00
|
|
|
debug_printf ("returning %d", res);
|
|
|
|
return res;
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
}
|
|
|
|
|
2009-09-26 07:55:00 +08:00
|
|
|
/* Linux provides this extension; it is basically a wrapper around the
|
|
|
|
POSIX:2008 faccessat (AT_FDCWD, fn, flags, AT_EACCESS). We also
|
|
|
|
provide eaccess as an alias for this, in cygwin.din. */
|
|
|
|
extern "C" int
|
|
|
|
euidaccess (const char *fn, int flags)
|
|
|
|
{
|
|
|
|
// flags were incorrectly specified
|
|
|
|
int res = -1;
|
|
|
|
if (flags & ~(F_OK|R_OK|W_OK|X_OK))
|
|
|
|
set_errno (EINVAL);
|
|
|
|
else
|
|
|
|
{
|
2011-07-26 21:30:41 +08:00
|
|
|
fhandler_base *fh = build_fh_name (fn, PC_SYM_FOLLOW | PC_KEEP_HANDLE,
|
|
|
|
stat_suffixes);
|
2009-09-26 07:55:00 +08:00
|
|
|
if (fh)
|
|
|
|
{
|
|
|
|
res = fh->fhaccess (flags, true);
|
|
|
|
delete fh;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
debug_printf ("returning %d", res);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2007-07-31 23:20:00 +08:00
|
|
|
static void
|
|
|
|
rename_append_suffix (path_conv &pc, const char *path, size_t len,
|
|
|
|
const char *suffix)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2007-07-31 23:20:00 +08:00
|
|
|
char buf[len + 5];
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-02-01 20:37:51 +08:00
|
|
|
if (ascii_strcasematch (path + len - 4, ".lnk")
|
|
|
|
|| ascii_strcasematch (path + len - 4, ".exe"))
|
2007-07-31 23:20:00 +08:00
|
|
|
len -= 4;
|
|
|
|
stpcpy (stpncpy (buf, path, len), suffix);
|
|
|
|
pc.check (buf, PC_SYM_NOFOLLOW);
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2009-11-07 04:51:03 +08:00
|
|
|
/* This function tests if a filename has one of the "approved" executable
|
|
|
|
suffix. This list is probably not complete... */
|
2009-11-05 22:44:12 +08:00
|
|
|
static inline bool
|
2009-11-07 04:51:03 +08:00
|
|
|
nt_path_has_executable_suffix (PUNICODE_STRING upath)
|
2009-11-05 22:44:12 +08:00
|
|
|
{
|
2010-03-05 00:20:37 +08:00
|
|
|
static const PUNICODE_STRING blessed_executable_suffixes[] =
|
2009-11-07 04:51:03 +08:00
|
|
|
{
|
|
|
|
&ro_u_com,
|
2009-11-21 20:44:13 +08:00
|
|
|
&ro_u_dll, /* Messy, messy. Per MSDN, the GetBinaryType function is
|
|
|
|
supposed to return with ERROR_BAD_EXE_FORMAT. if the file
|
|
|
|
is a DLL. On 64-bit Windows, this works as expected for
|
|
|
|
32-bit and 64-bit DLLs. On 32-bit Windows this only works
|
|
|
|
for 32-bit DLLs. For 64-bit DLLs, 32-bit Windows returns
|
|
|
|
true with the type set to SCS_64BIT_BINARY. */
|
2009-11-07 04:51:03 +08:00
|
|
|
&ro_u_exe,
|
|
|
|
&ro_u_scr,
|
|
|
|
&ro_u_sys,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2009-11-05 22:44:12 +08:00
|
|
|
USHORT pos = upath->Length / sizeof (WCHAR);
|
2009-11-07 04:51:03 +08:00
|
|
|
PWCHAR path;
|
|
|
|
UNICODE_STRING usuf;
|
|
|
|
const PUNICODE_STRING *suf;
|
2009-11-05 22:44:12 +08:00
|
|
|
|
|
|
|
/* Too short for a native path? */
|
|
|
|
if (pos < 8)
|
|
|
|
return false;
|
2009-11-07 04:51:03 +08:00
|
|
|
/* Assumption: All executable suffixes have a length of three. */
|
|
|
|
path = upath->Buffer + pos - 4;
|
|
|
|
if (*path != L'.')
|
|
|
|
return false;
|
|
|
|
RtlInitCountedUnicodeString (&usuf, path, 4 * sizeof (WCHAR));
|
|
|
|
for (suf = blessed_executable_suffixes; *suf; ++suf)
|
|
|
|
if (RtlEqualUnicodeString (&usuf, *suf, TRUE))
|
|
|
|
return true;
|
2009-11-05 22:44:12 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-08-17 21:12:15 +08:00
|
|
|
/* If newpath names an existing file and the RENAME_NOREPLACE flag is
|
|
|
|
specified, fail with EEXIST. Exception: Don't fail if the purpose
|
|
|
|
of the rename is just to change the case of oldpath on a
|
|
|
|
case-insensitive file system. */
|
|
|
|
static int
|
2019-01-09 21:45:37 +08:00
|
|
|
rename2 (const char *oldpath, const char *newpath, unsigned int at2flags)
|
2007-07-31 23:20:00 +08:00
|
|
|
{
|
2008-05-20 04:22:29 +08:00
|
|
|
tmp_pathbuf tp;
|
2007-07-31 23:20:00 +08:00
|
|
|
int res = -1;
|
|
|
|
path_conv oldpc, newpc, new2pc, *dstpc, *removepc = NULL;
|
2007-08-10 19:16:27 +08:00
|
|
|
bool old_dir_requested = false, new_dir_requested = false;
|
2007-07-31 23:20:00 +08:00
|
|
|
bool old_explicit_suffix = false, new_explicit_suffix = false;
|
2019-01-09 22:47:43 +08:00
|
|
|
bool use_posix_semantics;
|
2019-01-09 21:45:37 +08:00
|
|
|
bool noreplace = at2flags & RENAME_NOREPLACE;
|
2007-07-31 23:20:00 +08:00
|
|
|
size_t olen, nlen;
|
2007-08-10 19:16:27 +08:00
|
|
|
bool equal_path;
|
2011-11-07 18:03:30 +08:00
|
|
|
NTSTATUS status = STATUS_SUCCESS;
|
2007-08-10 19:16:27 +08:00
|
|
|
HANDLE fh = NULL, nfh;
|
2008-05-16 00:34:01 +08:00
|
|
|
HANDLE old_trans = NULL, trans = NULL;
|
2007-07-31 23:20:00 +08:00
|
|
|
OBJECT_ATTRIBUTES attr;
|
|
|
|
IO_STATUS_BLOCK io;
|
2007-08-02 19:11:34 +08:00
|
|
|
FILE_STANDARD_INFORMATION ofsi;
|
2007-07-31 23:20:00 +08:00
|
|
|
PFILE_RENAME_INFORMATION pfri;
|
2007-08-01 22:46:09 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2009-09-26 23:51:53 +08:00
|
|
|
{
|
2019-01-09 21:45:37 +08:00
|
|
|
if (at2flags & ~RENAME_NOREPLACE)
|
2017-08-17 21:12:15 +08:00
|
|
|
/* RENAME_NOREPLACE is the only flag currently supported. */
|
|
|
|
{
|
|
|
|
set_errno (EINVAL);
|
|
|
|
__leave;
|
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
if (!*oldpath || !*newpath)
|
2011-06-06 13:02:13 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
/* Reject rename("","x"), rename("x",""). */
|
|
|
|
set_errno (ENOENT);
|
|
|
|
__leave;
|
2011-06-06 13:02:13 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
if (has_dot_last_component (oldpath, true))
|
2011-06-06 13:02:13 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
/* Reject rename("dir/.","x"). */
|
|
|
|
oldpc.check (oldpath, PC_SYM_NOFOLLOW, stat_suffixes);
|
|
|
|
set_errno (oldpc.isdir () ? EINVAL : ENOTDIR);
|
|
|
|
__leave;
|
2011-06-06 13:02:13 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
if (has_dot_last_component (newpath, true))
|
2008-03-13 02:46:10 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
/* Reject rename("dir","x/."). */
|
|
|
|
newpc.check (newpath, PC_SYM_NOFOLLOW, stat_suffixes);
|
|
|
|
set_errno (!newpc.exists () ? ENOENT
|
|
|
|
: newpc.isdir () ? EINVAL : ENOTDIR);
|
|
|
|
__leave;
|
2008-03-13 02:46:10 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
|
|
|
|
/* A trailing slash requires that the pathname points to an existing
|
|
|
|
directory. If it's not, it's a ENOTDIR condition. The same goes
|
|
|
|
for newpath a bit further down this function. */
|
|
|
|
olen = strlen (oldpath);
|
|
|
|
if (isdirsep (oldpath[olen - 1]))
|
2006-05-28 23:50:14 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
char *buf;
|
|
|
|
char *p = stpcpy (buf = tp.c_get (), oldpath) - 1;
|
|
|
|
oldpath = buf;
|
|
|
|
while (p >= oldpath && isdirsep (*p))
|
|
|
|
*p-- = '\0';
|
|
|
|
olen = p + 1 - oldpath;
|
|
|
|
if (!olen)
|
2009-09-26 23:51:53 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
/* The root directory cannot be renamed. This also rejects
|
|
|
|
the corner case of rename("/","/"), even though it is the
|
|
|
|
same file. */
|
2009-09-26 23:51:53 +08:00
|
|
|
set_errno (EINVAL);
|
2014-08-22 17:21:33 +08:00
|
|
|
__leave;
|
2009-09-26 23:51:53 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
old_dir_requested = true;
|
2006-02-06 02:18:02 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
oldpc.check (oldpath, PC_SYM_NOFOLLOW, stat_suffixes);
|
|
|
|
if (oldpc.error)
|
2007-07-31 23:20:00 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
set_errno (oldpc.error);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
if (!oldpc.exists ())
|
|
|
|
{
|
|
|
|
set_errno (ENOENT);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
if (oldpc.isspecial () && !oldpc.issocket () && !oldpc.is_fs_special ())
|
|
|
|
{
|
|
|
|
/* No renames from virtual FS */
|
|
|
|
set_errno (EROFS);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
if (oldpc.has_attribute (FILE_ATTRIBUTE_REPARSE_POINT)
|
|
|
|
&& !oldpc.issymlink ())
|
|
|
|
{
|
|
|
|
/* Volume mount point. If we try to rename a volume mount point, NT
|
|
|
|
returns STATUS_NOT_SAME_DEVICE ==> Win32 ERROR_NOT_SAME_DEVICE ==>
|
|
|
|
errno EXDEV. That's bad since mv(1) will now perform a
|
|
|
|
cross-device move. So what we do here is to treat the volume
|
|
|
|
mount point just like Linux treats a mount point. */
|
|
|
|
set_errno (EBUSY);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
if (old_dir_requested && !oldpc.isdir ())
|
|
|
|
{
|
|
|
|
/* Reject rename("file/","x"). */
|
|
|
|
set_errno (ENOTDIR);
|
|
|
|
__leave;
|
|
|
|
}
|
2015-02-15 16:59:55 +08:00
|
|
|
if (oldpc.known_suffix ()
|
2014-08-22 17:21:33 +08:00
|
|
|
&& (ascii_strcasematch (oldpath + olen - 4, ".lnk")
|
|
|
|
|| ascii_strcasematch (oldpath + olen - 4, ".exe")))
|
|
|
|
old_explicit_suffix = true;
|
|
|
|
|
|
|
|
nlen = strlen (newpath);
|
|
|
|
if (isdirsep (newpath[nlen - 1]))
|
|
|
|
{
|
|
|
|
char *buf;
|
|
|
|
char *p = stpcpy (buf = tp.c_get (), newpath) - 1;
|
|
|
|
newpath = buf;
|
|
|
|
while (p >= newpath && isdirsep (*p))
|
|
|
|
*p-- = '\0';
|
|
|
|
nlen = p + 1 - newpath;
|
|
|
|
if (!nlen) /* The root directory is never empty. */
|
2007-07-31 23:20:00 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
set_errno (ENOTEMPTY);
|
|
|
|
__leave;
|
2007-07-31 23:20:00 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
new_dir_requested = true;
|
2007-07-31 23:20:00 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
newpc.check (newpath, PC_SYM_NOFOLLOW, stat_suffixes);
|
|
|
|
if (newpc.error)
|
|
|
|
{
|
|
|
|
set_errno (newpc.error);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
if (newpc.isspecial () && !newpc.issocket ())
|
|
|
|
{
|
|
|
|
/* No renames to virtual FSes */
|
|
|
|
set_errno (EROFS);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
if (new_dir_requested && !(newpc.exists ()
|
|
|
|
? newpc.isdir () : oldpc.isdir ()))
|
|
|
|
{
|
|
|
|
/* Reject rename("file1","file2/"), but allow rename("dir","d/"). */
|
|
|
|
set_errno (newpc.exists () ? ENOTDIR : ENOENT);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
if (newpc.exists ()
|
|
|
|
&& (oldpc.isdir () ? !newpc.isdir () : newpc.isdir ()))
|
|
|
|
{
|
|
|
|
/* Reject rename("file","dir") and rename("dir","file"). */
|
|
|
|
set_errno (newpc.isdir () ? EISDIR : ENOTDIR);
|
|
|
|
__leave;
|
|
|
|
}
|
2015-02-15 16:59:55 +08:00
|
|
|
if (newpc.known_suffix ()
|
2014-08-22 17:21:33 +08:00
|
|
|
&& (ascii_strcasematch (newpath + nlen - 4, ".lnk")
|
|
|
|
|| ascii_strcasematch (newpath + nlen - 4, ".exe")))
|
|
|
|
new_explicit_suffix = true;
|
|
|
|
|
|
|
|
/* This test is necessary in almost every case, so do it once here. */
|
|
|
|
equal_path = RtlEqualUnicodeString (oldpc.get_nt_native_path (),
|
|
|
|
newpc.get_nt_native_path (),
|
|
|
|
oldpc.objcaseinsensitive ());
|
|
|
|
|
|
|
|
/* First check if oldpath and newpath only differ by case. If so, it's
|
|
|
|
just a request to change the case of the filename. By simply setting
|
|
|
|
the file attributes to INVALID_FILE_ATTRIBUTES (which translates to
|
|
|
|
"file doesn't exist"), all later tests are skipped. */
|
|
|
|
if (oldpc.objcaseinsensitive () && newpc.exists () && equal_path
|
|
|
|
&& old_explicit_suffix == new_explicit_suffix)
|
2001-09-08 05:32:07 +08:00
|
|
|
{
|
2007-07-31 23:20:00 +08:00
|
|
|
if (RtlEqualUnicodeString (oldpc.get_nt_native_path (),
|
|
|
|
newpc.get_nt_native_path (),
|
2014-08-22 17:21:33 +08:00
|
|
|
FALSE))
|
2007-07-31 23:20:00 +08:00
|
|
|
{
|
|
|
|
res = 0;
|
2014-08-22 17:21:33 +08:00
|
|
|
__leave;
|
2007-07-31 23:20:00 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
newpc.file_attributes (INVALID_FILE_ATTRIBUTES);
|
2007-07-31 23:20:00 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
else if (oldpc.isdir ())
|
2008-02-16 01:53:11 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
/* Check for newpath being identical or a subdir of oldpath. */
|
|
|
|
if (RtlPrefixUnicodeString (oldpc.get_nt_native_path (),
|
|
|
|
newpc.get_nt_native_path (),
|
2016-10-19 19:26:03 +08:00
|
|
|
oldpc.objcaseinsensitive ()))
|
2007-07-31 23:20:00 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
if (newpc.get_nt_native_path ()->Length
|
|
|
|
== oldpc.get_nt_native_path ()->Length)
|
|
|
|
{
|
|
|
|
res = 0;
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
if (*(PWCHAR) ((PBYTE) newpc.get_nt_native_path ()->Buffer
|
|
|
|
+ oldpc.get_nt_native_path ()->Length) == L'\\')
|
|
|
|
{
|
|
|
|
set_errno (EINVAL);
|
|
|
|
__leave;
|
|
|
|
}
|
2007-07-31 23:20:00 +08:00
|
|
|
}
|
2001-06-01 19:53:20 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
else if (!newpc.exists ())
|
2006-05-28 23:50:14 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
if (equal_path && old_explicit_suffix != new_explicit_suffix)
|
2007-07-31 23:20:00 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
newpc.check (newpath, PC_SYM_NOFOLLOW);
|
|
|
|
if (RtlEqualUnicodeString (oldpc.get_nt_native_path (),
|
|
|
|
newpc.get_nt_native_path (),
|
|
|
|
oldpc.objcaseinsensitive ()))
|
|
|
|
{
|
|
|
|
res = 0;
|
|
|
|
__leave;
|
|
|
|
}
|
2007-07-31 23:20:00 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
else if (oldpc.is_lnk_special ()
|
|
|
|
&& !RtlEqualUnicodePathSuffix (newpc.get_nt_native_path (),
|
|
|
|
&ro_u_lnk, TRUE))
|
|
|
|
rename_append_suffix (newpc, newpath, nlen, ".lnk");
|
|
|
|
else if (oldpc.is_binary () && !old_explicit_suffix
|
2015-02-15 16:59:55 +08:00
|
|
|
&& oldpc.known_suffix ()
|
2014-08-22 17:21:33 +08:00
|
|
|
&& !nt_path_has_executable_suffix
|
2019-01-26 03:02:03 +08:00
|
|
|
(newpc.get_nt_native_path ()))
|
2014-08-22 17:21:33 +08:00
|
|
|
/* Never append .exe suffix if oldpath had .exe suffix given
|
|
|
|
explicitely, or if oldpath wasn't already a .exe file, or
|
|
|
|
if the destination filename has one of the blessed executable
|
|
|
|
suffixes.
|
|
|
|
Note: To rename an executable foo.exe to bar-without-suffix,
|
|
|
|
the .exe suffix must be given explicitly in oldpath. */
|
|
|
|
rename_append_suffix (newpc, newpath, nlen, ".exe");
|
2008-02-16 01:53:11 +08:00
|
|
|
}
|
2007-07-31 23:20:00 +08:00
|
|
|
else
|
2008-02-16 01:53:11 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
if (equal_path && old_explicit_suffix != new_explicit_suffix)
|
2007-07-31 23:20:00 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
newpc.check (newpath, PC_SYM_NOFOLLOW);
|
|
|
|
if (RtlEqualUnicodeString (oldpc.get_nt_native_path (),
|
|
|
|
newpc.get_nt_native_path (),
|
|
|
|
oldpc.objcaseinsensitive ()))
|
|
|
|
{
|
|
|
|
res = 0;
|
|
|
|
__leave;
|
|
|
|
}
|
2007-07-31 23:20:00 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
else if (oldpc.is_lnk_special ())
|
2010-09-11 03:55:26 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
if (!newpc.is_lnk_special ()
|
|
|
|
&& !RtlEqualUnicodePathSuffix (newpc.get_nt_native_path (),
|
|
|
|
&ro_u_lnk, TRUE))
|
|
|
|
{
|
|
|
|
rename_append_suffix (new2pc, newpath, nlen, ".lnk");
|
|
|
|
removepc = &newpc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (oldpc.is_binary ())
|
|
|
|
{
|
|
|
|
/* Never append .exe suffix if oldpath had .exe suffix given
|
|
|
|
explicitely, or if newfile is a binary (in which case the given
|
|
|
|
name probably makes sense as it is), or if the destination
|
|
|
|
filename has one of the blessed executable suffixes. */
|
2015-02-15 16:59:55 +08:00
|
|
|
if (!old_explicit_suffix && oldpc.known_suffix ()
|
2014-08-22 17:21:33 +08:00
|
|
|
&& !newpc.is_binary ()
|
|
|
|
&& !nt_path_has_executable_suffix
|
2019-01-26 03:02:03 +08:00
|
|
|
(newpc.get_nt_native_path ()))
|
2014-08-22 17:21:33 +08:00
|
|
|
{
|
|
|
|
rename_append_suffix (new2pc, newpath, nlen, ".exe");
|
|
|
|
removepc = &newpc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* If the new path is an existing .lnk symlink or a .exe file,
|
|
|
|
but the new path has not been specified with explicit suffix,
|
|
|
|
rename to the new name without suffix, as expected, but also
|
|
|
|
remove the clashing symlink or executable. Did I ever mention
|
|
|
|
how I hate the file suffix idea? */
|
|
|
|
if ((newpc.is_lnk_special ()
|
|
|
|
|| RtlEqualUnicodePathSuffix (newpc.get_nt_native_path (),
|
|
|
|
&ro_u_exe, TRUE))
|
|
|
|
&& !new_explicit_suffix)
|
|
|
|
{
|
|
|
|
new2pc.check (newpath, PC_SYM_NOFOLLOW, stat_suffixes);
|
|
|
|
newpc.get_nt_native_path ()->Length -= 4 * sizeof (WCHAR);
|
|
|
|
if (new2pc.is_binary () || new2pc.is_lnk_special ())
|
|
|
|
removepc = &new2pc;
|
|
|
|
}
|
2010-09-11 03:55:26 +08:00
|
|
|
}
|
2010-04-19 16:09:51 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
dstpc = (removepc == &newpc) ? &new2pc : &newpc;
|
|
|
|
|
|
|
|
/* Check cross-device before touching anything. Otherwise we might end
|
|
|
|
up with an unlinked target dir even if the actual rename didn't work.*/
|
|
|
|
if (oldpc.fs_type () != dstpc->fs_type ()
|
|
|
|
|| oldpc.fs_serial_number () != dstpc->fs_serial_number ())
|
2013-12-11 20:12:12 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
set_errno (EXDEV);
|
|
|
|
__leave;
|
2013-12-11 20:12:12 +08:00
|
|
|
}
|
2007-08-10 19:16:27 +08:00
|
|
|
|
2017-08-17 21:12:15 +08:00
|
|
|
/* Should we replace an existing file? */
|
|
|
|
if ((removepc || dstpc->exists ()) && noreplace)
|
|
|
|
{
|
|
|
|
set_errno (EEXIST);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
|
2019-01-09 22:47:43 +08:00
|
|
|
/* POSIX semantics only on local NTFS drives. */
|
2019-01-15 03:38:24 +08:00
|
|
|
use_posix_semantics = wincap.has_posix_rename_semantics ()
|
2019-01-09 22:47:43 +08:00
|
|
|
&& !oldpc.isremote ()
|
|
|
|
&& oldpc.fs_is_ntfs ();
|
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
/* Opening the file must be part of the transaction. It's not sufficient
|
|
|
|
to call only NtSetInformationFile under the transaction. Therefore we
|
2019-01-09 22:47:43 +08:00
|
|
|
have to start the transaction here, if necessary. Don't start
|
|
|
|
transaction on W10 1709 or later on local NTFS. Use POSIX semantics
|
|
|
|
instead. */
|
|
|
|
if (!use_posix_semantics
|
|
|
|
&& (dstpc->fs_flags () & FILE_SUPPORTS_TRANSACTIONS)
|
2014-08-22 17:21:33 +08:00
|
|
|
&& (dstpc->isdir ()
|
|
|
|
|| (!removepc && dstpc->has_attribute (FILE_ATTRIBUTE_READONLY))))
|
|
|
|
start_transaction (old_trans, trans);
|
|
|
|
|
|
|
|
int retry_count;
|
|
|
|
retry_count = 0;
|
|
|
|
retry:
|
|
|
|
/* Talking about inconsistent behaviour...
|
|
|
|
- DELETE is required to rename a file. So far, so good.
|
|
|
|
- At least one cifs FS (Tru64) needs FILE_READ_ATTRIBUTE, otherwise the
|
|
|
|
FileRenameInformation call fails with STATUS_ACCESS_DENIED. However,
|
|
|
|
on NFS we get a STATUS_ACCESS_DENIED if FILE_READ_ATTRIBUTE is used
|
|
|
|
and the file we try to rename is a symlink. Urgh.
|
|
|
|
- Samba (only some versions?) doesn't like the FILE_SHARE_DELETE
|
|
|
|
mode if the file has the R/O attribute set and returns
|
|
|
|
STATUS_ACCESS_DENIED in that case. */
|
|
|
|
{
|
|
|
|
ULONG access = DELETE
|
|
|
|
| (oldpc.fs_is_cifs () ? FILE_READ_ATTRIBUTES : 0);
|
|
|
|
ULONG sharing = FILE_SHARE_READ | FILE_SHARE_WRITE
|
|
|
|
| (oldpc.fs_is_samba () ? 0 : FILE_SHARE_DELETE);
|
|
|
|
ULONG flags = FILE_OPEN_FOR_BACKUP_INTENT
|
2018-03-01 23:41:45 +08:00
|
|
|
| (oldpc.is_known_reparse_point ()
|
|
|
|
? FILE_OPEN_REPARSE_POINT : 0);
|
2014-08-22 17:21:33 +08:00
|
|
|
status = NtOpenFile (&fh, access,
|
|
|
|
oldpc.get_object_attr (attr, sec_none_nih),
|
|
|
|
&io, sharing, flags);
|
|
|
|
}
|
2007-08-10 19:16:27 +08:00
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
debug_printf ("status %y", status);
|
|
|
|
if (status == STATUS_SHARING_VIOLATION
|
|
|
|
&& cygwait (10L) != WAIT_SIGNALED)
|
|
|
|
{
|
|
|
|
/* Typical BLODA problem. Some virus scanners check newly
|
|
|
|
generated files and while doing that disallow DELETE access.
|
|
|
|
That's really bad because it breaks applications which copy
|
|
|
|
files by creating a temporary filename and then rename the
|
|
|
|
temp filename to the target filename. This renaming fails due
|
|
|
|
to the jealous virus scanner and the application fails to
|
|
|
|
create the target file.
|
|
|
|
|
|
|
|
This kludge tries to work around that by yielding until the
|
|
|
|
sharing violation goes away, or a signal arrived, or after
|
|
|
|
about a second, give or take. */
|
|
|
|
if (++retry_count < 40)
|
|
|
|
{
|
|
|
|
yield ();
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (NT_TRANSACTIONAL_ERROR (status) && trans)
|
|
|
|
{
|
|
|
|
/* If NtOpenFile fails due to transactional problems, stop
|
|
|
|
transaction and go ahead without. */
|
|
|
|
stop_transaction (status, old_trans, trans);
|
|
|
|
debug_printf ("Transaction failure. Retry open.");
|
|
|
|
goto retry;
|
|
|
|
}
|
2007-08-10 19:16:27 +08:00
|
|
|
__seterrno_from_nt_status (status);
|
2014-08-22 17:21:33 +08:00
|
|
|
__leave;
|
2007-08-10 19:16:27 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
|
2019-01-09 22:47:43 +08:00
|
|
|
if (use_posix_semantics)
|
|
|
|
goto skip_pre_W10_checks;
|
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
/* Renaming a dir to another, existing dir fails always, even if
|
|
|
|
ReplaceIfExists is set to TRUE and the existing dir is empty. So
|
|
|
|
we have to remove the destination dir first. This also covers the
|
|
|
|
case that the destination directory is not empty. In that case,
|
|
|
|
unlink_nt returns with STATUS_DIRECTORY_NOT_EMPTY. */
|
|
|
|
if (dstpc->isdir ())
|
2008-02-16 01:53:11 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
status = unlink_nt (*dstpc);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
__seterrno_from_nt_status (status);
|
|
|
|
__leave;
|
|
|
|
}
|
2007-08-10 19:16:27 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
/* You can't copy a file if the destination exists and has the R/O
|
|
|
|
attribute set. Remove the R/O attribute first. But first check
|
|
|
|
if a removepc exists. If so, dstpc points to a non-existing file
|
|
|
|
due to a mangled suffix. */
|
|
|
|
else if (!removepc && dstpc->has_attribute (FILE_ATTRIBUTE_READONLY))
|
2008-02-16 01:53:11 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
status = NtOpenFile (&nfh, FILE_WRITE_ATTRIBUTES,
|
|
|
|
dstpc->get_object_attr (attr, sec_none_nih),
|
|
|
|
&io, FILE_SHARE_VALID_FLAGS,
|
|
|
|
FILE_OPEN_FOR_BACKUP_INTENT
|
2018-03-01 23:41:45 +08:00
|
|
|
| (dstpc->is_known_reparse_point ()
|
2014-08-22 17:21:33 +08:00
|
|
|
? FILE_OPEN_REPARSE_POINT : 0));
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
__seterrno_from_nt_status (status);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
status = NtSetAttributesFile (nfh, dstpc->file_attributes ()
|
|
|
|
& ~FILE_ATTRIBUTE_READONLY);
|
|
|
|
NtClose (nfh);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
__seterrno_from_nt_status (status);
|
|
|
|
__leave;
|
|
|
|
}
|
2007-08-10 19:16:27 +08:00
|
|
|
}
|
|
|
|
|
2019-01-09 22:47:43 +08:00
|
|
|
skip_pre_W10_checks:
|
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
/* SUSv3: If the old argument and the new argument resolve to the same
|
|
|
|
existing file, rename() shall return successfully and perform no
|
|
|
|
other action.
|
|
|
|
The test tries to be as quick as possible. Due to the above cross
|
|
|
|
device check we already know both files are on the same device. So
|
|
|
|
it just tests if oldpath has more than 1 hardlink, then it opens
|
|
|
|
newpath and tests for identical file ids. If so, oldpath and newpath
|
|
|
|
refer to the same file. */
|
|
|
|
if ((removepc || dstpc->exists ())
|
|
|
|
&& !oldpc.isdir ()
|
|
|
|
&& NT_SUCCESS (NtQueryInformationFile (fh, &io, &ofsi, sizeof ofsi,
|
|
|
|
FileStandardInformation))
|
|
|
|
&& ofsi.NumberOfLinks > 1
|
|
|
|
&& NT_SUCCESS (NtOpenFile (&nfh, READ_CONTROL,
|
2007-08-02 05:02:24 +08:00
|
|
|
(removepc ?: dstpc)->get_object_attr (attr, sec_none_nih),
|
2007-08-02 23:13:56 +08:00
|
|
|
&io, FILE_SHARE_VALID_FLAGS,
|
|
|
|
FILE_OPEN_FOR_BACKUP_INTENT
|
2018-03-01 23:41:45 +08:00
|
|
|
| ((removepc ?: dstpc)->is_known_reparse_point ()
|
2008-02-16 01:53:11 +08:00
|
|
|
? FILE_OPEN_REPARSE_POINT : 0))))
|
2007-08-02 05:02:24 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
FILE_INTERNAL_INFORMATION ofii, nfii;
|
|
|
|
|
|
|
|
if (NT_SUCCESS (NtQueryInformationFile (fh, &io, &ofii, sizeof ofii,
|
|
|
|
FileInternalInformation))
|
|
|
|
&& NT_SUCCESS (NtQueryInformationFile (nfh, &io, &nfii,
|
|
|
|
sizeof nfii,
|
|
|
|
FileInternalInformation))
|
2015-12-08 21:33:07 +08:00
|
|
|
&& ofii.IndexNumber.QuadPart == nfii.IndexNumber.QuadPart)
|
2014-08-22 17:21:33 +08:00
|
|
|
{
|
|
|
|
debug_printf ("%s and %s are the same file", oldpath, newpath);
|
|
|
|
NtClose (nfh);
|
|
|
|
res = 0;
|
|
|
|
__leave;
|
|
|
|
}
|
2007-08-02 05:02:24 +08:00
|
|
|
NtClose (nfh);
|
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
/* Create FILE_RENAME_INFORMATION struct. Using a tmp_pathbuf area
|
|
|
|
allows for paths of up to 32757 chars. This test is just for
|
|
|
|
paranoia's sake. */
|
|
|
|
if (dstpc->get_nt_native_path ()->Length
|
|
|
|
> NT_MAX_PATH * sizeof (WCHAR) - sizeof (FILE_RENAME_INFORMATION))
|
2008-05-16 00:34:01 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
debug_printf ("target filename too long");
|
|
|
|
set_errno (EINVAL);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
pfri = (PFILE_RENAME_INFORMATION) tp.w_get ();
|
2019-01-09 22:47:43 +08:00
|
|
|
if (use_posix_semantics)
|
|
|
|
pfri->Flags = noreplace ? 0
|
|
|
|
: (FILE_RENAME_REPLACE_IF_EXISTS
|
|
|
|
| FILE_RENAME_POSIX_SEMANTICS
|
|
|
|
| FILE_RENAME_IGNORE_READONLY_ATTRIBUTE);
|
|
|
|
else
|
|
|
|
pfri->ReplaceIfExists = !noreplace;
|
2014-08-22 17:21:33 +08:00
|
|
|
pfri->RootDirectory = NULL;
|
|
|
|
pfri->FileNameLength = dstpc->get_nt_native_path ()->Length;
|
|
|
|
memcpy (&pfri->FileName, dstpc->get_nt_native_path ()->Buffer,
|
|
|
|
pfri->FileNameLength);
|
2017-08-17 21:12:15 +08:00
|
|
|
/* If dstpc points to an existing file and RENAME_NOREPLACE has
|
|
|
|
been specified, then we should get NT error
|
|
|
|
STATUS_OBJECT_NAME_COLLISION ==> Win32 error
|
|
|
|
ERROR_ALREADY_EXISTS ==> Cygwin error EEXIST. */
|
2014-08-22 17:21:33 +08:00
|
|
|
status = NtSetInformationFile (fh, &io, pfri,
|
|
|
|
sizeof *pfri + pfri->FileNameLength,
|
2019-01-09 22:47:43 +08:00
|
|
|
use_posix_semantics
|
|
|
|
? FileRenameInformationEx
|
|
|
|
: FileRenameInformation);
|
2014-08-22 17:21:33 +08:00
|
|
|
/* This happens if the access rights don't allow deleting the destination.
|
|
|
|
Even if the handle to the original file is opened with BACKUP
|
|
|
|
and/or RECOVERY, these flags don't apply to the destination of the
|
|
|
|
rename operation. So, a privileged user can't rename a file to an
|
|
|
|
existing file, if the permissions of the existing file aren't right.
|
|
|
|
Like directories, we have to handle this separately by removing the
|
|
|
|
destination before renaming. */
|
|
|
|
if (status == STATUS_ACCESS_DENIED && dstpc->exists ()
|
|
|
|
&& !dstpc->isdir ())
|
|
|
|
{
|
2017-01-13 05:42:11 +08:00
|
|
|
bool need_open = false;
|
|
|
|
|
2015-12-15 22:19:05 +08:00
|
|
|
if ((dstpc->fs_flags () & FILE_SUPPORTS_TRANSACTIONS) && !trans)
|
2008-05-16 00:34:01 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
/* As mentioned earlier, opening the file must be part of the
|
|
|
|
transaction. Therefore we have to reopen the file here if the
|
|
|
|
transaction hasn't been started already. Unfortunately we
|
|
|
|
can't use the NT "reopen file from existing handle" feature.
|
|
|
|
In that case NtOpenFile returns STATUS_TRANSACTIONAL_CONFLICT.
|
|
|
|
We *have* to close the handle to the file first, *then* we can
|
|
|
|
re-open it. Fortunately nothing has happened yet, so the
|
|
|
|
atomicity of the rename functionality is not spoiled. */
|
|
|
|
NtClose (fh);
|
2017-01-13 05:42:11 +08:00
|
|
|
start_transaction (old_trans, trans);
|
|
|
|
need_open = true;
|
|
|
|
}
|
|
|
|
while (true)
|
|
|
|
{
|
|
|
|
status = STATUS_SUCCESS;
|
|
|
|
if (need_open)
|
|
|
|
status = NtOpenFile (&fh, DELETE,
|
|
|
|
oldpc.get_object_attr (attr, sec_none_nih),
|
|
|
|
&io, FILE_SHARE_VALID_FLAGS,
|
|
|
|
FILE_OPEN_FOR_BACKUP_INTENT
|
2018-03-01 23:41:45 +08:00
|
|
|
| (oldpc.is_known_reparse_point ()
|
2017-01-13 05:42:11 +08:00
|
|
|
? FILE_OPEN_REPARSE_POINT : 0));
|
|
|
|
if (NT_SUCCESS (status))
|
2013-12-11 20:12:12 +08:00
|
|
|
{
|
2017-01-13 05:42:11 +08:00
|
|
|
status = unlink_nt (*dstpc);
|
|
|
|
if (NT_SUCCESS (status))
|
|
|
|
break;
|
2013-12-11 20:12:12 +08:00
|
|
|
}
|
2017-01-13 05:42:11 +08:00
|
|
|
if (!NT_TRANSACTIONAL_ERROR (status) || !trans)
|
|
|
|
break;
|
|
|
|
/* If NtOpenFile or unlink_nt fail due to transactional problems,
|
|
|
|
stop transaction and retry without. */
|
|
|
|
NtClose (fh);
|
|
|
|
stop_transaction (status, old_trans, trans);
|
|
|
|
debug_printf ("Transaction failure %y. Retry open.", status);
|
2008-05-16 00:34:01 +08:00
|
|
|
}
|
2017-01-13 05:42:11 +08:00
|
|
|
if (NT_SUCCESS (status))
|
2014-08-22 17:21:33 +08:00
|
|
|
status = NtSetInformationFile (fh, &io, pfri,
|
|
|
|
sizeof *pfri + pfri->FileNameLength,
|
|
|
|
FileRenameInformation);
|
2008-05-16 00:34:01 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
if (NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
if (removepc)
|
|
|
|
unlink_nt (*removepc);
|
|
|
|
res = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
__seterrno_from_nt_status (status);
|
2008-05-16 00:34:01 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
__except (EFAULT)
|
2007-07-31 23:20:00 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
res = -1;
|
2007-07-31 23:20:00 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
__endtry
|
2007-08-10 19:16:27 +08:00
|
|
|
if (fh)
|
|
|
|
NtClose (fh);
|
2013-12-11 20:12:12 +08:00
|
|
|
/* Stop transaction if we started one. */
|
|
|
|
if (trans)
|
2008-05-16 00:34:01 +08:00
|
|
|
stop_transaction (status, old_trans, trans);
|
2014-08-22 17:21:33 +08:00
|
|
|
if (get_errno () != EFAULT)
|
|
|
|
syscall_printf ("%R = rename(%s, %s)", res, oldpath, newpath);
|
2000-02-18 03:38:33 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2017-08-17 21:12:15 +08:00
|
|
|
extern "C" int
|
|
|
|
rename (const char *oldpath, const char *newpath)
|
|
|
|
{
|
|
|
|
return rename2 (oldpath, newpath, 0);
|
|
|
|
}
|
|
|
|
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2000-02-18 03:38:33 +08:00
|
|
|
system (const char *cmdstring)
|
2014-08-22 17:21:33 +08:00
|
|
|
{
|
|
|
|
pthread_testcancel ();
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2005-07-03 10:40:30 +08:00
|
|
|
if (cmdstring == NULL)
|
2003-09-20 08:31:13 +08:00
|
|
|
return 1;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
int res = -1;
|
|
|
|
const char* command[4];
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
command[0] = "sh";
|
|
|
|
command[1] = "-c";
|
|
|
|
command[2] = cmdstring;
|
|
|
|
command[3] = (const char *) NULL;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
if ((res = spawnvp (_P_SYSTEM, "/bin/sh", command)) == -1)
|
|
|
|
{
|
|
|
|
// when exec fails, return value should be as if shell
|
|
|
|
// executed exit (127)
|
|
|
|
res = 127;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
2000-02-18 03:38:33 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2001-01-18 12:26:04 +08:00
|
|
|
extern "C" int
|
2000-02-18 03:38:33 +08:00
|
|
|
setdtablesize (int size)
|
|
|
|
{
|
2013-11-23 21:51:53 +08:00
|
|
|
if (size < 0)
|
|
|
|
{
|
|
|
|
set_errno (EINVAL);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-12-06 03:43:34 +08:00
|
|
|
if (size <= (int) cygheap->fdtab.size
|
2021-01-29 22:14:35 +08:00
|
|
|
|| cygheap->fdtab.extend (size - cygheap->fdtab.size, OPEN_MAX))
|
2001-01-18 12:26:04 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
return -1;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2000-02-18 03:38:33 +08:00
|
|
|
getdtablesize ()
|
|
|
|
{
|
2021-01-29 22:14:35 +08:00
|
|
|
return OPEN_MAX;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2009-09-19 05:27:02 +08:00
|
|
|
extern "C" int
|
2000-02-18 03:38:33 +08:00
|
|
|
getpagesize ()
|
|
|
|
{
|
2011-05-10 23:39:02 +08:00
|
|
|
return (size_t) wincap.allocation_granularity ();
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* FIXME: not all values are correct... */
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" long int
|
2000-02-18 03:38:33 +08:00
|
|
|
fpathconf (int fd, int v)
|
|
|
|
{
|
2001-10-16 07:39:33 +08:00
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd < 0)
|
|
|
|
return -1;
|
2006-11-08 01:59:54 +08:00
|
|
|
return cfd->fpathconf (v);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" long int
|
2000-02-18 03:38:33 +08:00
|
|
|
pathconf (const char *file, int v)
|
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
fhandler_base *fh = NULL;
|
2009-03-27 19:29:56 +08:00
|
|
|
long ret = -1;
|
2006-11-08 01:59:54 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2005-07-03 10:40:30 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
if (!*file)
|
|
|
|
{
|
|
|
|
set_errno (ENOENT);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (!(fh = build_fh_name (file, PC_SYM_FOLLOW, stat_suffixes)))
|
|
|
|
return -1;
|
|
|
|
if (!fh->exists ())
|
|
|
|
set_errno (ENOENT);
|
|
|
|
else
|
|
|
|
ret = fh->fpathconf (v);
|
2005-07-03 10:40:30 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
2009-03-27 19:29:56 +08:00
|
|
|
delete fh;
|
|
|
|
return ret;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2004-04-14 17:12:04 +08:00
|
|
|
extern "C" int
|
|
|
|
ttyname_r (int fd, char *buf, size_t buflen)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
2014-08-22 17:21:33 +08:00
|
|
|
|
|
|
|
__try
|
2004-04-14 17:12:04 +08:00
|
|
|
{
|
|
|
|
cygheap_fdget cfd (fd, true);
|
|
|
|
if (cfd < 0)
|
|
|
|
ret = EBADF;
|
|
|
|
else if (!cfd->is_tty ())
|
|
|
|
ret = ENOTTY;
|
|
|
|
else if (buflen < strlen (cfd->ttyname ()) + 1)
|
|
|
|
ret = ERANGE;
|
|
|
|
else
|
2004-05-29 03:50:07 +08:00
|
|
|
strcpy (buf, cfd->ttyname ());
|
2014-08-22 17:21:33 +08:00
|
|
|
debug_printf ("returning %d tty: %s", ret, ret ? "NULL" : buf);
|
2004-04-14 17:12:04 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
__except (NO_ERROR)
|
|
|
|
{
|
|
|
|
ret = EFAULT;
|
|
|
|
}
|
|
|
|
__endtry
|
2004-04-14 17:12:04 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2000-09-03 12:16:35 +08:00
|
|
|
extern "C" char *
|
|
|
|
ttyname (int fd)
|
|
|
|
{
|
2007-11-29 00:45:34 +08:00
|
|
|
static char name[TTY_NAME_MAX];
|
|
|
|
int ret = ttyname_r (fd, name, TTY_NAME_MAX);
|
2004-04-14 17:12:04 +08:00
|
|
|
if (ret)
|
|
|
|
{
|
|
|
|
set_errno (ret);
|
|
|
|
return NULL;
|
|
|
|
}
|
2003-09-27 13:35:02 +08:00
|
|
|
return name;
|
2000-09-03 12:16:35 +08:00
|
|
|
}
|
|
|
|
|
2000-07-30 00:24:59 +08:00
|
|
|
extern "C" char *
|
2000-02-18 03:38:33 +08:00
|
|
|
ctermid (char *str)
|
|
|
|
{
|
|
|
|
if (str == NULL)
|
2011-05-29 02:17:09 +08:00
|
|
|
str = _my_tls.locals.ttybuf;
|
|
|
|
if (myself->ctty < 0)
|
|
|
|
strcpy (str, "no tty");
|
2000-02-18 03:38:33 +08:00
|
|
|
else
|
2011-05-29 02:17:09 +08:00
|
|
|
{
|
|
|
|
device d;
|
|
|
|
d.parse (myself->ctty);
|
2016-06-23 22:56:41 +08:00
|
|
|
strcpy (str, d.name ());
|
2011-05-29 02:17:09 +08:00
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
2000-05-24 07:52:50 +08:00
|
|
|
/* Tells stdio if it should do the cr/lf conversion for this file */
|
2000-09-03 12:16:35 +08:00
|
|
|
extern "C" int
|
2000-05-24 07:52:50 +08:00
|
|
|
_cygwin_istext_for_stdio (int fd)
|
|
|
|
{
|
|
|
|
if (CYGWIN_VERSION_OLD_STDIO_CRLF_HANDLING)
|
|
|
|
{
|
2004-01-27 02:52:02 +08:00
|
|
|
syscall_printf ("fd %d: old API", fd);
|
2000-05-24 07:52:50 +08:00
|
|
|
return 0; /* we do it for old apps, due to getc/putc macros */
|
|
|
|
}
|
|
|
|
|
2001-10-16 11:31:50 +08:00
|
|
|
cygheap_fdget cfd (fd, false, false);
|
2001-10-16 07:39:33 +08:00
|
|
|
if (cfd < 0)
|
2000-05-24 07:52:50 +08:00
|
|
|
{
|
2004-01-27 02:52:02 +08:00
|
|
|
syscall_printf ("fd %d: not open", fd);
|
2000-05-24 07:52:50 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-01-27 02:52:02 +08:00
|
|
|
#if 0
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
if (cfd->get_device () != FH_FS)
|
2000-05-24 07:52:50 +08:00
|
|
|
{
|
2004-01-27 02:52:02 +08:00
|
|
|
syscall_printf ("fd not disk file. Defaulting to binary.");
|
2000-05-24 07:52:50 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2004-01-27 02:52:02 +08:00
|
|
|
#endif
|
2000-05-24 07:52:50 +08:00
|
|
|
|
2004-04-10 21:45:10 +08:00
|
|
|
if (cfd->wbinary () || cfd->rbinary ())
|
2000-05-24 07:52:50 +08:00
|
|
|
{
|
2004-01-27 02:52:02 +08:00
|
|
|
syscall_printf ("fd %d: opened as binary", fd);
|
2000-05-24 07:52:50 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-01-27 02:52:02 +08:00
|
|
|
syscall_printf ("fd %d: defaulting to text", fd);
|
2000-05-24 07:52:50 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2000-05-20 01:15:02 +08:00
|
|
|
/* internal newlib function */
|
2001-03-03 11:56:34 +08:00
|
|
|
extern "C" int _fwalk (struct _reent *ptr, int (*function) (FILE *));
|
2000-05-20 01:15:02 +08:00
|
|
|
|
|
|
|
static int
|
|
|
|
setmode_helper (FILE *f)
|
|
|
|
{
|
2005-06-10 06:33:57 +08:00
|
|
|
if (fileno (f) != _my_tls.locals.setmode_file)
|
2004-01-27 02:52:02 +08:00
|
|
|
{
|
2005-06-10 06:33:57 +08:00
|
|
|
syscall_printf ("improbable, but %d != %d", fileno (f), _my_tls.locals.setmode_file);
|
2004-01-27 02:52:02 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
syscall_printf ("file was %s now %s", f->_flags & __SCLE ? "text" : "binary",
|
2005-06-10 06:33:57 +08:00
|
|
|
_my_tls.locals.setmode_mode & O_TEXT ? "text" : "binary");
|
|
|
|
if (_my_tls.locals.setmode_mode & O_TEXT)
|
2000-05-20 01:15:02 +08:00
|
|
|
f->_flags |= __SCLE;
|
|
|
|
else
|
|
|
|
f->_flags &= ~__SCLE;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2000-07-09 13:29:51 +08:00
|
|
|
extern "C" int
|
|
|
|
getmode (int fd)
|
|
|
|
{
|
2001-10-16 07:39:33 +08:00
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd < 0)
|
|
|
|
return -1;
|
2000-07-09 13:29:51 +08:00
|
|
|
|
2001-10-16 07:39:33 +08:00
|
|
|
return cfd->get_flags () & (O_BINARY | O_TEXT);
|
2000-07-09 13:29:51 +08:00
|
|
|
}
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
/* Set a file descriptor into text or binary mode, returning the
|
|
|
|
previous mode. */
|
|
|
|
|
2000-07-09 13:29:51 +08:00
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
_setmode (int fd, int mode)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2001-10-16 07:39:33 +08:00
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd < 0)
|
|
|
|
return -1;
|
2001-04-24 00:46:30 +08:00
|
|
|
if (mode != O_BINARY && mode != O_TEXT && mode != 0)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
set_errno (EINVAL);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Note that we have no way to indicate the case that writes are
|
|
|
|
binary but not reads, or vice-versa. These cases can arise when
|
|
|
|
using the tty or console interface. People using those
|
|
|
|
interfaces should not use setmode. */
|
|
|
|
|
|
|
|
int res;
|
2004-04-10 21:45:10 +08:00
|
|
|
if (cfd->wbinary () && cfd->rbinary ())
|
2000-02-18 03:38:33 +08:00
|
|
|
res = O_BINARY;
|
2004-04-10 21:45:10 +08:00
|
|
|
else if (cfd->wbinset () && cfd->rbinset ())
|
2001-04-24 01:29:33 +08:00
|
|
|
res = O_TEXT; /* Specifically set O_TEXT */
|
2000-02-18 03:38:33 +08:00
|
|
|
else
|
2001-04-24 01:29:33 +08:00
|
|
|
res = 0;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2001-04-24 10:07:58 +08:00
|
|
|
if (!mode)
|
2001-10-16 07:39:33 +08:00
|
|
|
cfd->reset_to_open_binmode ();
|
2001-04-24 10:07:58 +08:00
|
|
|
else
|
2002-06-05 09:42:28 +08:00
|
|
|
cfd->set_flags ((cfd->get_flags () & ~(O_TEXT | O_BINARY)) | mode);
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2008-03-08 09:33:22 +08:00
|
|
|
syscall_printf ("(%d<%S>, %p) returning %s", fd,
|
2007-08-16 00:27:09 +08:00
|
|
|
cfd->pc.get_nt_native_path (), mode,
|
|
|
|
res & O_TEXT ? "text" : "binary");
|
2000-02-18 03:38:33 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2005-06-10 06:33:57 +08:00
|
|
|
extern "C" int
|
|
|
|
cygwin_setmode (int fd, int mode)
|
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
int res = _setmode (fd, mode);
|
2005-06-10 06:33:57 +08:00
|
|
|
if (res != -1)
|
|
|
|
{
|
|
|
|
_my_tls.locals.setmode_file = fd;
|
|
|
|
if (_cygwin_istext_for_stdio (fd))
|
|
|
|
_my_tls.locals.setmode_mode = O_TEXT;
|
|
|
|
else
|
|
|
|
_my_tls.locals.setmode_mode = O_BINARY;
|
|
|
|
_fwalk (_GLOBAL_REENT, setmode_helper);
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2006-08-08 03:29:14 +08:00
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
posix_fadvise (int fd, off_t offset, off_t len, int advice)
|
2006-08-08 03:29:14 +08:00
|
|
|
{
|
|
|
|
int res = -1;
|
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd >= 0)
|
|
|
|
res = cfd->fadvise (offset, len, advice);
|
|
|
|
else
|
2017-11-02 23:45:34 +08:00
|
|
|
res = EBADF;
|
2011-12-04 05:43:27 +08:00
|
|
|
syscall_printf ("%R = posix_fadvice(%d, %D, %D, %d)",
|
2006-12-12 23:58:08 +08:00
|
|
|
res, fd, offset, len, advice);
|
2006-08-08 03:29:14 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
posix_fallocate (int fd, off_t offset, off_t len)
|
2006-08-08 03:29:14 +08:00
|
|
|
{
|
2017-11-02 23:45:35 +08:00
|
|
|
int res = 0;
|
2006-08-08 03:29:14 +08:00
|
|
|
if (offset < 0 || len == 0)
|
2017-11-02 23:45:35 +08:00
|
|
|
res = EINVAL;
|
2006-08-08 03:29:14 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd >= 0)
|
|
|
|
res = cfd->ftruncate (offset + len, false);
|
|
|
|
else
|
2017-11-02 23:45:35 +08:00
|
|
|
res = EBADF;
|
2006-08-08 03:29:14 +08:00
|
|
|
}
|
2011-12-04 05:43:27 +08:00
|
|
|
syscall_printf ("%R = posix_fallocate(%d, %D, %D)", res, fd, offset, len);
|
2006-08-08 03:29:14 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2000-09-03 12:16:35 +08:00
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
ftruncate64 (int fd, off_t length)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2005-02-03 06:42:06 +08:00
|
|
|
int res = -1;
|
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd >= 0)
|
2017-11-03 02:13:09 +08:00
|
|
|
{
|
|
|
|
res = cfd->ftruncate (length, true);
|
|
|
|
if (res)
|
|
|
|
{
|
|
|
|
set_errno (res);
|
|
|
|
res = -1;
|
|
|
|
}
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
else
|
2005-02-03 06:42:06 +08:00
|
|
|
set_errno (EBADF);
|
2011-12-04 05:43:27 +08:00
|
|
|
syscall_printf ("%R = ftruncate(%d, %D)", res, fd, length);
|
2000-02-18 03:38:33 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2017-11-27 21:36:06 +08:00
|
|
|
#ifdef __i386__
|
2002-02-26 01:47:51 +08:00
|
|
|
/* ftruncate: P96 5.6.7.1 */
|
|
|
|
extern "C" int
|
2003-04-02 00:11:41 +08:00
|
|
|
ftruncate (int fd, _off_t length)
|
2002-02-26 01:47:51 +08:00
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
return ftruncate64 (fd, (off_t)length);
|
2002-02-26 01:47:51 +08:00
|
|
|
}
|
2017-11-27 21:36:06 +08:00
|
|
|
#else
|
|
|
|
EXPORT_ALIAS (ftruncate64, ftruncate)
|
2013-04-23 17:44:36 +08:00
|
|
|
#endif
|
2002-02-26 01:47:51 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
/* truncate: Provided by SVR4 and 4.3+BSD. Not part of POSIX.1 or XPG3 */
|
2000-09-03 12:16:35 +08:00
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
truncate64 (const char *pathname, off_t length)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
int res = -1;
|
|
|
|
|
|
|
|
fd = open (pathname, O_RDWR);
|
|
|
|
|
2004-12-01 23:00:40 +08:00
|
|
|
if (fd != -1)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2002-03-05 00:47:41 +08:00
|
|
|
res = ftruncate64 (fd, length);
|
2000-02-18 03:38:33 +08:00
|
|
|
close (fd);
|
|
|
|
}
|
2011-12-04 05:43:27 +08:00
|
|
|
syscall_printf ("%R = truncate(%s, %D)", res, pathname, length);
|
2000-02-18 03:38:33 +08:00
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2017-11-27 21:36:06 +08:00
|
|
|
#ifdef __i386__
|
2002-02-26 01:47:51 +08:00
|
|
|
/* truncate: Provided by SVR4 and 4.3+BSD. Not part of POSIX.1 or XPG3 */
|
|
|
|
extern "C" int
|
2003-04-02 00:11:41 +08:00
|
|
|
truncate (const char *pathname, _off_t length)
|
2002-02-26 01:47:51 +08:00
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
return truncate64 (pathname, (off_t)length);
|
2002-02-26 01:47:51 +08:00
|
|
|
}
|
2017-11-27 21:36:06 +08:00
|
|
|
#else
|
|
|
|
EXPORT_ALIAS (truncate64, truncate)
|
2013-04-23 17:44:36 +08:00
|
|
|
#endif
|
2002-02-26 01:47:51 +08:00
|
|
|
|
2000-09-03 12:16:35 +08:00
|
|
|
extern "C" long
|
2013-04-23 17:44:36 +08:00
|
|
|
_get_osfhandle (int fd)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2001-10-16 07:39:33 +08:00
|
|
|
long res;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2001-10-16 07:39:33 +08:00
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd >= 0)
|
|
|
|
res = (long) cfd->get_handle ();
|
2000-02-18 03:38:33 +08:00
|
|
|
else
|
2001-10-16 07:39:33 +08:00
|
|
|
res = -1;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2011-12-04 05:43:27 +08:00
|
|
|
syscall_printf ("%R = get_osfhandle(%d)", res, fd);
|
2000-02-18 03:38:33 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2000-09-03 12:16:35 +08:00
|
|
|
extern "C" int
|
2007-02-27 20:58:56 +08:00
|
|
|
fstatvfs (int fd, struct statvfs *sfs)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
|
|
|
{
|
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd < 0)
|
|
|
|
__leave;
|
|
|
|
return cfd->fstatvfs (sfs);
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return -1;
|
2007-02-27 20:58:56 +08:00
|
|
|
}
|
2004-04-10 21:45:10 +08:00
|
|
|
|
2007-02-27 20:58:56 +08:00
|
|
|
extern "C" int
|
|
|
|
statvfs (const char *name, struct statvfs *sfs)
|
|
|
|
{
|
|
|
|
int res = -1;
|
|
|
|
fhandler_base *fh = NULL;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
|
|
|
{
|
|
|
|
if (!(fh = build_fh_name (name, PC_SYM_FOLLOW, stat_suffixes)))
|
|
|
|
__leave;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
if (fh->error ())
|
|
|
|
{
|
|
|
|
debug_printf ("got %d error from build_fh_name", fh->error ());
|
|
|
|
set_errno (fh->error ());
|
|
|
|
}
|
|
|
|
else if (fh->exists ())
|
|
|
|
{
|
|
|
|
debug_printf ("(%s, %p), file_attributes %d", name, sfs, (DWORD) *fh);
|
|
|
|
res = fh->fstatvfs (sfs);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
set_errno (ENOENT);
|
2003-05-27 00:52:58 +08:00
|
|
|
|
2003-05-25 17:18:43 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
2007-02-27 20:58:56 +08:00
|
|
|
delete fh;
|
2014-08-22 17:21:33 +08:00
|
|
|
if (get_errno () != EFAULT)
|
|
|
|
syscall_printf ("%R = statvfs(%s,%p)", res, name, sfs);
|
2007-02-27 20:58:56 +08:00
|
|
|
return res;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2005-02-23 21:12:43 +08:00
|
|
|
extern "C" int
|
2007-02-27 20:58:56 +08:00
|
|
|
fstatfs (int fd, struct statfs *sfs)
|
2005-02-23 21:12:43 +08:00
|
|
|
{
|
2007-02-27 20:58:56 +08:00
|
|
|
struct statvfs vfs;
|
|
|
|
int ret = fstatvfs (fd, &vfs);
|
|
|
|
if (!ret)
|
|
|
|
{
|
|
|
|
sfs->f_type = vfs.f_flag;
|
|
|
|
sfs->f_bsize = vfs.f_bsize;
|
|
|
|
sfs->f_blocks = vfs.f_blocks;
|
|
|
|
sfs->f_bavail = vfs.f_bavail;
|
|
|
|
sfs->f_bfree = vfs.f_bfree;
|
|
|
|
sfs->f_files = -1;
|
|
|
|
sfs->f_ffree = -1;
|
|
|
|
sfs->f_fsid = vfs.f_fsid;
|
|
|
|
sfs->f_namelen = vfs.f_namemax;
|
|
|
|
}
|
|
|
|
return ret;
|
2005-02-23 21:12:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
statfs (const char *fname, struct statfs *sfs)
|
|
|
|
{
|
|
|
|
struct statvfs vfs;
|
|
|
|
int ret = statvfs (fname, &vfs);
|
|
|
|
if (!ret)
|
|
|
|
{
|
|
|
|
sfs->f_type = vfs.f_flag;
|
|
|
|
sfs->f_bsize = vfs.f_bsize;
|
|
|
|
sfs->f_blocks = vfs.f_blocks;
|
|
|
|
sfs->f_bavail = vfs.f_bavail;
|
|
|
|
sfs->f_bfree = vfs.f_bfree;
|
|
|
|
sfs->f_files = -1;
|
|
|
|
sfs->f_ffree = -1;
|
|
|
|
sfs->f_fsid = vfs.f_fsid;
|
|
|
|
sfs->f_namelen = vfs.f_namemax;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
/* setpgid: POSIX 4.3.3.1 */
|
2000-09-03 12:16:35 +08:00
|
|
|
extern "C" int
|
2000-02-18 03:38:33 +08:00
|
|
|
setpgid (pid_t pid, pid_t pgid)
|
|
|
|
{
|
|
|
|
int res = -1;
|
|
|
|
if (pid == 0)
|
|
|
|
pid = getpid ();
|
|
|
|
if (pgid == 0)
|
|
|
|
pgid = pid;
|
|
|
|
|
|
|
|
if (pgid < 0)
|
2005-07-03 10:40:30 +08:00
|
|
|
set_errno (EINVAL);
|
2000-02-18 03:38:33 +08:00
|
|
|
else
|
|
|
|
{
|
2003-09-14 01:14:15 +08:00
|
|
|
pinfo p (pid, PID_MAP_RW);
|
2000-07-30 00:24:59 +08:00
|
|
|
if (!p)
|
2005-07-03 10:40:30 +08:00
|
|
|
set_errno (ESRCH);
|
|
|
|
else if (p->pgid == pgid)
|
|
|
|
res = 0;
|
2000-07-30 00:24:59 +08:00
|
|
|
/* A process may only change the process group of itself and its children */
|
2005-07-03 10:40:30 +08:00
|
|
|
else if (p != myself && p->ppid != myself->pid)
|
|
|
|
set_errno (EPERM);
|
|
|
|
else
|
2000-07-30 00:24:59 +08:00
|
|
|
{
|
|
|
|
p->pgid = pgid;
|
2000-10-25 11:54:50 +08:00
|
|
|
if (p->pid != p->pgid)
|
|
|
|
p->set_has_pgid_children (0);
|
2000-07-30 00:24:59 +08:00
|
|
|
res = 0;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
2005-07-03 10:40:30 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
syscall_printf ("pid %d, pgid %d, res %d", pid, pgid, res);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2000-09-03 12:16:35 +08:00
|
|
|
extern "C" pid_t
|
2000-02-18 03:38:33 +08:00
|
|
|
getpgid (pid_t pid)
|
|
|
|
{
|
|
|
|
if (pid == 0)
|
|
|
|
pid = getpid ();
|
|
|
|
|
2000-07-30 00:24:59 +08:00
|
|
|
pinfo p (pid);
|
2013-04-23 17:44:36 +08:00
|
|
|
if (!p)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
set_errno (ESRCH);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return p->pgid;
|
|
|
|
}
|
|
|
|
|
2000-09-03 12:16:35 +08:00
|
|
|
extern "C" int
|
2000-02-18 03:38:33 +08:00
|
|
|
setpgrp (void)
|
|
|
|
{
|
|
|
|
return setpgid (0, 0);
|
|
|
|
}
|
|
|
|
|
2000-09-03 12:16:35 +08:00
|
|
|
extern "C" pid_t
|
2000-02-18 03:38:33 +08:00
|
|
|
getpgrp (void)
|
|
|
|
{
|
|
|
|
return getpgid (0);
|
|
|
|
}
|
|
|
|
|
2000-09-03 12:16:35 +08:00
|
|
|
extern "C" char *
|
2000-02-18 03:38:33 +08:00
|
|
|
ptsname (int fd)
|
|
|
|
{
|
2011-11-08 04:05:49 +08:00
|
|
|
static char buf[TTY_NAME_MAX];
|
|
|
|
return ptsname_r (fd, buf, sizeof (buf)) == 0 ? buf : NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
ptsname_r (int fd, char *buf, size_t buflen)
|
|
|
|
{
|
|
|
|
if (!buf)
|
|
|
|
{
|
|
|
|
set_errno (EINVAL);
|
|
|
|
return EINVAL;
|
|
|
|
}
|
|
|
|
|
2001-10-16 07:39:33 +08:00
|
|
|
cygheap_fdget cfd (fd);
|
|
|
|
if (cfd < 0)
|
2021-01-21 01:01:13 +08:00
|
|
|
return EBADF;
|
2011-11-08 04:05:49 +08:00
|
|
|
return cfd->ptsname_r (buf, buflen);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2020-01-29 00:57:50 +08:00
|
|
|
static int
|
|
|
|
mknod_worker (path_conv &pc, mode_t mode, _major_t major, _minor_t minor)
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
{
|
2008-03-07 19:24:51 +08:00
|
|
|
char buf[sizeof (":\\00000000:00000000:00000000") + PATH_MAX];
|
2020-01-29 00:57:50 +08:00
|
|
|
sprintf (buf, ":\\%x:%x:%x", major, minor, mode);
|
|
|
|
return symlink_worker (buf, pc, true);
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
}
|
|
|
|
|
2000-09-03 12:16:35 +08:00
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
mknod32 (const char *path, mode_t mode, dev_t dev)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2005-07-03 10:40:30 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
if (!*path)
|
|
|
|
{
|
|
|
|
set_errno (ENOENT);
|
|
|
|
__leave;
|
|
|
|
}
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
if (strlen (path) >= PATH_MAX)
|
|
|
|
__leave;
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
|
2020-01-29 00:57:50 +08:00
|
|
|
/* Trailing dirsep is a no-no, only errno differs. */
|
|
|
|
bool has_trailing_dirsep = isdirsep (path[strlen (path) - 1]);
|
|
|
|
|
|
|
|
path_conv w32path (path, PC_SYM_NOFOLLOW | PC_SYM_NOFOLLOW_DIR
|
|
|
|
| PC_POSIX, stat_suffixes);
|
|
|
|
|
|
|
|
if (w32path.exists () || has_trailing_dirsep)
|
|
|
|
{
|
|
|
|
set_errno (w32path.exists () ? EEXIST : ENOENT);
|
|
|
|
__leave;
|
|
|
|
}
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
mode_t type = mode & S_IFMT;
|
|
|
|
_major_t major = _major (dev);
|
|
|
|
_minor_t minor = _minor (dev);
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case S_IFCHR:
|
|
|
|
case S_IFBLK:
|
|
|
|
break;
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
case S_IFIFO:
|
|
|
|
major = _major (FH_FIFO);
|
|
|
|
minor = _minor (FH_FIFO);
|
|
|
|
break;
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
case 0:
|
|
|
|
case S_IFREG:
|
|
|
|
{
|
|
|
|
int fd = open (path, O_CREAT, mode);
|
|
|
|
if (fd < 0)
|
|
|
|
__leave;
|
|
|
|
close (fd);
|
|
|
|
return 0;
|
|
|
|
}
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
default:
|
|
|
|
set_errno (EINVAL);
|
|
|
|
__leave;
|
|
|
|
}
|
* devices.cc: New file.
* devices.gperf: New file.
* devices.shilka: New file.
* cygwin-gperf: New file.
* cygwin-shilka: New file.
* fhandler_fifo.cc: New file.
* fhandler_nodevice.cc : New file. Reorganize headers so that path.h precedes
fhandler.h throughout. Remove device argument and unit arguments from fhandler
constructors throughout. Remove pc arguments to fhandler functions and use
internal pc element instead, throughout. Use dev element in pc throughout.
Use major/minor elements rather than units and device numbers previously in
fhandler class. Use correct methods for fhandler file names rather than
directly accessing file name variables, throughout.
* Makefile.in (DLL_OFILES): Add devices.o, fhandler_fifo.o
* dcrt0.cc (dll_crt0_1): Call device::init.
* devices.h: Renumber devices based on more Linux-like major/minor numbers.
Add more devices. Declare standard device storage.
(device): Declare struct.
* dir.cc (opendir): Use new 'build_fh_name' to construct a fhandler_* type.
* dtable.cc (dtable::get_debugger_info): Ditto.
(cygwin_attach_handle_to_fd): Ditto.
(dtable::release): Remove special FH_SOCKET case in favor of generic
"need_fixup_before" test.
(dtable::init_std_file_from_handle): Use either build_fh_dev or build_fh_name
to build standard fhandler.
(dtable::build_fh_name): Renamed from dtable::build_fhandler_from_name. Move
out of dtable class. Don't accept a path_conv argument. Just build it here
and pass it to:
(build_fh_pc): Renamed from dtable::build_fhandler. Move out of dtable class.
Use intrinsic device type in path_conv to create new fhandler.
(build_fh_dev): Renamed from dtable::build_fhandler. Move out of dtable class.
Simplify arguments to just take new 'device' type and a name. Just return
pointer to fhandler rather than trying to insert into dtable.
(dtable::dup_worker): Accommodate above build_fh name changes.
(dtable::find_fifo): New (currently broken) function.
(handle_to_fn): Use strechr for efficiency.
* dtable.h: Reflect above build_fh name changes and argument differences.
(fhandler_base *&operator []): Return self rather than copy of self.
* fhandler.cc (fhandler_base::operator =): Use pc element to set normalized
path.
(fhandler_base::set_name): Ditto.
(fhandler_base::raw_read): Use method to access name.
(fhandler_base::write): Correctly use get_output_handle rather than get_handle.
(handler_base::device_access_denied): New function.
(fhandler_base::open): Eliminate pc argument and use pc element of
fhandler_base throughout.
(fhandler_base::fstat): Detect if device is based in filesystem and use
fstat_fs to calculate stat, if so.
(fhandler_base::fhandler_base): Eliminate handling of file names and, instead,
just free appropriate component from pc.
(fhandler_base::opendir): Remove path_conv parameter.
* fhandler.h: Remove all device flags.
(fhandler_base::pc): New element.
(fhandler_base::set_name): Change argument to path_conv.
(fhandler_base::error): New function.
(fhandler_base::exists): New function.
(fhandler_base::pc_binmode): New function.
(fhandler_base::dev): New function.
(fhandler_base::open_fs): New function.
(fhandler_base::fstat_fs): New function.
(fhandler_base::fstat_by_name): New function.
(fhandler_base::fstat_by_handle): New function.
(fhandler_base::isfifo): New function.
(fhandler_base::is_slow): New function.
(fhandler_base::is_auto_device): New function.
(fhandler_base::is_fs_special): New function.
(fhandler_base::device_access_denied): New function.
(fhandler_base::operator DWORD&): New operator.
(fhandler_base::get_name): Return normalized path from pc.
(fhandler_base::get_win32_name): Return windows path from pc.
(fhandler_base::isdevice): Renamed from is_device.
(fhandler_base::get_native_name): Return device format.
(fhandler_fifo): New class.
(fhandler_nodevice): New class.
(select_stuff::device_specific): Remove array.
(select_stuff::device_specific_pipe): New class element.
(select_stuff::device_specific_socket): New class element.
(select_stuff::device_specific_serial): New class element.
(select_stuff::select_stuff): Initialize new elements.
* fhandler_disk_file.cc (fhandler_base::fstat_by_handle): Move to base class
from fhandler_disk_file.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_base::fstat_by_name): Ditto.
(fhandler_disk_file::open): Move most functionality into
fhandler_base::open_fs.
(fhandler_base::open_fs): New function.
(fhandler_disk_file::close): Move most functionality into
fhandler_base::close_fs.
(fhandler_base::close_fs): New function.
* fhandler_mem.cc (fhandler_dev_mem::open): Use device name in debugging
output.
* fhandler_socket.cc (fhandler_socket::set_connect_secret): Copy standard
urandom device into appropriate place.
(fhandler_socket::accept): Reflect change in fdsock return value.
* fhandler_tty.cc: See "throughouts" above.
* net.cc: Accommodate fdsock change throughout.
(fdsock): Return success or failure, accept fd argument and device argument.
* path.cc (symlink_info::major): New element.
(symlink_info::minor): New element.
(symlink_info::parse_device): Declare new function.
(fs_info::update): Accommodate changes in path_conv class.
(path_conv::fillin): Ditto.
(path_conv::return_and_clear_normalized_path): Eliminate.
(path_conv::set_normalized_path): New function.
(path_conv::path_conv): Set info in dev element. Use path_conv methods Check
for FH_FS rather than FH_BAD to indicate when to fill in filesystem stuff.
where appropriate rather than direct access. Use set_normalized_path to set
normalized path.
(windows_device_names): Eliminate.
(get_dev): Ditto.
(get_raw_device_number): Ditto.
(get_device_number): Ditto.
(win32_device_name): Call new device name parser to do most of the heavy
lifting.
(mount_info::conv_to_win32_path): Fill in dev field as appropriate.
(symlink_worker): Handle new device files.
(symlink_info::check): Ditto.
(symlink_info::parse_device): Define new function.
* path.h (executable_states): Move here from fhandler.h.
(fs_info): Rename variables to *_storage and create methods for accessing same.
(path_conv): Add dev element, remove devn and unit and adjust inline methods to
accommodate.
(set_normalized_path): Declare new function.
* pinfo.cc (_pinfo::commune_recv): Add broken support for handling fifos.
(_pinfo::commune_send): Ditto.
* pipe.cc (fhandler_pipe::close): check for existence of handle before closing
it.
(handler_pipe::create): Rename from make_pipe. Change arguments to accept
fhandler_pipe array. Accommodate fifos.
(pipe): Rework to deal with fhandler_pipe::create changes.
(_pipe): Ditto.
* select.cc: Use individual device_specific types throughout rather than
indexing with obsolete device number.
(set_bits): Use is_socket call rather than checking device number.
* shared_info.h (CURR_MOUNT_MAGIC): Update.
(conv_to_win32_path): Reflect addition of device argument.
* syscalls.cc (mknod_worker): New function.
(open): Use build_fh_name to build fhandler.
(chown_worker): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(chmod_device): New function.
(chmod): Detect if this is an 'auto' device rather than an on-filesystem device
and handle appropriately. Use chmod_device to set mode of in-filesystem
devices.
(stat_worker): Eliminate path_conv argument. Call build_fh_name to construct
fhandler. Use fh->error() rather than pc->error to detect errors in fhandler
construction.
(access_worker): New function pulled from access. Accommodate in-filesystem
devices.
(access): Use access_worker.
(fpathconf): Detect if this is an 'auto' device rather than an on-filesystem
device and handle appropriately.
(mknod_worker): New function.
(mknod32): New function.
(chroot): Free normalized path -- assuming it was actually cmalloced.
* tty.cc (create_tty_master): Tweak for new device class.
(tty::common_init): Ditto.
* winsup.h (stat_worker): Remove.
(symlink_worker): Declare.
* exceptions.cc (set_process_mask): Just call sig_dispatch_pending and don't
worry about pending_signals since sig_dispatch_pending should always do the
right thing now.
(sig_handle): Reorganize SIGCONT handling to more closely conform to SUSv3.
* pinfo.h: Move __SIG enum to sigproc.h.
(PICOM_FIFO): New enum element.
(_pinfo): Remove 'thread2signal' stuff throughout class.
(_pinfo::commune_send): Make varargs.
(_pinfo::sigtodo): Eliminate.
(_pinfo::thread2signal): Ditto.
* signal.cc (kill_worker): Eliminate call to setthread2signal.
* sigproc.cc (local_sigtodo): Eliminate.
(getlocal_sigtodo): Ditto.
(sigelem): New class.
(pending_signals): New class.
(sigqueue): New variable, start of sigqueue linked list.
(sigcatch_nonmain): Eliminate.
(sigcatch_main): Eliminate.
(sigcatch_nosync): Eliminate.
(sigcomplete_nonmain): Eliminate.
(pending_signals): Eliminate.
(sig_clear): Call signal thread to clear pending signals, unless already in
signal thread.
(sigpending): Call signal thread to get pending signals.
(sig_dispatch_pending): Eliminate use of pending_signals and just check
sigqueue.
(sigproc_terminate): Eliminate all of the obsolete semaphore stuff. Close
signal pipe handle.
(sig_send): Eliminate all of the obsolete semaphore stuff and use pipe to send
signals.
(getevent): Eliminate.
(pending_signals::add): New function.
(pending_signals::del): New function.
(pending_signals::next): New function.
(wait_sig): Eliminate all of the obsolete semaphore stuff. Use pipe to
communicate and maintain a linked list of signals.
* sigproc.h: Move __SIG defines here. Add __SIGPENDING.
(sig_dispatch_pending): Remove "C" specifier.
(sig_handle): Accept a mask argument.
* thread.cc: Remove signal handling considerations throughout.
2003-09-25 08:37:18 +08:00
|
|
|
|
2020-01-29 00:57:50 +08:00
|
|
|
return mknod_worker (w32path, mode, major, minor);
|
2014-08-22 17:21:33 +08:00
|
|
|
}
|
|
|
|
__except (EFAULT)
|
|
|
|
__endtry
|
|
|
|
return -1;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2003-03-10 05:51:00 +08:00
|
|
|
extern "C" int
|
|
|
|
mknod (const char *_path, mode_t mode, __dev16_t dev)
|
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
return mknod32 (_path, mode, (dev_t) dev);
|
2003-03-10 05:51:00 +08:00
|
|
|
}
|
|
|
|
|
2001-04-13 00:50:13 +08:00
|
|
|
extern "C" int
|
2004-09-03 09:53:12 +08:00
|
|
|
mkfifo (const char *path, mode_t mode)
|
2001-04-13 00:50:13 +08:00
|
|
|
{
|
2004-09-03 09:53:12 +08:00
|
|
|
return mknod32 (path, (mode & ~S_IFMT) | S_IFIFO, 0);
|
2001-04-13 00:50:13 +08:00
|
|
|
}
|
|
|
|
|
2000-06-17 03:36:07 +08:00
|
|
|
/* seteuid: standards? */
|
2000-09-03 12:16:35 +08:00
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
seteuid32 (uid_t uid)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2005-04-15 16:19:07 +08:00
|
|
|
debug_printf ("uid: %u myself->uid: %u myself->gid: %u",
|
2005-05-02 11:50:11 +08:00
|
|
|
uid, myself->uid, myself->gid);
|
2002-05-27 19:48:15 +08:00
|
|
|
|
2009-10-13 18:23:31 +08:00
|
|
|
/* Same uid as we're just running under is usually a no-op.
|
|
|
|
|
|
|
|
Except we have an external token which is a restricted token. Or,
|
|
|
|
the external token is NULL, but the current impersonation token is
|
|
|
|
a restricted token. This allows to restrict user rights temporarily
|
|
|
|
like this:
|
|
|
|
|
|
|
|
cygwin_internal(CW_SET_EXTERNAL_TOKEN, restricted_token,
|
2011-06-06 13:02:13 +08:00
|
|
|
CW_TOKEN_RESTRICTED);
|
2009-10-13 18:23:31 +08:00
|
|
|
setuid (getuid ());
|
|
|
|
[...do stuff with restricted rights...]
|
|
|
|
cygwin_internal(CW_SET_EXTERNAL_TOKEN, INVALID_HANDLE_VALUE,
|
2011-06-06 13:02:13 +08:00
|
|
|
CW_TOKEN_RESTRICTED);
|
2009-10-13 18:23:31 +08:00
|
|
|
setuid (getuid ());
|
|
|
|
|
2015-12-16 04:43:33 +08:00
|
|
|
Note that using the current uid is a requirement! We have restricted
|
|
|
|
tokens galore (UAC), so this is really just a special case to restrict
|
|
|
|
your own processes to lesser rights. */
|
2009-10-13 18:23:31 +08:00
|
|
|
bool request_restricted_uid_switch = (uid == myself->uid
|
|
|
|
&& cygheap->user.ext_token_is_restricted);
|
|
|
|
if (uid == myself->uid && !cygheap->user.groups.ischanged
|
|
|
|
&& !request_restricted_uid_switch)
|
2002-05-27 19:48:15 +08:00
|
|
|
{
|
2002-07-02 11:06:32 +08:00
|
|
|
debug_printf ("Nothing happens");
|
2002-05-27 19:48:15 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-07-29 20:51:52 +08:00
|
|
|
cygsid usersid;
|
|
|
|
user_groups &groups = cygheap->user.groups;
|
2019-02-24 00:24:05 +08:00
|
|
|
HANDLE new_token = NULL;
|
2002-06-15 02:01:21 +08:00
|
|
|
struct passwd * pw_new;
|
2004-11-21 03:09:19 +08:00
|
|
|
bool token_is_internal, issamesid = false;
|
2003-11-29 04:55:59 +08:00
|
|
|
|
2002-12-10 Pierre Humblet <pierre.humblet@ieee.org>
* pwdgrp.h (pwdgrp_check::pwdgrp_state): Replace by
pwdgrp_check::isinitializing ().
(pwdgrp_check::isinitializing): Create.
* passwd.cc (grab_int): Change type to unsigned, use strtoul and
set the pointer content to 0 if the field is invalid.
(parse_pwd): Move validity test after getting pw_gid.
(read_etc_passwd): Replace "passwd_state <= " by
passwd_state::isinitializing ().
(internal_getpwuid): Ditto.
(internal_getpwnam): Ditto.
(getpwent): Ditto.
(getpass): Ditto.
* grp.cc (parse_grp): Use strtoul for gr_gid and verify the validity.
(read_etc_group): Replace "group_state <= " by
group_state::isinitializing ().
(internal_getgrgid): Ditto.
(getgrent32): Ditto.
(internal_getgrent): Ditto.
2002-12-10 Pierre Humblet <pierre.humblet@ieee.org>
* security.h: Move declarations of internal_getgrent,
internal_getpwsid and internal_getgrsid to pwdgrp.h.
* pwdgrp.h: Declare internal_getpwsid, internal_getpwnam,
internal_getpwuid, internal_getgrsid, internal_getgrgid,
internal_getgrnam, internal_getgrent and internal_getgroups.
Delete "emulated" from enum pwdgrp_state.
(pwdgrp_check::isuninitialized): Create.
(pwdgrp_check::pwdgrp_state): Change state to initializing
rather than to uninitialized.
(pwdgrp_read::gets): Remove trailing CRs.
* passwd.cc (grab_string): Don't look for NLs.
(grab_int): Ditto.
(parse_pwd): Don't look for CRs. Return 0 if entry is too short.
(search_for): Delete.
(read_etc_passwd): Simplify tests to actually read the file.
Set state to loaded before making internal_getpwXX calls.
Replace search_for calls by equivalent internal_pwgetXX calls.
(internal_getpwsid): Use passwd_state.isuninitialized to decide
to call read_etc_passwd.
(internal_getpwuid): Create.
(internal_getpwnam): Create.
(getpwuid32): Simply call internal_getpwuid.
(getpwuid_r32): Call internal_getpwuid.
(getpwnam): Simply call internal_getpwnam.
(getpwnam_r): Call internal_getpwnam.
* grp.cc (parse_grp): Don't look for CRs. Adjust blank space.
(add_grp_line): Adjust blank space.
(class group_lock): Ditto.
(read_etc_group): Simplify tests to actually read the file.
Set state to loaded before making internal_getgrXX calls.
Replace getgrXX calls by equivalent internal calls.
(internal_getgrsid): Use group_state.isuninitialized to decide
to call read_etc_group.
(internal_getgrgid): Create.
(internal_getgrnam): Create.
(getgroups32): Simply call internal_getgrgid.
(getgrnam32): Simply call internal_getgrnam.
(internal_getgrent): Call group_state.isuninitialized.
(internal_getgroups): Create from the former getgroups32, using
two of the four arguments. Set gid to myself->gid and username
to cygheap->user.name ().
(getgroups32): Simply call internal_getgroup.
(getgroups): Call internal_getgroup instead of getgroups32.
(setgroups32): Call internal versions of get{pw,gr}XX.
* sec_helper.cc: Include pwdgrp.h.
(is_grp_member): Call internal versions of get{pw,gr}XX.
* security.cc: Include pwdgrp.h.
(alloc_sd): Call internal versions of get{pw,gr}XX.
* syscalls.cc: Include pwdgrp.h.
(seteuid32): Call internal versions of get{pw,gr}XX.
(setegid32): Ditto.
* uinfo.cc: Include pwdgrp.h.
(internal_getlogin): Call internal versions of get{pw,gr}XX.
(cygheap_user::ontherange): Ditto.
* sec_acl.cc: Include pwdgrp.h.
(setacl): Call internal versions of get{pw,gr}XX.
(acl_access): Ditto and simplify logic.
(aclfromtext): Ditto.
2002-12-10 20:43:49 +08:00
|
|
|
pw_new = internal_getpwuid (uid);
|
2002-07-29 20:51:52 +08:00
|
|
|
if (!usersid.getfrompw (pw_new))
|
2000-04-20 06:33:20 +08:00
|
|
|
{
|
2002-05-27 19:48:15 +08:00
|
|
|
set_errno (EINVAL);
|
|
|
|
return -1;
|
|
|
|
}
|
2001-06-10 05:25:55 +08:00
|
|
|
|
2005-04-03 21:06:43 +08:00
|
|
|
cygheap->user.deimpersonate ();
|
2003-06-30 21:07:36 +08:00
|
|
|
|
|
|
|
/* Verify if the process token is suitable. */
|
2009-10-13 18:23:31 +08:00
|
|
|
/* First of all, skip all checks if a switch to a restricted token has been
|
|
|
|
requested, or if trying to switch back from it. */
|
|
|
|
if (request_restricted_uid_switch)
|
|
|
|
{
|
|
|
|
if (cygheap->user.external_token != NO_IMPERSONATION)
|
|
|
|
{
|
|
|
|
debug_printf ("Switch to restricted token");
|
|
|
|
new_token = cygheap->user.external_token;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
debug_printf ("Switch back from restricted token");
|
|
|
|
new_token = hProcToken;
|
|
|
|
cygheap->user.ext_token_is_restricted = false;
|
|
|
|
}
|
|
|
|
}
|
2008-11-26 18:18:10 +08:00
|
|
|
/* TODO, CV 2008-11-25: The check against saved_sid is a kludge and a
|
|
|
|
shortcut. We must check if it's really feasible in the long run.
|
|
|
|
The reason to add this shortcut is this: sshd switches back to the
|
|
|
|
privileged user running sshd at least twice in the process of
|
|
|
|
authentication. It calls seteuid first, then setegid. Due to this
|
|
|
|
order, the setgroups group list is still active when calling seteuid
|
|
|
|
and verify_token treats the original token of the privileged user as
|
|
|
|
insufficient. This in turn results in creating a new user token for
|
2019-01-27 01:33:41 +08:00
|
|
|
the privileged user instead of using the original token. This can have
|
2008-11-26 18:18:10 +08:00
|
|
|
unfortunate side effects. The created token has different group
|
|
|
|
memberships, different user rights, and misses possible network
|
2008-11-27 01:21:04 +08:00
|
|
|
credentials.
|
2008-11-26 18:18:10 +08:00
|
|
|
Therefore we try this shortcut now. When switching back to the
|
|
|
|
privileged user, we probably always want a correct (aka original)
|
|
|
|
user token for this privileged user, not only in sshd. */
|
2009-10-13 18:23:31 +08:00
|
|
|
else if ((uid == cygheap->user.saved_uid
|
|
|
|
&& usersid == cygheap->user.saved_sid ())
|
|
|
|
|| verify_token (hProcToken, usersid, groups))
|
2005-04-03 21:06:43 +08:00
|
|
|
new_token = hProcToken;
|
2003-07-15 01:04:21 +08:00
|
|
|
/* Verify if the external token is suitable */
|
2004-10-28 09:46:01 +08:00
|
|
|
else if (cygheap->user.external_token != NO_IMPERSONATION
|
2003-06-30 21:07:36 +08:00
|
|
|
&& verify_token (cygheap->user.external_token, usersid, groups))
|
2003-07-15 01:04:21 +08:00
|
|
|
new_token = cygheap->user.external_token;
|
|
|
|
/* Verify if the current token (internal or former external) is suitable */
|
2005-04-03 21:06:43 +08:00
|
|
|
else if (cygheap->user.curr_primary_token != NO_IMPERSONATION
|
|
|
|
&& cygheap->user.curr_primary_token != cygheap->user.external_token
|
|
|
|
&& verify_token (cygheap->user.curr_primary_token, usersid, groups,
|
2003-07-15 01:04:21 +08:00
|
|
|
&token_is_internal))
|
2005-04-03 21:06:43 +08:00
|
|
|
new_token = cygheap->user.curr_primary_token;
|
2003-07-15 01:04:21 +08:00
|
|
|
/* Verify if the internal token is suitable */
|
2004-10-28 09:46:01 +08:00
|
|
|
else if (cygheap->user.internal_token != NO_IMPERSONATION
|
2005-04-03 21:06:43 +08:00
|
|
|
&& cygheap->user.internal_token != cygheap->user.curr_primary_token
|
2003-06-30 21:07:36 +08:00
|
|
|
&& verify_token (cygheap->user.internal_token, usersid, groups,
|
|
|
|
&token_is_internal))
|
2003-07-15 01:04:21 +08:00
|
|
|
new_token = cygheap->user.internal_token;
|
2000-07-27 01:48:49 +08:00
|
|
|
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("Found token %p", new_token);
|
* autoload.cc: Add load statements for `LookupAccountNameW',
`LsaClose', `LsaEnumerateAccountRights', `LsaFreeMemory',
`LsaOpenPolicy', `LsaQueryInformationPolicy', `NetLocalGroupEnum',
`NetLocalGroupGetMembers', `NetServerEnum', `NetUserGetGroups' and
`NtCreateToken'.
* ntdll.h: Add declaration for `NtCreateToken'.
* sec_helper.cc: Add `well_known_local_sid', `well_known_dialup_sid',
`well_known_network_sid', `well_known_batch_sid',
`well_known_interactive_sid', `well_known_service_sid' and
`well_known_authenticated_users_sid'.
(cygsid::string): Define as const method.
(cygsid::get_sid): Set psid to NO_SID on error.
(cygsid::getfromstr): Ditto.
(cygsid::getfrompw): Simplify.
(cygsid::getfromgr): Check for gr == NULL.
(legal_sid_type): Move to security.h.
(set_process_privilege): Return -1 on error, otherwise 0 or 1 related
to previous privilege setting.
* security.cc (extract_nt_dom_user): Remove `static'.
(lsa2wchar): New function.
(open_local_policy): Ditto.
(close_local_policy): Ditto.
(get_lsa_srv_inf): Ditto.
(get_logon_server): Ditto.
(get_logon_server_and_user_domain): Ditto.
(get_user_groups): Ditto.
(is_group_member): Ditto.
(get_user_local_groups): Ditto.
(sid_in_token_groups): Ditto.
(get_user_primary_group): Ditto.
(get_group_sidlist): Ditto.
(get_system_priv_list): Ditto.
(get_priv_list): Ditto.
(get_dacl): Ditto.
(create_token): Ditto.
(subauth): Return immediately if SE_TCB_NAME can't be assigned.
Change all return statements in case of error to jumps to `out'
label. Add `out' label to support cleanup.
* security.h: Add extern declarations for `well_known_local_sid',
`well_known_dialup_sid', `well_known_network_sid',
`well_known_batch_sid', `well_known_interactive_sid',
`well_known_service_sid' and `well_known_authenticated_users_sid'.
Add extern declarations for functions `create_token',
`extract_nt_dom_user' and `get_logon_server_and_user_domain'.
(class cygsid): Add method `assign'. Change operator= to call new
`assign' method. Add `debug_print' method.
(class cygsidlist): New class.
(legal_sid_type): Moved from sec_helper.cc to here.
* spawn.cc (spawn_guts) Revert reversion of previous patch.
Call `RevertToSelf' and `ImpersonateLoggedOnUser' instead of `seteuid'
again.
* syscalls.cc (seteuid): Rearranged. Call `create_token' now when
needed. Call `subauth' if `create_token' fails. Try setting token
owner and primary group only if token was not explicitely created
by `create_token'.
* uinfo.cc (internal_getlogin): Try harder to generate correct user
information. Especially don't trust return value of `GetUserName'.
2001-05-20 16:10:47 +08:00
|
|
|
|
2008-11-26 18:18:10 +08:00
|
|
|
/* If no impersonation token is available, try to authenticate using
|
|
|
|
LSA private data stored password, LSA authentication using our own
|
|
|
|
LSA module, or, as last chance, NtCreateToken. */
|
2019-02-24 00:24:05 +08:00
|
|
|
if (new_token == NULL)
|
2002-05-27 19:48:15 +08:00
|
|
|
{
|
2019-03-05 03:30:37 +08:00
|
|
|
if (!(new_token = lsaprivkeyauth (pw_new)))
|
2008-11-27 01:21:04 +08:00
|
|
|
{
|
2019-02-19 04:00:59 +08:00
|
|
|
NTSTATUS status;
|
2019-02-23 01:27:38 +08:00
|
|
|
WCHAR domain[MAX_DOMAIN_NAME_LEN + 1];
|
|
|
|
WCHAR user[UNLEN + 1];
|
2019-02-19 04:00:59 +08:00
|
|
|
|
2019-01-27 01:33:41 +08:00
|
|
|
debug_printf ("lsaprivkeyauth failed, try s4uauth.");
|
2019-02-23 01:27:38 +08:00
|
|
|
extract_nt_dom_user (pw_new, domain, user);
|
|
|
|
if (!(new_token = s4uauth (true, domain, user, status)))
|
2019-01-27 01:33:41 +08:00
|
|
|
{
|
2019-02-19 04:00:59 +08:00
|
|
|
if (status != STATUS_INVALID_PARAMETER)
|
2008-11-26 18:18:10 +08:00
|
|
|
{
|
2019-02-19 04:00:59 +08:00
|
|
|
debug_printf ("s4uauth failed, bail out");
|
|
|
|
cygheap->user.reimpersonate ();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
/* If s4uauth fails with status code STATUS_INVALID_PARAMETER,
|
|
|
|
we're running on a system not implementing MsV1_0S4ULogon
|
|
|
|
(Windows 7 WOW64, Vista?). Fall back to create_token in
|
|
|
|
this single case only. */
|
|
|
|
debug_printf ("s4uauth failed, try create_token.");
|
|
|
|
if (!(new_token = create_token (usersid, groups)))
|
|
|
|
{
|
|
|
|
debug_printf ("create_token failed, bail out");
|
|
|
|
cygheap->user.reimpersonate ();
|
|
|
|
return -1;
|
2008-11-26 18:18:10 +08:00
|
|
|
}
|
2005-04-03 21:06:43 +08:00
|
|
|
}
|
2006-07-25 Corinna Vinschen <corinna@vinschen.de>
* include/cygwin/version.h: Bump DLL version to 1.7.0.
2006-07-25 Corinna Vinschen <corinna@vinschen.de>
* select.h: Remove.
* fhandler_socket.cc: Don't include select.h.
* select.cc: Ditto.
2006-07-25 Corinna Vinschen <corinna@vinschen.de>
* cygtls.h: Drop socket related includes.
(struct _local_storage): Remove exitsock and exitsock_sin. Add
select_sockevt.
* cygtls.cc: Accomodate above change throughout.
* fhandler.h (class fhandler_socket): Make wsock_evt public.
* fhandler_socket.cc (fhandler_socket::fhandler_socket): Accomodate
reordering members.
(fhandler_socket::evaluate_events): Drop FD_CONNECT event as soon as
it gets read once. Never remove FD_WRITE event here.
(fhandler_socket::wait_for_events): Wait 50 ms instead of INFINITE for
socket events.
(fhandler_socket::accept): Fix conditional. Set wsock_events members
of accepted socket to useful start values.
(fhandler_socket::recv_internal): Always drop FD_READ/FD_OOB events from
wsock_events after the call to WSARecvFrom.
(fhandler_socket::send_internal): Drop FD_WRITE event from wsock_events
if the call to WSASendTo fails with WSAEWOULDBLOCK. Fix return value
condition.
* select.cc (struct socketinf): Change to accomodate using socket event
handling.
(peek_socket): Use event handling for peeking socket.
(thread_socket): Ditto.
(start_thread_socket): Ditto.
(socket_cleanup): Same here.
* tlsoffsets.h: Regenerate.
2006-07-20 Corinna Vinschen <corinna@vinschen.de>
* fhandler.h (class fhandler_socket): Rearrange slightly to keep
event handling methods and members together. Drop owner status flag.
Split wait method. Rename event handling methods for readability.
* fhandler_socket.cc (struct wsa_event): Add owner field.
(LOCK_EVENTS): New macro.
(UNLOCK_EVENTS): Ditto.
(fhandler_socket::init_events): rename from prepare.
(fhandler_socket::evaluate_events): First half of former wait method.
Do everything but wait. Allow specifiying whether or not events from
event_mask should be erased from wsock_events->events. Simplify
OOB handling. Allow sending SIGURG to any process (group).
(fhandler_socket::wait_for_events): Second half of former wait method.
Call evaluate_events and wait in a loop if socket is blocking.
(fhandler_socket::release_events): Rename from release.
(fhandler_socket::connect): Accomodate above name changes.
(fhandler_socket::accept): Ditto.
(fhandler_socket::recv_internal): Ditto.
(fhandler_socket::send_internal): Ditto.
(fhandler_socket::close): Ditto.
(fhandler_socket::fcntl): Always set owner to given input value on
F_SETOWN. Handle F_GETOWN.
* net.cc (fdsock): Accomodate above name changes.
2006-07-20 Corinna Vinschen <corinna@vinschen.de>
* fhandler_socket.cc (fhandler_socket::wait): Set Winsock errno to
WSAEWOULDBLOCK instead of WSAEINPROGRESS.
2006-07-18 Brian Ford <Brian.Ford@FlightSafety.com>
Corinna Vinschen <corinna@vinschen.de>
* winsup.h (mmap_region_status): New enum.
(mmap_is_attached_or_noreserve_page): Adjust prototype and rename
as below.
* mmap.cc (mmap_is_attached_or_noreserve_page): Rename
mmap_is_attached_or_noreserve. Add region length parameter.
Return enum above.
* exceptions.cc (_cygtls::handle_exceptions): Accomodate above.
* fhandler.cc (fhandler_base::raw_read): Call above for NOACCESS
errors and retry on success to allow reads into untouched
MAP_NORESERVE buffers.
2006-07-18 Corinna Vinschen <corinna@vinschen.de>
* cygwin.din (posix_openpt): Export.
* tty.cc (posix_openpt): New function.
* include/cygwin/stdlib.h (posix_openpt): Declare.
* include/cygwin/version.h: Bump API minor number.
2006-07-14 Corinna Vinschen <corinna@vinschen.de>
* security.cc (get_token_group_sidlist): Always add the interactive
group to the token. Add comment. Create logon_id group SID by
copying it from incoming group list.
(create_token): Add subauth_token parameter. Use information in
subauth_token if present. Tweak SourceIdentifier if subauth_token
is present for debugging purposes.
* security.h (create_token): Add subauth_token parameter in declaration.
* syscalls.cc (seteuid32): Call subauth first. Call create_token
regardless. Use subauth token in call to create_token if subauth
succeeded.
2006-07-13 Corinna Vinschen <corinna@vinschen.de>
* include/netinet/in.h: Update copyright.
2006-07-13 Corinna Vinschen <corinna@vinschen.de>
* fhandler_socket.cc (fhandler_socket::wait): Rework function so that
WaitForMultipleObjects is really only called when necessary.
2006-07-12 Corinna Vinschen <corinna@vinschen.de>
* include/netdb.h: Declare rcmd, rcmd_af, rexec, rresvport,
rresvport_af, iruserok, iruserok_sa, ruserok.
2006-07-12 Corinna Vinschen <corinna@vinschen.de>
* Makefile.in (DLL_OFILES): Drop iruserok.o. Add rcmd.o.
* autoload.cc (rcmd): Drop definition.
* cygwin.din: Export bindresvport, bindresvport_sa, iruserok_sa,
rcmd_af, rresvport_af.
* net.cc (cygwin_rcmd): Remove.
(last_used_bindresvport): Rename from last_used_rrecvport.
(cygwin_bindresvport_sa): New function implementing bindresvport_sa.
(cygwin_bindresvport): New function implementing bindresvport.
(cygwin_rresvport): Remove.
* include/cygwin/version.h: Bump API minor number.
* include/netinet/in.h: Declare bindresvport and bindresvport_sa.
* libc/iruserok.c: Remove file.
* libc/rcmd.cc: New file implementing rcmd, rcmd_af, rresvport,
rresvport_af, iruserok_sa, iruserok and ruserok.
2006-07-12 Corinna Vinschen <corinna@vinschen.de>
* fhandler_socket.cc (fhandler_socket::getsockname): Return valid
result for unbound sockets.
2006-07-11 Corinna Vinschen <corinna@vinschen.de>
* fhandler_socket.cc (fhandler_socket::fixup_after_fork): Handle
wsock_mtx and wsock_evt on fork, thus handling close_on_exec correctly.
(fhandler_socket::fixup_after_exec): Drop misguided attempt to handle
close_on_exec here.
(fhandler_socket::dup): Call fixup_after_fork with NULL parent.
Add comment.
(fhandler_socket::set_close_on_exec): Handle wsock_mtx and wsock_evt.
2006-07-10 Corinna Vinschen <corinna@vinschen.de>
* fhandler.h (class fhandler_socket): Add wsock_mtx, wsock_evt
and wsock_events members. Remove closed status flag, add listener
status flag. Accomodate new implementation of socket event handling
methods. Declare recv* and send* functions ssize_t as the POSIX
equivalents.
(fhandler_socket::recv_internal): Declare.
(fhandler_socket::send_internal): Ditto.
* fhandler_socket.cc (EVENT_MASK): Define mask of selected events.
(fhandler_socket::fhandler_socket): Initialize new members.
(fhandler_socket::af_local_setblocking): Don't actually set the
socket to blocking mode. Keep sane event selection.
(fhandler_socket::af_local_unsetblocking): Don't actually set the
socket to previous blocking setting, just remember it.
(struct wsa_event): New structure to keep event data per shared
socket.
(NUM_SOCKS): Define number of shared sockets concurrently handled by
all active Cygwin processes.
(wsa_events): New shared datastructure keeping all wsa_event records.
(socket_serial_number): New shared variable to identify shared sockets.
(wsa_slot_mtx): Global mutex to serialize wsa_events access.
(search_wsa_event_slot): New static function to select a new wsa_event
slot for a new socket.
(fhandler_socket::prepare): Rewrite. Prepare event selection
per new socket.
(fhandler_socket::wait): Rewrite. Wait for socket events in thread
safe and multiple process safe.
(fhandler_socket::release): Rewrite. Close per-socket descriptor
mutex handle and event handle.
(fhandler_socket::dup): Duplicate wsock_mtx and wsock_evt. Fix
copy-paste error in debug output.
(fhandler_socket::connect): Accomodate new event handling.
(fhandler_socket::listen): Set listener flag on successful listen.
(fhandler_socket::accept): Accomodate new event handling.
(fhandler_socket::recv_internal): New inline method centralizing
common recv code.
(fhandler_socket::recvfrom): Call recv_internal now.
(fhandler_socket::recvmsg): Ditto. Streamline copying from iovec
to WSABUF.
(fhandler_socket::send_internal): New inline method centralizing
common send code.
(fhandler_socket::sendto): Call send_internal now.
(fhandler_socket::sendmsg): Ditto. Streamline copying from iovec
to WSABUF.
(fhandler_socket::close): Call release now.
(fhandler_socket::ioctl): Never actually switch to blocking mode.
Just keep track of the setting.
* net.cc (fdsock): Call prepare now.
(cygwin_connect): Revert again to event driven technique.
(cygwin_accept): Ditto.
* poll.cc (poll): Don't call recvfrom on a listening socket.
Remove special case for failing recvfrom.
* include/sys/socket.h: Declare recv* and send* functions ssize_t as
requested by POSIX.
2006-07-07 Corinna Vinschen <corinna@vinschen.de>
* net.cc (cygwin_inet_ntop): Fix data type of forth parameter.
2006-07-06 Corinna Vinschen <corinna@vinschen.de>
* include/cygwin/in6.h (struct in6_addr): Fix typo.
2006-07-06 Corinna Vinschen <corinna@vinschen.de>
* cygwin.din: Export in6addr_any, in6addr_loopback, freeaddrinfo,
gai_strerror, getaddrinfo, getnameinfo.
* fhandler_socket.cc: Include cygwin/in6.h.
(get_inet_addr): Accomodate AF_INET6 usage.
(fhandler_socket::connect): Ditto.
(fhandler_socket::listen): Ditto.
(fhandler_socket::sendto): Ditto.
* net.cc: Include cygwin/in6.h.
(in6addr_any): Define.
(in6addr_loopback): Define.
(cygwin_socket): Accomodate AF_INET6 usage.
(socketpair): Bind socketpairs only to loopback for security.
(inet_pton4): New static function.
(inet_pton6): Ditto.
(cygwin_inet_pton): New AF_INET6 aware inet_pton implementation.
(inet_ntop4): New static function.
(inet_ntop6): Ditto.
(cygwin_inet_ntop): New AF_INET6 aware inet_ntop implementation.
(ga_aistruct): New static function.
(ga_clone): Ditto.
(ga_echeck): Ditto.
(ga_nsearch): Ditto.
(ga_port): Ditto.
(ga_serv): Ditto.
(ga_unix): Ditto.
(gn_ipv46): Ditto.
(ipv4_freeaddrinfo): Ditto.
(ipv4_getaddrinfo): Ditto.
(ipv4_getnameinfo): Ditto.
(gai_errmap_t): New structure holding error code - error string mapping.
(cygwin_gai_strerror): New function implementing gai_strerror.
(w32_to_gai_err): New static function.
(get_ipv6_funcs): Ditto.
(load_ipv6_funcs): Ditto.
(cygwin_freeaddrinfo): New function implementing freeaddrinfo.
(cygwin_getaddrinfo): New function implementing getaddrinfo.
(cygwin_getnameinfo): New function implementing getnameinfo.
* include/netdb.h: Include stdint.h and cygwin/socket.h. Define
data types and macros used by getaddrinfo and friends. Declare
freeaddrinfo, gai_strerror, getaddrinfo and getnameinfo.
* include/cygwin/in.h: Add IPv6 related IPPROTOs. Remove definition
of struct sockaddr_in6. Include cygwin/in6.h instead.
* include/cygwin/in6.h: New header file defining IPv6 releated
data types and macros.
* include/cygwin/socket.h: Enable AF_INET6 and PF_INET6. Add
IPv6 related socket options.
* include/cygwin/version.h: Bump API minor number.
2006-07-06 Corinna Vinschen <corinna@vinschen.de>
* autoload.cc (DsGetDcNameA): Define.
(NetGetAnyDCName): Define.
* security.cc: Include dsgetdc.h.
(DsGetDcNameA): Declare.
(DS_FORCE_REDISCOVERY): Define.
(get_logon_server): Add bool parameter to control rediscovery of DC.
Use DsGetDcNameA function if supported, NetGetDCName/NetGetAnyDCName
otherwise.
(get_server_groups): Rediscover DC if get_user_groups fails and
try again.
(get_reg_security): Use correct error code macro when testing
RegGetKeySecurity return value.
* security.h (get_logon_server): Remove default vaue from wserver
parameter. Add rediscovery parameter.
* uinfo.cc (cygheap_user::env_logsrv): Accomodate rediscovery parameter
in call to get_logon_server.
2006-07-26 03:23:23 +08:00
|
|
|
}
|
2006-11-27 20:59:59 +08:00
|
|
|
|
2003-07-15 01:04:21 +08:00
|
|
|
/* Keep at most one internal token */
|
2004-10-28 09:46:01 +08:00
|
|
|
if (cygheap->user.internal_token != NO_IMPERSONATION)
|
2003-07-15 01:04:21 +08:00
|
|
|
CloseHandle (cygheap->user.internal_token);
|
|
|
|
cygheap->user.internal_token = new_token;
|
2002-05-27 19:48:15 +08:00
|
|
|
}
|
2004-10-28 09:46:01 +08:00
|
|
|
|
2005-04-03 21:06:43 +08:00
|
|
|
if (new_token != hProcToken)
|
2002-05-27 19:48:15 +08:00
|
|
|
{
|
2011-04-29 15:34:05 +08:00
|
|
|
NTSTATUS status;
|
|
|
|
|
2019-03-05 00:07:31 +08:00
|
|
|
if (!request_restricted_uid_switch)
|
|
|
|
load_user_profile (new_token, pw_new, usersid);
|
2003-11-29 04:55:59 +08:00
|
|
|
|
2003-07-15 01:04:21 +08:00
|
|
|
/* Try setting owner to same value as user. */
|
2011-04-29 15:34:05 +08:00
|
|
|
status = NtSetInformationToken (new_token, TokenOwner,
|
|
|
|
&usersid, sizeof usersid);
|
|
|
|
if (!NT_SUCCESS (status))
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("NtSetInformationToken (user.token, TokenOwner), %y",
|
2011-04-29 15:34:05 +08:00
|
|
|
status);
|
2003-07-15 01:04:21 +08:00
|
|
|
/* Try setting primary group in token to current group */
|
2011-04-29 15:34:05 +08:00
|
|
|
status = NtSetInformationToken (new_token, TokenPrimaryGroup,
|
|
|
|
&groups.pgsid, sizeof (cygsid));
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
debug_printf ("NtSetInformationToken (user.token, TokenPrimaryGroup),"
|
2013-04-23 17:44:36 +08:00
|
|
|
"%y", status);
|
2003-10-17 07:20:41 +08:00
|
|
|
/* Try setting default DACL */
|
2005-06-08 03:31:42 +08:00
|
|
|
PACL dacl_buf = (PACL) alloca (MAX_DACL_LEN (5));
|
|
|
|
if (sec_acl (dacl_buf, true, true, usersid))
|
2005-05-02 11:50:11 +08:00
|
|
|
{
|
2005-06-08 03:31:42 +08:00
|
|
|
TOKEN_DEFAULT_DACL tdacl = { dacl_buf };
|
2011-04-29 15:34:05 +08:00
|
|
|
status = NtSetInformationToken (new_token, TokenDefaultDacl,
|
|
|
|
&tdacl, sizeof (tdacl));
|
|
|
|
if (!NT_SUCCESS (status))
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("NtSetInformationToken (TokenDefaultDacl), %y",
|
2011-04-29 15:34:05 +08:00
|
|
|
status);
|
2005-04-03 21:06:43 +08:00
|
|
|
}
|
2002-05-27 19:48:15 +08:00
|
|
|
}
|
2003-06-30 21:07:36 +08:00
|
|
|
|
2003-11-29 04:55:59 +08:00
|
|
|
issamesid = (usersid == cygheap->user.sid ());
|
2003-07-15 01:04:21 +08:00
|
|
|
cygheap->user.set_sid (usersid);
|
2005-04-03 21:06:43 +08:00
|
|
|
cygheap->user.curr_primary_token = new_token == hProcToken ? NO_IMPERSONATION
|
2019-03-05 00:07:31 +08:00
|
|
|
: new_token;
|
2009-10-13 18:23:31 +08:00
|
|
|
cygheap->user.curr_token_is_restricted = false;
|
|
|
|
cygheap->user.setuid_to_restricted = false;
|
2007-07-17 04:01:15 +08:00
|
|
|
if (cygheap->user.curr_imp_token != NO_IMPERSONATION)
|
2005-04-03 21:06:43 +08:00
|
|
|
{
|
2007-07-17 04:01:15 +08:00
|
|
|
CloseHandle (cygheap->user.curr_imp_token);
|
|
|
|
cygheap->user.curr_imp_token = NO_IMPERSONATION;
|
2005-04-03 21:06:43 +08:00
|
|
|
}
|
|
|
|
if (cygheap->user.curr_primary_token != NO_IMPERSONATION)
|
|
|
|
{
|
2009-10-13 18:23:31 +08:00
|
|
|
/* HANDLE_FLAG_INHERIT may be missing in external token. */
|
|
|
|
if (!SetHandleInformation (cygheap->user.curr_primary_token,
|
|
|
|
HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT)
|
|
|
|
|| !DuplicateTokenEx (cygheap->user.curr_primary_token,
|
|
|
|
MAXIMUM_ALLOWED, &sec_none,
|
|
|
|
SecurityImpersonation, TokenImpersonation,
|
|
|
|
&cygheap->user.curr_imp_token))
|
2005-04-03 21:06:43 +08:00
|
|
|
{
|
|
|
|
__seterrno ();
|
|
|
|
cygheap->user.curr_primary_token = NO_IMPERSONATION;
|
|
|
|
return -1;
|
|
|
|
}
|
2009-10-13 18:23:31 +08:00
|
|
|
cygheap->user.curr_token_is_restricted = request_restricted_uid_switch;
|
2009-10-07 16:20:49 +08:00
|
|
|
set_cygwin_privileges (cygheap->user.curr_primary_token);
|
2007-07-17 04:01:15 +08:00
|
|
|
set_cygwin_privileges (cygheap->user.curr_imp_token);
|
2005-04-03 21:06:43 +08:00
|
|
|
}
|
|
|
|
if (!cygheap->user.reimpersonate ())
|
|
|
|
{
|
|
|
|
__seterrno ();
|
|
|
|
return -1;
|
|
|
|
}
|
2003-09-10 10:12:26 +08:00
|
|
|
|
2003-01-25 18:36:46 +08:00
|
|
|
cygheap->user.set_name (pw_new->pw_name);
|
2002-06-15 02:01:21 +08:00
|
|
|
myself->uid = uid;
|
2002-07-29 20:51:52 +08:00
|
|
|
groups.ischanged = FALSE;
|
2005-01-09 02:33:07 +08:00
|
|
|
if (!issamesid)
|
2008-07-28 06:31:48 +08:00
|
|
|
/* Recreate and fill out the user shared region for a new user. */
|
2010-03-16 05:29:15 +08:00
|
|
|
user_info::create (true);
|
2002-06-15 02:01:21 +08:00
|
|
|
return 0;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2017-11-27 21:36:06 +08:00
|
|
|
#ifdef __i386__
|
2002-05-29 23:04:29 +08:00
|
|
|
extern "C" int
|
|
|
|
seteuid (__uid16_t uid)
|
|
|
|
{
|
|
|
|
return seteuid32 (uid16touid32 (uid));
|
|
|
|
}
|
2017-11-27 21:36:06 +08:00
|
|
|
#else
|
|
|
|
EXPORT_ALIAS (seteuid32, seteuid)
|
2013-04-23 17:44:36 +08:00
|
|
|
#endif
|
2002-05-29 23:04:29 +08:00
|
|
|
|
|
|
|
/* setuid: POSIX 4.2.2.1 */
|
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
setuid32 (uid_t uid)
|
2002-05-29 23:04:29 +08:00
|
|
|
{
|
|
|
|
int ret = seteuid32 (uid);
|
|
|
|
if (!ret)
|
2009-10-13 18:23:31 +08:00
|
|
|
{
|
|
|
|
cygheap->user.real_uid = myself->uid;
|
|
|
|
/* If restricted token, forget original privileges on exec (). */
|
|
|
|
cygheap->user.setuid_to_restricted = cygheap->user.curr_token_is_restricted;
|
|
|
|
}
|
2002-05-29 23:04:29 +08:00
|
|
|
debug_printf ("real: %d, effective: %d", cygheap->user.real_uid, myself->uid);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-11-27 21:36:06 +08:00
|
|
|
#ifdef __i386__
|
2002-05-29 23:04:29 +08:00
|
|
|
extern "C" int
|
|
|
|
setuid (__uid16_t uid)
|
|
|
|
{
|
|
|
|
return setuid32 (uid16touid32 (uid));
|
|
|
|
}
|
2017-11-27 21:36:06 +08:00
|
|
|
#else
|
|
|
|
EXPORT_ALIAS (setuid32, setuid)
|
2013-04-23 17:44:36 +08:00
|
|
|
#endif
|
2002-05-29 23:04:29 +08:00
|
|
|
|
2003-01-24 23:23:15 +08:00
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
setreuid32 (uid_t ruid, uid_t euid)
|
2003-01-24 23:23:15 +08:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
bool tried = false;
|
2013-04-23 17:44:36 +08:00
|
|
|
uid_t old_euid = myself->uid;
|
2003-01-24 23:23:15 +08:00
|
|
|
|
|
|
|
if (ruid != ILLEGAL_UID && cygheap->user.real_uid != ruid && euid != ruid)
|
|
|
|
tried = !(ret = seteuid32 (ruid));
|
|
|
|
if (!ret && euid != ILLEGAL_UID)
|
|
|
|
ret = seteuid32 (euid);
|
|
|
|
if (tried && (ret || euid == ILLEGAL_UID) && seteuid32 (old_euid))
|
|
|
|
system_printf ("Cannot restore original euid %u", old_euid);
|
|
|
|
if (!ret && ruid != ILLEGAL_UID)
|
|
|
|
cygheap->user.real_uid = ruid;
|
|
|
|
debug_printf ("real: %u, effective: %u", cygheap->user.real_uid, myself->uid);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-11-27 21:36:06 +08:00
|
|
|
#ifdef __i386__
|
2003-01-24 23:23:15 +08:00
|
|
|
extern "C" int
|
|
|
|
setreuid (__uid16_t ruid, __uid16_t euid)
|
|
|
|
{
|
|
|
|
return setreuid32 (uid16touid32 (ruid), uid16touid32 (euid));
|
|
|
|
}
|
2017-11-27 21:36:06 +08:00
|
|
|
#else
|
|
|
|
EXPORT_ALIAS (setreuid32, setreuid)
|
2013-04-23 17:44:36 +08:00
|
|
|
#endif
|
2003-01-24 23:23:15 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
/* setegid: from System V. */
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
setegid32 (gid_t gid)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2003-01-25 18:36:46 +08:00
|
|
|
debug_printf ("new egid: %u current: %u", gid, myself->gid);
|
2002-05-27 19:48:15 +08:00
|
|
|
|
2007-02-23 23:15:50 +08:00
|
|
|
if (gid == myself->gid)
|
2002-09-13 17:00:28 +08:00
|
|
|
{
|
2003-01-25 18:36:46 +08:00
|
|
|
myself->gid = gid;
|
|
|
|
return 0;
|
2002-09-13 17:00:28 +08:00
|
|
|
}
|
|
|
|
|
2011-04-29 15:34:05 +08:00
|
|
|
NTSTATUS status;
|
2002-07-29 20:51:52 +08:00
|
|
|
user_groups * groups = &cygheap->user.groups;
|
2002-05-27 19:48:15 +08:00
|
|
|
cygsid gsid;
|
2013-04-23 17:44:36 +08:00
|
|
|
struct group * gr = internal_getgrgid (gid);
|
2003-01-25 18:36:46 +08:00
|
|
|
|
|
|
|
if (!gsid.getfromgr (gr))
|
2000-06-17 03:36:07 +08:00
|
|
|
{
|
2002-05-27 19:48:15 +08:00
|
|
|
set_errno (EINVAL);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
myself->gid = gid;
|
2001-04-25 17:43:25 +08:00
|
|
|
|
2002-07-29 20:51:52 +08:00
|
|
|
groups->update_pgrp (gsid);
|
2002-06-17 07:34:43 +08:00
|
|
|
if (cygheap->user.issetuid ())
|
2002-05-27 19:48:15 +08:00
|
|
|
{
|
2005-04-03 21:06:43 +08:00
|
|
|
/* If impersonated, update impersonation token... */
|
2011-04-29 15:34:05 +08:00
|
|
|
status = NtSetInformationToken (cygheap->user.primary_token (),
|
|
|
|
TokenPrimaryGroup, &gsid, sizeof gsid);
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
debug_printf ("NtSetInformationToken (primary_token, "
|
2013-04-23 17:44:36 +08:00
|
|
|
"TokenPrimaryGroup), %y", status);
|
2011-04-29 15:34:05 +08:00
|
|
|
status = NtSetInformationToken (cygheap->user.imp_token (),
|
|
|
|
TokenPrimaryGroup, &gsid, sizeof gsid);
|
|
|
|
if (!NT_SUCCESS (status))
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("NtSetInformationToken (token, TokenPrimaryGroup), %y",
|
2011-04-29 15:34:05 +08:00
|
|
|
status);
|
2005-04-03 21:06:43 +08:00
|
|
|
}
|
|
|
|
cygheap->user.deimpersonate ();
|
2011-04-29 15:34:05 +08:00
|
|
|
status = NtSetInformationToken (hProcToken, TokenPrimaryGroup,
|
|
|
|
&gsid, sizeof gsid);
|
|
|
|
if (!NT_SUCCESS (status))
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("NtSetInformationToken (hProcToken, TokenPrimaryGroup), %y",
|
2011-04-29 15:34:05 +08:00
|
|
|
status);
|
2006-12-13 00:27:32 +08:00
|
|
|
clear_procimptoken ();
|
2005-04-03 21:06:43 +08:00
|
|
|
cygheap->user.reimpersonate ();
|
2000-06-17 03:36:07 +08:00
|
|
|
return 0;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2017-11-27 21:36:06 +08:00
|
|
|
#ifdef __i386__
|
Change internal gid datatype from __gid16_t to __gid32_t
throughout.
* cygwin.din: Export new symbols chown32, fchown32, getegid32,
getgid32, getgrgid32, getgrnam32, getgroups32, initgroups32, lchown32,
setgid32, setegid32, getgrent32.
* grp.cc (grp32togrp16): New static function.
(getgrgid32): New function.
(getgrnam32): Ditto.
(getgrent32): Ditto.
(getgroups32): Change name of internal function from getgroups.
(getgroups32): New function.
(initgroups32): Ditto.
* syscalls.cc (chown32): Ditto.
(lchown32): Ditto.
(fchown32): Ditto.
(setegid32): Ditto.
(setgid32): Ditto.
* uinfo.cc (getgid32): Ditto.
(getegid32): Ditto.
* include/cygwin/grp.h: Remove declaration of getgrgid() and getgrnam().
Declare getgrgid32() and getgrnam32() instead. Declare getgid32().
2002-05-28 22:10:55 +08:00
|
|
|
extern "C" int
|
|
|
|
setegid (__gid16_t gid)
|
|
|
|
{
|
2002-05-29 23:04:29 +08:00
|
|
|
return setegid32 (gid16togid32 (gid));
|
Change internal gid datatype from __gid16_t to __gid32_t
throughout.
* cygwin.din: Export new symbols chown32, fchown32, getegid32,
getgid32, getgrgid32, getgrnam32, getgroups32, initgroups32, lchown32,
setgid32, setegid32, getgrent32.
* grp.cc (grp32togrp16): New static function.
(getgrgid32): New function.
(getgrnam32): Ditto.
(getgrent32): Ditto.
(getgroups32): Change name of internal function from getgroups.
(getgroups32): New function.
(initgroups32): Ditto.
* syscalls.cc (chown32): Ditto.
(lchown32): Ditto.
(fchown32): Ditto.
(setegid32): Ditto.
(setgid32): Ditto.
* uinfo.cc (getgid32): Ditto.
(getegid32): Ditto.
* include/cygwin/grp.h: Remove declaration of getgrgid() and getgrnam().
Declare getgrgid32() and getgrnam32() instead. Declare getgid32().
2002-05-28 22:10:55 +08:00
|
|
|
}
|
2017-11-27 21:36:06 +08:00
|
|
|
#else
|
|
|
|
EXPORT_ALIAS (setegid32, setegid)
|
2013-04-23 17:44:36 +08:00
|
|
|
#endif
|
Change internal gid datatype from __gid16_t to __gid32_t
throughout.
* cygwin.din: Export new symbols chown32, fchown32, getegid32,
getgid32, getgrgid32, getgrnam32, getgroups32, initgroups32, lchown32,
setgid32, setegid32, getgrent32.
* grp.cc (grp32togrp16): New static function.
(getgrgid32): New function.
(getgrnam32): Ditto.
(getgrent32): Ditto.
(getgroups32): Change name of internal function from getgroups.
(getgroups32): New function.
(initgroups32): Ditto.
* syscalls.cc (chown32): Ditto.
(lchown32): Ditto.
(fchown32): Ditto.
(setegid32): Ditto.
(setgid32): Ditto.
* uinfo.cc (getgid32): Ditto.
(getegid32): Ditto.
* include/cygwin/grp.h: Remove declaration of getgrgid() and getgrnam().
Declare getgrgid32() and getgrnam32() instead. Declare getgid32().
2002-05-28 22:10:55 +08:00
|
|
|
|
|
|
|
/* setgid: POSIX 4.2.2.1 */
|
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
setgid32 (gid_t gid)
|
Change internal gid datatype from __gid16_t to __gid32_t
throughout.
* cygwin.din: Export new symbols chown32, fchown32, getegid32,
getgid32, getgrgid32, getgrnam32, getgroups32, initgroups32, lchown32,
setgid32, setegid32, getgrent32.
* grp.cc (grp32togrp16): New static function.
(getgrgid32): New function.
(getgrnam32): Ditto.
(getgrent32): Ditto.
(getgroups32): Change name of internal function from getgroups.
(getgroups32): New function.
(initgroups32): Ditto.
* syscalls.cc (chown32): Ditto.
(lchown32): Ditto.
(fchown32): Ditto.
(setegid32): Ditto.
(setgid32): Ditto.
* uinfo.cc (getgid32): Ditto.
(getegid32): Ditto.
* include/cygwin/grp.h: Remove declaration of getgrgid() and getgrnam().
Declare getgrgid32() and getgrnam32() instead. Declare getgid32().
2002-05-28 22:10:55 +08:00
|
|
|
{
|
|
|
|
int ret = setegid32 (gid);
|
|
|
|
if (!ret)
|
|
|
|
cygheap->user.real_gid = myself->gid;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-11-27 21:36:06 +08:00
|
|
|
#ifdef __i386__
|
Change internal gid datatype from __gid16_t to __gid32_t
throughout.
* cygwin.din: Export new symbols chown32, fchown32, getegid32,
getgid32, getgrgid32, getgrnam32, getgroups32, initgroups32, lchown32,
setgid32, setegid32, getgrent32.
* grp.cc (grp32togrp16): New static function.
(getgrgid32): New function.
(getgrnam32): Ditto.
(getgrent32): Ditto.
(getgroups32): Change name of internal function from getgroups.
(getgroups32): New function.
(initgroups32): Ditto.
* syscalls.cc (chown32): Ditto.
(lchown32): Ditto.
(fchown32): Ditto.
(setegid32): Ditto.
(setgid32): Ditto.
* uinfo.cc (getgid32): Ditto.
(getegid32): Ditto.
* include/cygwin/grp.h: Remove declaration of getgrgid() and getgrnam().
Declare getgrgid32() and getgrnam32() instead. Declare getgid32().
2002-05-28 22:10:55 +08:00
|
|
|
extern "C" int
|
|
|
|
setgid (__gid16_t gid)
|
|
|
|
{
|
2002-05-29 23:04:29 +08:00
|
|
|
int ret = setegid32 (gid16togid32 (gid));
|
Change internal gid datatype from __gid16_t to __gid32_t
throughout.
* cygwin.din: Export new symbols chown32, fchown32, getegid32,
getgid32, getgrgid32, getgrnam32, getgroups32, initgroups32, lchown32,
setgid32, setegid32, getgrent32.
* grp.cc (grp32togrp16): New static function.
(getgrgid32): New function.
(getgrnam32): Ditto.
(getgrent32): Ditto.
(getgroups32): Change name of internal function from getgroups.
(getgroups32): New function.
(initgroups32): Ditto.
* syscalls.cc (chown32): Ditto.
(lchown32): Ditto.
(fchown32): Ditto.
(setegid32): Ditto.
(setgid32): Ditto.
* uinfo.cc (getgid32): Ditto.
(getegid32): Ditto.
* include/cygwin/grp.h: Remove declaration of getgrgid() and getgrnam().
Declare getgrgid32() and getgrnam32() instead. Declare getgid32().
2002-05-28 22:10:55 +08:00
|
|
|
if (!ret)
|
|
|
|
cygheap->user.real_gid = myself->gid;
|
|
|
|
return ret;
|
|
|
|
}
|
2017-11-27 21:36:06 +08:00
|
|
|
#else
|
|
|
|
EXPORT_ALIAS (setgid32, setgid)
|
2013-04-23 17:44:36 +08:00
|
|
|
#endif
|
Change internal gid datatype from __gid16_t to __gid32_t
throughout.
* cygwin.din: Export new symbols chown32, fchown32, getegid32,
getgid32, getgrgid32, getgrnam32, getgroups32, initgroups32, lchown32,
setgid32, setegid32, getgrent32.
* grp.cc (grp32togrp16): New static function.
(getgrgid32): New function.
(getgrnam32): Ditto.
(getgrent32): Ditto.
(getgroups32): Change name of internal function from getgroups.
(getgroups32): New function.
(initgroups32): Ditto.
* syscalls.cc (chown32): Ditto.
(lchown32): Ditto.
(fchown32): Ditto.
(setegid32): Ditto.
(setgid32): Ditto.
* uinfo.cc (getgid32): Ditto.
(getegid32): Ditto.
* include/cygwin/grp.h: Remove declaration of getgrgid() and getgrnam().
Declare getgrgid32() and getgrnam32() instead. Declare getgid32().
2002-05-28 22:10:55 +08:00
|
|
|
|
2003-01-24 23:23:15 +08:00
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
setregid32 (gid_t rgid, gid_t egid)
|
2003-01-24 23:23:15 +08:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
bool tried = false;
|
2013-04-23 17:44:36 +08:00
|
|
|
gid_t old_egid = myself->gid;
|
2003-01-24 23:23:15 +08:00
|
|
|
|
|
|
|
if (rgid != ILLEGAL_GID && cygheap->user.real_gid != rgid && egid != rgid)
|
|
|
|
tried = !(ret = setegid32 (rgid));
|
|
|
|
if (!ret && egid != ILLEGAL_GID)
|
|
|
|
ret = setegid32 (egid);
|
|
|
|
if (tried && (ret || egid == ILLEGAL_GID) && setegid32 (old_egid))
|
|
|
|
system_printf ("Cannot restore original egid %u", old_egid);
|
|
|
|
if (!ret && rgid != ILLEGAL_GID)
|
|
|
|
cygheap->user.real_gid = rgid;
|
|
|
|
debug_printf ("real: %u, effective: %u", cygheap->user.real_gid, myself->gid);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-11-27 21:36:06 +08:00
|
|
|
#ifdef __i386__
|
2003-01-24 23:23:15 +08:00
|
|
|
extern "C" int
|
|
|
|
setregid (__gid16_t rgid, __gid16_t egid)
|
|
|
|
{
|
|
|
|
return setregid32 (gid16togid32 (rgid), gid16togid32 (egid));
|
|
|
|
}
|
2017-11-27 21:36:06 +08:00
|
|
|
#else
|
|
|
|
EXPORT_ALIAS (setregid32, setregid)
|
2013-04-23 17:44:36 +08:00
|
|
|
#endif
|
2003-01-24 23:23:15 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
/* chroot: privileged Unix system call. */
|
2000-07-20 04:14:24 +08:00
|
|
|
/* FIXME: Not privileged here. How should this be done? */
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2000-07-20 04:14:24 +08:00
|
|
|
chroot (const char *newroot)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2005-05-13 23:46:07 +08:00
|
|
|
path_conv path (newroot, PC_SYM_FOLLOW | PC_POSIX);
|
2000-07-27 01:48:49 +08:00
|
|
|
|
2004-05-08 10:55:38 +08:00
|
|
|
int ret = -1;
|
2000-07-20 04:14:24 +08:00
|
|
|
if (path.error)
|
2004-05-08 10:55:38 +08:00
|
|
|
set_errno (path.error);
|
2001-10-01 12:10:07 +08:00
|
|
|
else if (!path.exists ())
|
2004-05-08 10:55:38 +08:00
|
|
|
set_errno (ENOENT);
|
2001-10-01 12:10:07 +08:00
|
|
|
else if (!path.isdir ())
|
2004-05-08 10:55:38 +08:00
|
|
|
set_errno (ENOTDIR);
|
2006-03-03 02:08:09 +08:00
|
|
|
else if (path.isspecial ())
|
|
|
|
set_errno (EPERM);
|
2001-10-01 12:10:07 +08:00
|
|
|
else
|
|
|
|
{
|
2004-05-08 10:55:38 +08:00
|
|
|
getwinenv("PATH="); /* Save the native PATH */
|
2015-02-15 16:59:55 +08:00
|
|
|
cygheap->root.set (path.get_posix (), path.get_win32 (),
|
2008-07-17 04:20:45 +08:00
|
|
|
!!path.objcaseinsensitive ());
|
2001-10-01 12:10:07 +08:00
|
|
|
ret = 0;
|
2000-07-20 04:14:24 +08:00
|
|
|
}
|
|
|
|
|
2011-12-04 05:43:27 +08:00
|
|
|
syscall_printf ("%R = chroot(%s)", ret, newroot ?: "NULL");
|
2000-07-20 04:14:24 +08:00
|
|
|
return ret;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2000-02-18 03:38:33 +08:00
|
|
|
creat (const char *path, mode_t mode)
|
|
|
|
{
|
|
|
|
return open (path, O_WRONLY | O_CREAT | O_TRUNC, mode);
|
|
|
|
}
|
|
|
|
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" void
|
2000-02-18 03:38:33 +08:00
|
|
|
__assertfail ()
|
|
|
|
{
|
|
|
|
exit (99);
|
|
|
|
}
|
|
|
|
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2000-02-18 03:38:33 +08:00
|
|
|
vhangup ()
|
|
|
|
{
|
|
|
|
set_errno (ENOSYS);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" int
|
2005-01-26 06:45:11 +08:00
|
|
|
setpriority (int which, id_t who, int value)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2005-01-26 21:07:48 +08:00
|
|
|
DWORD prio = nice_to_winprio (value);
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
switch (which)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2005-01-26 21:07:48 +08:00
|
|
|
case PRIO_PROCESS:
|
|
|
|
if (!who)
|
|
|
|
who = myself->pid;
|
|
|
|
if ((pid_t) who == myself->pid)
|
|
|
|
{
|
2009-12-19 04:32:04 +08:00
|
|
|
if (!SetPriorityClass (GetCurrentProcess (), prio))
|
2005-01-26 21:07:48 +08:00
|
|
|
{
|
|
|
|
set_errno (EACCES);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
myself->nice = value;
|
|
|
|
debug_printf ("Set nice to %d", myself->nice);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PRIO_PGRP:
|
|
|
|
if (!who)
|
|
|
|
who = myself->pgid;
|
|
|
|
break;
|
|
|
|
case PRIO_USER:
|
|
|
|
if (!who)
|
|
|
|
who = myself->uid;
|
|
|
|
break;
|
|
|
|
default:
|
2005-01-26 06:45:11 +08:00
|
|
|
set_errno (EINVAL);
|
|
|
|
return -1;
|
|
|
|
}
|
2005-01-26 21:07:48 +08:00
|
|
|
winpids pids ((DWORD) PID_MAP_RW);
|
|
|
|
for (DWORD i = 0; i < pids.npids; ++i)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2005-01-26 21:07:48 +08:00
|
|
|
_pinfo *p = pids[i];
|
|
|
|
if (p)
|
|
|
|
{
|
|
|
|
switch (which)
|
|
|
|
{
|
|
|
|
case PRIO_PROCESS:
|
|
|
|
if ((pid_t) who != p->pid)
|
|
|
|
continue;
|
|
|
|
break;
|
|
|
|
case PRIO_PGRP:
|
|
|
|
if ((pid_t) who != p->pgid)
|
|
|
|
continue;
|
|
|
|
break;
|
|
|
|
case PRIO_USER:
|
2013-04-23 17:44:36 +08:00
|
|
|
if ((uid_t) who != p->uid)
|
2005-01-26 21:07:48 +08:00
|
|
|
continue;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
HANDLE proc_h = OpenProcess (PROCESS_SET_INFORMATION, FALSE,
|
|
|
|
p->dwProcessId);
|
|
|
|
if (!proc_h)
|
|
|
|
error = EPERM;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!SetPriorityClass (proc_h, prio))
|
|
|
|
error = EACCES;
|
|
|
|
else
|
|
|
|
p->nice = value;
|
|
|
|
CloseHandle (proc_h);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pids.reset ();
|
|
|
|
if (error)
|
|
|
|
{
|
|
|
|
set_errno (error);
|
2005-01-26 06:45:11 +08:00
|
|
|
return -1;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
2005-01-26 06:45:11 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2005-01-26 06:45:11 +08:00
|
|
|
extern "C" int
|
|
|
|
getpriority (int which, id_t who)
|
|
|
|
{
|
2005-01-26 21:07:48 +08:00
|
|
|
int nice = NZERO * 2; /* Illegal value */
|
|
|
|
|
|
|
|
switch (which)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2005-01-26 21:07:48 +08:00
|
|
|
case PRIO_PROCESS:
|
|
|
|
if (!who)
|
|
|
|
who = myself->pid;
|
|
|
|
if ((pid_t) who == myself->pid)
|
2019-10-30 23:47:25 +08:00
|
|
|
{
|
|
|
|
DWORD winprio = GetPriorityClass(GetCurrentProcess());
|
|
|
|
if (winprio != nice_to_winprio(myself->nice))
|
|
|
|
myself->nice = winprio_to_nice(winprio);
|
|
|
|
return myself->nice;
|
|
|
|
}
|
2005-01-26 21:07:48 +08:00
|
|
|
break;
|
|
|
|
case PRIO_PGRP:
|
|
|
|
if (!who)
|
|
|
|
who = myself->pgid;
|
|
|
|
break;
|
|
|
|
case PRIO_USER:
|
|
|
|
if (!who)
|
|
|
|
who = myself->uid;
|
|
|
|
break;
|
|
|
|
default:
|
2005-01-26 06:45:11 +08:00
|
|
|
set_errno (EINVAL);
|
2000-02-18 03:38:33 +08:00
|
|
|
return -1;
|
|
|
|
}
|
2005-01-26 21:07:48 +08:00
|
|
|
winpids pids ((DWORD) 0);
|
|
|
|
for (DWORD i = 0; i < pids.npids; ++i)
|
|
|
|
{
|
|
|
|
_pinfo *p = pids[i];
|
|
|
|
if (p)
|
2005-05-02 11:50:11 +08:00
|
|
|
switch (which)
|
2005-01-26 21:07:48 +08:00
|
|
|
{
|
|
|
|
case PRIO_PROCESS:
|
|
|
|
if ((pid_t) who == p->pid)
|
|
|
|
{
|
|
|
|
nice = p->nice;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PRIO_PGRP:
|
|
|
|
if ((pid_t) who == p->pgid && p->nice < nice)
|
|
|
|
nice = p->nice;
|
|
|
|
break;
|
|
|
|
case PRIO_USER:
|
2013-04-23 17:44:36 +08:00
|
|
|
if ((uid_t) who == p->uid && p->nice < nice)
|
2005-01-26 21:07:48 +08:00
|
|
|
nice = p->nice;
|
2016-03-20 18:58:35 +08:00
|
|
|
break;
|
2005-01-26 21:07:48 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
pids.reset ();
|
|
|
|
if (nice == NZERO * 2)
|
|
|
|
{
|
|
|
|
set_errno (ESRCH);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return nice;
|
2005-01-26 06:45:11 +08:00
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2005-01-26 06:45:11 +08:00
|
|
|
extern "C" int
|
|
|
|
nice (int incr)
|
|
|
|
{
|
|
|
|
return setpriority (PRIO_PROCESS, myself->pid, myself->nice + incr);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2003-12-07 20:56:59 +08:00
|
|
|
static void
|
|
|
|
locked_append (int fd, const void * buf, size_t size)
|
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
struct flock lock_buffer = {F_WRLCK, SEEK_SET, 0, 0, 0};
|
2003-12-07 20:56:59 +08:00
|
|
|
int count = 0;
|
|
|
|
|
|
|
|
do
|
2013-04-23 17:44:36 +08:00
|
|
|
if ((lock_buffer.l_start = lseek64 (fd, 0, SEEK_END)) != (off_t) -1
|
2008-04-01 18:22:33 +08:00
|
|
|
&& fcntl64 (fd, F_SETLKW, &lock_buffer) != -1)
|
2003-12-07 20:56:59 +08:00
|
|
|
{
|
2013-04-23 17:44:36 +08:00
|
|
|
if (lseek64 (fd, 0, SEEK_END) != (off_t) -1)
|
2003-12-07 20:56:59 +08:00
|
|
|
write (fd, buf, size);
|
|
|
|
lock_buffer.l_type = F_UNLCK;
|
2008-04-01 18:22:33 +08:00
|
|
|
fcntl64 (fd, F_SETLK, &lock_buffer);
|
2003-12-07 20:56:59 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
while (count++ < 1000
|
|
|
|
&& (errno == EACCES || errno == EAGAIN)
|
|
|
|
&& !usleep (1000));
|
|
|
|
}
|
|
|
|
|
2000-09-30 09:56:40 +08:00
|
|
|
extern "C" void
|
2003-09-10 23:51:59 +08:00
|
|
|
updwtmp (const char *wtmp_file, const struct utmp *ut)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2003-09-10 23:51:59 +08:00
|
|
|
int fd;
|
|
|
|
|
2003-12-07 20:56:59 +08:00
|
|
|
if ((fd = open (wtmp_file, O_WRONLY | O_BINARY, 0)) >= 0)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2003-12-07 20:56:59 +08:00
|
|
|
locked_append (fd, ut, sizeof *ut);
|
2003-03-29 20:44:01 +08:00
|
|
|
close (fd);
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2003-03-29 20:44:01 +08:00
|
|
|
static int utmp_fd = -1;
|
|
|
|
static bool utmp_readonly = false;
|
2001-12-28 23:53:27 +08:00
|
|
|
static char *utmp_file = (char *) _PATH_UTMP;
|
|
|
|
|
2003-03-29 20:44:01 +08:00
|
|
|
static void
|
|
|
|
internal_setutent (bool force_readwrite)
|
2001-12-28 23:53:27 +08:00
|
|
|
{
|
2003-03-29 20:44:01 +08:00
|
|
|
if (force_readwrite && utmp_readonly)
|
|
|
|
endutent ();
|
|
|
|
if (utmp_fd < 0)
|
|
|
|
{
|
|
|
|
utmp_fd = open (utmp_file, O_RDWR | O_BINARY);
|
|
|
|
/* If open fails, we assume an unprivileged process (who?). In this
|
|
|
|
case we try again for reading only unless the process calls
|
|
|
|
pututline() (==force_readwrite) in which case opening just fails. */
|
|
|
|
if (utmp_fd < 0 && !force_readwrite)
|
2003-07-26 12:53:59 +08:00
|
|
|
{
|
2003-03-29 20:44:01 +08:00
|
|
|
utmp_fd = open (utmp_file, O_RDONLY | O_BINARY);
|
|
|
|
if (utmp_fd >= 0)
|
|
|
|
utmp_readonly = true;
|
2003-07-26 12:53:59 +08:00
|
|
|
}
|
2003-03-29 20:44:01 +08:00
|
|
|
}
|
2003-03-08 11:36:39 +08:00
|
|
|
else
|
|
|
|
lseek (utmp_fd, 0, SEEK_SET);
|
2001-12-28 23:53:27 +08:00
|
|
|
}
|
|
|
|
|
2003-03-29 20:44:01 +08:00
|
|
|
extern "C" void
|
|
|
|
setutent ()
|
|
|
|
{
|
|
|
|
internal_setutent (false);
|
|
|
|
}
|
|
|
|
|
2001-12-28 23:53:27 +08:00
|
|
|
extern "C" void
|
|
|
|
endutent ()
|
|
|
|
{
|
2003-03-29 20:44:01 +08:00
|
|
|
if (utmp_fd >= 0)
|
2002-11-07 10:19:52 +08:00
|
|
|
{
|
|
|
|
close (utmp_fd);
|
2003-03-29 20:44:01 +08:00
|
|
|
utmp_fd = -1;
|
|
|
|
utmp_readonly = false;
|
2002-11-07 10:19:52 +08:00
|
|
|
}
|
2001-12-28 23:53:27 +08:00
|
|
|
}
|
|
|
|
|
2016-01-07 22:40:40 +08:00
|
|
|
extern "C" int
|
2005-01-26 06:45:11 +08:00
|
|
|
utmpname (const char *file)
|
2001-12-28 23:53:27 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2001-12-28 23:53:27 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
if (*file)
|
|
|
|
{
|
|
|
|
endutent ();
|
|
|
|
utmp_file = strdup (file);
|
2016-01-07 22:40:40 +08:00
|
|
|
if (utmp_file)
|
|
|
|
{
|
|
|
|
debug_printf ("New UTMP file: %s", utmp_file);
|
|
|
|
return 0;
|
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
}
|
2001-12-28 23:53:27 +08:00
|
|
|
}
|
2016-01-07 22:40:40 +08:00
|
|
|
__except (EFAULT) {}
|
2014-08-22 17:21:33 +08:00
|
|
|
__endtry
|
2016-01-07 22:40:40 +08:00
|
|
|
debug_printf ("Setting UTMP file failed");
|
|
|
|
return -1;
|
2001-12-28 23:53:27 +08:00
|
|
|
}
|
2011-02-22 17:17:57 +08:00
|
|
|
|
2005-03-04 06:08:12 +08:00
|
|
|
EXPORT_ALIAS (utmpname, utmpxname)
|
2001-12-28 23:53:27 +08:00
|
|
|
|
2003-08-05 12:49:44 +08:00
|
|
|
/* Note: do not make NO_COPY */
|
|
|
|
static struct utmp utmp_data_buf[16];
|
|
|
|
static unsigned utix = 0;
|
|
|
|
#define nutdbuf (sizeof (utmp_data_buf) / sizeof (utmp_data_buf[0]))
|
|
|
|
#define utmp_data ({ \
|
2011-01-31 21:58:59 +08:00
|
|
|
if (utix >= nutdbuf) \
|
2003-08-05 12:49:44 +08:00
|
|
|
utix = 0; \
|
|
|
|
utmp_data_buf + utix++; \
|
|
|
|
})
|
|
|
|
|
2004-12-16 01:29:01 +08:00
|
|
|
static struct utmpx *
|
|
|
|
copy_ut_to_utx (struct utmp *ut, struct utmpx *utx)
|
|
|
|
{
|
|
|
|
if (!ut)
|
|
|
|
return NULL;
|
|
|
|
memcpy (utx, ut, sizeof *ut);
|
|
|
|
utx->ut_tv.tv_sec = ut->ut_time;
|
|
|
|
utx->ut_tv.tv_usec = 0;
|
|
|
|
return utx;
|
|
|
|
}
|
|
|
|
|
2001-12-28 23:53:27 +08:00
|
|
|
extern "C" struct utmp *
|
|
|
|
getutent ()
|
|
|
|
{
|
2003-03-29 20:44:01 +08:00
|
|
|
if (utmp_fd < 0)
|
|
|
|
{
|
|
|
|
internal_setutent (false);
|
|
|
|
if (utmp_fd < 0)
|
2003-07-26 12:53:59 +08:00
|
|
|
return NULL;
|
2003-03-29 20:44:01 +08:00
|
|
|
}
|
2003-08-05 12:49:44 +08:00
|
|
|
|
|
|
|
utmp *ut = utmp_data;
|
|
|
|
if (read (utmp_fd, ut, sizeof *ut) != sizeof *ut)
|
2001-12-28 23:53:27 +08:00
|
|
|
return NULL;
|
2003-08-05 12:49:44 +08:00
|
|
|
return ut;
|
2001-12-28 23:53:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" struct utmp *
|
2008-07-30 12:58:24 +08:00
|
|
|
getutid (const struct utmp *id)
|
2001-12-28 23:53:27 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2003-03-29 20:44:01 +08:00
|
|
|
{
|
|
|
|
if (utmp_fd < 0)
|
2001-12-28 23:53:27 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
internal_setutent (false);
|
|
|
|
if (utmp_fd < 0)
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
utmp *ut = utmp_data;
|
|
|
|
while (read (utmp_fd, ut, sizeof *ut) == sizeof *ut)
|
|
|
|
{
|
|
|
|
switch (id->ut_type)
|
|
|
|
{
|
|
|
|
case RUN_LVL:
|
|
|
|
case BOOT_TIME:
|
|
|
|
case OLD_TIME:
|
|
|
|
case NEW_TIME:
|
|
|
|
if (id->ut_type == ut->ut_type)
|
|
|
|
return ut;
|
|
|
|
break;
|
|
|
|
case INIT_PROCESS:
|
|
|
|
case LOGIN_PROCESS:
|
|
|
|
case USER_PROCESS:
|
|
|
|
case DEAD_PROCESS:
|
|
|
|
if (strncmp (id->ut_id, ut->ut_id, UT_IDLEN) == 0)
|
|
|
|
return ut;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2001-12-28 23:53:27 +08:00
|
|
|
}
|
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
2001-12-28 23:53:27 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" struct utmp *
|
2008-07-30 12:58:24 +08:00
|
|
|
getutline (const struct utmp *line)
|
2001-12-28 23:53:27 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2003-03-29 20:44:01 +08:00
|
|
|
{
|
|
|
|
if (utmp_fd < 0)
|
2014-08-22 17:21:33 +08:00
|
|
|
{
|
|
|
|
internal_setutent (false);
|
|
|
|
if (utmp_fd < 0)
|
|
|
|
__leave;
|
|
|
|
}
|
2003-08-05 12:49:44 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
utmp *ut = utmp_data;
|
|
|
|
while (read (utmp_fd, ut, sizeof *ut) == sizeof *ut)
|
|
|
|
if ((ut->ut_type == LOGIN_PROCESS ||
|
|
|
|
ut->ut_type == USER_PROCESS) &&
|
|
|
|
!strncmp (ut->ut_line, line->ut_line, sizeof (ut->ut_line)))
|
|
|
|
return ut;
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
2001-12-28 23:53:27 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
2002-11-07 10:19:52 +08:00
|
|
|
|
2004-12-16 01:29:01 +08:00
|
|
|
extern "C" struct utmp *
|
2008-07-30 12:58:24 +08:00
|
|
|
pututline (const struct utmp *ut)
|
2002-11-07 10:19:52 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2003-08-05 12:49:44 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
internal_setutent (true);
|
|
|
|
if (utmp_fd < 0)
|
|
|
|
{
|
|
|
|
debug_printf ("error: utmp_fd %d", utmp_fd);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
debug_printf ("ut->ut_type %d, ut->ut_pid %d, ut->ut_line '%s', ut->ut_id '%s'\n",
|
|
|
|
ut->ut_type, ut->ut_pid, ut->ut_line, ut->ut_id);
|
|
|
|
debug_printf ("ut->ut_user '%s', ut->ut_host '%s'\n",
|
|
|
|
ut->ut_user, ut->ut_host);
|
2003-12-07 20:56:59 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
struct utmp *u;
|
|
|
|
if ((u = getutid (ut)))
|
|
|
|
{
|
|
|
|
lseek (utmp_fd, -sizeof *ut, SEEK_CUR);
|
|
|
|
write (utmp_fd, ut, sizeof *ut);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
locked_append (utmp_fd, ut, sizeof *ut);
|
|
|
|
/* The documentation says to return a pointer to this which implies that
|
|
|
|
this has to be cast from a const. That doesn't seem right but the
|
|
|
|
documentation seems pretty clear on this. */
|
|
|
|
return (struct utmp *) ut;
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return NULL;
|
2004-12-16 01:29:01 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" void
|
|
|
|
setutxent ()
|
|
|
|
{
|
|
|
|
internal_setutent (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" void
|
|
|
|
endutxent ()
|
|
|
|
{
|
|
|
|
endutent ();
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" struct utmpx *
|
|
|
|
getutxent ()
|
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
/* POSIX: Not required to be thread safe. */
|
2004-12-16 01:29:01 +08:00
|
|
|
static struct utmpx utx;
|
|
|
|
return copy_ut_to_utx (getutent (), &utx);
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" struct utmpx *
|
|
|
|
getutxid (const struct utmpx *id)
|
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
/* POSIX: Not required to be thread safe. */
|
2004-12-16 01:29:01 +08:00
|
|
|
static struct utmpx utx;
|
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
|
|
|
{
|
|
|
|
((struct utmpx *)id)->ut_time = id->ut_tv.tv_sec;
|
|
|
|
return copy_ut_to_utx (getutid ((struct utmp *) id), &utx);
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return NULL;
|
2004-12-16 01:29:01 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" struct utmpx *
|
|
|
|
getutxline (const struct utmpx *line)
|
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
/* POSIX: Not required to be thread safe. */
|
2004-12-16 01:29:01 +08:00
|
|
|
static struct utmpx utx;
|
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
|
|
|
{
|
|
|
|
((struct utmpx *)line)->ut_time = line->ut_tv.tv_sec;
|
|
|
|
return copy_ut_to_utx (getutline ((struct utmp *) line), &utx);
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return NULL;
|
2004-12-16 01:29:01 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" struct utmpx *
|
|
|
|
pututxline (const struct utmpx *utmpx)
|
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
/* POSIX: Not required to be thread safe. */
|
2004-12-16 01:29:01 +08:00
|
|
|
static struct utmpx utx;
|
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
|
|
|
{
|
|
|
|
((struct utmpx *)utmpx)->ut_time = utmpx->ut_tv.tv_sec;
|
|
|
|
return copy_ut_to_utx (pututline ((struct utmp *) utmpx), &utx);
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return NULL;
|
2002-11-07 10:19:52 +08:00
|
|
|
}
|
2003-04-16 11:03:45 +08:00
|
|
|
|
2006-02-03 06:46:37 +08:00
|
|
|
extern "C" void
|
|
|
|
updwtmpx (const char *wtmpx_file, const struct utmpx *utmpx)
|
|
|
|
{
|
|
|
|
((struct utmpx *)utmpx)->ut_time = utmpx->ut_tv.tv_sec;
|
|
|
|
updwtmp (wtmpx_file, (const struct utmp *) utmpx);
|
|
|
|
}
|
|
|
|
|
2011-04-19 18:02:06 +08:00
|
|
|
extern "C" long
|
|
|
|
gethostid (void)
|
2003-04-16 11:03:45 +08:00
|
|
|
{
|
2012-01-23 20:59:44 +08:00
|
|
|
/* Fetch the globally unique MachineGuid value from
|
|
|
|
HKLM/Software/Microsoft/Cryptography and hash it. */
|
|
|
|
|
|
|
|
/* Caution: sizeof long might become > 4 when we go 64 bit, but gethostid
|
|
|
|
is supposed to return a 32 bit value, despite the return type long.
|
|
|
|
That's why hostid is *not* long here. */
|
|
|
|
int32_t hostid = 0x40291372; /* Choose a nice start value */
|
|
|
|
WCHAR wguid[38];
|
|
|
|
|
|
|
|
reg_key key (HKEY_LOCAL_MACHINE,
|
|
|
|
KEY_READ | (wincap.is_wow64() ? KEY_WOW64_64KEY : 0),
|
|
|
|
L"SOFTWARE", L"Microsoft", L"Cryptography", NULL);
|
|
|
|
key.get_string (L"MachineGuid", wguid, 38,
|
|
|
|
L"00000000-0000-0000-0000-000000000000");
|
|
|
|
/* SDBM hash */
|
|
|
|
for (PWCHAR wp = wguid; *wp; ++wp)
|
|
|
|
hostid = *wp + (hostid << 6) + (hostid << 16) - hostid;
|
2013-04-23 17:44:36 +08:00
|
|
|
debug_printf ("hostid %08y from MachineGuid %W", hostid, wguid);
|
2012-01-23 20:59:44 +08:00
|
|
|
return (int32_t) hostid; /* Avoid sign extension. */
|
2003-04-16 11:03:45 +08:00
|
|
|
}
|
2003-09-09 04:08:53 +08:00
|
|
|
|
|
|
|
#define ETC_SHELLS "/etc/shells"
|
|
|
|
static int shell_index;
|
* Makefile.in (DLL_OFILES): Add getopt.o and iruserok.o.
* cygwin.din: Export __check_rhosts_file, __rcmd_errstr, optarg,
opterr, optind, optopt, optreset, getopt, getopt_long, iruserok
and ruserok.
* getopt.c: Moved from lib to here. Define opt* variables as
dllexport.
* iruserok.c: Moved from lib to here. Rearrange function order.
Prefer using 64/32 bit functions.
* syscalls.cc (shell_fp): Define as struct __sFILE64.
(getusershell): Use fopen64 instead of fopen.
* winsup.h: Add declarations for seteuid32, fopen64,
cygwin_gethostbyname and cygwin_inet_addr.
* include/getopt.h: Declare opt* variables dllimport.
* include/cygwin/version.h: Bump API minor number.
2003-09-11 03:13:05 +08:00
|
|
|
static struct __sFILE64 *shell_fp;
|
2003-09-09 04:08:53 +08:00
|
|
|
|
|
|
|
extern "C" char *
|
|
|
|
getusershell ()
|
|
|
|
{
|
|
|
|
/* List of default shells if no /etc/shells exists, defined as on Linux.
|
|
|
|
FIXME: SunOS has a far longer list, containing all shells which
|
|
|
|
might be shipped with the OS. Should we do the same for the Cygwin
|
|
|
|
distro, adding bash, tcsh, ksh, pdksh and zsh? */
|
2013-04-23 17:44:36 +08:00
|
|
|
static const char *def_shells[] = {
|
2003-09-09 04:08:53 +08:00
|
|
|
"/bin/sh",
|
|
|
|
"/bin/csh",
|
|
|
|
"/usr/bin/sh",
|
|
|
|
"/usr/bin/csh",
|
|
|
|
NULL
|
|
|
|
};
|
2008-03-07 19:24:51 +08:00
|
|
|
static char buf[PATH_MAX];
|
2003-09-09 04:08:53 +08:00
|
|
|
int ch, buf_idx;
|
|
|
|
|
* Makefile.in (DLL_OFILES): Add getopt.o and iruserok.o.
* cygwin.din: Export __check_rhosts_file, __rcmd_errstr, optarg,
opterr, optind, optopt, optreset, getopt, getopt_long, iruserok
and ruserok.
* getopt.c: Moved from lib to here. Define opt* variables as
dllexport.
* iruserok.c: Moved from lib to here. Rearrange function order.
Prefer using 64/32 bit functions.
* syscalls.cc (shell_fp): Define as struct __sFILE64.
(getusershell): Use fopen64 instead of fopen.
* winsup.h: Add declarations for seteuid32, fopen64,
cygwin_gethostbyname and cygwin_inet_addr.
* include/getopt.h: Declare opt* variables dllimport.
* include/cygwin/version.h: Bump API minor number.
2003-09-11 03:13:05 +08:00
|
|
|
if (!shell_fp && !(shell_fp = fopen64 (ETC_SHELLS, "rt")))
|
2003-09-09 04:08:53 +08:00
|
|
|
{
|
|
|
|
if (def_shells[shell_index])
|
2003-11-29 04:55:59 +08:00
|
|
|
return strcpy (buf, def_shells[shell_index++]);
|
2003-09-09 04:08:53 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
/* Skip white space characters. */
|
|
|
|
while ((ch = getc (shell_fp)) != EOF && isspace (ch))
|
|
|
|
;
|
|
|
|
/* Get each non-whitespace character as part of the shell path as long as
|
|
|
|
it fits in buf. */
|
|
|
|
for (buf_idx = 0;
|
2014-05-19 16:29:47 +08:00
|
|
|
ch != EOF && !isspace (ch) && buf_idx < (PATH_MAX - 1);
|
2003-09-09 04:08:53 +08:00
|
|
|
buf_idx++, ch = getc (shell_fp))
|
|
|
|
buf[buf_idx] = ch;
|
|
|
|
/* Skip any trailing non-whitespace character not fitting in buf. If the
|
2008-03-07 19:24:51 +08:00
|
|
|
path is longer than PATH_MAX, it's invalid anyway. */
|
2003-09-09 04:08:53 +08:00
|
|
|
while (ch != EOF && !isspace (ch))
|
|
|
|
ch = getc (shell_fp);
|
|
|
|
if (buf_idx)
|
|
|
|
{
|
|
|
|
buf[buf_idx] = '\0';
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" void
|
|
|
|
setusershell ()
|
|
|
|
{
|
|
|
|
if (shell_fp)
|
|
|
|
fseek (shell_fp, 0L, SEEK_SET);
|
|
|
|
shell_index = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" void
|
|
|
|
endusershell ()
|
|
|
|
{
|
|
|
|
if (shell_fp)
|
2005-08-24 23:50:11 +08:00
|
|
|
{
|
|
|
|
fclose (shell_fp);
|
|
|
|
shell_fp = NULL;
|
|
|
|
}
|
2003-09-09 04:08:53 +08:00
|
|
|
shell_index = 0;
|
|
|
|
}
|
2004-05-18 00:06:02 +08:00
|
|
|
|
|
|
|
extern "C" void
|
|
|
|
flockfile (FILE *file)
|
|
|
|
{
|
|
|
|
_flockfile (file);
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
ftrylockfile (FILE *file)
|
|
|
|
{
|
|
|
|
return _ftrylockfile (file);
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" void
|
|
|
|
funlockfile (FILE *file)
|
|
|
|
{
|
|
|
|
_funlockfile (file);
|
|
|
|
}
|
2006-12-12 02:55:29 +08:00
|
|
|
|
|
|
|
extern "C" FILE *
|
2006-12-12 23:58:08 +08:00
|
|
|
popen (const char *command, const char *in_type)
|
2006-12-12 02:55:29 +08:00
|
|
|
{
|
2006-12-12 23:58:08 +08:00
|
|
|
const char *type = in_type;
|
2014-01-17 19:07:37 +08:00
|
|
|
char fdopen_flags[3] = "\0\0";
|
|
|
|
int pipe_flags = 0;
|
2006-12-12 02:55:29 +08:00
|
|
|
|
2014-01-17 19:07:37 +08:00
|
|
|
#define rw fdopen_flags[0]
|
|
|
|
#define bintext fdopen_flags[1]
|
|
|
|
|
|
|
|
/* Sanity check. GLibc allows any order and any number of repetition,
|
|
|
|
as long as the string doesn't contradict itself. We do the same here. */
|
|
|
|
while (*type)
|
|
|
|
{
|
|
|
|
if (*type == 'r' || *type == 'w')
|
|
|
|
{
|
|
|
|
if (rw && rw != *type)
|
|
|
|
break;
|
|
|
|
rw = *type++;
|
|
|
|
}
|
|
|
|
else if (*type == 'b' || *type == 't')
|
|
|
|
{
|
|
|
|
if (bintext && bintext != *type)
|
|
|
|
break;
|
|
|
|
bintext = *type++;
|
|
|
|
}
|
|
|
|
else if (*type == 'e')
|
|
|
|
{
|
|
|
|
pipe_flags = O_CLOEXEC;
|
|
|
|
++type;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
2006-12-12 23:58:08 +08:00
|
|
|
if ((rw != 'r' && rw != 'w') || (*type != '\0'))
|
2006-12-12 02:55:29 +08:00
|
|
|
{
|
|
|
|
set_errno (EINVAL);
|
|
|
|
return NULL;
|
|
|
|
}
|
2006-12-12 23:58:08 +08:00
|
|
|
|
|
|
|
int fds[2];
|
2014-01-17 19:07:37 +08:00
|
|
|
if (pipe2 (fds, pipe_flags) < 0)
|
2006-12-12 23:58:08 +08:00
|
|
|
return NULL;
|
|
|
|
|
2009-08-18 09:40:46 +08:00
|
|
|
int myix = rw == 'r' ? 0 : 1;
|
|
|
|
|
|
|
|
lock_process now;
|
2014-01-17 19:07:37 +08:00
|
|
|
FILE *fp = fdopen (fds[myix], fdopen_flags);
|
2009-08-18 09:40:46 +08:00
|
|
|
if (fp)
|
|
|
|
{
|
|
|
|
/* If fds are in the range of stdin/stdout/stderr, move them
|
|
|
|
out of the way (possibly temporarily). Otherwise, spawn_guts
|
|
|
|
will be confused. We do this here rather than adding logic to
|
|
|
|
spawn_guts because spawn_guts is likely to be a more frequently
|
|
|
|
used routine and having stdin/stdout/stderr closed and reassigned
|
|
|
|
to pipe handles is an unlikely event. */
|
2009-08-18 09:51:35 +08:00
|
|
|
int orig_fds[2] = {fds[0], fds[1]};
|
2009-08-18 09:40:46 +08:00
|
|
|
for (int i = 0; i < 2; i++)
|
|
|
|
if (fds[i] <= 2)
|
|
|
|
{
|
|
|
|
cygheap_fdnew newfd(3);
|
|
|
|
cygheap->fdtab.move_fd (fds[i], newfd);
|
|
|
|
fds[i] = newfd;
|
|
|
|
}
|
2006-12-12 02:55:29 +08:00
|
|
|
|
2009-08-18 09:40:46 +08:00
|
|
|
int myfd = fds[myix]; /* myfd - convenience variable for manipulation
|
|
|
|
of the "parent" end of the pipe. */
|
|
|
|
int stdchild = myix ^ 1; /* stdchild denotes the index into fd for the
|
|
|
|
handle which will be redirected to
|
|
|
|
stdin/stdout */
|
2009-08-18 09:51:35 +08:00
|
|
|
int __std[2];
|
|
|
|
__std[myix] = -1; /* -1 means don't pass this fd to the child
|
|
|
|
process */
|
|
|
|
__std[stdchild] = fds[stdchild]; /* Do pass this as the std handle */
|
2006-12-12 02:55:29 +08:00
|
|
|
|
2009-08-18 09:40:46 +08:00
|
|
|
const char *argv[4] =
|
|
|
|
{
|
|
|
|
"/bin/sh",
|
|
|
|
"-c",
|
|
|
|
command,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2014-01-17 19:07:37 +08:00
|
|
|
/* With 'e' flag given, we have to revert the close-on-exec on the child
|
|
|
|
end of the pipe. Otherwise don't pass our end of the pipe to the
|
|
|
|
child process. */
|
|
|
|
if (pipe_flags & O_CLOEXEC)
|
|
|
|
fcntl64 (__std[stdchild], F_SETFD, 0);
|
|
|
|
else
|
|
|
|
fcntl64 (myfd, F_SETFD, FD_CLOEXEC);
|
2009-08-18 09:40:46 +08:00
|
|
|
|
|
|
|
/* Also don't pass the file handle currently associated with stdin/stdout
|
|
|
|
to the child. This function may actually fail if the stdchild fd
|
|
|
|
is closed. But that's ok. */
|
|
|
|
int stdchild_state = fcntl64 (stdchild, F_GETFD, 0);
|
|
|
|
fcntl64 (stdchild, F_SETFD, stdchild_state | FD_CLOEXEC);
|
|
|
|
|
|
|
|
/* Start a shell process to run the given command without forking. */
|
2011-11-14 09:29:49 +08:00
|
|
|
pid_t pid = ch_spawn.worker ("/bin/sh", argv, cur_environ (), _P_NOWAIT,
|
|
|
|
__std[0], __std[1]);
|
2009-08-18 09:40:46 +08:00
|
|
|
|
|
|
|
/* Reinstate the close-on-exec state */
|
|
|
|
fcntl64 (stdchild, F_SETFD, stdchild_state);
|
|
|
|
|
|
|
|
/* If pid >= 0 then spawn_guts succeeded. */
|
|
|
|
if (pid >= 0)
|
|
|
|
{
|
|
|
|
close (fds[stdchild]); /* Close the child end of the pipe. */
|
|
|
|
/* Move the fd back to its original slot if it has been moved since
|
|
|
|
we're always supposed to open the lowest numbered available fd
|
|
|
|
and, if fds[mix] != orig_fds[myix] then orig_fds[myix] is
|
|
|
|
presumably lower. */
|
|
|
|
if (fds[myix] != orig_fds[myix])
|
|
|
|
cygheap->fdtab.move_fd (fds[myix], myfd = orig_fds[myix]);
|
|
|
|
fhandler_pipe *fh = (fhandler_pipe *) cygheap->fdtab[myfd];
|
2014-01-17 19:07:37 +08:00
|
|
|
/* Flag that this handle is associated with popen. */
|
2009-08-18 09:40:46 +08:00
|
|
|
fh->set_popen_pid (pid);
|
|
|
|
return fp;
|
|
|
|
}
|
2008-09-11 12:34:24 +08:00
|
|
|
}
|
2006-12-12 02:55:29 +08:00
|
|
|
|
2009-08-18 09:40:46 +08:00
|
|
|
/* If we reach here we've seen an error but the pipe handles are open.
|
|
|
|
Close them and return NULL. */
|
2006-12-12 02:55:29 +08:00
|
|
|
int save_errno = get_errno ();
|
2014-06-24 03:05:15 +08:00
|
|
|
if (fp)
|
|
|
|
{
|
|
|
|
/* Must fclose fp to avoid memory leak. */
|
|
|
|
fclose (fp);
|
|
|
|
close (fds[myix ^ 1]);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
close (fds[0]);
|
|
|
|
close (fds[1]);
|
|
|
|
}
|
2006-12-12 02:55:29 +08:00
|
|
|
set_errno (save_errno);
|
2014-01-17 19:07:37 +08:00
|
|
|
|
|
|
|
#undef rw
|
|
|
|
#undef bintext
|
|
|
|
|
2006-12-12 02:55:29 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
pclose (FILE *fp)
|
|
|
|
{
|
|
|
|
fhandler_pipe *fh = (fhandler_pipe *) cygheap->fdtab[fileno(fp)];
|
|
|
|
|
|
|
|
if (fh->get_device () != FH_PIPEW && fh->get_device () != FH_PIPER)
|
|
|
|
{
|
|
|
|
set_errno (EBADF);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int pid = fh->get_popen_pid ();
|
|
|
|
if (!pid)
|
|
|
|
{
|
|
|
|
set_errno (ECHILD);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fclose (fp))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
int status;
|
|
|
|
while (1)
|
|
|
|
if (waitpid (pid, &status, 0) == pid)
|
|
|
|
break;
|
|
|
|
else if (get_errno () == EINTR)
|
|
|
|
continue;
|
|
|
|
else
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
2008-04-23 19:13:52 +08:00
|
|
|
|
|
|
|
/* Preliminary(?) implementation of the openat family of functions. */
|
|
|
|
|
|
|
|
static int
|
2008-05-22 19:18:46 +08:00
|
|
|
gen_full_path_at (char *path_ret, int dirfd, const char *pathname,
|
|
|
|
bool null_pathname_allowed = false)
|
2008-04-23 19:13:52 +08:00
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
/* Set null_pathname_allowed to true to allow GLIBC compatible behaviour
|
|
|
|
for NULL pathname. Only used by futimesat. */
|
|
|
|
if (!pathname && !null_pathname_allowed)
|
2008-04-23 19:13:52 +08:00
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
set_errno (EFAULT);
|
2008-04-23 19:13:52 +08:00
|
|
|
return -1;
|
|
|
|
}
|
2008-05-22 19:18:46 +08:00
|
|
|
if (pathname)
|
2008-04-23 19:13:52 +08:00
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
if (!*pathname)
|
|
|
|
{
|
|
|
|
set_errno (ENOENT);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (strlen (pathname) >= PATH_MAX)
|
|
|
|
{
|
|
|
|
set_errno (ENAMETOOLONG);
|
|
|
|
return -1;
|
|
|
|
}
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
2008-12-16 04:53:18 +08:00
|
|
|
if (pathname && isabspath (pathname))
|
2008-04-23 19:13:52 +08:00
|
|
|
stpcpy (path_ret, pathname);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
if (dirfd == AT_FDCWD)
|
2009-05-13 23:00:06 +08:00
|
|
|
{
|
|
|
|
cwdstuff::cwd_lock.acquire ();
|
|
|
|
p = stpcpy (path_ret, cygheap->cwd.get_posix ());
|
|
|
|
cwdstuff::cwd_lock.release ();
|
|
|
|
}
|
2008-04-23 19:13:52 +08:00
|
|
|
else
|
2008-11-27 01:21:04 +08:00
|
|
|
{
|
2008-04-23 19:13:52 +08:00
|
|
|
cygheap_fdget cfd (dirfd);
|
|
|
|
if (cfd < 0)
|
|
|
|
return -1;
|
|
|
|
if (!cfd->pc.isdir ())
|
|
|
|
{
|
|
|
|
set_errno (ENOTDIR);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
p = stpcpy (path_ret, cfd->get_name ());
|
|
|
|
}
|
|
|
|
if (!p)
|
2008-11-27 01:21:04 +08:00
|
|
|
{
|
2008-04-23 19:13:52 +08:00
|
|
|
set_errno (ENOTDIR);
|
|
|
|
return -1;
|
|
|
|
}
|
2008-05-22 19:18:46 +08:00
|
|
|
if (pathname)
|
|
|
|
{
|
|
|
|
if (p[-1] != '/')
|
|
|
|
*p++ = '/';
|
|
|
|
stpcpy (p, pathname);
|
|
|
|
}
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
openat (int dirfd, const char *pathname, int flags, ...)
|
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
tmp_pathbuf tp;
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
|
|
|
{
|
|
|
|
char *path = tp.c_get ();
|
|
|
|
if (gen_full_path_at (path, dirfd, pathname))
|
|
|
|
__leave;
|
2008-11-27 01:21:04 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
va_list ap;
|
|
|
|
mode_t mode;
|
2008-04-23 19:13:52 +08:00
|
|
|
|
2014-08-22 17:21:33 +08:00
|
|
|
va_start (ap, flags);
|
|
|
|
mode = va_arg (ap, mode_t);
|
|
|
|
va_end (ap);
|
|
|
|
return open (path, flags, mode);
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return -1;
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
faccessat (int dirfd, const char *pathname, int mode, int flags)
|
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
tmp_pathbuf tp;
|
2008-04-23 19:13:52 +08:00
|
|
|
int res = -1;
|
2014-08-22 17:21:33 +08:00
|
|
|
|
|
|
|
__try
|
2008-04-23 19:13:52 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
char *path = tp.c_get ();
|
|
|
|
if (!gen_full_path_at (path, dirfd, pathname))
|
2008-11-27 01:21:04 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
if ((mode & ~(F_OK|R_OK|W_OK|X_OK))
|
|
|
|
|| (flags & ~(AT_SYMLINK_NOFOLLOW|AT_EACCESS)))
|
|
|
|
set_errno (EINVAL);
|
|
|
|
else
|
2008-04-23 19:13:52 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
fhandler_base *fh = build_fh_name (path,
|
|
|
|
(flags & AT_SYMLINK_NOFOLLOW
|
|
|
|
? PC_SYM_NOFOLLOW
|
|
|
|
: PC_SYM_FOLLOW)
|
|
|
|
| PC_KEEP_HANDLE,
|
|
|
|
stat_suffixes);
|
|
|
|
if (fh)
|
|
|
|
{
|
|
|
|
res = fh->fhaccess (mode, !!(flags & AT_EACCESS));
|
|
|
|
delete fh;
|
|
|
|
}
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
2008-04-23 19:13:52 +08:00
|
|
|
debug_printf ("returning %d", res);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
fchmodat (int dirfd, const char *pathname, mode_t mode, int flags)
|
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
tmp_pathbuf tp;
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2009-09-22 20:13:53 +08:00
|
|
|
{
|
2021-01-27 04:54:05 +08:00
|
|
|
if (flags & ~AT_SYMLINK_NOFOLLOW)
|
2014-08-22 17:21:33 +08:00
|
|
|
{
|
2021-01-27 04:54:05 +08:00
|
|
|
set_errno (EINVAL);
|
2014-08-22 17:21:33 +08:00
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
char *path = tp.c_get ();
|
|
|
|
if (gen_full_path_at (path, dirfd, pathname))
|
|
|
|
__leave;
|
2021-01-27 04:54:05 +08:00
|
|
|
if (flags & AT_SYMLINK_NOFOLLOW)
|
|
|
|
{
|
|
|
|
/* BSD has lchmod, but Linux does not. POSIX says
|
|
|
|
AT_SYMLINK_NOFOLLOW is allowed to fail on symlinks.
|
|
|
|
Linux blindly fails even for non-symlinks, but we allow
|
|
|
|
it to succeed. */
|
|
|
|
path_conv pc (path, PC_SYM_NOFOLLOW, stat_suffixes);
|
|
|
|
if (pc.issymlink ())
|
|
|
|
{
|
|
|
|
set_errno (EOPNOTSUPP);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
return chmod (path, mode);
|
2009-09-22 20:13:53 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return -1;
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
fchownat (int dirfd, const char *pathname, uid_t uid, gid_t gid, int flags)
|
2008-04-23 19:13:52 +08:00
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
tmp_pathbuf tp;
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2009-09-22 20:13:53 +08:00
|
|
|
{
|
2019-12-28 06:38:32 +08:00
|
|
|
if (flags & ~(AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH))
|
2014-08-22 17:21:33 +08:00
|
|
|
{
|
|
|
|
set_errno (EINVAL);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
char *path = tp.c_get ();
|
2019-12-28 06:38:32 +08:00
|
|
|
int res = gen_full_path_at (path, dirfd, pathname);
|
|
|
|
if (res)
|
|
|
|
{
|
|
|
|
if (!(errno == ENOENT && (flags & AT_EMPTY_PATH)))
|
|
|
|
__leave;
|
|
|
|
/* pathname is an empty string. Operate on dirfd. */
|
|
|
|
if (dirfd == AT_FDCWD)
|
|
|
|
{
|
|
|
|
cwdstuff::cwd_lock.acquire ();
|
|
|
|
strcpy (path, cygheap->cwd.get_posix ());
|
|
|
|
cwdstuff::cwd_lock.release ();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
cygheap_fdget cfd (dirfd);
|
|
|
|
if (cfd < 0)
|
|
|
|
__leave;
|
|
|
|
strcpy (path, cfd->get_name ());
|
|
|
|
/* If dirfd refers to a symlink (which was necessarily
|
|
|
|
opened with O_PATH | O_NOFOLLOW), we must operate
|
|
|
|
directly on that symlink.. */
|
|
|
|
flags = AT_SYMLINK_NOFOLLOW;
|
|
|
|
}
|
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
return chown_worker (path, (flags & AT_SYMLINK_NOFOLLOW)
|
|
|
|
? PC_SYM_NOFOLLOW : PC_SYM_FOLLOW, uid, gid);
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return -1;
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
2013-11-25 19:38:08 +08:00
|
|
|
fstatat (int dirfd, const char *__restrict pathname, struct stat *__restrict st,
|
|
|
|
int flags)
|
2008-04-23 19:13:52 +08:00
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
tmp_pathbuf tp;
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2009-09-22 20:13:53 +08:00
|
|
|
{
|
2019-12-28 06:38:32 +08:00
|
|
|
if (flags & ~(AT_SYMLINK_NOFOLLOW | AT_EMPTY_PATH))
|
2014-08-22 17:21:33 +08:00
|
|
|
{
|
|
|
|
set_errno (EINVAL);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
char *path = tp.c_get ();
|
2019-12-28 06:38:32 +08:00
|
|
|
int res = gen_full_path_at (path, dirfd, pathname);
|
|
|
|
if (res)
|
|
|
|
{
|
|
|
|
if (!(errno == ENOENT && (flags & AT_EMPTY_PATH)))
|
|
|
|
__leave;
|
|
|
|
/* pathname is an empty string. Operate on dirfd. */
|
|
|
|
if (dirfd == AT_FDCWD)
|
|
|
|
{
|
|
|
|
cwdstuff::cwd_lock.acquire ();
|
|
|
|
strcpy (path, cygheap->cwd.get_posix ());
|
|
|
|
cwdstuff::cwd_lock.release ();
|
|
|
|
}
|
|
|
|
else
|
2021-01-13 03:18:28 +08:00
|
|
|
return fstat64 (dirfd, st);
|
2019-12-28 06:38:32 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
path_conv pc (path, ((flags & AT_SYMLINK_NOFOLLOW)
|
|
|
|
? PC_SYM_NOFOLLOW : PC_SYM_FOLLOW)
|
|
|
|
| PC_POSIX | PC_KEEP_HANDLE, stat_suffixes);
|
|
|
|
return stat_worker (pc, st);
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return -1;
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
|
|
|
|
2008-04-24 17:59:54 +08:00
|
|
|
extern int utimens_worker (path_conv &, const struct timespec *);
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
utimensat (int dirfd, const char *pathname, const struct timespec *times,
|
|
|
|
int flags)
|
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
tmp_pathbuf tp;
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2009-09-22 20:13:53 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
char *path = tp.c_get ();
|
|
|
|
if (flags & ~AT_SYMLINK_NOFOLLOW)
|
|
|
|
{
|
|
|
|
set_errno (EINVAL);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
if (gen_full_path_at (path, dirfd, pathname))
|
|
|
|
__leave;
|
|
|
|
path_conv win32 (path, PC_POSIX | ((flags & AT_SYMLINK_NOFOLLOW)
|
|
|
|
? PC_SYM_NOFOLLOW : PC_SYM_FOLLOW),
|
|
|
|
stat_suffixes);
|
|
|
|
return utimens_worker (win32, times);
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return -1;
|
2008-04-24 17:59:54 +08:00
|
|
|
}
|
|
|
|
|
2008-04-23 19:13:52 +08:00
|
|
|
extern "C" int
|
2021-01-27 00:26:35 +08:00
|
|
|
futimesat (int dirfd, const char *pathname, const struct timeval times[2])
|
2008-04-23 19:13:52 +08:00
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
tmp_pathbuf tp;
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
|
|
|
{
|
|
|
|
char *path = tp.c_get ();
|
|
|
|
if (gen_full_path_at (path, dirfd, pathname, true))
|
|
|
|
__leave;
|
|
|
|
return utimes (path, times);
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return -1;
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
linkat (int olddirfd, const char *oldpathname,
|
|
|
|
int newdirfd, const char *newpathname,
|
|
|
|
int flags)
|
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
tmp_pathbuf tp;
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2008-04-23 19:13:52 +08:00
|
|
|
{
|
2019-01-08 02:36:37 +08:00
|
|
|
if (flags & ~(AT_SYMLINK_FOLLOW | AT_EMPTY_PATH))
|
2008-04-23 19:13:52 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
set_errno (EINVAL);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
char *oldpath = tp.c_get ();
|
2019-01-08 02:36:37 +08:00
|
|
|
/* AT_EMPTY_PATH with an empty oldpathname is equivalent to
|
|
|
|
|
|
|
|
linkat(AT_FDCWD, "/proc/self/fd/<olddirfd>", newdirfd,
|
|
|
|
newname, AT_SYMLINK_FOLLOW);
|
|
|
|
|
|
|
|
Convert the request accordingly. */
|
|
|
|
if ((flags & AT_EMPTY_PATH) && oldpathname && oldpathname[0] == '\0')
|
|
|
|
{
|
|
|
|
if (olddirfd == AT_FDCWD)
|
|
|
|
{
|
|
|
|
set_errno (EPERM);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
__small_sprintf (oldpath, "/proc/%d/fd/%d", myself->pid, olddirfd);
|
|
|
|
flags = AT_SYMLINK_FOLLOW;
|
|
|
|
}
|
|
|
|
else if (gen_full_path_at (oldpath, olddirfd, oldpathname))
|
2014-08-22 17:21:33 +08:00
|
|
|
__leave;
|
|
|
|
char *newpath = tp.c_get ();
|
|
|
|
if (gen_full_path_at (newpath, newdirfd, newpathname))
|
|
|
|
__leave;
|
|
|
|
if (flags & AT_SYMLINK_FOLLOW)
|
|
|
|
{
|
2019-01-06 05:15:58 +08:00
|
|
|
path_conv old_name (oldpath,
|
|
|
|
PC_SYM_FOLLOW | PC_SYM_NOFOLLOW_PROCFD | PC_POSIX,
|
|
|
|
stat_suffixes);
|
2014-08-22 17:21:33 +08:00
|
|
|
if (old_name.error)
|
|
|
|
{
|
|
|
|
set_errno (old_name.error);
|
|
|
|
__leave;
|
|
|
|
}
|
2015-02-15 16:59:55 +08:00
|
|
|
strcpy (oldpath, old_name.get_posix ());
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
return link (oldpath, newpath);
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return -1;
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
mkdirat (int dirfd, const char *pathname, mode_t mode)
|
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
tmp_pathbuf tp;
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
|
|
|
{
|
|
|
|
char *path = tp.c_get ();
|
|
|
|
if (gen_full_path_at (path, dirfd, pathname))
|
|
|
|
__leave;
|
|
|
|
return mkdir (path, mode);
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return -1;
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
mkfifoat (int dirfd, const char *pathname, mode_t mode)
|
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
tmp_pathbuf tp;
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
|
|
|
{
|
|
|
|
char *path = tp.c_get ();
|
|
|
|
if (gen_full_path_at (path, dirfd, pathname))
|
|
|
|
__leave;
|
|
|
|
return mkfifo (path, mode);
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return -1;
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
2013-04-23 17:44:36 +08:00
|
|
|
mknodat (int dirfd, const char *pathname, mode_t mode, dev_t dev)
|
2008-04-23 19:13:52 +08:00
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
tmp_pathbuf tp;
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
|
|
|
{
|
|
|
|
char *path = tp.c_get ();
|
|
|
|
if (gen_full_path_at (path, dirfd, pathname))
|
|
|
|
__leave;
|
|
|
|
return mknod32 (path, mode, dev);
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return -1;
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" ssize_t
|
2013-11-25 19:38:08 +08:00
|
|
|
readlinkat (int dirfd, const char *__restrict pathname, char *__restrict buf,
|
|
|
|
size_t bufsize)
|
2008-04-23 19:13:52 +08:00
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
tmp_pathbuf tp;
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
|
|
|
{
|
|
|
|
char *path = tp.c_get ();
|
2019-12-28 06:17:35 +08:00
|
|
|
int res = gen_full_path_at (path, dirfd, pathname);
|
|
|
|
if (res)
|
|
|
|
{
|
|
|
|
if (errno != ENOENT)
|
|
|
|
__leave;
|
|
|
|
/* pathname is an empty string. This is OK if dirfd refers
|
|
|
|
to a symlink that was opened with O_PATH | O_NOFOLLOW.
|
|
|
|
In this case, readlinkat operates on the symlink. */
|
|
|
|
cygheap_fdget cfd (dirfd);
|
|
|
|
if (cfd < 0)
|
|
|
|
__leave;
|
|
|
|
if (!(cfd->issymlink ()
|
|
|
|
&& cfd->get_flags () & O_PATH
|
|
|
|
&& cfd->get_flags () & O_NOFOLLOW))
|
|
|
|
__leave;
|
|
|
|
strcpy (path, cfd->get_name ());
|
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
return readlink (path, buf, bufsize);
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return -1;
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
2017-08-17 21:12:15 +08:00
|
|
|
renameat2 (int olddirfd, const char *oldpathname,
|
|
|
|
int newdirfd, const char *newpathname, unsigned int flags)
|
2008-04-23 19:13:52 +08:00
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
tmp_pathbuf tp;
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
|
|
|
{
|
|
|
|
char *oldpath = tp.c_get ();
|
|
|
|
if (gen_full_path_at (oldpath, olddirfd, oldpathname))
|
|
|
|
__leave;
|
|
|
|
char *newpath = tp.c_get ();
|
|
|
|
if (gen_full_path_at (newpath, newdirfd, newpathname))
|
|
|
|
__leave;
|
2017-08-17 21:12:15 +08:00
|
|
|
return rename2 (oldpath, newpath, flags);
|
2014-08-22 17:21:33 +08:00
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return -1;
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
|
|
|
|
2017-08-17 21:12:15 +08:00
|
|
|
extern "C" int
|
|
|
|
renameat (int olddirfd, const char *oldpathname,
|
|
|
|
int newdirfd, const char *newpathname)
|
|
|
|
{
|
|
|
|
return renameat2 (olddirfd, oldpathname, newdirfd, newpathname, 0);
|
|
|
|
}
|
|
|
|
|
2012-02-22 09:58:24 +08:00
|
|
|
extern "C" int
|
|
|
|
scandirat (int dirfd, const char *pathname, struct dirent ***namelist,
|
|
|
|
int (*select) (const struct dirent *),
|
|
|
|
int (*compar) (const struct dirent **, const struct dirent **))
|
|
|
|
{
|
|
|
|
tmp_pathbuf tp;
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
|
|
|
{
|
|
|
|
char *path = tp.c_get ();
|
|
|
|
if (gen_full_path_at (path, dirfd, pathname))
|
|
|
|
__leave;
|
2017-07-04 21:11:06 +08:00
|
|
|
return scandir (path, namelist, select, compar);
|
2014-08-22 17:21:33 +08:00
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return -1;
|
2012-02-22 09:58:24 +08:00
|
|
|
}
|
|
|
|
|
2008-04-23 19:13:52 +08:00
|
|
|
extern "C" int
|
|
|
|
symlinkat (const char *oldpath, int newdirfd, const char *newpathname)
|
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
tmp_pathbuf tp;
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
|
|
|
{
|
|
|
|
char *newpath = tp.c_get ();
|
|
|
|
if (gen_full_path_at (newpath, newdirfd, newpathname))
|
|
|
|
__leave;
|
|
|
|
return symlink (oldpath, newpath);
|
|
|
|
}
|
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return -1;
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
unlinkat (int dirfd, const char *pathname, int flags)
|
|
|
|
{
|
2008-05-22 19:18:46 +08:00
|
|
|
tmp_pathbuf tp;
|
2014-08-22 17:21:33 +08:00
|
|
|
__try
|
2009-09-22 20:13:53 +08:00
|
|
|
{
|
2014-08-22 17:21:33 +08:00
|
|
|
if (flags & ~AT_REMOVEDIR)
|
|
|
|
{
|
|
|
|
set_errno (EINVAL);
|
|
|
|
__leave;
|
|
|
|
}
|
|
|
|
char *path = tp.c_get ();
|
|
|
|
if (gen_full_path_at (path, dirfd, pathname))
|
|
|
|
__leave;
|
|
|
|
return (flags & AT_REMOVEDIR) ? rmdir (path) : unlink (path);
|
2009-09-22 20:13:53 +08:00
|
|
|
}
|
2014-08-22 17:21:33 +08:00
|
|
|
__except (EFAULT) {}
|
|
|
|
__endtry
|
|
|
|
return -1;
|
2008-04-23 19:13:52 +08:00
|
|
|
}
|
2019-01-07 19:31:28 +08:00
|
|
|
|
|
|
|
static int __reg3
|
|
|
|
pipe_worker (int filedes[2], unsigned int psize, int mode)
|
|
|
|
{
|
|
|
|
fhandler_pipe *fhs[2];
|
|
|
|
int res = fhandler_pipe::create (fhs, psize, mode);
|
|
|
|
if (!res)
|
|
|
|
{
|
|
|
|
cygheap_fdnew fdin;
|
|
|
|
cygheap_fdnew fdout (fdin, false);
|
2019-02-05 22:32:08 +08:00
|
|
|
char buf[sizeof ("pipe:[9223372036854775807]")];
|
|
|
|
__small_sprintf (buf, "pipe:[%D]", fhs[0]->get_plain_ino ());
|
2019-01-07 19:31:28 +08:00
|
|
|
fhs[0]->pc.set_posix (buf);
|
|
|
|
__small_sprintf (buf, "pipe:[%D]", fhs[1]->get_plain_ino ());
|
|
|
|
fhs[1]->pc.set_posix (buf);
|
|
|
|
fdin = fhs[0];
|
|
|
|
fdout = fhs[1];
|
|
|
|
filedes[0] = fdin;
|
|
|
|
filedes[1] = fdout;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
_pipe (int filedes[2], unsigned int psize, int mode)
|
|
|
|
{
|
|
|
|
int res = pipe_worker (filedes, psize, mode);
|
|
|
|
int read, write;
|
|
|
|
if (res != 0)
|
|
|
|
read = write = -1;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
read = filedes[0];
|
|
|
|
write = filedes[1];
|
|
|
|
}
|
|
|
|
syscall_printf ("%R = _pipe([%d, %d], %u, %y)", res, read, write, psize, mode);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
pipe (int filedes[2])
|
|
|
|
{
|
|
|
|
int res = pipe_worker (filedes, DEFAULT_PIPEBUFSIZE, O_BINARY);
|
|
|
|
int read, write;
|
|
|
|
if (res != 0)
|
|
|
|
read = write = -1;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
read = filedes[0];
|
|
|
|
write = filedes[1];
|
|
|
|
}
|
|
|
|
syscall_printf ("%R = pipe([%d, %d])", res, read, write);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" int
|
|
|
|
pipe2 (int filedes[2], int mode)
|
|
|
|
{
|
|
|
|
int res = pipe_worker (filedes, DEFAULT_PIPEBUFSIZE, mode);
|
|
|
|
int read, write;
|
|
|
|
if (res != 0)
|
|
|
|
read = write = -1;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
read = filedes[0];
|
|
|
|
write = filedes[1];
|
|
|
|
}
|
|
|
|
syscall_printf ("%R = pipe2([%d, %d], %y)", res, read, write, mode);
|
|
|
|
return res;
|
|
|
|
}
|