extern const int proc_len;
class select_record;
+class select_stuff;
class fhandler_disk_file;
class inode_t;
typedef struct __DIR DIR;
query_write_attributes = 4
};
+enum del_lock_called_from {
+ on_close,
+ after_fork,
+ after_exec
+};
+
class fhandler_base
{
friend class dtable;
/* Used for advisory file locking. See flock.cc. */
long long unique_id;
- void del_my_locks (bool);
+ void del_my_locks (del_lock_called_from);
HANDLE read_state;
int wait_overlapped (bool, bool, DWORD *, DWORD = 0) __attribute__ ((regparm (3)));
return close_on_exec () ? &sec_none_nih : &sec_none;
}
+ virtual int fixup_before_fork_exec (DWORD) { return 0; }
virtual void fixup_after_fork (HANDLE);
virtual void fixup_after_exec ();
void create_read_state (LONG n)
/* fixup fd possibly non-inherited handles after fork */
bool fork_fixup (HANDLE, HANDLE &, const char *);
+ virtual bool need_fixup_before () const {return false;}
virtual int open (int, mode_t = 0);
int open_fs (int, mode_t = 0);
virtual char const *ttyname () { return get_name (); }
virtual void __stdcall read (void *ptr, size_t& len) __attribute__ ((regparm (3)));
virtual void __stdcall read_overlapped (void *ptr, size_t& len) __attribute__ ((regparm (3)));
- virtual int write (const void *ptr, size_t len);
- virtual int __stdcall write_overlapped (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 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);
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 tcsetpgrp (const pid_t pid);
virtual int tcgetpgrp ();
virtual bool is_tty () const { return false; }
- virtual bool isdevice () { return true; }
- virtual bool isfifo () { 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 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 ()
{
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)));
+ 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
void af_local_set_sockpair_cred ();
private:
+ 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 */
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);
+ 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 writev (const struct iovec *, int iovcnt, ssize_t tot = -1);
+ 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 dup (fhandler_base *child);
void set_close_on_exec (bool val);
+ int fixup_before_fork_exec (DWORD);
void fixup_after_fork (HANDLE);
+ void fixup_after_exec ();
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;}
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)));
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 raw_read (void *ptr, size_t& len);
- int raw_write (const void *, size_t);
+ 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 dup (fhandler_base *child);
int ioctl (unsigned int cmd, void *);
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);
- void init (HANDLE, DWORD, mode_t);
+ 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;
};
-enum fifo_state
-{
- fifo_unknown,
- fifo_wait_for_client,
- fifo_wait_for_server,
- fifo_ok
-};
class fhandler_fifo: public fhandler_base
{
+ 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 ();
- void raw_read (void *, size_t&);
- int raw_write (const void *, size_t);
+ void __stdcall raw_read (void *, size_t&);
+ ssize_t __stdcall raw_write (const void *, size_t);
int open (int, mode_t);
- bool isfifo () { return true; }
+ int close ();
+ int dup (fhandler_base *child);
+ 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_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_raw: public fhandler_base
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);
int open (int flags, mode_t mode);
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)));
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 ();
- 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);
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);
+ select_record *select_read (select_stuff *);
+ select_record *select_write (select_stuff *);
+ select_record *select_except (select_stuff *);
bool is_slow () {return true;}
};
inline UINT get_console_cp ();
DWORD con_to_str (char *d, int dlen, WCHAR w);
- DWORD str_to_con (mbtowc_p, char *, PWCHAR d, const char *s, DWORD sz);
+ 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 ();
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);}
int close ();
_off64_t lseek (_off64_t, int);
void set_close_on_exec (bool val);
- 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 *);
bool is_slow () {return true;}
};
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);
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; }
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 ();
int dup (fhandler_base *);
void fixup_after_fork (HANDLE parent);
void fixup_after_exec ();
+ int tcgetpgrp ();
};
class fhandler_tty_master: public fhandler_pty_master
public:
fhandler_dev_null ();
- 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);
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);
+ select_record *select_read (select_stuff *);
+ select_record *select_write (select_stuff *);
+ select_record *select_except (select_stuff *);
bool is_slow () {return true;}
};
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);
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);
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) {}
-};
#endif /* _FHANDLER_H_ */
OSDN Git Service
