fhandler_dev_tape (fhandler_tape.cc)
fhandler_pipe
- fhandler_socket (net.cc)
+ fhandler_socket (fhandler_socket.cc)
fhandler_tty_slave (tty.cc)
fhandler_pty_master (tty.cc)
fhandler_dev_mem /dev/mem implementation (fhandler_mem.cc)
+ fhandler_dev_clipboard /dev/clipboard implementation (fhandler_clipboard.cc)
+
fhandler_proc Interesting possibility, not implemented yet
*/
FH_ZERO = 0x00000014, /* is the zero device */
FH_RANDOM = 0x00000015, /* is a random device */
FH_MEM = 0x00000016, /* is a mem device */
+ FH_CLIPBOARD = 0x00000017, /* is a clipbaord device */
- FH_NDEV = 0x00000017, /* Maximum number of devices */
+ FH_NDEV = 0x00000018, /* Maximum number of devices */
FH_DEVMASK = 0x00000fff, /* devices live here */
FH_BAD = 0xffffffff
};
class path_conv;
class fhandler_disk_file;
+enum bg_check_types
+{
+ bg_error = -1,
+ bg_eof = 0,
+ bg_ok = 1,
+ bg_signalled = 2
+};
+
+enum executable_states
+{
+ is_executable,
+ not_executable,
+ dont_care_if_executable,
+ dont_know_if_executable
+};
+
class fhandler_base
{
private:
int access_;
HANDLE io_handle;
- int rpos_; /* Used in text reading */
- int rsize_;
-
unsigned long namehash_; /* hashed filename, used as inode num */
/* Full unix path name of this file */
virtual ~fhandler_base ();
/* Non-virtual simple accessor functions. */
- void set_io_handle (HANDLE);
+ void set_io_handle (HANDLE x) { io_handle = x; }
void set_cb (size_t size) { cb = size; }
DWORD get_device () { return status & FH_DEVMASK; }
void set_need_fork_fixup () { FHSETF (FFIXUP); }
virtual void set_close_on_exec (int val);
- virtual void fixup_after_fork (HANDLE parent);
+
+ virtual void fixup_before_fork_exec (DWORD) {}
+ virtual void fixup_after_fork (HANDLE);
+ virtual void fixup_after_exec (HANDLE) {}
int get_symlink_p () { return FHISSETF (SYMLINK); }
void set_symlink_p (int val) { FHCONDSETF (val, SYMLINK); }
void set_socket_p () { FHSETF (LOCAL); }
int get_execable_p () { return FHISSETF (EXECABL); }
- void set_execable_p (int val) { FHCONDSETF (val, EXECABL); }
+ void set_execable_p (executable_states val)
+ {
+ FHCONDSETF (val == is_executable, EXECABL);
+ }
void set_execable_p () { FHSETF (EXECABL); }
int get_append_p () { return FHISSETF (APPEND); }
}
virtual int open (int flags, mode_t mode = 0);
virtual int close ();
- virtual int fstat (struct stat *buf);
+ virtual int fstat (struct stat *buf) { return stat_dev (get_device (), get_unit (), get_namehash (), buf); }
virtual int ioctl (unsigned int cmd, void *);
+ virtual int fcntl (int cmd, void *);
virtual char const * ttyname () { return get_name(); }
virtual int read (void *ptr, size_t len);
virtual int write (const void *ptr, size_t len);
virtual void dump ();
virtual int dup (fhandler_base *child);
+ virtual HANDLE mmap (caddr_t *addr, size_t len, DWORD access,
+ int flags, off_t off);
+ virtual int munmap (HANDLE h, caddr_t addr, size_t len);
+ virtual int msync (HANDLE h, caddr_t addr, size_t len, int flags);
+ virtual BOOL fixup_mmap_after_fork (HANDLE h, DWORD access, DWORD offset,
+ DWORD size, void *address);
+
void *operator new (size_t, void *p) {return p;}
virtual void init (HANDLE, DWORD, mode_t);
virtual int raw_read (void *ptr, size_t ulen);
virtual int raw_write (const void *ptr, size_t ulen);
- virtual void fixup_after_exec (HANDLE) {}
-
/* Virtual accessor functions to hide the fact
that some fd's have two handles. */
- virtual HANDLE get_handle () const { return io_handle; }
- virtual HANDLE get_io_handle () const { return io_handle; }
- virtual HANDLE get_output_handle () const { return io_handle; }
+ virtual HANDLE& get_handle () { return io_handle; }
+ 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);
{
return windows_device_names[FHDEVN (status)];
}
- virtual int bg_check (int) {return 1;}
+ virtual bg_check_types bg_check (int) {return bg_ok;}
void clear_readahead ()
{
raixput = raixget = ralen = rabuflen = 0;
{
private:
int addr_family;
+ struct _WSAPROTOCOL_INFOA *prot_info_ptr;
+
public:
fhandler_socket (const char *name = 0);
- fhandler_socket (unsigned int, const char *name = 0);
- int get_socket () const { return (int) get_handle(); }
+ ~fhandler_socket ();
+ int get_socket () { return (int) get_handle(); }
fhandler_socket * is_socket () { return this; }
int write (const void *ptr, size_t len);
int read (void *ptr, size_t len);
int ioctl (unsigned int cmd, void *);
+ int fcntl (int cmd, void *);
off_t lseek (off_t, int) { return 0; }
int close ();
void hclose (HANDLE) {close ();}
+ int dup (fhandler_base *child);
+
+ virtual void fixup_before_fork_exec (DWORD);
+ void fixup_after_fork (HANDLE);
+ void fixup_after_exec (HANDLE parent) { fixup_after_fork (parent); }
select_record *select_read (select_record *s);
select_record *select_write (select_record *s);
int dup (fhandler_base *child);
int ioctl (unsigned int cmd, void *buf);
+
+ void fixup_after_fork (HANDLE);
+ void fixup_after_exec (HANDLE parent) { fixup_after_fork (parent); }
};
class fhandler_dev_floppy: public fhandler_dev_raw
class fhandler_disk_file: public fhandler_base
{
-private:
- int check_execable_p (const char *path);
-
public:
fhandler_disk_file (const char *name);
int lock (int, struct flock *);
BOOL is_device () { return FALSE; }
int fstat (struct stat *buf);
+
+ HANDLE mmap (caddr_t *addr, size_t len, DWORD access, int flags, off_t off);
+ int munmap (HANDLE h, caddr_t addr, size_t len);
+ int msync (HANDLE h, caddr_t addr, size_t len, int flags);
+ BOOL fixup_mmap_after_fork (HANDLE h, DWORD access, DWORD offset,
+ DWORD size, void *address);
};
class fhandler_serial: public fhandler_base
fhandler_termios (DWORD dev, const char *name = 0, int unit = 0) :
fhandler_base (dev, name, unit)
{
- // nothing to do
+ set_need_fork_fixup ();
}
- HANDLE get_output_handle () const { return output_handle; }
+ HANDLE& get_output_handle () { return output_handle; }
int line_edit (const char *rptr, int nread, int always_accept = 0);
void set_output_handle (HANDLE h) { output_handle = h; }
void tcinit (tty_min *this_tc, int force = FALSE);
int tcgetpgrp ();
int tcsetpgrp (int pid);
void set_ctty (int ttynum, int flags);
- int bg_check (int sig);
+ 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 (HANDLE parent) { fixup_after_fork (parent); }
};
-/* This is a input and output console handle */
-class fhandler_console: public fhandler_termios
+enum ansi_intensity
{
-private:
-
-/* Output state */
+ INTENSITY_INVISIBLE,
+ INTENSITY_DIM,
+ INTENSITY_NORMAL,
+ INTENSITY_BOLD
+};
- // enum {normal, gotesc, gotsquare, gotarg1, gotcommand} state;
#define normal 1
#define gotesc 2
#define gotsquare 3
#define gettitle 7
#define eattitle 8
#define MAXARGS 10
+
+/* This is a input and output console handle */
+class fhandler_console: public fhandler_termios
+{
+private:
+
+ WORD default_color, underline_color, dim_color;
+
+ /* Used to determine if an input keystroke should be modified with META. */
+ int meta_mask;
+
+/* Output state */
int state_;
int args_[MAXARGS];
int nargs_;
-
- DWORD default_color;
+ unsigned rarg;
+ BOOL saw_question_mark;
+
+ char my_title_buf [TITLESIZE + 1];
+
+ WORD current_win32_attr;
+ ansi_intensity intensity;
+ BOOL underline, blink, reverse;
+ WORD fg, bg;
+
+ /* saved cursor coordinates */
+ int savex, savey;
+
+ struct
+ {
+ short Top, Bottom;
+ } scroll_region;
+ struct
+ {
+ SHORT winTop;
+ SHORT winBottom;
+ COORD dwWinSize;
+ COORD dwBufferSize;
+ COORD dwCursorPosition;
+ WORD wAttributes;
+ } info;
+
+ COORD dwLastCursorPosition;
+ DWORD dwLastButtonState;
+ int nModifiers;
+
+ BOOL use_mouse;
+ BOOL raw_win32_keyboard_mode;
/* Output calls */
+ void set_default_attr ();
+ WORD get_win32_attr ();
BOOL fillin_info ();
void clear_screen (int, int, int, int);
void cursor_rel (int, int);
const unsigned char * write_normal (unsigned const char*, unsigned const char *);
void char_command (char);
+ BOOL set_raw_win32_keyboard_mode (BOOL);
int output_tcsetattr (int a, const struct termios *t);
/* Input calls */
int tcsetattr (int a, const struct termios *t);
int tcgetattr (struct termios *t);
- int tcsetpgrp (const pid_t pid);
-
/* Special dup as we must dup two handles */
int dup (fhandler_base *child);
int ioctl (unsigned int cmd, void *);
void init (HANDLE, DWORD, mode_t);
+ bool mouse_aware () {return use_mouse;}
select_record *select_read (select_record *s);
select_record *select_write (select_record *s);
// Ioctl() request in tty::cmd/arg.
HANDLE ioctl_done_event; // Raised by master on ioctl() completion.
// Ioctl() status in tty::ioctl_retval.
- HANDLE output_mutex;
+ HANDLE output_mutex, input_mutex;
+ HANDLE input_available_event;
HANDLE inuse; // used to indicate that a tty is in use
int ioctl (unsigned int cmd, void *);
off_t lseek (off_t, int) { return 0; }
+ select_record *select_read (select_record *s);
+ int ready_for_read (int fd, DWORD howlong, int ignra);
};
class fhandler_pty_master: public fhandler_tty_common
class fhandler_dev_mem: public fhandler_base
{
protected:
- unsigned long pos;
+ int unit;
+ DWORD mem_size;
+ DWORD pos;
public:
fhandler_dev_mem (const char *name, int unit);
int fstat (struct stat *buf);
int dup (fhandler_base *child);
+ HANDLE mmap (caddr_t *addr, size_t len, DWORD access, int flags, off_t off);
+ int munmap (HANDLE h, caddr_t addr, size_t len);
+ int msync (HANDLE h, caddr_t addr, size_t len, int flags);
+ BOOL fixup_mmap_after_fork (HANDLE h, DWORD access, DWORD offset,
+ DWORD size, void *address);
+
+ void dump ();
+} ;
+
+class fhandler_dev_clipboard: public fhandler_base
+{
+public:
+ fhandler_dev_clipboard (const char *name);
+ int is_windows (void) { return 1; }
+ int open (const char *path, int flags, mode_t mode = 0);
+ int write (const void *ptr, size_t len);
+ int read (void *ptr, size_t len);
+ off_t lseek (off_t offset, int whence);
+ int close (void);
+
void dump ();
};
int wait (fd_set *readfds, fd_set *writefds, fd_set *exceptfds, DWORD ms);
};
-uid_t __stdcall get_file_owner (int, const char *);
-gid_t __stdcall get_file_group (int, const char *);
int __stdcall set_console_state_for_spawn ();
#endif /* _FHANDLER_H_ */
OSDN Git Service
