2000-02-18 03:38:33 +08:00
|
|
|
/* fhandler.cc. See console.cc for fhandler_console functions.
|
|
|
|
|
2005-02-03 06:42:06 +08:00
|
|
|
Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
|
2012-01-22 14:45:08 +08:00
|
|
|
2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Red Hat, Inc.
|
2000-02-18 03:38:33 +08:00
|
|
|
|
|
|
|
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. */
|
|
|
|
|
2000-08-03 00:28:18 +08:00
|
|
|
#include "winsup.h"
|
2000-02-18 03:38:33 +08:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <stdlib.h>
|
2002-08-30 23:47:10 +08:00
|
|
|
#include <sys/uio.h>
|
2004-04-15 00:36:26 +08:00
|
|
|
#include <sys/acl.h>
|
2012-03-08 17:36:11 +08:00
|
|
|
#include <sys/param.h>
|
2000-08-22 11:58:47 +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"
|
2001-08-07 08:01:42 +08:00
|
|
|
#include "cygwin/version.h"
|
2001-10-01 12:10:07 +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"
|
2001-04-19 05:10:15 +08:00
|
|
|
#include "dtable.h"
|
|
|
|
#include "cygheap.h"
|
2001-10-05 12:21:41 +08:00
|
|
|
#include "pinfo.h"
|
2001-10-01 12:10:07 +08:00
|
|
|
#include <assert.h>
|
2003-05-26 17:54:01 +08:00
|
|
|
#include <winioctl.h>
|
2004-04-17 05:22:13 +08:00
|
|
|
#include "ntdll.h"
|
2007-07-08 01:00:33 +08:00
|
|
|
#include "cygtls.h"
|
|
|
|
#include "sigproc.h"
|
2011-11-29 23:34:49 +08:00
|
|
|
#include "shared_info.h"
|
2011-07-22 04:21:46 +08:00
|
|
|
#include <asm/socket.h>
|
2012-06-18 04:50:24 +08:00
|
|
|
#include "cygwait.h"
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2011-03-10 00:47:44 +08:00
|
|
|
#define MAX_OVERLAPPED_WRITE_LEN (64 * 1024 * 1024)
|
|
|
|
#define MIN_OVERLAPPED_WRITE_LEN (1 * 1024 * 1024)
|
|
|
|
|
2011-11-07 18:06:45 +08:00
|
|
|
static const int CHUNK_SIZE = 1024; /* Used for crlf conversions */
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2001-09-06 12:41:59 +08:00
|
|
|
struct __cygwin_perfile *perfile_table;
|
2000-07-09 13:29:51 +08:00
|
|
|
|
2011-11-29 23:34:49 +08:00
|
|
|
HANDLE NO_COPY fhandler_base_overlapped::asio_done;
|
|
|
|
LONG NO_COPY fhandler_base_overlapped::asio_close_counter;
|
|
|
|
|
2011-10-16 06:37:30 +08:00
|
|
|
void
|
|
|
|
fhandler_base::reset (const fhandler_base *from)
|
2000-09-03 12:16:35 +08:00
|
|
|
{
|
2011-10-23 00:26:30 +08:00
|
|
|
pc << from->pc;
|
2000-09-03 12:16:35 +08:00
|
|
|
rabuf = NULL;
|
|
|
|
ralen = 0;
|
|
|
|
raixget = 0;
|
|
|
|
raixput = 0;
|
|
|
|
rabuflen = 0;
|
2012-01-22 14:45:08 +08:00
|
|
|
_refcnt = 0;
|
2000-09-03 12:16:35 +08:00
|
|
|
}
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
int
|
2002-02-20 06:06:50 +08:00
|
|
|
fhandler_base::puts_readahead (const char *s, size_t len)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
int success = 1;
|
2004-12-12 10:15:34 +08:00
|
|
|
while ((len == (size_t) -1 ? *s : len--)
|
2000-09-03 12:16:35 +08:00
|
|
|
&& (success = put_readahead (*s++) > 0))
|
2000-02-18 03:38:33 +08:00
|
|
|
continue;
|
|
|
|
return success;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fhandler_base::put_readahead (char value)
|
|
|
|
{
|
|
|
|
char *newrabuf;
|
|
|
|
if (raixput < rabuflen)
|
|
|
|
/* Nothing to do */;
|
|
|
|
else if ((newrabuf = (char *) realloc (rabuf, rabuflen += 32)))
|
|
|
|
rabuf = newrabuf;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
rabuf[raixput++] = value;
|
|
|
|
ralen++;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fhandler_base::get_readahead ()
|
|
|
|
{
|
|
|
|
int chret = -1;
|
|
|
|
if (raixget < ralen)
|
2001-04-19 05:10:15 +08:00
|
|
|
chret = ((unsigned char) rabuf[raixget++]) & 0xff;
|
2000-02-18 03:38:33 +08:00
|
|
|
/* FIXME - not thread safe */
|
|
|
|
if (raixget >= ralen)
|
|
|
|
raixget = raixput = ralen = 0;
|
|
|
|
return chret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fhandler_base::peek_readahead (int queryput)
|
|
|
|
{
|
|
|
|
int chret = -1;
|
|
|
|
if (!queryput && raixget < ralen)
|
|
|
|
chret = ((unsigned char) rabuf[raixget]) & 0xff;
|
|
|
|
else if (queryput && raixput > 0)
|
|
|
|
chret = ((unsigned char) rabuf[raixput - 1]) & 0xff;
|
|
|
|
return chret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2002-02-20 06:06:50 +08:00
|
|
|
fhandler_base::set_readahead_valid (int val, int ch)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
if (!val)
|
|
|
|
ralen = raixget = raixput = 0;
|
|
|
|
if (ch != -1)
|
2002-09-22 11:38:57 +08:00
|
|
|
put_readahead (ch);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fhandler_base::eat_readahead (int n)
|
|
|
|
{
|
|
|
|
int oralen = ralen;
|
|
|
|
if (n < 0)
|
|
|
|
n = ralen;
|
|
|
|
if (n > 0 && ralen)
|
|
|
|
{
|
2000-02-21 13:20:38 +08:00
|
|
|
if ((int) (ralen -= n) < 0)
|
2000-02-18 03:38:33 +08:00
|
|
|
ralen = 0;
|
|
|
|
|
|
|
|
if (raixget >= ralen)
|
|
|
|
raixget = raixput = ralen = 0;
|
|
|
|
else if (raixput > ralen)
|
|
|
|
raixput = ralen;
|
|
|
|
}
|
|
|
|
|
|
|
|
return oralen;
|
|
|
|
}
|
|
|
|
|
2000-03-12 14:29:54 +08:00
|
|
|
int
|
|
|
|
fhandler_base::get_readahead_into_buffer (char *buf, size_t buflen)
|
|
|
|
{
|
|
|
|
int ch;
|
|
|
|
int copied_chars = 0;
|
|
|
|
|
|
|
|
while (buflen)
|
|
|
|
if ((ch = get_readahead ()) < 0)
|
|
|
|
break;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
buf[copied_chars++] = (unsigned char)(ch & 0xff);
|
|
|
|
buflen--;
|
|
|
|
}
|
|
|
|
|
|
|
|
return copied_chars;
|
|
|
|
}
|
|
|
|
|
* 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
|
|
|
/* Record the file name. and name hash */
|
|
|
|
void
|
|
|
|
fhandler_base::set_name (path_conv &in_pc)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2011-10-23 00:26:30 +08:00
|
|
|
pc << in_pc;
|
2001-10-01 12:10:07 +08:00
|
|
|
}
|
|
|
|
|
2005-01-31 18:28:55 +08:00
|
|
|
char *fhandler_base::get_proc_fd_name (char *buf)
|
|
|
|
{
|
|
|
|
if (get_name ())
|
|
|
|
return strcpy (buf, get_name ());
|
|
|
|
if (dev ().name)
|
|
|
|
return strcpy (buf, dev ().name);
|
2005-02-01 23:11:47 +08:00
|
|
|
return strcpy (buf, "");
|
2005-01-31 18:28:55 +08:00
|
|
|
}
|
|
|
|
|
2000-11-27 05:45:16 +08:00
|
|
|
/* Detect if we are sitting at EOF for conditions where Windows
|
|
|
|
returns an error but UNIX doesn't. */
|
2011-05-05 17:05:04 +08:00
|
|
|
int __stdcall
|
|
|
|
is_at_eof (HANDLE h)
|
2000-11-27 05:45:16 +08:00
|
|
|
{
|
2007-10-15 16:25:38 +08:00
|
|
|
IO_STATUS_BLOCK io;
|
|
|
|
FILE_POSITION_INFORMATION fpi;
|
|
|
|
FILE_STANDARD_INFORMATION fsi;
|
|
|
|
|
|
|
|
if (NT_SUCCESS (NtQueryInformationFile (h, &io, &fsi, sizeof fsi,
|
|
|
|
FileStandardInformation))
|
|
|
|
&& NT_SUCCESS (NtQueryInformationFile (h, &io, &fpi, sizeof fpi,
|
|
|
|
FilePositionInformation))
|
|
|
|
&& fsi.EndOfFile.QuadPart == fpi.CurrentByteOffset.QuadPart)
|
|
|
|
return 1;
|
2000-11-27 05:45:16 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-06-20 08:36:40 +08:00
|
|
|
void
|
|
|
|
fhandler_base::set_flags (int flags, int supplied_bin)
|
|
|
|
{
|
|
|
|
int bin;
|
|
|
|
int fmode;
|
|
|
|
debug_printf ("flags %p, supplied_bin %p", flags, supplied_bin);
|
|
|
|
if ((bin = flags & (O_BINARY | O_TEXT)))
|
|
|
|
debug_printf ("O_TEXT/O_BINARY set in flags %p", bin);
|
2004-04-10 21:45:10 +08:00
|
|
|
else if (rbinset () && wbinset ())
|
|
|
|
bin = rbinary () ? O_BINARY : O_TEXT; // FIXME: Not quite right
|
2002-06-20 08:36:40 +08:00
|
|
|
else if ((fmode = get_default_fmode (flags)) & O_BINARY)
|
|
|
|
bin = O_BINARY;
|
|
|
|
else if (fmode & O_TEXT)
|
|
|
|
bin = O_TEXT;
|
|
|
|
else if (supplied_bin)
|
|
|
|
bin = supplied_bin;
|
|
|
|
else
|
2008-07-18 16:16:40 +08:00
|
|
|
bin = wbinary () || rbinary () ? O_BINARY : O_TEXT;
|
2002-06-20 08:36:40 +08:00
|
|
|
|
|
|
|
openflags = flags | bin;
|
|
|
|
|
|
|
|
bin &= O_BINARY;
|
2004-04-10 21:45:10 +08:00
|
|
|
rbinary (bin ? true : false);
|
|
|
|
wbinary (bin ? true : false);
|
2002-06-20 08:36:40 +08:00
|
|
|
syscall_printf ("filemode set to %s", bin ? "binary" : "text");
|
|
|
|
}
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
/* Normal file i/o handlers. */
|
|
|
|
|
|
|
|
/* Cover function to ReadFile to achieve (as much as possible) Posix style
|
|
|
|
semantics and use of errno. */
|
2009-07-25 04:54:33 +08:00
|
|
|
void __stdcall
|
2002-12-14 12:01:32 +08:00
|
|
|
fhandler_base::raw_read (void *ptr, size_t& ulen)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2003-09-07 10:22:58 +08:00
|
|
|
#define bytes_read ulen
|
2002-12-14 12:01:32 +08:00
|
|
|
|
2006-08-10 22:16:24 +08:00
|
|
|
int try_noreserve = 1;
|
2002-12-14 12:01:32 +08:00
|
|
|
DWORD len = ulen;
|
2002-12-15 02:01:08 +08:00
|
|
|
|
2006-08-10 22:16:24 +08:00
|
|
|
retry:
|
2003-09-01 10:05:32 +08:00
|
|
|
ulen = (size_t) -1;
|
2007-07-08 01:00:33 +08:00
|
|
|
BOOL res = ReadFile (get_handle (), ptr, len, (DWORD *) &ulen, NULL);
|
2002-12-14 12:01:32 +08:00
|
|
|
if (!res)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
/* Some errors are not really errors. Detect such cases here. */
|
|
|
|
|
2002-12-14 12:01:32 +08:00
|
|
|
DWORD errcode = GetLastError ();
|
2000-02-18 03:38:33 +08:00
|
|
|
switch (errcode)
|
|
|
|
{
|
|
|
|
case ERROR_BROKEN_PIPE:
|
|
|
|
/* This is really EOF. */
|
|
|
|
bytes_read = 0;
|
|
|
|
break;
|
|
|
|
case ERROR_MORE_DATA:
|
|
|
|
/* `bytes_read' is supposedly valid. */
|
|
|
|
break;
|
2000-11-27 05:45:16 +08:00
|
|
|
case ERROR_NOACCESS:
|
2011-05-05 17:05:04 +08:00
|
|
|
if (is_at_eof (get_handle ()))
|
2002-12-14 12:01:32 +08:00
|
|
|
{
|
|
|
|
bytes_read = 0;
|
|
|
|
break;
|
|
|
|
}
|
2006-08-10 22:16:24 +08:00
|
|
|
if (try_noreserve)
|
|
|
|
{
|
|
|
|
try_noreserve = 0;
|
|
|
|
switch (mmap_is_attached_or_noreserve (ptr, len))
|
|
|
|
{
|
|
|
|
case MMAP_NORESERVE_COMMITED:
|
|
|
|
goto retry;
|
|
|
|
case MMAP_RAISE_SIGBUS:
|
|
|
|
raise(SIGBUS);
|
|
|
|
case MMAP_NONE:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
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
|
|
|
/*FALLTHRU*/
|
2001-10-01 12:10:07 +08:00
|
|
|
case ERROR_INVALID_FUNCTION:
|
|
|
|
case ERROR_INVALID_PARAMETER:
|
2002-09-19 11:30:20 +08:00
|
|
|
case ERROR_INVALID_HANDLE:
|
2006-07-14 04:56:24 +08:00
|
|
|
if (pc.isdir ())
|
2001-10-01 12:10:07 +08:00
|
|
|
{
|
|
|
|
set_errno (EISDIR);
|
2003-09-07 10:22:58 +08:00
|
|
|
bytes_read = (size_t) -1;
|
2002-12-14 12:01:32 +08:00
|
|
|
break;
|
2001-10-01 12:10:07 +08:00
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
default:
|
2005-06-08 02:41:31 +08:00
|
|
|
syscall_printf ("ReadFile %s(%p) failed, %E", get_name (), get_handle ());
|
2000-09-03 12:16:35 +08:00
|
|
|
__seterrno_from_win_error (errcode);
|
2003-09-07 10:22:58 +08:00
|
|
|
bytes_read = (size_t) -1;
|
2000-02-18 03:38:33 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2002-12-14 12:01:32 +08:00
|
|
|
#undef bytes_read
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Cover function to WriteFile to provide Posix interface and semantics
|
|
|
|
(as much as possible). */
|
2009-07-25 04:54:33 +08:00
|
|
|
ssize_t __stdcall
|
2000-02-18 03:38:33 +08:00
|
|
|
fhandler_base::raw_write (const void *ptr, size_t len)
|
|
|
|
{
|
2007-10-15 16:25:38 +08:00
|
|
|
NTSTATUS status;
|
|
|
|
IO_STATUS_BLOCK io;
|
2011-11-04 01:47:33 +08:00
|
|
|
static _RDATA LARGE_INTEGER off_current =
|
|
|
|
{ QuadPart:FILE_USE_FILE_POINTER_POSITION };
|
|
|
|
static _RDATA LARGE_INTEGER off_append =
|
|
|
|
{ QuadPart:FILE_WRITE_TO_END_OF_FILE };
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2007-10-15 16:25:38 +08:00
|
|
|
status = NtWriteFile (get_output_handle (), NULL, NULL, NULL, &io,
|
|
|
|
(PVOID) ptr, len,
|
|
|
|
(get_flags () & O_APPEND) ? &off_append : &off_current,
|
|
|
|
NULL);
|
|
|
|
if (!NT_SUCCESS (status))
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2007-10-15 16:25:38 +08:00
|
|
|
__seterrno_from_nt_status (status);
|
2000-02-18 03:38:33 +08:00
|
|
|
if (get_errno () == EPIPE)
|
|
|
|
raise (SIGPIPE);
|
|
|
|
return -1;
|
|
|
|
}
|
2007-10-15 16:25:38 +08:00
|
|
|
return io.Information;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2000-07-09 13:29:51 +08:00
|
|
|
int
|
|
|
|
fhandler_base::get_default_fmode (int flags)
|
|
|
|
{
|
2002-07-14 04:00:27 +08:00
|
|
|
int fmode = __fmode;
|
2000-07-09 13:29:51 +08:00
|
|
|
if (perfile_table)
|
|
|
|
{
|
|
|
|
size_t nlen = strlen (get_name ());
|
2005-12-15 00:38:22 +08:00
|
|
|
unsigned accflags = (flags & O_ACCMODE);
|
2000-07-09 13:29:51 +08:00
|
|
|
for (__cygwin_perfile *pf = perfile_table; pf->name; pf++)
|
2005-12-15 00:38:22 +08:00
|
|
|
if (!*pf->name && (pf->flags & O_ACCMODE) == accflags)
|
2002-07-14 04:00:27 +08:00
|
|
|
{
|
2005-12-15 00:38:22 +08:00
|
|
|
fmode = pf->flags & ~O_ACCMODE;
|
2002-07-14 04:00:27 +08:00
|
|
|
break;
|
|
|
|
}
|
2000-11-03 12:27:03 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
size_t pflen = strlen (pf->name);
|
|
|
|
const char *stem = get_name () + nlen - pflen;
|
|
|
|
if (pflen > nlen || (stem != get_name () && !isdirsep (stem[-1])))
|
|
|
|
continue;
|
2005-12-15 00:38:22 +08:00
|
|
|
else if ((pf->flags & O_ACCMODE) == accflags
|
2008-07-17 04:20:45 +08:00
|
|
|
&& pathmatch (stem, pf->name, !!pc.objcaseinsensitive ()))
|
2002-07-14 04:00:27 +08:00
|
|
|
{
|
2005-12-15 00:38:22 +08:00
|
|
|
fmode = pf->flags & ~O_ACCMODE;
|
2002-07-14 04:00:27 +08:00
|
|
|
break;
|
|
|
|
}
|
2000-11-03 12:27:03 +08:00
|
|
|
}
|
2000-07-09 13:29:51 +08:00
|
|
|
}
|
2002-07-14 04:00:27 +08:00
|
|
|
return fmode;
|
2000-07-09 13:29: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
|
|
|
bool
|
|
|
|
fhandler_base::device_access_denied (int flags)
|
|
|
|
{
|
|
|
|
int mode = 0;
|
|
|
|
|
|
|
|
if (flags & O_RDWR)
|
|
|
|
mode |= R_OK | W_OK;
|
|
|
|
if (flags & (O_WRONLY | O_APPEND))
|
|
|
|
mode |= W_OK;
|
|
|
|
if (!mode)
|
|
|
|
mode |= R_OK;
|
|
|
|
|
2009-09-25 21:44:45 +08:00
|
|
|
return fhaccess (mode, true);
|
2004-01-24 11:40:33 +08:00
|
|
|
}
|
|
|
|
|
2004-01-25 04:34:27 +08:00
|
|
|
int
|
2009-09-25 21:44:45 +08:00
|
|
|
fhandler_base::fhaccess (int flags, bool effective)
|
2004-01-24 11:40:33 +08:00
|
|
|
{
|
2004-01-25 04:34:27 +08:00
|
|
|
int res = -1;
|
2004-01-24 11:40:33 +08:00
|
|
|
if (error ())
|
|
|
|
{
|
|
|
|
set_errno (error ());
|
2004-01-25 04:34:27 +08:00
|
|
|
goto done;
|
2004-01-24 11:40:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!exists ())
|
|
|
|
{
|
|
|
|
set_errno (ENOENT);
|
2004-01-25 04:34:27 +08:00
|
|
|
goto done;
|
2004-01-24 11:40:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!(flags & (R_OK | W_OK | X_OK)))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (is_fs_special ())
|
|
|
|
/* short circuit */;
|
2007-10-30 20:32:16 +08:00
|
|
|
else if (has_attribute (FILE_ATTRIBUTE_READONLY) && (flags & W_OK)
|
|
|
|
&& !pc.isdir ())
|
2004-01-26 07:39:26 +08:00
|
|
|
goto eaccess_done;
|
2008-07-15 04:22:03 +08:00
|
|
|
else if (has_acls ())
|
2004-01-24 11:40:33 +08:00
|
|
|
{
|
2009-09-25 21:44:45 +08:00
|
|
|
res = check_file_access (pc, flags, effective);
|
2004-01-25 04:34:27 +08:00
|
|
|
goto done;
|
2004-01-24 11:40:33 +08:00
|
|
|
}
|
2008-07-15 04:22:03 +08:00
|
|
|
else if (get_device () == FH_REGISTRY && open (O_RDONLY, 0) && get_handle ())
|
2006-10-21 19:05:32 +08:00
|
|
|
{
|
2009-09-25 21:44:45 +08:00
|
|
|
res = check_registry_access (get_handle (), flags, effective);
|
2006-10-21 19:05:32 +08:00
|
|
|
close ();
|
|
|
|
return res;
|
|
|
|
}
|
2004-01-24 11:40:33 +08:00
|
|
|
|
|
|
|
struct __stat64 st;
|
2004-01-25 04:34:27 +08:00
|
|
|
if (fstat (&st))
|
|
|
|
goto done;
|
|
|
|
|
2004-01-24 11:40:33 +08:00
|
|
|
if (flags & R_OK)
|
|
|
|
{
|
2009-09-25 21:44:45 +08:00
|
|
|
if (st.st_uid == (effective ? myself->uid : cygheap->user.real_uid))
|
2004-01-24 11:40:33 +08:00
|
|
|
{
|
|
|
|
if (!(st.st_mode & S_IRUSR))
|
2004-01-26 07:39:26 +08:00
|
|
|
goto eaccess_done;
|
2004-01-24 11:40:33 +08:00
|
|
|
}
|
2009-09-25 21:44:45 +08:00
|
|
|
else if (st.st_gid == (effective ? myself->gid : cygheap->user.real_gid))
|
2004-01-24 11:40:33 +08:00
|
|
|
{
|
|
|
|
if (!(st.st_mode & S_IRGRP))
|
2004-01-26 07:39:26 +08:00
|
|
|
goto eaccess_done;
|
2004-01-24 11:40:33 +08:00
|
|
|
}
|
|
|
|
else if (!(st.st_mode & S_IROTH))
|
2004-01-26 07:39:26 +08:00
|
|
|
goto eaccess_done;
|
2004-01-24 11:40:33 +08:00
|
|
|
}
|
2004-01-25 04:34:27 +08:00
|
|
|
|
2004-01-24 11:40:33 +08:00
|
|
|
if (flags & W_OK)
|
|
|
|
{
|
2009-09-25 21:44:45 +08:00
|
|
|
if (st.st_uid == (effective ? myself->uid : cygheap->user.real_uid))
|
2004-01-24 11:40:33 +08:00
|
|
|
{
|
|
|
|
if (!(st.st_mode & S_IWUSR))
|
2004-01-26 07:39:26 +08:00
|
|
|
goto eaccess_done;
|
2004-01-24 11:40:33 +08:00
|
|
|
}
|
2009-09-25 21:44:45 +08:00
|
|
|
else if (st.st_gid == (effective ? myself->gid : cygheap->user.real_gid))
|
2004-01-24 11:40:33 +08:00
|
|
|
{
|
|
|
|
if (!(st.st_mode & S_IWGRP))
|
2004-01-26 07:39:26 +08:00
|
|
|
goto eaccess_done;
|
2004-01-24 11:40:33 +08:00
|
|
|
}
|
|
|
|
else if (!(st.st_mode & S_IWOTH))
|
2004-01-26 07:39:26 +08:00
|
|
|
goto eaccess_done;
|
2004-01-24 11:40:33 +08:00
|
|
|
}
|
2004-01-25 04:34:27 +08:00
|
|
|
|
2004-01-24 11:40:33 +08:00
|
|
|
if (flags & X_OK)
|
|
|
|
{
|
2009-09-25 21:44:45 +08:00
|
|
|
if (st.st_uid == (effective ? myself->uid : cygheap->user.real_uid))
|
2004-01-24 11:40:33 +08:00
|
|
|
{
|
|
|
|
if (!(st.st_mode & S_IXUSR))
|
2004-01-26 07:39:26 +08:00
|
|
|
goto eaccess_done;
|
2004-01-24 11:40:33 +08:00
|
|
|
}
|
2009-09-25 21:44:45 +08:00
|
|
|
else if (st.st_gid == (effective ? myself->gid : cygheap->user.real_gid))
|
2004-01-24 11:40:33 +08:00
|
|
|
{
|
|
|
|
if (!(st.st_mode & S_IXGRP))
|
2004-01-26 07:39:26 +08:00
|
|
|
goto eaccess_done;
|
2004-01-24 11:40:33 +08:00
|
|
|
}
|
|
|
|
else if (!(st.st_mode & S_IXOTH))
|
2004-01-26 07:39:26 +08:00
|
|
|
goto eaccess_done;
|
2004-01-24 11:40:33 +08:00
|
|
|
}
|
2004-01-26 07:39:26 +08:00
|
|
|
|
2004-01-25 04:34:27 +08:00
|
|
|
res = 0;
|
2004-01-26 07:39:26 +08:00
|
|
|
goto done;
|
|
|
|
|
|
|
|
eaccess_done:
|
|
|
|
set_errno (EACCES);
|
2004-01-24 11:40:33 +08:00
|
|
|
done:
|
2007-07-17 22:39:02 +08:00
|
|
|
if (!res && (flags & W_OK) && get_device () == FH_FS
|
|
|
|
&& (pc.fs_flags () & FILE_READ_ONLY_VOLUME))
|
|
|
|
{
|
|
|
|
set_errno (EROFS);
|
|
|
|
res = -1;
|
|
|
|
}
|
2004-01-25 04:34:27 +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
|
|
|
}
|
|
|
|
|
2011-05-06 06:30:53 +08:00
|
|
|
int
|
|
|
|
fhandler_base::open_with_arch (int flags, mode_t mode)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
if (!(res = (archetype && archetype->io_handle)
|
|
|
|
|| open (flags, (mode & 07777) & ~cygheap->umask)))
|
|
|
|
{
|
|
|
|
if (archetype)
|
|
|
|
delete archetype;
|
|
|
|
}
|
|
|
|
else if (archetype)
|
|
|
|
{
|
2011-10-16 06:37:30 +08:00
|
|
|
if (!archetype->get_io_handle ())
|
2011-05-06 06:30:53 +08:00
|
|
|
{
|
2011-10-16 06:37:30 +08:00
|
|
|
copyto (archetype);
|
2011-05-06 06:30:53 +08:00
|
|
|
archetype_usecount (1);
|
|
|
|
archetype->archetype = NULL;
|
2011-10-16 06:37:30 +08:00
|
|
|
usecount = 0;
|
2011-05-06 06:30:53 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-10-20 22:02:54 +08:00
|
|
|
char *name;
|
|
|
|
/* Preserve any name (like /dev/tty) derived from build_fh_pc. */
|
|
|
|
if (!get_name ())
|
|
|
|
name = NULL;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
name = (char *) alloca (strlen (get_name ()) + 1);
|
|
|
|
strcpy (name, get_name ());
|
|
|
|
}
|
2011-05-06 06:30:53 +08:00
|
|
|
fhandler_base *arch = archetype;
|
2011-10-16 06:37:30 +08:00
|
|
|
archetype->copyto (this);
|
2011-10-20 22:02:54 +08:00
|
|
|
if (name)
|
|
|
|
set_name (name);
|
2011-05-06 06:30:53 +08:00
|
|
|
archetype = arch;
|
|
|
|
archetype_usecount (1);
|
|
|
|
usecount = 0;
|
|
|
|
}
|
|
|
|
open_setup (flags);
|
|
|
|
}
|
|
|
|
|
2011-07-04 13:08:28 +08:00
|
|
|
close_on_exec (flags & O_CLOEXEC);
|
2011-05-06 06:30:53 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2004-04-17 05:22:13 +08:00
|
|
|
/* Open system call handler function. */
|
|
|
|
int
|
|
|
|
fhandler_base::open (int flags, mode_t mode)
|
|
|
|
{
|
|
|
|
int res = 0;
|
2008-07-18 20:21:22 +08:00
|
|
|
HANDLE fh;
|
2004-04-17 05:22:13 +08:00
|
|
|
ULONG file_attributes = 0;
|
2007-02-22 19:17:01 +08:00
|
|
|
ULONG shared = (get_major () == DEV_TAPE_MAJOR ? 0 : FILE_SHARE_VALID_FLAGS);
|
2004-04-17 05:22:13 +08:00
|
|
|
ULONG create_disposition;
|
|
|
|
OBJECT_ATTRIBUTES attr;
|
|
|
|
IO_STATUS_BLOCK io;
|
|
|
|
NTSTATUS status;
|
2008-05-20 23:11:23 +08:00
|
|
|
PFILE_FULL_EA_INFORMATION p = NULL;
|
|
|
|
ULONG plen = 0;
|
2004-04-17 05:22:13 +08:00
|
|
|
|
2007-08-13 23:08:25 +08:00
|
|
|
syscall_printf ("(%S, %p)", pc.get_nt_native_path (), flags);
|
2004-04-30 22:02:37 +08:00
|
|
|
|
2010-01-15 02:46:02 +08:00
|
|
|
pc.get_object_attr (attr, *sec_none_cloexec (flags));
|
2004-04-17 05:22:13 +08:00
|
|
|
|
2011-06-17 19:04:44 +08:00
|
|
|
options = FILE_OPEN_FOR_BACKUP_INTENT;
|
2004-04-17 05:22:13 +08:00
|
|
|
switch (query_open ())
|
|
|
|
{
|
|
|
|
case query_read_control:
|
2007-02-27 20:58:56 +08:00
|
|
|
access = READ_CONTROL;
|
|
|
|
break;
|
|
|
|
case query_read_attributes:
|
2006-02-23 00:40:42 +08:00
|
|
|
access = READ_CONTROL | FILE_READ_ATTRIBUTES;
|
2004-05-29 03:50:07 +08:00
|
|
|
break;
|
2004-04-17 05:22:13 +08:00
|
|
|
case query_write_control:
|
2007-03-01 23:13:47 +08:00
|
|
|
access = READ_CONTROL | WRITE_OWNER | WRITE_DAC | FILE_WRITE_ATTRIBUTES;
|
2004-05-29 03:50:07 +08:00
|
|
|
break;
|
2010-09-25 00:22:53 +08:00
|
|
|
case query_write_dac:
|
|
|
|
access = READ_CONTROL | WRITE_DAC | FILE_WRITE_ATTRIBUTES;
|
|
|
|
break;
|
2005-02-20 19:44:32 +08:00
|
|
|
case query_write_attributes:
|
|
|
|
access = READ_CONTROL | FILE_WRITE_ATTRIBUTES;
|
|
|
|
break;
|
2004-04-17 05:22:13 +08:00
|
|
|
default:
|
2005-12-15 00:38:22 +08:00
|
|
|
if ((flags & O_ACCMODE) == O_RDONLY)
|
2009-05-04 17:16:42 +08:00
|
|
|
access = GENERIC_READ;
|
2005-12-15 00:38:22 +08:00
|
|
|
else if ((flags & O_ACCMODE) == O_WRONLY)
|
2009-05-04 17:16:42 +08:00
|
|
|
access = GENERIC_WRITE | READ_CONTROL | FILE_READ_ATTRIBUTES;
|
2004-04-17 05:22:13 +08:00
|
|
|
else
|
2009-05-04 17:16:42 +08:00
|
|
|
access = GENERIC_READ | GENERIC_WRITE;
|
2005-12-14 23:54:33 +08:00
|
|
|
if (flags & O_SYNC)
|
2011-06-17 19:04:44 +08:00
|
|
|
options |= FILE_WRITE_THROUGH;
|
2005-12-14 23:54:33 +08:00
|
|
|
if (flags & O_DIRECT)
|
2011-06-17 19:04:44 +08:00
|
|
|
options |= FILE_NO_INTERMEDIATE_BUFFERING;
|
2004-04-20 19:01:22 +08:00
|
|
|
if (get_major () != DEV_SERIAL_MAJOR && get_major () != DEV_TAPE_MAJOR)
|
2004-04-17 05:22:13 +08:00
|
|
|
{
|
2011-06-17 19:04:44 +08:00
|
|
|
options |= FILE_SYNCHRONOUS_IO_NONALERT;
|
2004-04-17 05:22:13 +08:00
|
|
|
access |= SYNCHRONIZE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-08-25 21:35:43 +08:00
|
|
|
/* Don't use the FILE_OVERWRITE{_IF} flags here. See below for an
|
|
|
|
explanation, why that's not such a good idea. */
|
2004-04-17 05:22:13 +08:00
|
|
|
if ((flags & O_EXCL) && (flags & O_CREAT))
|
|
|
|
create_disposition = FILE_CREATE;
|
2011-08-25 21:35:43 +08:00
|
|
|
else
|
|
|
|
create_disposition = (flags & O_CREAT) ? FILE_OPEN_IF : FILE_OPEN;
|
2004-04-17 05:22:13 +08:00
|
|
|
|
2007-10-18 20:40:27 +08:00
|
|
|
if (get_device () == FH_FS)
|
2004-04-17 05:22:13 +08:00
|
|
|
{
|
2007-10-18 20:40:27 +08:00
|
|
|
/* Add the reparse point flag to native symlinks, otherwise we open the
|
|
|
|
target, not the symlink. This would break lstat. */
|
|
|
|
if (pc.is_rep_symlink ())
|
2011-06-17 19:04:44 +08:00
|
|
|
options |= FILE_OPEN_REPARSE_POINT;
|
2007-10-18 20:40:27 +08:00
|
|
|
|
2011-07-01 19:23:43 +08:00
|
|
|
if (pc.fs_is_nfs ())
|
|
|
|
{
|
|
|
|
/* Make sure we can read EAs of files on an NFS share. Also make
|
|
|
|
sure that we're going to act on the file itself, even if it's a
|
|
|
|
a symlink. */
|
|
|
|
access |= FILE_READ_EA;
|
|
|
|
if (query_open ())
|
|
|
|
{
|
|
|
|
if (query_open () >= query_write_control)
|
|
|
|
access |= FILE_WRITE_EA;
|
|
|
|
plen = sizeof nfs_aol_ffei;
|
|
|
|
p = (PFILE_FULL_EA_INFORMATION) &nfs_aol_ffei;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-26 00:50:29 +08:00
|
|
|
/* Starting with Windows 2000, when trying to overwrite an already
|
|
|
|
existing file with FILE_ATTRIBUTE_HIDDEN and/or FILE_ATTRIBUTE_SYSTEM
|
|
|
|
attribute set, CreateFile fails with ERROR_ACCESS_DENIED.
|
|
|
|
Per MSDN you have to create the file with the same attributes as
|
|
|
|
already specified for the file. */
|
|
|
|
if (((flags & O_CREAT) || create_disposition == FILE_OVERWRITE)
|
|
|
|
&& has_attribute (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM))
|
|
|
|
file_attributes |= pc.file_attributes ();
|
|
|
|
|
|
|
|
if (flags & O_CREAT)
|
2004-04-17 05:22:13 +08:00
|
|
|
{
|
2008-04-26 00:59:41 +08:00
|
|
|
file_attributes |= FILE_ATTRIBUTE_NORMAL;
|
|
|
|
|
2009-10-24 16:26:01 +08:00
|
|
|
if (pc.fs_is_nfs ())
|
2008-05-20 23:11:23 +08:00
|
|
|
{
|
|
|
|
/* When creating a file on an NFS share, we have to set the
|
2008-11-27 01:21:04 +08:00
|
|
|
file mode by writing a NFS fattr3 structure with the
|
2008-05-20 23:11:23 +08:00
|
|
|
correct mode bits set. */
|
|
|
|
access |= FILE_WRITE_EA;
|
|
|
|
plen = sizeof (FILE_FULL_EA_INFORMATION) + sizeof (NFS_V3_ATTR)
|
|
|
|
+ sizeof (fattr3);
|
|
|
|
p = (PFILE_FULL_EA_INFORMATION) alloca (plen);
|
|
|
|
p->NextEntryOffset = 0;
|
|
|
|
p->Flags = 0;
|
|
|
|
p->EaNameLength = sizeof (NFS_V3_ATTR) - 1;
|
|
|
|
p->EaValueLength = sizeof (fattr3);
|
|
|
|
strcpy (p->EaName, NFS_V3_ATTR);
|
|
|
|
fattr3 *nfs_attr = (fattr3 *) (p->EaName
|
2008-11-27 01:21:04 +08:00
|
|
|
+ p->EaNameLength + 1);
|
2008-05-20 23:11:23 +08:00
|
|
|
memset (nfs_attr, 0, sizeof (fattr3));
|
|
|
|
nfs_attr->type = NF3REG;
|
|
|
|
nfs_attr->mode = mode;
|
|
|
|
}
|
2009-10-24 16:26:01 +08:00
|
|
|
else if (!has_acls () && !(mode & (S_IWUSR | S_IWGRP | S_IWOTH)))
|
|
|
|
/* If mode has no write bits set, and ACLs are not used, we set
|
|
|
|
the DOS R/O attribute. */
|
|
|
|
file_attributes |= FILE_ATTRIBUTE_READONLY;
|
2007-10-18 20:40:27 +08:00
|
|
|
/* The file attributes are needed for later use in, e.g. fchmod. */
|
|
|
|
pc.file_attributes (file_attributes);
|
2011-07-05 20:02:10 +08:00
|
|
|
/* Never set the WRITE_DAC flag here. Calls to fstat may return
|
|
|
|
wrong st_ctime information after calls to fchmod, fchown, etc
|
2011-12-04 04:35:36 +08:00
|
|
|
because Windows only guarantees the update of metadata when
|
2011-07-05 20:02:10 +08:00
|
|
|
the handle is closed or flushed. However, flushing the file
|
2011-12-03 22:21:30 +08:00
|
|
|
on every fstat to enforce POSIXy stat behaviour is excessivly
|
|
|
|
slow, compared to an extra open/close to change the file's
|
2011-07-05 20:02:10 +08:00
|
|
|
security descriptor. */
|
2004-04-17 05:22:13 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-18 20:21:22 +08:00
|
|
|
status = NtCreateFile (&fh, access, &attr, &io, NULL, file_attributes, shared,
|
2011-06-17 19:04:44 +08:00
|
|
|
create_disposition, options, p, plen);
|
2004-04-17 05:22:13 +08:00
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
2008-03-06 18:01:33 +08:00
|
|
|
/* Trying to create a directory should return EISDIR, not ENOENT. */
|
2008-03-06 02:31:09 +08:00
|
|
|
PUNICODE_STRING upath = pc.get_nt_native_path ();
|
2008-03-06 18:16:07 +08:00
|
|
|
if (status == STATUS_OBJECT_NAME_INVALID && (flags & O_CREAT)
|
2008-03-06 02:31:09 +08:00
|
|
|
&& upath->Buffer[upath->Length / sizeof (WCHAR) - 1] == '\\')
|
|
|
|
set_errno (EISDIR);
|
|
|
|
else
|
|
|
|
__seterrno_from_nt_status (status);
|
2004-04-17 05:22:13 +08:00
|
|
|
if (!nohandle ())
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2009-10-24 16:26:01 +08:00
|
|
|
/* Always create files using a NULL SD. Create correct permission bits
|
|
|
|
afterwards, maintaining the owner and group information just like chmod.
|
|
|
|
|
|
|
|
This is done for two reasons.
|
2008-08-08 00:20:03 +08:00
|
|
|
|
2009-10-24 16:26:01 +08:00
|
|
|
On Windows filesystems we need to create the file with default
|
|
|
|
permissions to allow inheriting ACEs. When providing an explicit DACL
|
|
|
|
in calls to [Nt]CreateFile, the created file will not inherit default
|
|
|
|
permissions from the parent object. This breaks not only Windows
|
|
|
|
inheritance, but also POSIX ACL inheritance.
|
2008-08-08 00:20:03 +08:00
|
|
|
|
2009-10-24 16:26:01 +08:00
|
|
|
Another reason to do this are remote shares. Files on a remote share
|
|
|
|
are created as the user used for authentication. In a domain that's
|
2008-08-08 00:20:03 +08:00
|
|
|
usually the user you're logged in as. Outside of a domain you're
|
|
|
|
authenticating using a local user account on the sharing machine.
|
|
|
|
If the SIDs of the client machine are used, that's entirely
|
2009-10-24 16:26:01 +08:00
|
|
|
unexpected behaviour. Doing it like we do here creates the expected SD
|
|
|
|
in a domain as well as on standalone servers.
|
|
|
|
This is the result of a discussion on the samba-technical list, starting at
|
|
|
|
http://lists.samba.org/archive/samba-technical/2008-July/060247.html */
|
2009-10-31 03:58:53 +08:00
|
|
|
if (io.Information == FILE_CREATED && has_acls ())
|
|
|
|
set_file_attribute (fh, pc, ILLEGAL_UID, ILLEGAL_GID, S_JUSTCREATED | mode);
|
2008-07-18 20:21:22 +08:00
|
|
|
|
2011-08-25 21:35:43 +08:00
|
|
|
/* If you O_TRUNC a file on Linux, the data is truncated, but the EAs are
|
|
|
|
preserved. If you open a file on Windows with FILE_OVERWRITE{_IF} or
|
|
|
|
FILE_SUPERSEDE, all streams are truncated, including the EAs. So we don't
|
|
|
|
use the FILE_OVERWRITE{_IF} flags, but instead just open the file and set
|
|
|
|
the size of the data stream explicitely to 0. Apart from being more Linux
|
|
|
|
compatible, this implementation has the pleasant side-effect to be more
|
|
|
|
than 5% faster than using FILE_OVERWRITE{_IF} (tested on W7 32 bit). */
|
|
|
|
if ((flags & O_TRUNC)
|
|
|
|
&& (flags & O_ACCMODE) != O_RDONLY
|
|
|
|
&& io.Information != FILE_CREATED
|
|
|
|
&& get_device () == FH_FS)
|
|
|
|
{
|
|
|
|
FILE_END_OF_FILE_INFORMATION feofi = { EndOfFile:{ QuadPart:0 } };
|
|
|
|
status = NtSetInformationFile (fh, &io, &feofi, sizeof feofi,
|
|
|
|
FileEndOfFileInformation);
|
|
|
|
/* In theory, truncating the file should never fail, since the opened
|
2011-08-28 04:01:29 +08:00
|
|
|
handle has FILE_WRITE_DATA permissions, which is all you need to
|
2011-08-25 21:35:43 +08:00
|
|
|
be allowed to truncate a file. Better safe than sorry. */
|
|
|
|
if (!NT_SUCCESS (status))
|
|
|
|
{
|
|
|
|
__seterrno_from_nt_status (status);
|
|
|
|
NtClose (fh);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-18 20:21:22 +08:00
|
|
|
set_io_handle (fh);
|
2004-04-17 05:22:13 +08:00
|
|
|
set_flags (flags, pc.binmode ());
|
|
|
|
|
|
|
|
res = 1;
|
|
|
|
set_open_status ();
|
|
|
|
done:
|
2004-06-17 21:34:26 +08:00
|
|
|
debug_printf ("%x = NtCreateFile "
|
2007-08-13 23:08:25 +08:00
|
|
|
"(%p, %x, %S, io, NULL, %x, %x, %x, %x, NULL, 0)",
|
2008-07-18 20:21:22 +08:00
|
|
|
status, fh, access, pc.get_nt_native_path (), file_attributes,
|
2011-06-17 19:04:44 +08:00
|
|
|
shared, create_disposition, options);
|
2004-06-17 21:34:26 +08:00
|
|
|
|
2011-12-04 05:43:27 +08:00
|
|
|
syscall_printf ("%d = fhandler_base::open(%S, %p)",
|
2007-08-13 23:08:25 +08:00
|
|
|
res, pc.get_nt_native_path (), flags);
|
2004-04-17 05:22:13 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
/* states:
|
|
|
|
open buffer in binary mode? Just do the read.
|
|
|
|
|
|
|
|
open buffer in text mode? Scan buffer for control zs and handle
|
|
|
|
the first one found. Then scan buffer, converting every \r\n into
|
|
|
|
an \n. If last char is an \r, look ahead one more char, if \n then
|
|
|
|
modify \r, if not, remember char.
|
|
|
|
*/
|
2009-07-25 04:54:33 +08:00
|
|
|
void __stdcall
|
2002-12-14 12:01:32 +08:00
|
|
|
fhandler_base::read (void *in_ptr, size_t& len)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
char *ptr = (char *) in_ptr;
|
2006-07-27 11:32:51 +08:00
|
|
|
ssize_t copied_chars = get_readahead_into_buffer (ptr, len);
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2011-05-29 02:17:09 +08:00
|
|
|
if (copied_chars)
|
2002-12-14 12:01:32 +08:00
|
|
|
{
|
|
|
|
len = (size_t) copied_chars;
|
2002-12-15 02:01:08 +08:00
|
|
|
goto out;
|
2002-12-14 12:01:32 +08:00
|
|
|
}
|
2001-11-03 13:42:21 +08:00
|
|
|
|
2006-07-27 11:32:51 +08:00
|
|
|
len -= copied_chars;
|
2002-12-15 02:01:08 +08:00
|
|
|
if (!len)
|
2002-12-14 12:01:32 +08:00
|
|
|
{
|
|
|
|
len = (size_t) copied_chars;
|
2002-12-15 02:01:08 +08:00
|
|
|
goto out;
|
2000-10-08 02:12:11 +08:00
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2005-02-06 13:04:34 +08:00
|
|
|
raw_read (ptr + copied_chars, len);
|
2002-12-15 02:01:08 +08:00
|
|
|
if (!copied_chars)
|
|
|
|
/* nothing */;
|
|
|
|
else if ((ssize_t) len > 0)
|
|
|
|
len += copied_chars;
|
|
|
|
else
|
|
|
|
len = copied_chars;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2009-07-25 04:54:33 +08:00
|
|
|
if (rbinary () || (ssize_t) len <= 0)
|
2002-12-15 02:01:08 +08:00
|
|
|
goto out;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
|
|
|
/* Scan buffer and turn \r\n into \n */
|
2002-12-15 02:01:08 +08:00
|
|
|
char *src, *dst, *end;
|
|
|
|
src = (char *) ptr;
|
|
|
|
dst = (char *) ptr;
|
|
|
|
end = src + len - 1;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
|
|
|
/* Read up to the last but one char - the last char needs special handling */
|
|
|
|
while (src < end)
|
|
|
|
{
|
2002-12-14 12:01:32 +08:00
|
|
|
if (*src == '\r' && src[1] == '\n')
|
|
|
|
src++;
|
|
|
|
*dst++ = *src++;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2002-12-15 02:01:08 +08:00
|
|
|
/* If not beyond end and last char is a '\r' then read one more
|
|
|
|
to see if we should translate this one too */
|
|
|
|
if (src > end)
|
|
|
|
/* nothing */;
|
|
|
|
else if (*src != '\r')
|
|
|
|
*dst++ = *src;
|
|
|
|
else
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2002-12-15 02:01:08 +08:00
|
|
|
char c1;
|
|
|
|
size_t c1len = 1;
|
|
|
|
raw_read (&c1, c1len);
|
|
|
|
if (c1len <= 0)
|
2000-02-18 03:38:33 +08:00
|
|
|
/* nothing */;
|
2002-12-15 02:01:08 +08:00
|
|
|
else if (c1 == '\n')
|
|
|
|
*dst++ = '\n';
|
2000-02-18 03:38:33 +08:00
|
|
|
else
|
2002-12-14 12:01:32 +08:00
|
|
|
{
|
2002-12-15 02:01:08 +08:00
|
|
|
set_readahead_valid (1, c1);
|
|
|
|
*dst++ = *src;
|
2002-12-14 12:01:32 +08:00
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2002-12-15 02:01:08 +08:00
|
|
|
len = dst - (char *) ptr;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
|
|
|
#ifndef NOSTRACE
|
2005-12-30 04:46:34 +08:00
|
|
|
if (strace.active ())
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
char buf[16 * 6 + 1];
|
|
|
|
char *p = buf;
|
|
|
|
|
|
|
|
for (int i = 0; i < copied_chars && i < 16; ++i)
|
|
|
|
{
|
|
|
|
unsigned char c = ((unsigned char *) ptr)[i];
|
2004-12-05 15:28:27 +08:00
|
|
|
__small_sprintf (p, " %c", c);
|
2000-02-18 03:38:33 +08:00
|
|
|
p += strlen (p);
|
|
|
|
}
|
2004-12-05 09:53:47 +08:00
|
|
|
*p = '\0';
|
2000-02-18 03:38:33 +08:00
|
|
|
debug_printf ("read %d bytes (%s%s)", copied_chars, buf,
|
|
|
|
copied_chars > 16 ? " ..." : "");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2002-12-15 02:01:08 +08:00
|
|
|
out:
|
2004-04-10 21:45:10 +08:00
|
|
|
debug_printf ("returning %d, %s mode", len, rbinary () ? "binary" : "text");
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2009-07-25 04:54:33 +08:00
|
|
|
ssize_t __stdcall
|
2000-02-18 03:38:33 +08:00
|
|
|
fhandler_base::write (const void *ptr, size_t len)
|
|
|
|
{
|
|
|
|
int res;
|
2007-10-15 16:25:38 +08:00
|
|
|
IO_STATUS_BLOCK io;
|
|
|
|
FILE_POSITION_INFORMATION fpi;
|
|
|
|
FILE_STANDARD_INFORMATION fsi;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2007-10-15 16:25:38 +08:00
|
|
|
if (did_lseek ())
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2004-04-10 21:45:10 +08:00
|
|
|
did_lseek (false); /* don't do it again */
|
2003-05-26 17:54:01 +08:00
|
|
|
|
2007-10-15 16:25:38 +08:00
|
|
|
if (!(get_flags () & O_APPEND)
|
|
|
|
&& NT_SUCCESS (NtQueryInformationFile (get_output_handle (),
|
|
|
|
&io, &fsi, sizeof fsi,
|
|
|
|
FileStandardInformation))
|
|
|
|
&& NT_SUCCESS (NtQueryInformationFile (get_output_handle (),
|
|
|
|
&io, &fpi, sizeof fpi,
|
|
|
|
FilePositionInformation))
|
|
|
|
&& fpi.CurrentByteOffset.QuadPart
|
|
|
|
>= fsi.EndOfFile.QuadPart + (128 * 1024)
|
2008-04-01 02:03:25 +08:00
|
|
|
&& (pc.fs_flags () & FILE_SUPPORTS_SPARSE_FILES))
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2007-02-23 00:22:38 +08:00
|
|
|
/* If the file system supports sparse files and the application
|
|
|
|
is writing after a long seek beyond EOF, convert the file to
|
|
|
|
a sparse file. */
|
2007-10-15 16:25:38 +08:00
|
|
|
NTSTATUS status;
|
|
|
|
status = NtFsControlFile (get_output_handle (), NULL, NULL, NULL,
|
|
|
|
&io, FSCTL_SET_SPARSE, NULL, 0, NULL, 0);
|
2011-12-17 15:01:21 +08:00
|
|
|
debug_printf ("%p = NtFsControlFile(%S, FSCTL_SET_SPARSE)",
|
|
|
|
status, pc.get_nt_native_path ());
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-04-10 21:45:10 +08:00
|
|
|
if (wbinary ())
|
2011-12-17 15:01:21 +08:00
|
|
|
res = raw_write (ptr, len);
|
2000-02-18 03:38:33 +08:00
|
|
|
else
|
|
|
|
{
|
2000-10-08 02:12:11 +08:00
|
|
|
debug_printf ("text write");
|
2000-02-18 03:38:33 +08:00
|
|
|
/* This is the Microsoft/DJGPP way. Still not ideal, but it's
|
2000-10-08 02:12:11 +08:00
|
|
|
compatible.
|
|
|
|
Modified slightly by CGF 2000-10-07 */
|
2000-02-18 03:38:33 +08:00
|
|
|
|
|
|
|
int left_in_data = len;
|
|
|
|
char *data = (char *)ptr;
|
2000-10-08 02:12:11 +08:00
|
|
|
res = 0;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
|
|
|
while (left_in_data > 0)
|
|
|
|
{
|
2000-10-08 02:12:11 +08:00
|
|
|
char buf[CHUNK_SIZE + 1], *buf_ptr = buf;
|
2000-02-18 03:38:33 +08:00
|
|
|
int left_in_buf = CHUNK_SIZE;
|
|
|
|
|
|
|
|
while (left_in_buf > 0 && left_in_data > 0)
|
|
|
|
{
|
2000-10-08 02:12:11 +08:00
|
|
|
char ch = *data++;
|
|
|
|
if (ch == '\n')
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
*buf_ptr++ = '\r';
|
|
|
|
left_in_buf--;
|
|
|
|
}
|
2000-10-08 02:12:11 +08:00
|
|
|
*buf_ptr++ = ch;
|
2000-02-18 03:38:33 +08:00
|
|
|
left_in_buf--;
|
|
|
|
left_in_data--;
|
2000-10-08 02:12:11 +08:00
|
|
|
if (left_in_data > 0 && ch == '\r' && *data == '\n')
|
|
|
|
{
|
|
|
|
*buf_ptr++ = *data++;
|
|
|
|
left_in_buf--;
|
|
|
|
left_in_data--;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* We've got a buffer-full, or we're out of data. Write it out */
|
2000-10-08 02:12:11 +08:00
|
|
|
int nbytes;
|
2000-02-18 03:38:33 +08:00
|
|
|
int want = buf_ptr - buf;
|
2000-10-08 02:12:11 +08:00
|
|
|
if ((nbytes = raw_write (buf, want)) == want)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2000-10-08 02:12:11 +08:00
|
|
|
/* Keep track of how much written not counting additional \r's */
|
|
|
|
res = data - (char *)ptr;
|
|
|
|
continue;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
2000-10-08 02:12:11 +08:00
|
|
|
if (nbytes == -1)
|
|
|
|
res = -1; /* Error */
|
|
|
|
else
|
|
|
|
res += nbytes; /* Partial write. Return total bytes written. */
|
|
|
|
break; /* All done */
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
2000-10-08 02:12:11 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2009-07-25 04:54:33 +08:00
|
|
|
ssize_t __stdcall
|
2002-08-30 23:47:10 +08:00
|
|
|
fhandler_base::readv (const struct iovec *const iov, const int iovcnt,
|
|
|
|
ssize_t tot)
|
|
|
|
{
|
|
|
|
assert (iov);
|
|
|
|
assert (iovcnt >= 1);
|
|
|
|
|
2003-07-29 05:13:17 +08:00
|
|
|
size_t len = tot;
|
2002-08-30 23:47:10 +08:00
|
|
|
if (iovcnt == 1)
|
2002-12-14 12:01:32 +08:00
|
|
|
{
|
2003-07-29 05:13:17 +08:00
|
|
|
len = iov->iov_len;
|
2002-12-14 12:01:32 +08:00
|
|
|
read (iov->iov_base, len);
|
|
|
|
return len;
|
|
|
|
}
|
2002-08-30 23:47:10 +08:00
|
|
|
|
|
|
|
if (tot == -1) // i.e. if not pre-calculated by the caller.
|
|
|
|
{
|
2003-07-29 05:13:17 +08:00
|
|
|
len = 0;
|
2002-08-30 23:47:10 +08:00
|
|
|
const struct iovec *iovptr = iov + iovcnt;
|
2002-09-19 11:30:20 +08:00
|
|
|
do
|
2002-08-30 23:47:10 +08:00
|
|
|
{
|
|
|
|
iovptr -= 1;
|
2003-07-29 05:13:17 +08:00
|
|
|
len += iovptr->iov_len;
|
2002-08-30 23:47:10 +08:00
|
|
|
}
|
|
|
|
while (iovptr != iov);
|
|
|
|
}
|
|
|
|
|
2003-07-29 05:13:17 +08:00
|
|
|
if (!len)
|
2002-08-30 23:47:10 +08:00
|
|
|
return 0;
|
|
|
|
|
2005-11-09 07:25:55 +08:00
|
|
|
char *buf = (char *) malloc (len);
|
2002-08-30 23:47:10 +08:00
|
|
|
|
|
|
|
if (!buf)
|
|
|
|
{
|
|
|
|
set_errno (ENOMEM);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2003-07-29 05:13:17 +08:00
|
|
|
read (buf, len);
|
|
|
|
ssize_t nbytes = (ssize_t) len;
|
2002-08-30 23:47:10 +08:00
|
|
|
|
|
|
|
const struct iovec *iovptr = iov;
|
|
|
|
|
2005-11-09 07:25:55 +08:00
|
|
|
char *p = buf;
|
2002-08-30 23:47:10 +08:00
|
|
|
while (nbytes > 0)
|
|
|
|
{
|
2012-03-08 17:36:11 +08:00
|
|
|
const int frag = MIN (nbytes, (ssize_t) iovptr->iov_len);
|
2005-11-09 07:25:55 +08:00
|
|
|
memcpy (iovptr->iov_base, p, frag);
|
|
|
|
p += frag;
|
2002-08-30 23:47:10 +08:00
|
|
|
iovptr += 1;
|
|
|
|
nbytes -= frag;
|
|
|
|
}
|
|
|
|
|
2005-07-01 01:00:10 +08:00
|
|
|
free (buf);
|
2003-07-29 05:13:17 +08:00
|
|
|
return len;
|
2002-08-30 23:47:10 +08:00
|
|
|
}
|
|
|
|
|
2009-07-25 04:54:33 +08:00
|
|
|
ssize_t __stdcall
|
2002-08-30 23:47:10 +08:00
|
|
|
fhandler_base::writev (const struct iovec *const iov, const int iovcnt,
|
|
|
|
ssize_t tot)
|
|
|
|
{
|
|
|
|
assert (iov);
|
|
|
|
assert (iovcnt >= 1);
|
|
|
|
|
|
|
|
if (iovcnt == 1)
|
|
|
|
return write (iov->iov_base, iov->iov_len);
|
|
|
|
|
|
|
|
if (tot == -1) // i.e. if not pre-calculated by the caller.
|
|
|
|
{
|
|
|
|
tot = 0;
|
|
|
|
const struct iovec *iovptr = iov + iovcnt;
|
2002-09-19 11:30:20 +08:00
|
|
|
do
|
2002-08-30 23:47:10 +08:00
|
|
|
{
|
|
|
|
iovptr -= 1;
|
|
|
|
tot += iovptr->iov_len;
|
|
|
|
}
|
|
|
|
while (iovptr != iov);
|
|
|
|
}
|
|
|
|
|
|
|
|
assert (tot >= 0);
|
|
|
|
|
|
|
|
if (tot == 0)
|
|
|
|
return 0;
|
|
|
|
|
2005-07-01 01:00:10 +08:00
|
|
|
char *const buf = (char *) malloc (tot);
|
2002-08-30 23:47:10 +08:00
|
|
|
|
|
|
|
if (!buf)
|
|
|
|
{
|
|
|
|
set_errno (ENOMEM);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
char *bufptr = buf;
|
|
|
|
const struct iovec *iovptr = iov;
|
|
|
|
int nbytes = tot;
|
|
|
|
|
|
|
|
while (nbytes != 0)
|
|
|
|
{
|
2012-03-08 17:36:11 +08:00
|
|
|
const int frag = MIN (nbytes, (ssize_t) iovptr->iov_len);
|
2002-08-30 23:47:10 +08:00
|
|
|
memcpy (bufptr, iovptr->iov_base, frag);
|
|
|
|
bufptr += frag;
|
|
|
|
iovptr += 1;
|
|
|
|
nbytes -= frag;
|
|
|
|
}
|
2005-07-01 01:00:10 +08:00
|
|
|
ssize_t ret = write (buf, tot);
|
|
|
|
free (buf);
|
|
|
|
return ret;
|
2002-08-30 23:47:10 +08:00
|
|
|
}
|
|
|
|
|
2003-04-02 00:11:41 +08:00
|
|
|
_off64_t
|
|
|
|
fhandler_base::lseek (_off64_t offset, int whence)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2007-10-15 16:25:38 +08:00
|
|
|
NTSTATUS status;
|
|
|
|
IO_STATUS_BLOCK io;
|
|
|
|
FILE_POSITION_INFORMATION fpi;
|
|
|
|
FILE_STANDARD_INFORMATION fsi;
|
2002-02-26 01:47:51 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
/* Seeks on text files is tough, we rewind and read till we get to the
|
|
|
|
right place. */
|
|
|
|
|
|
|
|
if (whence != SEEK_CUR || offset != 0)
|
|
|
|
{
|
|
|
|
if (whence == SEEK_CUR)
|
|
|
|
offset -= ralen - raixget;
|
|
|
|
set_readahead_valid (0);
|
|
|
|
}
|
|
|
|
|
2007-10-15 16:25:38 +08:00
|
|
|
switch (whence)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2007-10-15 16:25:38 +08:00
|
|
|
case SEEK_SET:
|
|
|
|
fpi.CurrentByteOffset.QuadPart = offset;
|
|
|
|
break;
|
|
|
|
case SEEK_CUR:
|
|
|
|
status = NtQueryInformationFile (get_handle (), &io, &fpi, sizeof fpi,
|
|
|
|
FilePositionInformation);
|
|
|
|
if (!NT_SUCCESS (status))
|
2008-02-16 01:53:11 +08:00
|
|
|
{
|
2007-10-15 16:25:38 +08:00
|
|
|
__seterrno_from_nt_status (status);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
fpi.CurrentByteOffset.QuadPart += offset;
|
|
|
|
break;
|
|
|
|
default: /* SEEK_END */
|
|
|
|
status = NtQueryInformationFile (get_handle (), &io, &fsi, sizeof fsi,
|
|
|
|
FileStandardInformation);
|
|
|
|
if (!NT_SUCCESS (status))
|
2008-02-16 01:53:11 +08:00
|
|
|
{
|
2007-10-15 16:25:38 +08:00
|
|
|
__seterrno_from_nt_status (status);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
fpi.CurrentByteOffset.QuadPart = fsi.EndOfFile.QuadPart + offset;
|
|
|
|
break;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
2007-10-15 16:25:38 +08:00
|
|
|
|
|
|
|
debug_printf ("setting file pointer to %U", fpi.CurrentByteOffset.QuadPart);
|
|
|
|
status = NtSetInformationFile (get_handle (), &io, &fpi, sizeof fpi,
|
|
|
|
FilePositionInformation);
|
|
|
|
if (!NT_SUCCESS (status))
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2007-10-15 16:25:38 +08:00
|
|
|
__seterrno_from_nt_status (status);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
_off64_t res = fpi.CurrentByteOffset.QuadPart;
|
2003-11-18 06:18:42 +08:00
|
|
|
|
2007-10-15 16:25:38 +08:00
|
|
|
/* When next we write(), we will check to see if *this* seek went beyond
|
|
|
|
the end of the file and if so, potentially sparsify the file. */
|
|
|
|
did_lseek (true);
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2007-10-15 16:25:38 +08:00
|
|
|
/* If this was a SEEK_CUR with offset 0, we still might have
|
|
|
|
readahead that we have to take into account when calculating
|
|
|
|
the actual position for the application. */
|
|
|
|
if (whence == SEEK_CUR)
|
|
|
|
res -= ralen - raixget;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2005-07-30 01:04:46 +08:00
|
|
|
ssize_t __stdcall
|
|
|
|
fhandler_base::pread (void *, size_t, _off64_t)
|
|
|
|
{
|
|
|
|
set_errno (ESPIPE);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ssize_t __stdcall
|
|
|
|
fhandler_base::pwrite (void *, size_t, _off64_t)
|
|
|
|
{
|
|
|
|
set_errno (ESPIPE);
|
|
|
|
return -1;
|
|
|
|
}
|
2011-05-06 06:30:53 +08:00
|
|
|
|
|
|
|
int
|
|
|
|
fhandler_base::close_with_arch ()
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
fhandler_base *fh;
|
|
|
|
if (usecount)
|
|
|
|
{
|
|
|
|
if (!--usecount)
|
|
|
|
debug_printf ("closing passed in archetype, usecount %d", usecount);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
debug_printf ("not closing passed in archetype, usecount %d", usecount);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
fh = this;
|
|
|
|
}
|
|
|
|
else if (!archetype)
|
|
|
|
fh = this;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
cleanup ();
|
|
|
|
if (archetype_usecount (-1) == 0)
|
|
|
|
{
|
|
|
|
debug_printf ("closing archetype");
|
|
|
|
fh = archetype;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
debug_printf ("not closing archetype");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
res = fh->close ();
|
|
|
|
if (archetype)
|
|
|
|
{
|
|
|
|
cygheap->fdtab.delete_archetype (archetype);
|
|
|
|
archetype = NULL;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
2005-07-30 01:04:46 +08:00
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
int
|
2001-09-01 13:17:34 +08:00
|
|
|
fhandler_base::close ()
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
int res = -1;
|
|
|
|
|
2002-09-22 11:38:57 +08:00
|
|
|
syscall_printf ("closing '%s' handle %p", get_name (), get_handle ());
|
2004-04-10 21:45:10 +08:00
|
|
|
if (nohandle () || CloseHandle (get_handle ()))
|
2000-02-18 03:38:33 +08:00
|
|
|
res = 0;
|
|
|
|
else
|
|
|
|
{
|
2011-12-17 08:03:31 +08:00
|
|
|
paranoid_printf ("CloseHandle failed, %E");
|
2000-02-18 03:38:33 +08:00
|
|
|
__seterrno ();
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2011-11-29 23:34:49 +08:00
|
|
|
DWORD WINAPI
|
|
|
|
flush_async_io (void *arg)
|
|
|
|
{
|
|
|
|
fhandler_base_overlapped *fh = (fhandler_base_overlapped *) arg;
|
2012-02-01 07:52:52 +08:00
|
|
|
debug_only_printf ("waiting for write I/O for %s", fh->get_name ());
|
|
|
|
DWORD nbytes;
|
|
|
|
bool res = GetOverlappedResult (fh->get_output_handle (),
|
|
|
|
fh->get_overlapped (), &nbytes, true);
|
2011-11-29 23:34:49 +08:00
|
|
|
debug_printf ("finished waiting for I/O from %s, res %d", fh->get_name (),
|
|
|
|
res);
|
|
|
|
fh->close ();
|
|
|
|
delete fh;
|
|
|
|
|
|
|
|
InterlockedDecrement (&fhandler_base_overlapped::asio_close_counter);
|
|
|
|
SetEvent (fhandler_base_overlapped::asio_done);
|
|
|
|
|
|
|
|
_my_tls._ctinfo->auto_release ();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
fhandler_base_overlapped::flush_all_async_io ()
|
|
|
|
{
|
|
|
|
while (asio_close_counter > 0)
|
|
|
|
if (WaitForSingleObject (asio_done, INFINITE) != WAIT_OBJECT_0)
|
|
|
|
{
|
|
|
|
system_printf ("WaitForSingleObject failed, possible data loss in pipe, %E");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
asio_close_counter = 0;
|
|
|
|
if (asio_done)
|
|
|
|
CloseHandle (asio_done);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Start a thread to handle closing of overlapped asynchronous I/O since
|
|
|
|
Windows amazingly does not seem to always flush I/O on close. */
|
|
|
|
void
|
|
|
|
fhandler_base_overlapped::check_later ()
|
|
|
|
{
|
|
|
|
set_close_on_exec (true);
|
|
|
|
char buf[MAX_PATH];
|
|
|
|
if (!asio_done
|
|
|
|
&& !(asio_done = CreateEvent (&sec_none_nih, false, false,
|
|
|
|
shared_name (buf, "asio",
|
|
|
|
GetCurrentProcessId ()))))
|
|
|
|
api_fatal ("CreateEvent failed, %E");
|
|
|
|
|
|
|
|
InterlockedIncrement (&asio_close_counter);
|
|
|
|
if (!new cygthread(flush_async_io, this, "flasio"))
|
|
|
|
api_fatal ("couldn't create a thread to track async I/O, %E");
|
|
|
|
debug_printf ("started thread to handle asynchronous closing for %s", get_name ());
|
|
|
|
}
|
2010-04-03 02:55:02 +08:00
|
|
|
|
|
|
|
int
|
|
|
|
fhandler_base_overlapped::close ()
|
|
|
|
{
|
2011-11-29 23:34:49 +08:00
|
|
|
int res;
|
2012-02-01 07:52:52 +08:00
|
|
|
int writer = (get_access () & GENERIC_WRITE);
|
2011-11-29 23:34:49 +08:00
|
|
|
/* Need to treat non-blocking I/O specially because Windows appears to
|
|
|
|
be brain-dead */
|
2012-02-01 07:52:52 +08:00
|
|
|
if (writer && is_nonblocking () && has_ongoing_io ())
|
2011-02-21 11:18:30 +08:00
|
|
|
{
|
2011-11-29 23:34:49 +08:00
|
|
|
clone (HEAP_3_FHANDLER)->check_later ();
|
|
|
|
res = 0;
|
2011-02-21 11:18:30 +08:00
|
|
|
}
|
2011-11-29 23:34:49 +08:00
|
|
|
else
|
|
|
|
{
|
2011-12-18 12:07:47 +08:00
|
|
|
/* Cancelling seems to be necessary for cases where a reader is
|
|
|
|
still executing when a signal handler performs a close. */
|
2012-02-01 07:52:52 +08:00
|
|
|
if (!writer)
|
|
|
|
CancelIo (get_io_handle ());
|
2011-11-29 23:34:49 +08:00
|
|
|
destroy_overlapped ();
|
|
|
|
res = fhandler_base::close ();
|
|
|
|
}
|
|
|
|
return res;
|
2010-04-03 02:55:02 +08:00
|
|
|
}
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
int
|
|
|
|
fhandler_base::ioctl (unsigned int cmd, void *buf)
|
|
|
|
{
|
2003-10-25 20:32:56 +08:00
|
|
|
int res;
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2003-10-25 20:32:56 +08:00
|
|
|
switch (cmd)
|
|
|
|
{
|
|
|
|
case FIONBIO:
|
|
|
|
set_nonblocking (*(int *) buf);
|
|
|
|
res = 0;
|
|
|
|
break;
|
2011-07-22 04:21:46 +08:00
|
|
|
case FIONREAD:
|
2011-10-12 07:20:38 +08:00
|
|
|
case TIOCSCTTY:
|
2011-07-22 04:21:46 +08:00
|
|
|
set_errno (ENOTTY);
|
|
|
|
res = -1;
|
|
|
|
break;
|
2003-10-25 20:32:56 +08:00
|
|
|
default:
|
|
|
|
set_errno (EINVAL);
|
|
|
|
res = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-12-04 05:43:27 +08:00
|
|
|
syscall_printf ("%d = ioctl(%x, %p)", res, cmd, buf);
|
2003-10-25 20:32:56 +08:00
|
|
|
return res;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2003-12-02 01:26:28 +08:00
|
|
|
fhandler_base::lock (int, struct __flock64 *)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2002-09-19 11:30:20 +08:00
|
|
|
set_errno (EINVAL);
|
2000-02-18 03:38:33 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2001-10-05 12:21:41 +08:00
|
|
|
int __stdcall
|
* 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
|
|
|
fhandler_base::fstat (struct __stat64 *buf)
|
2001-10-05 12:21:41 +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
|
|
|
if (is_fs_special ())
|
|
|
|
return fstat_fs (buf);
|
|
|
|
|
2001-10-05 12:21:41 +08:00
|
|
|
switch (get_device ())
|
|
|
|
{
|
2002-06-24 10:23:14 +08:00
|
|
|
case FH_PIPE:
|
2007-06-12 16:28:44 +08:00
|
|
|
buf->st_mode = S_IFIFO | S_IRUSR | S_IWUSR;
|
2002-06-24 10:23:14 +08:00
|
|
|
break;
|
2001-10-05 12:21:41 +08:00
|
|
|
case FH_PIPEW:
|
2007-06-12 16:28:44 +08:00
|
|
|
buf->st_mode = S_IFIFO | S_IWUSR;
|
2001-10-05 12:21:41 +08:00
|
|
|
break;
|
|
|
|
case FH_PIPER:
|
2007-06-12 16:28:44 +08:00
|
|
|
buf->st_mode = S_IFIFO | S_IRUSR;
|
2002-06-24 10:23:14 +08:00
|
|
|
break;
|
2005-02-23 20:30:31 +08:00
|
|
|
case FH_FULL:
|
|
|
|
buf->st_mode = S_IFCHR | S_IRUSR | S_IWUSR | S_IWGRP | S_IWOTH;
|
|
|
|
break;
|
2001-10-05 12:21:41 +08:00
|
|
|
default:
|
2002-06-24 10:23:14 +08:00
|
|
|
buf->st_mode = S_IFCHR | STD_RBITS | STD_WBITS | S_IWGRP | S_IWOTH;
|
2001-10-05 12:21:41 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2003-04-02 01:17:46 +08:00
|
|
|
buf->st_uid = geteuid32 ();
|
|
|
|
buf->st_gid = getegid32 ();
|
2001-10-05 12:21:41 +08:00
|
|
|
buf->st_nlink = 1;
|
2007-01-04 17:17:55 +08:00
|
|
|
buf->st_blksize = PREFERRED_IO_BLKSIZE;
|
2010-03-29 23:02:50 +08:00
|
|
|
|
|
|
|
buf->st_ctim.tv_sec = 1164931200L; /* Arbitrary value: 2006-12-01 */
|
2007-02-26 22:19:00 +08:00
|
|
|
buf->st_ctim.tv_nsec = 0L;
|
2010-03-29 23:02:50 +08:00
|
|
|
buf->st_birthtim = buf->st_ctim;
|
|
|
|
buf->st_mtim.tv_sec = time (NULL); /* Arbitrary value: current time,
|
|
|
|
like Linux */
|
|
|
|
buf->st_mtim.tv_nsec = 0L;
|
|
|
|
buf->st_atim = buf->st_mtim;
|
|
|
|
|
2001-10-05 12:21:41 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-02-27 20:58:56 +08:00
|
|
|
int __stdcall
|
|
|
|
fhandler_base::fstatvfs (struct statvfs *sfs)
|
|
|
|
{
|
|
|
|
/* If we hit this base implementation, it's some device in /dev.
|
|
|
|
Just call statvfs on /dev for simplicity. */
|
2010-06-15 20:05:15 +08:00
|
|
|
path_conv pc ("/dev", PC_KEEP_HANDLE);
|
2007-02-27 20:58:56 +08:00
|
|
|
fhandler_disk_file fh (pc);
|
|
|
|
return fh.fstatvfs (sfs);
|
|
|
|
}
|
|
|
|
|
2009-07-04 02:05:51 +08:00
|
|
|
int
|
2000-02-18 03:38:33 +08:00
|
|
|
fhandler_base::init (HANDLE f, DWORD a, mode_t bin)
|
|
|
|
{
|
|
|
|
set_io_handle (f);
|
2001-04-24 10:07:58 +08:00
|
|
|
access = a;
|
2000-02-18 03:38:33 +08:00
|
|
|
a &= GENERIC_READ | GENERIC_WRITE;
|
2002-06-05 09:42:28 +08:00
|
|
|
int flags = 0;
|
2000-02-18 03:38:33 +08:00
|
|
|
if (a == GENERIC_READ)
|
2002-06-05 09:42:28 +08:00
|
|
|
flags = O_RDONLY;
|
2002-06-01 04:48:14 +08:00
|
|
|
else if (a == GENERIC_WRITE)
|
2002-06-05 09:42:28 +08:00
|
|
|
flags = O_WRONLY;
|
2002-06-01 04:48:14 +08:00
|
|
|
else if (a == (GENERIC_READ | GENERIC_WRITE))
|
2002-06-05 09:42:28 +08:00
|
|
|
flags = O_RDWR;
|
2002-07-04 02:02:54 +08:00
|
|
|
set_flags (flags | bin);
|
2001-04-24 10:07:58 +08:00
|
|
|
set_open_status ();
|
2004-04-10 21:45:10 +08:00
|
|
|
debug_printf ("created new fhandler_base for handle %p, bin %d", f, rbinary ());
|
2009-07-04 02:05:51 +08:00
|
|
|
return 1;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-10-16 06:37:30 +08:00
|
|
|
fhandler_base::dup (fhandler_base *child, int)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
debug_printf ("in fhandler_base dup");
|
|
|
|
|
|
|
|
HANDLE nh;
|
2011-05-07 04:12:20 +08:00
|
|
|
if (!nohandle () && !archetype)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2009-12-19 04:32:04 +08:00
|
|
|
if (!DuplicateHandle (GetCurrentProcess (), get_handle (),
|
|
|
|
GetCurrentProcess (), &nh,
|
|
|
|
0, TRUE, DUPLICATE_SAME_ACCESS))
|
2002-09-22 11:38:57 +08:00
|
|
|
{
|
2004-09-10 16:34:37 +08:00
|
|
|
debug_printf ("dup(%s) failed, handle %x, %E",
|
|
|
|
get_name (), get_handle ());
|
2002-09-22 11:38:57 +08:00
|
|
|
__seterrno ();
|
|
|
|
return -1;
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
|
2004-01-24 07:05:33 +08:00
|
|
|
VerifyHandle (nh);
|
2002-09-22 11:38:57 +08:00
|
|
|
child->set_io_handle (nh);
|
|
|
|
}
|
2000-02-18 03:38:33 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-03 02:55:02 +08:00
|
|
|
int
|
2011-10-16 06:37:30 +08:00
|
|
|
fhandler_base_overlapped::dup (fhandler_base *child, int flags)
|
2010-04-03 02:55:02 +08:00
|
|
|
{
|
2011-10-16 06:37:30 +08:00
|
|
|
int res = fhandler_base::dup (child, flags) ||
|
2010-04-03 02:55:02 +08:00
|
|
|
((fhandler_base_overlapped *) child)->setup_overlapped ();
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2000-10-24 04:16:52 +08:00
|
|
|
int fhandler_base::fcntl (int cmd, void *arg)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
|
|
|
|
switch (cmd)
|
|
|
|
{
|
|
|
|
case F_GETFD:
|
2004-04-10 21:45:10 +08:00
|
|
|
res = close_on_exec () ? FD_CLOEXEC : 0;
|
2000-10-24 04:16:52 +08:00
|
|
|
break;
|
|
|
|
case F_SETFD:
|
2004-04-10 21:45:10 +08:00
|
|
|
set_close_on_exec (((int) arg & FD_CLOEXEC) ? 1 : 0);
|
2000-10-24 04:16:52 +08:00
|
|
|
res = 0;
|
|
|
|
break;
|
|
|
|
case F_GETFL:
|
|
|
|
res = get_flags ();
|
2006-03-23 00:42:45 +08:00
|
|
|
debug_printf ("GETFL: %p", res);
|
2000-10-24 04:16:52 +08:00
|
|
|
break;
|
|
|
|
case F_SETFL:
|
2000-10-24 04:29:31 +08:00
|
|
|
{
|
2009-06-15 07:42:09 +08:00
|
|
|
/* Only O_APPEND, O_ASYNC and O_NONBLOCK/O_NDELAY are allowed.
|
|
|
|
Each other flag will be ignored.
|
|
|
|
Since O_ASYNC isn't defined in fcntl.h it's currently
|
|
|
|
ignored as well. */
|
2001-09-08 05:32:07 +08:00
|
|
|
const int allowed_flags = O_APPEND | O_NONBLOCK_MASK;
|
2001-08-07 08:01:42 +08:00
|
|
|
int new_flags = (int) arg & allowed_flags;
|
2001-09-08 05:32:07 +08:00
|
|
|
/* Carefully test for the O_NONBLOCK or deprecated OLD_O_NDELAY flag.
|
2001-08-07 08:01:42 +08:00
|
|
|
Set only the flag that has been passed in. If both are set, just
|
|
|
|
record O_NONBLOCK. */
|
|
|
|
if ((new_flags & OLD_O_NDELAY) && (new_flags & O_NONBLOCK))
|
2003-10-24 20:11:20 +08:00
|
|
|
new_flags &= ~OLD_O_NDELAY;
|
2001-08-07 08:01:42 +08:00
|
|
|
set_flags ((get_flags () & ~allowed_flags) | new_flags);
|
2000-10-24 04:29:31 +08:00
|
|
|
}
|
2000-10-24 04:16:52 +08:00
|
|
|
res = 0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
set_errno (EINVAL);
|
|
|
|
res = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
/* Base terminal handlers. These just return errors. */
|
|
|
|
|
|
|
|
int
|
2000-02-21 13:20:38 +08:00
|
|
|
fhandler_base::tcflush (int)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
set_errno (ENOTTY);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2000-02-21 13:20:38 +08:00
|
|
|
fhandler_base::tcsendbreak (int)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
set_errno (ENOTTY);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2005-07-05 11:16:46 +08:00
|
|
|
fhandler_base::tcdrain ()
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
set_errno (ENOTTY);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2000-02-21 13:20:38 +08:00
|
|
|
fhandler_base::tcflow (int)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
set_errno (ENOTTY);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2000-02-21 13:20:38 +08:00
|
|
|
fhandler_base::tcsetattr (int, const struct termios *)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
set_errno (ENOTTY);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2000-02-21 13:20:38 +08:00
|
|
|
fhandler_base::tcgetattr (struct termios *)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
set_errno (ENOTTY);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2000-02-21 13:20:38 +08:00
|
|
|
fhandler_base::tcsetpgrp (const pid_t)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
set_errno (ENOTTY);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2005-07-05 11:16:46 +08:00
|
|
|
fhandler_base::tcgetpgrp ()
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
set_errno (ENOTTY);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-02-28 22:03:03 +08:00
|
|
|
pid_t
|
2011-10-12 07:20:38 +08:00
|
|
|
fhandler_base::tcgetsid ()
|
|
|
|
{
|
|
|
|
set_errno (ENOTTY);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-11-08 04:05:49 +08:00
|
|
|
int
|
|
|
|
fhandler_base::ptsname_r (char *, size_t)
|
|
|
|
{
|
|
|
|
set_errno (ENOTTY);
|
|
|
|
return ENOTTY;
|
|
|
|
}
|
|
|
|
|
2000-02-18 03:38:33 +08:00
|
|
|
/* Normal I/O constructor */
|
2004-04-09 16:43:29 +08:00
|
|
|
fhandler_base::fhandler_base () :
|
|
|
|
status (),
|
|
|
|
open_status (),
|
2001-04-24 10:07:58 +08:00
|
|
|
access (0),
|
2000-02-18 03:38:33 +08:00
|
|
|
io_handle (NULL),
|
2008-04-01 02:03:25 +08:00
|
|
|
ino (0),
|
2011-12-17 08:03:31 +08:00
|
|
|
_refcnt (0),
|
2001-04-24 10:07:58 +08:00
|
|
|
openflags (0),
|
2000-02-18 03:38:33 +08:00
|
|
|
rabuf (NULL),
|
|
|
|
ralen (0),
|
|
|
|
raixget (0),
|
|
|
|
raixput (0),
|
2001-04-24 10:07:58 +08:00
|
|
|
rabuflen (0),
|
2008-04-01 02:03:25 +08:00
|
|
|
unique_id (0),
|
2003-12-11 14:12:41 +08:00
|
|
|
archetype (NULL),
|
|
|
|
usecount (0)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2011-12-17 08:03:31 +08:00
|
|
|
isclosed (false);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Normal I/O destructor */
|
2005-07-05 11:16:46 +08:00
|
|
|
fhandler_base::~fhandler_base ()
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2000-09-03 12:16:35 +08:00
|
|
|
if (rabuf)
|
|
|
|
free (rabuf);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************************/
|
|
|
|
/* /dev/null */
|
|
|
|
|
2001-10-14 01:23:35 +08:00
|
|
|
fhandler_dev_null::fhandler_dev_null () :
|
* 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
|
|
|
fhandler_base ()
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2000-04-20 12:38:10 +08:00
|
|
|
void
|
2006-12-12 02:55:29 +08:00
|
|
|
fhandler_base::set_no_inheritance (HANDLE &h, bool not_inheriting)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2007-02-23 01:09:46 +08:00
|
|
|
if (!SetHandleInformation (h, HANDLE_FLAG_INHERIT,
|
|
|
|
not_inheriting ? 0 : HANDLE_FLAG_INHERIT))
|
|
|
|
debug_printf ("SetHandleInformation failed, %E");
|
2002-07-15 03:15:32 +08:00
|
|
|
#ifdef DEBUGGING_AND_FDS_PROTECTED
|
2001-10-24 12:16:45 +08:00
|
|
|
if (h)
|
2002-07-14 04:00:27 +08:00
|
|
|
setclexec (oh, h, not_inheriting);
|
2000-02-18 03:38:33 +08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2006-05-25 13:40:51 +08:00
|
|
|
bool
|
2000-02-18 03:38:33 +08:00
|
|
|
fhandler_base::fork_fixup (HANDLE parent, HANDLE &h, const char *name)
|
|
|
|
{
|
2004-01-24 07:05:33 +08:00
|
|
|
HANDLE oh = h;
|
2006-05-25 13:40:51 +08:00
|
|
|
bool res = false;
|
2004-04-10 21:45:10 +08:00
|
|
|
if (/* !is_socket () && */ !close_on_exec ())
|
2001-07-21 11:20:01 +08:00
|
|
|
debug_printf ("handle %p already opened", h);
|
2009-12-19 04:32:04 +08:00
|
|
|
else if (!DuplicateHandle (parent, h, GetCurrentProcess (), &h,
|
|
|
|
0, !close_on_exec (), DUPLICATE_SAME_ACCESS))
|
2000-02-18 03:38:33 +08:00
|
|
|
system_printf ("%s - %E, handle %s<%p>", get_name (), name, h);
|
2006-05-25 13:40:51 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (oh != h)
|
|
|
|
VerifyHandle (h);
|
|
|
|
res = true;
|
|
|
|
}
|
|
|
|
return res;
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2004-04-10 21:45:10 +08:00
|
|
|
fhandler_base::set_close_on_exec (bool val)
|
2000-02-18 03:38:33 +08:00
|
|
|
{
|
2004-04-10 21:45:10 +08:00
|
|
|
if (!nohandle ())
|
2004-02-03 04:33:09 +08:00
|
|
|
set_no_inheritance (io_handle, val);
|
2004-04-10 21:45:10 +08:00
|
|
|
close_on_exec (val);
|
2000-02-18 03:38:33 +08:00
|
|
|
debug_printf ("set close_on_exec for %s to %d", get_name (), val);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
fhandler_base::fixup_after_fork (HANDLE parent)
|
|
|
|
{
|
|
|
|
debug_printf ("inheriting '%s' from parent", get_name ());
|
2004-04-10 21:45:10 +08:00
|
|
|
if (!nohandle ())
|
2002-09-19 11:30:20 +08:00
|
|
|
fork_fixup (parent, io_handle, "io_handle");
|
2008-04-01 02:03:25 +08:00
|
|
|
/* POSIX locks are not inherited across fork. */
|
|
|
|
if (unique_id)
|
2009-07-22 23:46:36 +08:00
|
|
|
del_my_locks (after_fork);
|
2000-02-18 03:38:33 +08:00
|
|
|
}
|
2001-08-15 15:49:15 +08:00
|
|
|
|
2010-04-03 02:55:02 +08:00
|
|
|
void
|
|
|
|
fhandler_base_overlapped::fixup_after_fork (HANDLE parent)
|
|
|
|
{
|
|
|
|
setup_overlapped ();
|
|
|
|
fhandler_base::fixup_after_fork (parent);
|
|
|
|
}
|
|
|
|
|
2006-06-02 23:41:34 +08:00
|
|
|
void
|
|
|
|
fhandler_base::fixup_after_exec ()
|
|
|
|
{
|
|
|
|
debug_printf ("here for '%s'", get_name ());
|
2008-04-01 02:03:25 +08:00
|
|
|
if (unique_id && close_on_exec ())
|
2009-07-22 23:46:36 +08:00
|
|
|
del_my_locks (after_exec);
|
2006-06-02 23:41:34 +08:00
|
|
|
}
|
2010-04-03 02:55:02 +08:00
|
|
|
void
|
|
|
|
fhandler_base_overlapped::fixup_after_exec ()
|
|
|
|
{
|
|
|
|
setup_overlapped ();
|
|
|
|
fhandler_base::fixup_after_exec ();
|
|
|
|
}
|
2006-06-02 23:41:34 +08:00
|
|
|
|
2001-11-24 11:11:39 +08:00
|
|
|
bool
|
2001-08-15 15:49:15 +08:00
|
|
|
fhandler_base::is_nonblocking ()
|
|
|
|
{
|
|
|
|
return (openflags & O_NONBLOCK_MASK) != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
fhandler_base::set_nonblocking (int yes)
|
|
|
|
{
|
|
|
|
int current = openflags & O_NONBLOCK_MASK;
|
|
|
|
int new_flags = yes ? (!current ? O_NONBLOCK : current) : 0;
|
|
|
|
openflags = (openflags & ~O_NONBLOCK_MASK) | new_flags;
|
|
|
|
}
|
2001-11-21 14:47:57 +08:00
|
|
|
|
2005-05-25 12:32:59 +08:00
|
|
|
int
|
|
|
|
fhandler_base::mkdir (mode_t)
|
|
|
|
{
|
|
|
|
if (exists ())
|
|
|
|
set_errno (EEXIST);
|
|
|
|
else
|
|
|
|
set_errno (EROFS);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fhandler_base::rmdir ()
|
|
|
|
{
|
|
|
|
if (!exists ())
|
|
|
|
set_errno (ENOENT);
|
|
|
|
else if (!pc.isdir ())
|
|
|
|
set_errno (ENOTDIR);
|
|
|
|
else
|
|
|
|
set_errno (EROFS);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2001-11-21 14:47:57 +08:00
|
|
|
DIR *
|
2007-06-29 23:13:01 +08:00
|
|
|
fhandler_base::opendir (int fd)
|
2001-11-21 14:47:57 +08:00
|
|
|
{
|
|
|
|
set_errno (ENOTDIR);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-08-20 14:19:55 +08:00
|
|
|
int
|
|
|
|
fhandler_base::readdir (DIR *, dirent *)
|
2001-11-21 14:47:57 +08:00
|
|
|
{
|
2005-08-20 14:19:55 +08:00
|
|
|
return ENOTDIR;
|
2001-11-21 14:47:57 +08:00
|
|
|
}
|
|
|
|
|
2010-07-06 00:59:56 +08:00
|
|
|
long
|
2001-11-21 14:47:57 +08:00
|
|
|
fhandler_base::telldir (DIR *)
|
|
|
|
{
|
|
|
|
set_errno (ENOTDIR);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-07-06 00:59:56 +08:00
|
|
|
fhandler_base::seekdir (DIR *, long)
|
2001-11-21 14:47:57 +08:00
|
|
|
{
|
|
|
|
set_errno (ENOTDIR);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
fhandler_base::rewinddir (DIR *)
|
|
|
|
{
|
|
|
|
set_errno (ENOTDIR);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fhandler_base::closedir (DIR *)
|
|
|
|
{
|
|
|
|
set_errno (ENOTDIR);
|
|
|
|
return -1;
|
|
|
|
}
|
2004-04-14 04:36:58 +08:00
|
|
|
|
|
|
|
int
|
|
|
|
fhandler_base::fchmod (mode_t mode)
|
|
|
|
{
|
2004-12-26 10:10:30 +08:00
|
|
|
extern int chmod_device (path_conv& pc, mode_t mode);
|
|
|
|
if (pc.is_fs_special ())
|
|
|
|
return chmod_device (pc, mode);
|
2004-04-14 04:36:58 +08:00
|
|
|
/* By default, just succeeds. */
|
|
|
|
return 0;
|
|
|
|
}
|
2004-04-14 21:40:07 +08:00
|
|
|
|
|
|
|
int
|
|
|
|
fhandler_base::fchown (__uid32_t uid, __gid32_t gid)
|
|
|
|
{
|
2004-12-26 10:10:30 +08:00
|
|
|
if (pc.is_fs_special ())
|
|
|
|
return ((fhandler_disk_file *) this)->fhandler_disk_file::fchown (uid, gid);
|
2004-04-14 21:40:07 +08:00
|
|
|
/* By default, just succeeds. */
|
|
|
|
return 0;
|
|
|
|
}
|
2004-04-15 00:36:26 +08:00
|
|
|
|
|
|
|
int
|
|
|
|
fhandler_base::facl (int cmd, int nentries, __aclent32_t *aclbufp)
|
|
|
|
{
|
2005-01-15 06:03:40 +08:00
|
|
|
int res = -1;
|
|
|
|
switch (cmd)
|
|
|
|
{
|
|
|
|
case SETACL:
|
|
|
|
/* By default, just succeeds. */
|
|
|
|
res = 0;
|
|
|
|
break;
|
|
|
|
case GETACL:
|
|
|
|
if (!aclbufp)
|
|
|
|
set_errno(EFAULT);
|
|
|
|
else if (nentries < MIN_ACL_ENTRIES)
|
|
|
|
set_errno (ENOSPC);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
aclbufp[0].a_type = USER_OBJ;
|
|
|
|
aclbufp[0].a_id = myself->uid;
|
|
|
|
aclbufp[0].a_perm = (S_IRUSR | S_IWUSR) >> 6;
|
|
|
|
aclbufp[1].a_type = GROUP_OBJ;
|
|
|
|
aclbufp[1].a_id = myself->gid;
|
|
|
|
aclbufp[1].a_perm = (S_IRGRP | S_IWGRP) >> 3;
|
|
|
|
aclbufp[2].a_type = OTHER_OBJ;
|
|
|
|
aclbufp[2].a_id = ILLEGAL_GID;
|
|
|
|
aclbufp[2].a_perm = S_IROTH | S_IWOTH;
|
|
|
|
aclbufp[3].a_type = CLASS_OBJ;
|
|
|
|
aclbufp[3].a_id = ILLEGAL_GID;
|
|
|
|
aclbufp[3].a_perm = S_IRWXU | S_IRWXG | S_IRWXO;
|
|
|
|
res = MIN_ACL_ENTRIES;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case GETACLCNT:
|
|
|
|
res = MIN_ACL_ENTRIES;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
set_errno (EINVAL);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return res;
|
2004-04-15 00:36:26 +08:00
|
|
|
}
|
2005-02-03 06:42:06 +08:00
|
|
|
|
* Makefile.in (DLL_OFILES): Add ntea.o.
* cygwin.din (getxattr, listxattr, removexattr, setxattr, lgetxattr,
llistxattr, lremovexattr, lsetxattr, fgetxattr, flistxattr,
fremovexattr, fsetxattr): Export Linux extended attribute functions.
Sort.
* errno.cc (errmap): Add mappings for ERROR_EAS_DIDNT_FIT,
ERROR_EAS_NOT_SUPPORTED, ERROR_EA_LIST_INCONSISTENT,
ERROR_EA_TABLE_FULL, ERROR_FILE_CORRUPT, ERROR_INVALID_EA_NAME.
* fhandler.h (class fhandler_base): Declare new fgetxattr and
fsetxattr methods.
(class fhandler_disk_file): Ditto.
* fhandler.cc (fhandler_base::fgetxattr): New method.
(fhandler_base::fsetxattr): New method.
* fhandler_disk_file.cc (fhandler_disk_file::fgetxattr): New method.
(fhandler_disk_file::fsetxattr): New method.
* ntdll.h (STATUS_EA_TOO_LARGE): Define.
(STATUS_NONEXISTENT_EA_ENTRY): Define.
(STATUS_NO_EAS_ON_FILE): Define.
* ntea.cc (read_ea): Rewrite for long pathnames and for using with
Linux extended attribute functions.
(write_ea): Ditto.
(getxattr_worker): New static function.
(getxattr): New function.
(lgetxattr): New function.
(fgetxattr): New function.
(listxattr): New function.
(llistxattr): New function.
(flistxattr): New function.
(setxattr_worker): New static function.
(setxattr): New function.
(lsetxattr): New function.
(fsetxattr): New function.
(removexattr): New function.
(lsetxattr): New function.
(fsetxattr): New function.
* security.h (read_ea): Change declaration according to above changes.
(write_ea): Ditto.
* include/cygwin/version.h: Bump API minor version.
2008-02-10 23:43:04 +08:00
|
|
|
ssize_t
|
|
|
|
fhandler_base::fgetxattr (const char *name, void *value, size_t size)
|
|
|
|
{
|
|
|
|
set_errno (ENOTSUP);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fhandler_base::fsetxattr (const char *name, const void *value, size_t size,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
set_errno (ENOTSUP);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2005-02-03 06:42:06 +08:00
|
|
|
int
|
2006-08-08 03:29:14 +08:00
|
|
|
fhandler_base::fadvise (_off64_t offset, _off64_t length, int advice)
|
|
|
|
{
|
|
|
|
set_errno (EINVAL);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
fhandler_base::ftruncate (_off64_t length, bool allow_truncate)
|
2005-02-03 06:42:06 +08:00
|
|
|
{
|
|
|
|
set_errno (EINVAL);
|
|
|
|
return -1;
|
|
|
|
}
|
2005-02-20 05:53:36 +08:00
|
|
|
|
|
|
|
int
|
|
|
|
fhandler_base::link (const char *newpath)
|
|
|
|
{
|
2009-09-26 23:51:53 +08:00
|
|
|
set_errno (EPERM);
|
2005-02-20 05:53:36 +08:00
|
|
|
return -1;
|
|
|
|
}
|
2005-02-20 19:44:32 +08:00
|
|
|
|
|
|
|
int
|
2008-04-24 17:59:54 +08:00
|
|
|
fhandler_base::utimens (const struct timespec *tvp)
|
2005-02-20 19:44:32 +08:00
|
|
|
{
|
2005-04-14 00:17:37 +08:00
|
|
|
if (is_fs_special ())
|
2008-04-24 17:59:54 +08:00
|
|
|
return utimens_fs (tvp);
|
2005-04-14 00:17:37 +08:00
|
|
|
|
2005-02-20 19:44:32 +08:00
|
|
|
set_errno (EINVAL);
|
|
|
|
return -1;
|
|
|
|
}
|
2005-02-20 21:28:23 +08:00
|
|
|
|
|
|
|
int
|
|
|
|
fhandler_base::fsync ()
|
|
|
|
{
|
2005-02-22 23:30:09 +08:00
|
|
|
if (!get_handle () || nohandle ())
|
|
|
|
{
|
|
|
|
set_errno (EINVAL);
|
|
|
|
return -1;
|
|
|
|
}
|
2005-02-20 21:28:23 +08:00
|
|
|
if (pc.isdir ()) /* Just succeed. */
|
|
|
|
return 0;
|
|
|
|
if (FlushFileBuffers (get_handle ()))
|
|
|
|
return 0;
|
2011-02-01 16:46:48 +08:00
|
|
|
|
|
|
|
/* Ignore ERROR_INVALID_FUNCTION because FlushFileBuffers() always fails
|
|
|
|
with this code on raw devices which are unbuffered by default. */
|
|
|
|
DWORD errcode = GetLastError();
|
|
|
|
if (errcode == ERROR_INVALID_FUNCTION)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
__seterrno_from_win_error (errcode);
|
2005-02-20 21:28:23 +08:00
|
|
|
return -1;
|
|
|
|
}
|
2006-11-08 01:59:54 +08:00
|
|
|
|
|
|
|
int
|
|
|
|
fhandler_base::fpathconf (int v)
|
|
|
|
{
|
2008-02-16 17:43:19 +08:00
|
|
|
int ret;
|
|
|
|
|
2006-11-08 01:59:54 +08:00
|
|
|
switch (v)
|
|
|
|
{
|
|
|
|
case _PC_LINK_MAX:
|
|
|
|
return pc.fs_is_ntfs () || pc.fs_is_samba () || pc.fs_is_nfs ()
|
|
|
|
? LINK_MAX : 1;
|
|
|
|
case _PC_MAX_CANON:
|
|
|
|
if (is_tty ())
|
2007-02-20 08:16:18 +08:00
|
|
|
return MAX_CANON;
|
2006-11-08 01:59:54 +08:00
|
|
|
set_errno (EINVAL);
|
|
|
|
break;
|
|
|
|
case _PC_MAX_INPUT:
|
|
|
|
if (is_tty ())
|
2007-02-20 08:16:18 +08:00
|
|
|
return MAX_INPUT;
|
2006-11-08 01:59:54 +08:00
|
|
|
set_errno (EINVAL);
|
|
|
|
break;
|
|
|
|
case _PC_NAME_MAX:
|
|
|
|
/* NAME_MAX is without trailing \0 */
|
2008-02-16 17:43:19 +08:00
|
|
|
if (!pc.isdir ())
|
2008-11-27 01:21:04 +08:00
|
|
|
return NAME_MAX;
|
2008-02-16 17:43:19 +08:00
|
|
|
ret = NT_MAX_PATH - strlen (get_name ()) - 2;
|
|
|
|
return ret < 0 ? 0 : ret > NAME_MAX ? NAME_MAX : ret;
|
2006-11-08 01:59:54 +08:00
|
|
|
case _PC_PATH_MAX:
|
|
|
|
/* PATH_MAX is with trailing \0 */
|
2008-02-16 17:43:19 +08:00
|
|
|
if (!pc.isdir ())
|
|
|
|
return PATH_MAX;
|
|
|
|
ret = NT_MAX_PATH - strlen (get_name ()) - 1;
|
|
|
|
return ret < 0 ? 0 : ret > PATH_MAX ? PATH_MAX : ret;
|
2006-11-08 01:59:54 +08:00
|
|
|
case _PC_PIPE_BUF:
|
|
|
|
if (pc.isdir ()
|
|
|
|
|| get_device () == FH_FIFO || get_device () == FH_PIPE
|
|
|
|
|| get_device () == FH_PIPER || get_device () == FH_PIPEW)
|
2007-02-20 08:16:18 +08:00
|
|
|
return PIPE_BUF;
|
2006-11-08 01:59:54 +08:00
|
|
|
set_errno (EINVAL);
|
|
|
|
break;
|
|
|
|
case _PC_CHOWN_RESTRICTED:
|
|
|
|
return 1;
|
|
|
|
case _PC_NO_TRUNC:
|
|
|
|
return 1;
|
|
|
|
case _PC_VDISABLE:
|
2007-02-08 01:22:40 +08:00
|
|
|
if (is_tty ())
|
2007-02-20 08:16:18 +08:00
|
|
|
return _POSIX_VDISABLE;
|
2007-02-08 01:22:40 +08:00
|
|
|
set_errno (EINVAL);
|
2006-11-08 01:59:54 +08:00
|
|
|
break;
|
|
|
|
case _PC_ASYNC_IO:
|
|
|
|
case _PC_PRIO_IO:
|
|
|
|
break;
|
2007-02-08 01:22:40 +08:00
|
|
|
case _PC_SYNC_IO:
|
|
|
|
return 1;
|
2006-11-08 01:59:54 +08:00
|
|
|
case _PC_FILESIZEBITS:
|
|
|
|
return FILESIZEBITS;
|
|
|
|
case _PC_2_SYMLINKS:
|
|
|
|
return 1;
|
|
|
|
case _PC_SYMLINK_MAX:
|
2007-02-08 01:22:40 +08:00
|
|
|
return SYMLINK_MAX;
|
2006-11-08 01:59:54 +08:00
|
|
|
case _PC_POSIX_PERMISSIONS:
|
|
|
|
case _PC_POSIX_SECURITY:
|
|
|
|
if (get_device () == FH_FS)
|
2008-07-15 04:46:27 +08:00
|
|
|
return pc.has_acls () || pc.fs_is_nfs ();
|
2006-11-08 01:59:54 +08:00
|
|
|
set_errno (EINVAL);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
set_errno (EINVAL);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
2007-07-08 01:00:33 +08:00
|
|
|
|
|
|
|
/* Overlapped I/O */
|
|
|
|
|
2011-03-10 00:47:44 +08:00
|
|
|
int __stdcall __attribute__ ((regparm (1)))
|
2010-04-03 02:55:02 +08:00
|
|
|
fhandler_base_overlapped::setup_overlapped ()
|
2007-07-08 01:00:33 +08:00
|
|
|
{
|
2008-12-24 02:22:33 +08:00
|
|
|
OVERLAPPED *ov = get_overlapped_buffer ();
|
2007-07-08 01:00:33 +08:00
|
|
|
memset (ov, 0, sizeof (*ov));
|
2010-04-03 02:55:02 +08:00
|
|
|
set_overlapped (ov);
|
|
|
|
ov->hEvent = CreateEvent (&sec_none_nih, true, true, NULL);
|
2011-05-31 08:26:37 +08:00
|
|
|
io_pending = false;
|
2010-04-03 02:55:02 +08:00
|
|
|
return ov->hEvent ? 0 : -1;
|
2007-07-08 01:00:33 +08:00
|
|
|
}
|
|
|
|
|
2011-03-10 00:47:44 +08:00
|
|
|
void __stdcall __attribute__ ((regparm (1)))
|
2010-03-31 12:26:11 +08:00
|
|
|
fhandler_base_overlapped::destroy_overlapped ()
|
2007-07-08 01:00:33 +08:00
|
|
|
{
|
|
|
|
OVERLAPPED *ov = get_overlapped ();
|
|
|
|
if (ov && ov->hEvent)
|
|
|
|
{
|
2011-12-18 12:07:47 +08:00
|
|
|
SetEvent (ov->hEvent);
|
2007-07-08 01:00:33 +08:00
|
|
|
CloseHandle (ov->hEvent);
|
|
|
|
ov->hEvent = NULL;
|
|
|
|
}
|
2010-04-03 02:55:02 +08:00
|
|
|
io_pending = false;
|
|
|
|
get_overlapped () = NULL;
|
2007-07-08 01:00:33 +08:00
|
|
|
}
|
|
|
|
|
2011-03-10 00:47:44 +08:00
|
|
|
bool __stdcall __attribute__ ((regparm (1)))
|
2010-03-31 12:26:11 +08:00
|
|
|
fhandler_base_overlapped::has_ongoing_io ()
|
|
|
|
{
|
|
|
|
if (!io_pending)
|
|
|
|
return false;
|
2011-05-31 08:26:37 +08:00
|
|
|
|
2011-04-29 16:27:11 +08:00
|
|
|
if (!IsEventSignalled (get_overlapped ()->hEvent))
|
2011-11-29 23:34:49 +08:00
|
|
|
return true;
|
2010-03-31 12:26:11 +08:00
|
|
|
io_pending = false;
|
2011-05-31 08:26:37 +08:00
|
|
|
DWORD nbytes;
|
2012-02-01 13:27:42 +08:00
|
|
|
GetOverlappedResult (get_output_handle (), get_overlapped (), &nbytes, false);
|
2010-03-31 12:26:11 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-03-10 00:47:44 +08:00
|
|
|
fhandler_base_overlapped::wait_return __stdcall __attribute__ ((regparm (3)))
|
|
|
|
fhandler_base_overlapped::wait_overlapped (bool inres, bool writing, DWORD *bytes, bool nonblocking, DWORD len)
|
2007-07-08 01:00:33 +08:00
|
|
|
{
|
2008-12-24 02:22:33 +08:00
|
|
|
if (!get_overlapped ())
|
2011-03-10 00:47:44 +08:00
|
|
|
return inres ? overlapped_success : overlapped_error;
|
2009-01-27 13:21:08 +08:00
|
|
|
|
2011-05-31 08:26:37 +08:00
|
|
|
wait_return res = overlapped_unknown;
|
|
|
|
DWORD err;
|
|
|
|
if (inres)
|
|
|
|
/* handle below */;
|
|
|
|
else if ((err = GetLastError ()) != ERROR_IO_PENDING)
|
2011-03-10 06:48:05 +08:00
|
|
|
res = overlapped_error;
|
2011-05-31 08:26:37 +08:00
|
|
|
else if (!nonblocking)
|
|
|
|
/* handle below */;
|
|
|
|
else if (!writing)
|
|
|
|
SetEvent (get_overlapped ()->hEvent); /* Force immediate WFMO return */
|
2011-03-10 06:48:05 +08:00
|
|
|
else
|
2009-06-14 13:38:55 +08:00
|
|
|
{
|
2011-05-31 08:26:37 +08:00
|
|
|
*bytes = len; /* Assume that this worked */
|
|
|
|
io_pending = true; /* but don't allow subsequent */
|
|
|
|
res = overlapped_success; /* writes until completed */
|
|
|
|
}
|
|
|
|
if (res == overlapped_unknown)
|
|
|
|
{
|
2011-12-10 00:02:56 +08:00
|
|
|
DWORD wfres = cygwait (get_overlapped ()->hEvent);
|
2011-12-16 13:27:15 +08:00
|
|
|
HANDLE h = writing ? get_output_handle () : get_handle ();
|
|
|
|
BOOL wores;
|
2011-12-17 08:03:31 +08:00
|
|
|
if (isclosed ())
|
2011-12-18 12:07:47 +08:00
|
|
|
{
|
2011-12-22 02:34:57 +08:00
|
|
|
switch (wfres)
|
2011-12-18 12:07:47 +08:00
|
|
|
{
|
|
|
|
case WAIT_OBJECT_0:
|
|
|
|
err = ERROR_INVALID_HANDLE;
|
|
|
|
break;
|
2012-06-18 04:50:24 +08:00
|
|
|
case WAIT_SIGNALED:
|
2011-12-18 12:07:47 +08:00
|
|
|
err = ERROR_INVALID_AT_INTERRUPT_TIME;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
err = GetLastError ();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
res = overlapped_error;
|
|
|
|
}
|
2011-12-16 13:27:15 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Cancelling here to prevent races. It's possible that the I/O has
|
|
|
|
completed already, in which case this is a no-op. Otherwise,
|
|
|
|
WFMO returned because 1) This is a non-blocking call, 2) a signal
|
|
|
|
arrived, or 3) the operation was cancelled. These cases may be
|
|
|
|
overridden by the return of GetOverlappedResult which could detect
|
|
|
|
that I/O completion occurred. */
|
|
|
|
CancelIo (h);
|
2011-12-17 00:29:34 +08:00
|
|
|
wores = GetOverlappedResult (h, get_overlapped (), bytes, false);
|
2011-12-16 13:27:15 +08:00
|
|
|
err = GetLastError ();
|
|
|
|
ResetEvent (get_overlapped ()->hEvent); /* Probably not needed but CYA */
|
|
|
|
debug_printf ("wfres %d, wores %d, bytes %u", wfres, wores, *bytes);
|
2011-12-18 12:07:47 +08:00
|
|
|
if (wores)
|
|
|
|
res = overlapped_success; /* operation succeeded */
|
|
|
|
else if (wfres == WAIT_OBJECT_0 + 1)
|
|
|
|
{
|
|
|
|
err = ERROR_INVALID_AT_INTERRUPT_TIME; /* forces an EINTR below */
|
|
|
|
debug_printf ("signal");
|
|
|
|
res = overlapped_error;
|
|
|
|
}
|
|
|
|
else if (wfres == WAIT_OBJECT_0 + 2)
|
|
|
|
pthread::static_cancel_self (); /* never returns */
|
|
|
|
else if (nonblocking)
|
|
|
|
res = overlapped_nonblocking_no_data; /* more handling below */
|
|
|
|
else
|
|
|
|
{
|
|
|
|
debug_printf ("GetOverLappedResult failed, h %p, bytes %u, %E", h, *bytes);
|
|
|
|
res = overlapped_error;
|
|
|
|
}
|
2007-07-08 01:00:33 +08:00
|
|
|
}
|
|
|
|
}
|
2007-07-30 01:24:54 +08:00
|
|
|
|
2011-05-29 23:30:27 +08:00
|
|
|
if (res == overlapped_success)
|
2012-03-13 05:29:36 +08:00
|
|
|
{
|
|
|
|
debug_printf ("normal %s, %u bytes ispipe() %d", writing ? "write" : "read", *bytes, ispipe ());
|
|
|
|
if (*bytes == 0 && !writing && ispipe ())
|
|
|
|
res = overlapped_nullread;
|
|
|
|
}
|
2011-05-31 08:26:37 +08:00
|
|
|
else if (res == overlapped_nonblocking_no_data)
|
|
|
|
{
|
|
|
|
*bytes = (DWORD) -1;
|
|
|
|
set_errno (EAGAIN);
|
|
|
|
debug_printf ("no data to read for nonblocking I/O");
|
|
|
|
}
|
2011-03-10 06:48:05 +08:00
|
|
|
else if (err == ERROR_HANDLE_EOF || err == ERROR_BROKEN_PIPE)
|
2008-12-21 03:20:00 +08:00
|
|
|
{
|
2011-10-30 12:50:36 +08:00
|
|
|
debug_printf ("EOF, %E");
|
2011-03-10 00:47:44 +08:00
|
|
|
*bytes = 0;
|
|
|
|
res = overlapped_success;
|
2011-06-04 08:12:29 +08:00
|
|
|
if (writing && err == ERROR_BROKEN_PIPE)
|
|
|
|
raise (SIGPIPE);
|
2008-12-21 03:20:00 +08:00
|
|
|
}
|
2011-03-10 06:48:05 +08:00
|
|
|
else
|
|
|
|
{
|
2011-11-29 23:34:49 +08:00
|
|
|
debug_printf ("res %u, Win32 Error %u", (unsigned) res, err);
|
2011-03-10 06:48:05 +08:00
|
|
|
*bytes = (DWORD) -1;
|
2011-05-31 08:26:37 +08:00
|
|
|
__seterrno_from_win_error (err);
|
2011-06-04 08:12:29 +08:00
|
|
|
if (writing && err == ERROR_NO_DATA)
|
2011-05-31 08:26:37 +08:00
|
|
|
raise (SIGPIPE);
|
2011-03-10 06:48:05 +08:00
|
|
|
}
|
2008-12-21 03:20:00 +08:00
|
|
|
|
2007-07-08 01:00:33 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2011-03-10 00:47:44 +08:00
|
|
|
void __stdcall __attribute__ ((regparm (3)))
|
2011-05-06 01:44:42 +08:00
|
|
|
fhandler_base_overlapped::raw_read (void *ptr, size_t& len)
|
2007-07-08 01:00:33 +08:00
|
|
|
{
|
2009-06-29 03:23:13 +08:00
|
|
|
DWORD nbytes;
|
2011-05-31 08:26:37 +08:00
|
|
|
bool keep_looping;
|
|
|
|
do
|
2011-03-10 00:47:44 +08:00
|
|
|
{
|
2011-05-31 08:26:37 +08:00
|
|
|
bool res = ReadFile (get_handle (), ptr, len, &nbytes,
|
|
|
|
get_overlapped ());
|
|
|
|
switch (wait_overlapped (res, false, &nbytes, is_nonblocking ()))
|
2011-03-10 00:47:44 +08:00
|
|
|
{
|
2012-03-13 05:29:36 +08:00
|
|
|
case overlapped_nullread:
|
|
|
|
keep_looping = true;
|
|
|
|
break;
|
2011-05-31 08:26:37 +08:00
|
|
|
default: /* Added to quiet gcc */
|
|
|
|
case overlapped_success:
|
|
|
|
case overlapped_error:
|
|
|
|
keep_looping = false;
|
|
|
|
break;
|
2011-03-10 00:47:44 +08:00
|
|
|
}
|
|
|
|
}
|
2011-05-31 08:26:37 +08:00
|
|
|
while (keep_looping);
|
2009-06-29 03:23:13 +08:00
|
|
|
len = (size_t) nbytes;
|
2007-07-08 01:00:33 +08:00
|
|
|
}
|
|
|
|
|
2011-03-10 00:47:44 +08:00
|
|
|
ssize_t __stdcall __attribute__ ((regparm (3)))
|
2011-05-06 01:44:42 +08:00
|
|
|
fhandler_base_overlapped::raw_write (const void *ptr, size_t len)
|
2007-07-08 01:00:33 +08:00
|
|
|
{
|
2011-03-14 04:20:58 +08:00
|
|
|
size_t nbytes;
|
2010-03-31 12:26:11 +08:00
|
|
|
if (has_ongoing_io ())
|
2011-11-29 23:34:49 +08:00
|
|
|
{
|
|
|
|
set_errno (EAGAIN);
|
|
|
|
nbytes = (DWORD) -1;
|
|
|
|
}
|
2010-03-31 12:26:11 +08:00
|
|
|
else
|
2011-03-10 00:47:44 +08:00
|
|
|
{
|
2011-03-14 04:20:58 +08:00
|
|
|
size_t chunk;
|
|
|
|
if (!max_atomic_write || len < max_atomic_write)
|
|
|
|
chunk = len;
|
|
|
|
else if (is_nonblocking ())
|
|
|
|
chunk = len = max_atomic_write;
|
|
|
|
else
|
|
|
|
chunk = max_atomic_write;
|
|
|
|
|
|
|
|
nbytes = 0;
|
|
|
|
DWORD nbytes_now = 0;
|
|
|
|
/* Write to fd in smaller chunks, accumlating a total.
|
|
|
|
If there's an error, just return the accumulated total
|
|
|
|
unless the first write fails, in which case return value
|
|
|
|
from wait_overlapped(). */
|
|
|
|
while (nbytes < len)
|
2011-03-10 00:47:44 +08:00
|
|
|
{
|
2011-03-14 04:20:58 +08:00
|
|
|
size_t left = len - nbytes;
|
|
|
|
size_t len1;
|
|
|
|
if (left > chunk)
|
|
|
|
len1 = chunk;
|
|
|
|
else
|
|
|
|
len1 = left;
|
|
|
|
bool res = WriteFile (get_output_handle (), ptr, len1, &nbytes_now,
|
2011-03-10 00:47:44 +08:00
|
|
|
get_overlapped ());
|
2011-03-14 04:20:58 +08:00
|
|
|
switch (wait_overlapped (res, true, &nbytes_now,
|
|
|
|
is_nonblocking (), len1))
|
2011-03-10 00:47:44 +08:00
|
|
|
{
|
|
|
|
case overlapped_success:
|
2011-03-14 04:20:58 +08:00
|
|
|
ptr = ((char *) ptr) + chunk;
|
|
|
|
nbytes += nbytes_now;
|
|
|
|
/* fall through intentionally */
|
2011-03-10 00:47:44 +08:00
|
|
|
case overlapped_error:
|
2011-03-14 04:20:58 +08:00
|
|
|
len = 0; /* terminate loop */
|
2011-05-31 08:26:37 +08:00
|
|
|
case overlapped_unknown:
|
2012-03-13 05:29:36 +08:00
|
|
|
case overlapped_nullread:
|
2011-05-31 08:26:37 +08:00
|
|
|
case overlapped_nonblocking_no_data:
|
2011-03-10 00:47:44 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-03-14 04:20:58 +08:00
|
|
|
if (!nbytes)
|
|
|
|
nbytes = nbytes_now;
|
2011-03-10 00:47:44 +08:00
|
|
|
}
|
|
|
|
return nbytes;
|
|
|
|
}
|