/* fhandler.h
Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
- 2005, 2006 Red Hat, Inc.
+ 2005, 2006, 2007, 2008, 2009 Red Hat, Inc.
This file is part of Cygwin.
both flags are set. */
#define O_NONBLOCK_MASK (O_NONBLOCK | OLD_O_NDELAY)
+/* It appears that 64K is the block size used for buffered I/O on NT.
+ Using this blocksize in read/write calls in the application results
+ in a much better performance than using smaller values. */
+#define PREFERRED_IO_BLKSIZE ((blksize_t) 65536)
+
extern const char *windows_device_names[];
extern struct __cygwin_perfile *perfile_table;
#define __fmode (*(user_data->fmode_ptr))
extern const int proc_len;
class select_record;
+class select_stuff;
class fhandler_disk_file;
+class inode_t;
typedef struct __DIR DIR;
struct dirent;
struct iovec;
dirent_saw_eof = 0x0004,
dirent_isroot = 0x0008,
dirent_set_d_ino = 0x0010,
- dirent_get_d_ino = 0x0020
+ dirent_get_d_ino = 0x0020,
+ dirent_nfs_d_ino = 0x0040,
+
+ /* Global flags which must not be deleted on rewinddir or seekdir. */
+ dirent_info_mask = 0x0078
};
enum conn_state
enum query_state {
no_query = 0,
query_read_control = 1,
- query_stat_control = 2,
+ query_read_attributes = 2,
query_write_control = 3,
query_write_attributes = 4
};
+enum del_lock_called_from {
+ on_close,
+ after_fork,
+ after_exec
+};
+
class fhandler_base
{
friend class dtable;
unsigned wbinset : 1; /* binary write mode explicitly set */
unsigned nohandle : 1; /* No handle associated with fhandler. */
unsigned uninterruptible_io : 1; /* Set if I/O should be uninterruptible. */
- unsigned append_mode : 1; /* always append */
unsigned did_lseek : 1; /* set when lseek is called as a flag that
_write should check if we've moved
beyond EOF, zero filling or making
read or write access */
unsigned close_on_exec : 1; /* close-on-exec */
unsigned need_fork_fixup : 1; /* Set if need to fixup after fork. */
- unsigned has_changed : 1; /* Flag used to set ctime on close. */
public:
status_flags () :
rbinary (0), rbinset (0), wbinary (0), wbinset (0), nohandle (0),
- uninterruptible_io (0), append_mode (0), did_lseek (0),
- query_open (no_query), close_on_exec (0), need_fork_fixup (0),
- has_changed (0)
+ uninterruptible_io (0), did_lseek (0),
+ query_open (no_query), close_on_exec (0), need_fork_fixup (0)
{}
} status, open_status;
int access;
HANDLE io_handle;
- __ino64_t namehash; /* hashed filename, used as inode num */
+ __ino64_t ino; /* file ID or hashed filename, depends on FS. */
protected:
/* File open flags from open () and fcntl () calls */
size_t raixput;
size_t rabuflen;
- DWORD fs_flags;
+ /* Used for advisory file locking. See flock.cc. */
+ long long unique_id;
+ void del_my_locks (del_lock_called_from);
+
HANDLE read_state;
- path_conv pc;
+ int wait_overlapped (bool, bool, DWORD *, DWORD = 0) __attribute__ ((regparm (3)));
+ bool setup_overlapped (bool doit = true) __attribute__ ((regparm (2)));
+ void destroy_overlapped () __attribute__ ((regparm (1)));
public:
class fhandler_base *archetype;
int usecount;
- void set_name (path_conv &pc);
+ path_conv pc;
+
+ virtual void set_name (path_conv &pc);
+ virtual void set_name (const char *s) {pc.set_normalized_path (s);}
int error () const {return pc.error;}
void set_error (int error) {pc.error = error;}
bool exists () const {return pc.exists ();}
void set_flags (int x, int supplied_bin = 0);
bool is_nonblocking ();
- void set_nonblocking (int yes);
+ void set_nonblocking (int);
bool wbinary () const { return status.wbinset ? status.wbinary : 1; }
bool rbinary () const { return status.rbinset ? status.rbinary : 1; }
IMPLEMENT_STATUS_FLAG (bool, rbinset)
IMPLEMENT_STATUS_FLAG (bool, nohandle)
IMPLEMENT_STATUS_FLAG (bool, uninterruptible_io)
- IMPLEMENT_STATUS_FLAG (bool, append_mode)
IMPLEMENT_STATUS_FLAG (bool, did_lseek)
IMPLEMENT_STATUS_FLAG (query_state, query_open)
IMPLEMENT_STATUS_FLAG (bool, close_on_exec)
IMPLEMENT_STATUS_FLAG (bool, need_fork_fixup)
- IMPLEMENT_STATUS_FLAG (bool, has_changed)
int get_default_fmode (int flags);
return close_on_exec () ? &sec_none_nih : &sec_none;
}
- virtual void fixup_before_fork_exec (DWORD) {}
+ virtual int fixup_before_fork_exec (DWORD) { return 0; }
virtual void fixup_after_fork (HANDLE);
- virtual void fixup_after_exec () {}
+ virtual void fixup_after_exec ();
void create_read_state (LONG n)
{
read_state = CreateSemaphore (&sec_none_nih, 0, n, NULL);
ReleaseSemaphore (read_state, n, NULL);
}
- void set_fs_flags (DWORD flags) { fs_flags = flags; }
- bool get_fs_flags (DWORD flagval = UINT32_MAX)
- { return (fs_flags & (flagval)); }
-
bool get_readahead_valid () { return raixget < ralen; }
int puts_readahead (const char *s, size_t len = (size_t) -1);
int put_readahead (char value);
bool has_attribute (DWORD x) const {return pc.has_attribute (x);}
const char *get_name () const { return pc.normalized_path; }
const char *get_win32_name () { return pc.get_win32 (); }
- __ino64_t get_namehash () { return namehash ?: namehash = hash_path_name (0, get_win32_name ()); }
+ __dev32_t get_dev () { return pc.fs_serial_number (); }
+ __ino64_t get_ino () { return ino ?: ino = hash_path_name (0, pc.get_nt_native_path ()); }
+ long long get_unique_id () const { return unique_id; }
/* Returns name used for /proc/<pid>/fd in buf. */
virtual char *get_proc_fd_name (char *buf);
virtual void hclose (HANDLE h) {CloseHandle (h);}
- virtual void set_no_inheritance (HANDLE &h, int not_inheriting);
+ virtual void set_no_inheritance (HANDLE &, bool);
/* fixup fd possibly non-inherited handles after fork */
- void fork_fixup (HANDLE parent, HANDLE &h, const char *name);
+ bool fork_fixup (HANDLE, HANDLE &, const char *);
virtual bool need_fixup_before () const {return false;}
- int open_9x (int flags, mode_t mode = 0);
- virtual int open (int flags, mode_t mode = 0);
- int open_fs (int flags, mode_t mode = 0);
+ virtual int open (int, mode_t = 0);
+ int open_fs (int, mode_t = 0);
virtual int close ();
- int close_fs ();
+ int close_fs () { return fhandler_base::close (); }
virtual int __stdcall fstat (struct __stat64 *buf) __attribute__ ((regparm (2)));
int __stdcall fstat_fs (struct __stat64 *buf) __attribute__ ((regparm (2)));
int __stdcall fstat_helper (struct __stat64 *buf,
FILETIME ftChangeTime,
FILETIME ftLastAccessTime,
FILETIME ftLastWriteTime,
+ FILETIME ftCreationTime,
DWORD dwVolumeSerialNumber,
ULONGLONG nFileSize,
LONGLONG nAllocSize,
DWORD nNumberOfLinks,
DWORD dwFileAttributes)
__attribute__ ((regparm (3)));
+ int __stdcall fstat_by_nfs_ea (struct __stat64 *buf) __attribute__ ((regparm (2)));
int __stdcall fstat_by_handle (struct __stat64 *buf) __attribute__ ((regparm (2)));
int __stdcall fstat_by_name (struct __stat64 *buf) __attribute__ ((regparm (2)));
- int fhandler_base::utimes_fs (const struct timeval *) __attribute__ ((regparm (2)));
+ virtual int __stdcall fstatvfs (struct statvfs *buf) __attribute__ ((regparm (2)));
+ int utimens_fs (const struct timespec *) __attribute__ ((regparm (2)));
virtual int __stdcall fchmod (mode_t mode) __attribute__ ((regparm (1)));
virtual int __stdcall fchown (__uid32_t uid, __gid32_t gid) __attribute__ ((regparm (2)));
virtual int __stdcall facl (int, int, __acl32 *) __attribute__ ((regparm (3)));
- virtual int __stdcall ftruncate (_off64_t) __attribute__ ((regparm (2)));
+ virtual ssize_t __stdcall fgetxattr (const char *, void *, size_t) __attribute__ ((regparm (3)));
+ virtual int __stdcall fsetxattr (const char *, const void *, size_t, int) __attribute__ ((regparm (3)));
+ virtual int __stdcall fadvise (_off64_t, _off64_t, int) __attribute__ ((regparm (3)));
+ virtual int __stdcall ftruncate (_off64_t, bool) __attribute__ ((regparm (3)));
virtual int __stdcall link (const char *) __attribute__ ((regparm (2)));
- virtual int __stdcall utimes (const struct timeval *) __attribute__ ((regparm (2)));
+ virtual int __stdcall utimens (const struct timespec *) __attribute__ ((regparm (2)));
virtual int __stdcall fsync () __attribute__ ((regparm (1)));
virtual int ioctl (unsigned int cmd, void *);
virtual int fcntl (int cmd, void *);
virtual char const *ttyname () { return get_name (); }
virtual void __stdcall read (void *ptr, size_t& len) __attribute__ ((regparm (3)));
- virtual int write (const void *ptr, size_t len);
- virtual ssize_t readv (const struct iovec *, int iovcnt, ssize_t tot = -1);
- virtual ssize_t writev (const struct iovec *, int iovcnt, ssize_t tot = -1);
+ virtual void __stdcall read_overlapped (void *ptr, size_t& len) __attribute__ ((regparm (3)));
+ virtual bool __stdcall has_ongoing_io (bool) __attribute__ ((regparm (2)));
+ virtual ssize_t __stdcall write (const void *ptr, size_t len);
+ virtual ssize_t __stdcall write_overlapped (const void *ptr, size_t len);
+ virtual ssize_t __stdcall readv (const struct iovec *, int iovcnt, ssize_t tot = -1);
+ virtual ssize_t __stdcall writev (const struct iovec *, int iovcnt, ssize_t tot = -1);
virtual ssize_t __stdcall pread (void *, size_t, _off64_t) __attribute__ ((regparm (3)));
virtual ssize_t __stdcall pwrite (void *, size_t, _off64_t) __attribute__ ((regparm (3)));
virtual _off64_t lseek (_off64_t offset, int whence);
virtual int lock (int, struct __flock64 *);
virtual int dup (fhandler_base *child);
+ virtual int fpathconf (int);
virtual HANDLE mmap (caddr_t *addr, size_t len, int prot,
int flags, _off64_t off);
void *operator new (size_t, void *p) __attribute__ ((nothrow)) {return p;}
- virtual void init (HANDLE, DWORD, mode_t);
+ virtual int init (HANDLE, DWORD, mode_t);
virtual int tcflush (int);
virtual int tcsendbreak (int);
virtual int tcgetattr (struct termios *t);
virtual int tcsetpgrp (const pid_t pid);
virtual int tcgetpgrp ();
- virtual int is_tty () { return 0; }
- virtual bool isdevice () { return true; }
- virtual bool isfifo () { return false; }
+ virtual bool is_tty () const { return false; }
+ virtual bool ispipe () const { return false; }
+ virtual pid_t get_popen_pid () const {return 0;}
+ virtual bool isdevice () const { return true; }
+ virtual bool isfifo () const { return false; }
virtual char *ptsname () { return NULL;}
virtual class fhandler_socket *is_socket () { return NULL; }
virtual class fhandler_console *is_console () { return 0; }
virtual int is_windows () {return 0; }
- virtual void raw_read (void *ptr, size_t& ulen);
- virtual int raw_write (const void *ptr, size_t ulen);
+ virtual void __stdcall raw_read (void *ptr, size_t& ulen);
+ virtual ssize_t __stdcall raw_write (const void *ptr, size_t ulen);
+ virtual OVERLAPPED *get_overlapped () {return NULL;}
+ virtual OVERLAPPED *get_overlapped_buffer () {return NULL;}
+ virtual void set_overlapped (OVERLAPPED *) {}
/* Virtual accessor functions to hide the fact
that some fd's have two handles. */
virtual HANDLE& get_io_handle () { return io_handle; }
virtual HANDLE& get_output_handle () { return io_handle; }
virtual bool hit_eof () {return false;}
- virtual select_record *select_read (select_record *s);
- virtual select_record *select_write (select_record *s);
- virtual select_record *select_except (select_record *s);
+ virtual select_record *select_read (select_stuff *);
+ virtual select_record *select_write (select_stuff *);
+ virtual select_record *select_except (select_stuff *);
virtual int ready_for_read (int fd, DWORD howlong);
virtual const char *get_native_name ()
{
rabuf = NULL;
}
void operator delete (void *);
- virtual HANDLE get_guard () const {return NULL;}
virtual void set_eof () {}
virtual int mkdir (mode_t mode);
virtual int rmdir ();
- virtual DIR *opendir ();
+ virtual DIR *opendir (int fd) __attribute__ ((regparm (2)));
virtual int readdir (DIR *, dirent *) __attribute__ ((regparm (3)));
virtual _off64_t telldir (DIR *);
virtual void seekdir (DIR *, _off64_t);
virtual void rewinddir (DIR *);
virtual int closedir (DIR *);
- virtual bool is_slow () {return 0;}
+ virtual bool is_slow () {return false;}
bool is_auto_device () {return isdevice () && !dev ().isfs ();}
bool is_fs_special () {return pc.is_fs_special ();}
bool issymlink () {return pc.issymlink ();}
bool device_access_denied (int) __attribute__ ((regparm (2)));
- int fhaccess (int flags) __attribute__ ((regparm (2)));
- friend class fhandler_fifo;
+ int fhaccess (int flags, bool) __attribute__ ((regparm (3)));
};
class fhandler_mailslot : public fhandler_base
{
+ POBJECT_ATTRIBUTES get_object_attr (OBJECT_ATTRIBUTES &, PUNICODE_STRING);
public:
fhandler_mailslot ();
int __stdcall fstat (struct __stat64 *buf) __attribute__ ((regparm (2)));
int open (int flags, mode_t mode = 0);
- int write (const void *ptr, size_t len);
+ ssize_t __stdcall write (const void *ptr, size_t len);
int ioctl (unsigned int cmd, void *);
- select_record *select_read (select_record *s);
+ select_record *select_read (select_stuff *);
+};
+
+struct wsa_event
+{
+ LONG serial_number;
+ long events;
+ int connect_errorcode;
+ pid_t owner;
};
class fhandler_socket: public fhandler_base
int type;
int connect_secret[4];
+ wsa_event *wsock_events;
+ HANDLE wsock_mtx;
+ HANDLE wsock_evt;
+ public:
+ bool init_events ();
+ int evaluate_events (const long event_mask, long &events, const bool erase);
+ const HANDLE wsock_event () const { return wsock_evt; }
+ const LONG serial_number () const { return wsock_events->serial_number; }
+ private:
+ int wait_for_events (const long event_mask, bool dontwait = false);
+ void release_events ();
+
pid_t sec_pid;
__uid32_t sec_uid;
__gid32_t sec_gid;
void af_local_set_sockpair_cred ();
private:
- struct _WSAPROTOCOL_INFOA *prot_info_ptr;
+ int _rmem;
+ int _wmem;
+ public:
+ int &rmem () { return _rmem; }
+ int &wmem () { return _wmem; }
+ void rmem (int nrmem) { _rmem = nrmem; }
+ void wmem (int nwmem) { _wmem = nwmem; }
+
+ private:
+ struct _WSAPROTOCOL_INFOW *prot_info_ptr;
+ public:
+ void init_fixup_before ();
+ bool need_fixup_before () const {return prot_info_ptr != NULL;}
+
+ private:
char *sun_path;
+ char *peer_sun_path;
struct status_flags
{
unsigned async_io : 1; /* async I/O */
unsigned saw_shutdown_read : 1; /* Socket saw a SHUT_RD */
unsigned saw_shutdown_write : 1; /* Socket saw a SHUT_WR */
unsigned saw_reuseaddr : 1; /* Socket saw SO_REUSEADDR call */
- unsigned closed : 1;
- unsigned owner : 1;
+ unsigned listener : 1; /* listen called */
unsigned connect_state : 2;
public:
status_flags () :
async_io (0), saw_shutdown_read (0), saw_shutdown_write (0),
- closed (0), owner (0), connect_state (unconnected)
+ listener (0), connect_state (unconnected)
{}
} status;
- bool prepare (HANDLE &event, long event_mask);
- int wait (HANDLE event, int flags, DWORD timeout = 10);
- void release (HANDLE event);
-
public:
fhandler_socket ();
~fhandler_socket ();
IMPLEMENT_STATUS_FLAG (bool, saw_shutdown_read)
IMPLEMENT_STATUS_FLAG (bool, saw_shutdown_write)
IMPLEMENT_STATUS_FLAG (bool, saw_reuseaddr)
- IMPLEMENT_STATUS_FLAG (bool, closed)
- IMPLEMENT_STATUS_FLAG (bool, owner)
+ IMPLEMENT_STATUS_FLAG (bool, listener)
IMPLEMENT_STATUS_FLAG (conn_state, connect_state)
int bind (const struct sockaddr *name, int namelen);
int getpeereid (pid_t *pid, __uid32_t *euid, __gid32_t *egid);
int open (int flags, mode_t mode = 0);
- ssize_t readv (const struct iovec *, int iovcnt, ssize_t tot = -1);
- int recvfrom (void *ptr, size_t len, int flags,
- struct sockaddr *from, int *fromlen);
- int recvmsg (struct msghdr *msg, int flags, ssize_t tot = -1);
-
- ssize_t writev (const struct iovec *, int iovcnt, ssize_t tot = -1);
- int sendto (const void *ptr, size_t len, int flags,
+ ssize_t __stdcall readv (const struct iovec *, int iovcnt, ssize_t tot = -1);
+ inline ssize_t recv_internal (struct _WSAMSG *wsamsg);
+ ssize_t recvfrom (void *ptr, size_t len, int flags,
+ struct sockaddr *from, int *fromlen);
+ ssize_t recvmsg (struct msghdr *msg, int flags);
+
+ ssize_t __stdcall writev (const struct iovec *, int iovcnt, ssize_t tot = -1);
+ inline ssize_t send_internal (struct _WSAMSG *wsamsg, int flags);
+ ssize_t sendto (const void *ptr, size_t len, int flags,
const struct sockaddr *to, int tolen);
- int sendmsg (const struct msghdr *msg, int flags, ssize_t tot = -1);
+ ssize_t sendmsg (const struct msghdr *msg, int flags);
int ioctl (unsigned int cmd, void *);
int fcntl (int cmd, void *);
int dup (fhandler_base *child);
void set_close_on_exec (bool val);
- virtual void fixup_before_fork_exec (DWORD);
+ int fixup_before_fork_exec (DWORD);
void fixup_after_fork (HANDLE);
void fixup_after_exec ();
- bool need_fixup_before () const {return true;}
char *get_proc_fd_name (char *buf);
- select_record *select_read (select_record *s);
- select_record *select_write (select_record *s);
- select_record *select_except (select_record *s);
+ select_record *select_read (select_stuff *);
+ select_record *select_write (select_stuff *);
+ select_record *select_except (select_stuff *);
+ int ready_for_read (int, DWORD) { return true; }
void set_addr_family (int af) {addr_family = af;}
int get_addr_family () {return addr_family;}
void set_socket_type (int st) { type = st;}
int get_socket_type () {return type;}
void set_sun_path (const char *path);
char *get_sun_path () {return sun_path;}
+ void set_peer_sun_path (const char *path);
+ char *get_peer_sun_path () {return peer_sun_path;}
int __stdcall fstat (struct __stat64 *buf) __attribute__ ((regparm (2)));
+ int __stdcall fstatvfs (struct statvfs *buf) __attribute__ ((regparm (2)));
int __stdcall fchmod (mode_t mode) __attribute__ ((regparm (1)));
int __stdcall fchown (__uid32_t uid, __gid32_t gid) __attribute__ ((regparm (2)));
int __stdcall facl (int, int, __acl32 *) __attribute__ ((regparm (3)));
int __stdcall link (const char *) __attribute__ ((regparm (2)));
- bool is_slow () {return 1;}
+ bool is_slow () {return true;}
};
class fhandler_pipe: public fhandler_base
{
-protected:
- HANDLE guard;
- bool broken_pipe;
- HANDLE writepipe_exists;
- DWORD orig_pid;
- unsigned id;
+private:
+ pid_t popen_pid;
+ OVERLAPPED io_status;
+ OVERLAPPED *overlapped;
public:
fhandler_pipe ();
+
+ OVERLAPPED *get_overlapped () {return overlapped;}
+ OVERLAPPED *get_overlapped_buffer () {return &io_status;}
+ void set_overlapped (OVERLAPPED *ov) {overlapped = ov;}
+
+ bool ispipe() const { return true; }
+
+ void set_popen_pid (pid_t pid) {popen_pid = pid;}
+ pid_t get_popen_pid () const {return popen_pid;}
_off64_t lseek (_off64_t offset, int whence);
- select_record *select_read (select_record *s);
- select_record *select_write (select_record *s);
- select_record *select_except (select_record *s);
+ select_record *select_read (select_stuff *);
+ select_record *select_write (select_stuff *);
+ select_record *select_except (select_stuff *);
char *get_proc_fd_name (char *buf);
- void set_close_on_exec (bool val);
- void __stdcall read (void *ptr, size_t& len) __attribute__ ((regparm (3)));
+ void __stdcall raw_read (void *ptr, size_t& len);
+ ssize_t __stdcall raw_write (const void *, size_t);
int open (int flags, mode_t mode = 0);
- int close ();
- void create_guard ()
- {
- guard = CreateMutex (&sec_none, FALSE, NULL);
- ProtectHandleINH (guard);
- }
int dup (fhandler_base *child);
int ioctl (unsigned int cmd, void *);
- void fixup_in_child ();
- virtual void fixup_after_fork (HANDLE);
- void fixup_after_exec ();
- bool hit_eof ();
- void set_eof () {broken_pipe = true;}
- HANDLE get_guard () const {return guard;}
+ int __stdcall fstatvfs (struct statvfs *buf) __attribute__ ((regparm (2)));
+ int __stdcall fadvise (_off64_t, _off64_t, int) __attribute__ ((regparm (3)));
+ int __stdcall ftruncate (_off64_t, bool) __attribute__ ((regparm (3)));
int ready_for_read (int fd, DWORD howlong);
- static int create (fhandler_pipe *[2], unsigned, int, bool = false);
- bool is_slow () {return true;}
- static int create_selectable (LPSECURITY_ATTRIBUTES, HANDLE&, HANDLE&, DWORD, bool);
+ int init (HANDLE, DWORD, mode_t);
+ static int create (fhandler_pipe *[2], unsigned, int);
+ static int create_selectable (LPSECURITY_ATTRIBUTES, HANDLE&, HANDLE&, DWORD, const char * = NULL);
friend class fhandler_fifo;
};
-class fhandler_fifo: public fhandler_pipe
+class fhandler_fifo: public fhandler_base
{
- HANDLE output_handle;
- long read_use;
- long write_use;
- virtual HANDLE& get_io_handle () { return io_handle ?: output_handle; }
+ enum fifo_state
+ {
+ fifo_unknown,
+ fifo_wait_for_client,
+ fifo_wait_for_server,
+ fifo_wait_for_next_client,
+ fifo_eof,
+ fifo_error,
+ fifo_eintr,
+ fifo_ok
+ };
+ fifo_state wait_state;
+ HANDLE dummy_client;
+ HANDLE open_nonserver (const char *, unsigned, LPSECURITY_ATTRIBUTES);
+ OVERLAPPED io_status;
+ bool wait (bool) __attribute__ ((regparm (1)));
+ char *fifo_name (char *) __attribute__ ((regparm (2)));
public:
fhandler_fifo ();
- int open (int flags, mode_t mode = 0);
- int open_not_mine (int flags) __attribute__ ((regparm (2)));
+ void __stdcall raw_read (void *, size_t&);
+ ssize_t __stdcall raw_write (const void *, size_t);
+ int open (int, mode_t);
int close ();
- void set_use (int flags) __attribute__ ((regparm (2)));
- bool isfifo () { return true; }
- HANDLE& get_output_handle () { return output_handle; }
- void set_output_handle (HANDLE h) { output_handle = h; }
- void set_use ();
int dup (fhandler_base *child);
- bool is_slow () {return true;}
- void close_one_end ();
+ bool isfifo () const { return true; }
+ void set_close_on_exec (bool val);
+ int __stdcall fstatvfs (struct statvfs *buf) __attribute__ ((regparm (2)));
+ OVERLAPPED *get_overlapped () {return &io_status;}
+ OVERLAPPED *get_overlapped_buffer () {return &io_status;}
+ select_record *select_read (select_stuff *);
+ select_record *select_write (select_stuff *);
+ select_record *select_except (select_stuff *);
};
class fhandler_dev_raw: public fhandler_base
IMPLEMENT_STATUS_FLAG (bool, eom_detected)
inline _off64_t get_current_position ();
- int fhandler_dev_floppy::get_drive_info (struct hd_geometry *geo);
+ int get_drive_info (struct hd_geometry *geo);
BOOL write_file (const void *buf, DWORD to_write, DWORD *written, int *err);
BOOL read_file (void *buf, DWORD to_read, DWORD *read, int *err);
int open (int flags, mode_t mode = 0);
int dup (fhandler_base *child);
- void raw_read (void *ptr, size_t& ulen);
- int raw_write (const void *ptr, size_t ulen);
+ void __stdcall raw_read (void *ptr, size_t& ulen);
+ ssize_t __stdcall raw_write (const void *ptr, size_t ulen);
_off64_t lseek (_off64_t offset, int whence);
int ioctl (unsigned int cmd, void *buf);
};
virtual int open (int flags, mode_t mode = 0);
virtual int close ();
- void raw_read (void *ptr, size_t& ulen);
- int raw_write (const void *ptr, size_t ulen);
+ void __stdcall raw_read (void *ptr, size_t& ulen);
+ ssize_t __stdcall raw_write (const void *ptr, size_t ulen);
virtual _off64_t lseek (_off64_t offset, int whence);
class fhandler_disk_file: public fhandler_base
{
- void touch_ctime ();
- int readdir_helper (DIR *, dirent *, DWORD, DWORD, char *) __attribute__ ((regparm (3)));
- int readdir_9x (DIR *, dirent *) __attribute__ ((regparm (3)));
+ int readdir_helper (DIR *, dirent *, DWORD, DWORD, PUNICODE_STRING fname) __attribute__ ((regparm (3)));
public:
fhandler_disk_file ();
fhandler_disk_file (path_conv &pc);
int open (int flags, mode_t mode);
- int close ();
int lock (int, struct __flock64 *);
- bool isdevice () { return false; }
+ bool isdevice () const { return false; }
int __stdcall fstat (struct __stat64 *buf) __attribute__ ((regparm (2)));
int __stdcall fchmod (mode_t mode) __attribute__ ((regparm (1)));
int __stdcall fchown (__uid32_t uid, __gid32_t gid) __attribute__ ((regparm (2)));
int __stdcall facl (int, int, __acl32 *) __attribute__ ((regparm (3)));
- int __stdcall ftruncate (_off64_t) __attribute__ ((regparm (2)));
+ ssize_t __stdcall fgetxattr (const char *, void *, size_t) __attribute__ ((regparm (3)));
+ int __stdcall fsetxattr (const char *, const void *, size_t, int) __attribute__ ((regparm (3)));
+ int __stdcall fadvise (_off64_t, _off64_t, int) __attribute__ ((regparm (3)));
+ int __stdcall ftruncate (_off64_t, bool) __attribute__ ((regparm (3)));
int __stdcall link (const char *) __attribute__ ((regparm (2)));
- int __stdcall utimes (const struct timeval *) __attribute__ ((regparm (2)));
+ int __stdcall utimens (const struct timespec *) __attribute__ ((regparm (2)));
+ int __stdcall fstatvfs (struct statvfs *buf) __attribute__ ((regparm (2)));
HANDLE mmap (caddr_t *addr, size_t len, int prot, int flags, _off64_t off);
int munmap (HANDLE h, caddr_t addr, size_t len);
_off64_t offset, DWORD size, void *address);
int mkdir (mode_t mode);
int rmdir ();
- DIR *opendir ();
+ DIR *opendir (int fd) __attribute__ ((regparm (2)));
int readdir (DIR *, dirent *) __attribute__ ((regparm (3)));
_off64_t telldir (DIR *);
void seekdir (DIR *, _off64_t);
class fhandler_cygdrive: public fhandler_disk_file
{
+ enum
+ {
+ DRVSZ = sizeof ("x:\\")
+ };
int ndrives;
const char *pdrive;
+ char pdrive_buf[1 + (2 * 26 * DRVSZ)];
void set_drives ();
public:
fhandler_cygdrive ();
int open (int flags, mode_t mode);
int close ();
- DIR *opendir ();
+ DIR *opendir (int fd) __attribute__ ((regparm (2)));
int readdir (DIR *, dirent *) __attribute__ ((regparm (3)));
void rewinddir (DIR *);
int closedir (DIR *);
int open (int flags, mode_t mode);
int close ();
- void init (HANDLE h, DWORD a, mode_t flags);
+ int init (HANDLE h, DWORD a, mode_t flags);
void overlapped_setup ();
int dup (fhandler_base *child);
- void raw_read (void *ptr, size_t& ulen);
- int raw_write (const void *ptr, size_t ulen);
+ void __stdcall raw_read (void *ptr, size_t& ulen);
+ ssize_t __stdcall raw_write (const void *ptr, size_t ulen);
int tcsendbreak (int);
int tcdrain ();
int tcflow (int);
int tcgetattr (struct termios *t);
_off64_t lseek (_off64_t, int) { return 0; }
int tcflush (int);
- int is_tty () { return 1; }
+ bool is_tty () const { return true; }
void fixup_after_fork (HANDLE parent);
void fixup_after_exec ();
permission checking on pgrps. */
virtual int tcgetpgrp () { return pgrp_; }
virtual int tcsetpgrp (const pid_t pid) { pgrp_ = pid; return 0; }
- select_record *select_read (select_record *s);
- select_record *select_write (select_record *s);
- select_record *select_except (select_record *s);
- bool is_slow () {return 1;}
+ select_record *select_read (select_stuff *);
+ select_record *select_write (select_stuff *);
+ select_record *select_except (select_stuff *);
+ bool is_slow () {return true;}
};
#define acquire_output_mutex(ms) \
- __acquire_output_mutex (__PRETTY_FUNCTION__, __LINE__, ms);
+ __acquire_output_mutex (__PRETTY_FUNCTION__, __LINE__, ms)
#define release_output_mutex() \
- __release_output_mutex (__PRETTY_FUNCTION__, __LINE__);
+ __release_output_mutex (__PRETTY_FUNCTION__, __LINE__)
class tty;
class tty_min;
line_edit_status line_edit (const char *rptr, int nread, termios&);
void set_output_handle (HANDLE h) { output_handle = h; }
void tcinit (tty_min *this_tc, bool force = false);
- virtual int is_tty () { return 1; }
+ bool is_tty () const { return true; }
int tcgetpgrp ();
int tcsetpgrp (int pid);
bg_check_types bg_check (int sig);
virtual DWORD __acquire_output_mutex (const char *fn, int ln, DWORD ms) {return 1;}
virtual void __release_output_mutex (const char *fn, int ln) {}
- void fixup_after_fork (HANDLE);
- void fixup_after_exec ();
void echo_erase (int force = 0);
virtual _off64_t lseek (_off64_t, int);
};
unsigned rarg;
bool saw_question_mark;
bool alternate_charset_active;
+ bool metabit;
char my_title_buf [TITLESIZE + 1];
bool use_mouse;
bool raw_win32_keyboard_mode;
- bool con_to_str (char *d, const char *s, DWORD sz);
- bool str_to_con (char *d, const char *s, DWORD sz);
+ inline UINT get_console_cp ();
+ DWORD con_to_str (char *d, int dlen, WCHAR w);
+ DWORD str_to_con (mbtowc_p, const char *, PWCHAR d, const char *s, DWORD sz);
void set_color (HANDLE);
bool fillin_info (HANDLE);
void set_default_attr ();
class fhandler_console: public fhandler_termios
{
private:
+ static const unsigned MAX_WRITE_CHARS;
static dev_console *dev_state;
static bool invisible_console;
+ /* Used when we encounter a truncated multi-byte sequence. The
+ lead bytes are stored here and revisited in the next write call. */
+ struct {
+ int len;
+ unsigned char buf[4]; /* Max len of valid UTF-8 sequence. */
+ } trunc_buf;
+ PWCHAR write_buf;
+
/* Output calls */
void set_default_attr ();
void cursor_set (bool, int, int);
void cursor_get (int *, int *);
void cursor_rel (int, int);
+ inline void write_replacement_char ();
+ inline bool write_console (PWCHAR, DWORD, DWORD&);
const unsigned char *write_normal (unsigned const char*, unsigned const char *);
void char_command (char);
bool set_raw_win32_keyboard_mode (bool);
int igncr_enabled ();
int input_tcsetattr (int a, const struct termios *t);
void set_cursor_maybe ();
+ static bool create_invisible_console (HWINSTA);
+ static bool create_invisible_console_workaround ();
public:
fhandler_console ();
int open (int flags, mode_t mode = 0);
- int write (const void *ptr, size_t len);
- void doecho (const void *str, DWORD len) { (void) write (str, len); }
void __stdcall read (void *ptr, size_t& len) __attribute__ ((regparm (3)));
+ ssize_t __stdcall write (const void *ptr, size_t len);
+ void doecho (const void *str, DWORD len) { (void) write (str, len); }
int close ();
int tcflush (int);
int dup (fhandler_base *child);
int ioctl (unsigned int cmd, void *);
- void init (HANDLE, DWORD, mode_t);
+ int init (HANDLE, DWORD, mode_t);
bool mouse_aware () {return dev_state->use_mouse;}
- select_record *select_read (select_record *s);
- select_record *select_write (select_record *s);
- select_record *select_except (select_record *s);
+ select_record *select_read (select_stuff *);
+ select_record *select_write (select_stuff *);
+ select_record *select_except (select_stuff *);
void fixup_after_fork_exec (bool);
void fixup_after_exec () {fixup_after_fork_exec (true);}
void fixup_after_fork (HANDLE) {fixup_after_fork_exec (false);}
void set_input_state ();
void send_winch_maybe ();
static tty_min *get_tty_stuff (int);
- bool is_slow () {return 1;}
+ bool is_slow () {return true;}
static bool need_invisible ();
- static bool fhandler_console::has_a () {return !invisible_console;}
+ static bool has_a () {return !invisible_console;}
};
class fhandler_tty_common: public fhandler_termios
fhandler_tty_common ()
: fhandler_termios (), output_done_event (NULL),
ioctl_request_event (NULL), ioctl_done_event (NULL), output_mutex (NULL),
- input_mutex (NULL), input_available_event (NULL), inuse (NULL)
+ input_mutex (NULL), input_available_event (NULL)
{
// nothing to do
}
// Ioctl() status in tty::ioctl_retval.
HANDLE output_mutex, input_mutex;
HANDLE input_available_event;
- HANDLE inuse; // used to indicate that a tty is in use
DWORD __acquire_output_mutex (const char *fn, int ln, DWORD ms);
void __release_output_mutex (const char *fn, int ln);
- virtual int dup (fhandler_base *child);
-
tty *get_ttyp () { return (tty *) tc; }
int close ();
_off64_t lseek (_off64_t, int);
void set_close_on_exec (bool val);
- void fixup_after_fork (HANDLE parent);
- select_record *select_read (select_record *s);
- select_record *select_write (select_record *s);
- select_record *select_except (select_record *s);
- bool is_slow () {return 1;}
+ select_record *select_read (select_stuff *);
+ select_record *select_write (select_stuff *);
+ select_record *select_except (select_stuff *);
+ bool is_slow () {return true;}
};
class fhandler_tty_slave: public fhandler_tty_common
{
+ HANDLE inuse; // used to indicate that a tty is in use
public:
/* Constructor */
fhandler_tty_slave ();
int open (int flags, mode_t mode = 0);
- int write (const void *ptr, size_t len);
+ ssize_t __stdcall write (const void *ptr, size_t len);
void __stdcall read (void *ptr, size_t& len) __attribute__ ((regparm (3)));
- void init (HANDLE, DWORD, mode_t);
+ int init (HANDLE, DWORD, mode_t);
int tcsetattr (int a, const struct termios *t);
int tcgetattr (struct termios *t);
int close ();
int dup (fhandler_base *child);
void fixup_after_fork (HANDLE parent);
+ void fixup_after_exec ();
- select_record *select_read (select_record *s);
+ select_record *select_read (select_stuff *);
int cygserver_attach_tty (HANDLE*, HANDLE*);
int get_unit ();
virtual char const *ttyname () { return pc.dev.name; }
class fhandler_pty_master: public fhandler_tty_common
{
int pktmode; // non-zero if pty in a packet mode.
-protected:
- device slave; // device type of slave
public:
int need_nl; // Next read should start with \n
+ DWORD dwProcessId; // Owner of master handles
/* Constructor */
fhandler_pty_master ();
void doecho (const void *str, DWORD len);
int accept_input ();
int open (int flags, mode_t mode = 0);
- int write (const void *ptr, size_t len);
+ ssize_t __stdcall write (const void *ptr, size_t len);
void __stdcall read (void *ptr, size_t& len) __attribute__ ((regparm (3)));
int close ();
char *ptsname ();
- void set_close_on_exec (bool val);
+ HANDLE from_master, to_master;
bool hit_eof ();
- int get_unit () const { return slave.minor; }
+ bool setup (bool);
+ int dup (fhandler_base *);
+ void fixup_after_fork (HANDLE parent);
+ void fixup_after_exec ();
+ int tcgetpgrp ();
};
class fhandler_tty_master: public fhandler_pty_master
int init ();
int init_console ();
void set_winsize (bool);
- bool is_slow () {return 1;}
+ bool is_slow () {return true;}
};
class fhandler_dev_null: public fhandler_base
{
public:
fhandler_dev_null ();
- int open (int, mode_t);
- select_record *select_read (select_record *s);
- select_record *select_write (select_record *s);
- select_record *select_except (select_record *s);
+ select_record *select_read (select_stuff *);
+ select_record *select_write (select_stuff *);
+ select_record *select_except (select_stuff *);
};
class fhandler_dev_zero: public fhandler_base
public:
fhandler_dev_zero ();
int open (int flags, mode_t mode = 0);
- int write (const void *ptr, size_t len);
+ ssize_t __stdcall write (const void *ptr, size_t len);
void __stdcall read (void *ptr, size_t& len) __attribute__ ((regparm (3)));
_off64_t lseek (_off64_t offset, int whence);
protected:
HCRYPTPROV crypt_prov;
long pseudo;
+ _off64_t dummy_offset;
bool crypt_gen_random (void *ptr, size_t len);
int pseudo_write (const void *ptr, size_t len);
public:
fhandler_dev_random ();
int open (int flags, mode_t mode = 0);
- int write (const void *ptr, size_t len);
+ ssize_t __stdcall write (const void *ptr, size_t len);
void __stdcall read (void *ptr, size_t& len) __attribute__ ((regparm (3)));
_off64_t lseek (_off64_t offset, int whence);
int close ();
~fhandler_dev_mem ();
int open (int flags, mode_t mode = 0);
- int write (const void *ptr, size_t ulen);
+ ssize_t __stdcall write (const void *ptr, size_t ulen);
void __stdcall read (void *ptr, size_t& len) __attribute__ ((regparm (3)));
_off64_t lseek (_off64_t offset, int whence);
int __stdcall fstat (struct __stat64 *buf) __attribute__ ((regparm (2)));
fhandler_dev_clipboard ();
int is_windows () { return 1; }
int open (int flags, mode_t mode = 0);
- int write (const void *ptr, size_t len);
+ ssize_t __stdcall write (const void *ptr, size_t len);
void __stdcall read (void *ptr, size_t& len) __attribute__ ((regparm (3)));
_off64_t lseek (_off64_t offset, int whence);
int close ();
fhandler_windows ();
int is_windows () { return 1; }
int open (int flags, mode_t mode = 0);
- int write (const void *ptr, size_t len);
+ ssize_t __stdcall write (const void *ptr, size_t len);
void __stdcall read (void *ptr, size_t& len) __attribute__ ((regparm (3)));
int ioctl (unsigned int cmd, void *);
_off64_t lseek (_off64_t, int) { return 0; }
void set_close_on_exec (bool val);
void fixup_after_fork (HANDLE parent);
- select_record *select_read (select_record *s);
- select_record *select_write (select_record *s);
- select_record *select_except (select_record *s);
- bool is_slow () {return 1;}
+ select_record *select_read (select_stuff *);
+ select_record *select_write (select_stuff *);
+ select_record *select_except (select_stuff *);
+ bool is_slow () {return true;}
};
class fhandler_dev_dsp: public fhandler_base
fhandler_dev_dsp ();
int open (int flags, mode_t mode = 0);
- int write (const void *ptr, size_t len);
+ ssize_t __stdcall write (const void *ptr, size_t len);
void __stdcall read (void *ptr, size_t& len) __attribute__ ((regparm (3)));
int ioctl (unsigned int cmd, void *);
_off64_t lseek (_off64_t, int);
{
protected:
char *filebuf;
- size_t bufalloc;
_off64_t filesize;
_off64_t position;
int fileid; // unique within each class
virtual ~fhandler_virtual();
virtual int exists();
- virtual DIR *opendir ();
+ DIR *opendir (int fd) __attribute__ ((regparm (2)));
_off64_t telldir (DIR *);
void seekdir (DIR *, _off64_t);
void rewinddir (DIR *);
int closedir (DIR *);
- int write (const void *ptr, size_t len);
+ ssize_t __stdcall write (const void *ptr, size_t len);
void __stdcall read (void *ptr, size_t& len) __attribute__ ((regparm (3)));
_off64_t lseek (_off64_t, int);
int dup (fhandler_base *child);
int open (int flags, mode_t mode = 0);
int close ();
int __stdcall fstat (struct stat *buf) __attribute__ ((regparm (2)));
+ int __stdcall fstatvfs (struct statvfs *buf) __attribute__ ((regparm (2)));
int __stdcall fchmod (mode_t mode) __attribute__ ((regparm (1)));
int __stdcall fchown (__uid32_t uid, __gid32_t gid) __attribute__ ((regparm (2)));
int __stdcall facl (int, int, __acl32 *) __attribute__ ((regparm (3)));
{
private:
char *value_name;
+ DWORD wow64;
+ int prefix_len;
public:
fhandler_registry ();
+ void set_name (path_conv &pc);
int exists();
int readdir (DIR *, dirent *) __attribute__ ((regparm (3)));
_off64_t telldir (DIR *);
int __stdcall fstat (struct __stat64 *buf) __attribute__ ((regparm (2)));
bool fill_filebuf ();
int close ();
+ int dup (fhandler_base *child);
};
class pinfo;
public:
fhandler_process ();
int exists();
- DIR *opendir ();
+ DIR *opendir (int fd) __attribute__ ((regparm (2)));
+ int readdir (DIR *, dirent *) __attribute__ ((regparm (3)));
+ int open (int flags, mode_t mode = 0);
+ int __stdcall fstat (struct __stat64 *buf) __attribute__ ((regparm (2)));
+ bool fill_filebuf ();
+};
+
+class fhandler_procnet: public fhandler_proc
+{
+ pid_t pid;
+ public:
+ fhandler_procnet ();
+ int exists();
int readdir (DIR *, dirent *) __attribute__ ((regparm (3)));
int open (int flags, mode_t mode = 0);
int __stdcall fstat (struct __stat64 *buf) __attribute__ ((regparm (2)));
char __virtual[sizeof (fhandler_virtual)];
char __windows[sizeof (fhandler_windows)];
} fhandler_union;
-
-struct select_record
-{
- int fd;
- HANDLE h;
- fhandler_base *fh;
- int thread_errno;
- bool windows_handle;
- bool read_ready, write_ready, except_ready;
- bool read_selected, write_selected, except_selected;
- bool except_on_write;
- int (*startup) (select_record *me, class select_stuff *stuff);
- int (*peek) (select_record *, bool);
- int (*verify) (select_record *me, fd_set *readfds, fd_set *writefds,
- fd_set *exceptfds);
- void (*cleanup) (select_record *me, class select_stuff *stuff);
- struct select_record *next;
- void set_select_errno () {__seterrno (); thread_errno = errno;}
- int saw_error () {return thread_errno;}
-
- select_record (fhandler_base *in_fh = NULL) : fd (0), h (NULL),
- fh (in_fh), thread_errno (0), windows_handle (false),
- read_ready (false), write_ready (false), except_ready (false),
- read_selected (false), write_selected (false),
- except_selected (false), except_on_write (false),
- startup (NULL), peek (NULL), verify (NULL), cleanup (NULL),
- next (NULL) {}
-};
-
-class select_stuff
-{
- public:
- ~select_stuff ();
- bool always_ready, windows_used;
- select_record start;
- void *device_specific_pipe;
- void *device_specific_socket;
- void *device_specific_serial;
- void *device_specific_mailslot;
-
- int test_and_set (int i, fd_set *readfds, fd_set *writefds,
- fd_set *exceptfds);
- int poll (fd_set *readfds, fd_set *writefds, fd_set *exceptfds);
- int wait (fd_set *readfds, fd_set *writefds, fd_set *exceptfds, DWORD ms);
- void cleanup ();
- select_stuff (): always_ready (0), windows_used (0), start (0),
- device_specific_pipe (0),
- device_specific_socket (0),
- device_specific_serial (0),
- device_specific_mailslot (0) {}
-};
-
-void __stdcall set_console_state_for_spawn (bool);
#endif /* _FHANDLER_H_ */
OSDN Git Service
