3 Copyright 1996, 1997, 1998, 1999, 2000 Cygnus Solutions.
5 This file is part of Cygwin.
7 This software is a copyrighted work licensed under the terms of the
8 Cygwin license. Please consult the file "CYGWIN_LICENSE" for
14 #include <sys/ioctl.h>
18 Code is located in fhandler.cc unless another file name is given.
20 fhandler_base normal I/O
23 fhandler_serial Adds vmin and vtime.
24 fhandler_dev_null Not really I/O
25 fhandler_dev_zero Faked
27 fhandler_dev_raw (fhandler_raw.cc)
28 fhandler_dev_floppy (fhandler_floppy.cc)
29 fhandler_dev_tape (fhandler_tape.cc)
32 fhandler_socket (net.cc)
34 fhandler_tty_slave (tty.cc)
35 fhandler_pty_master (tty.cc)
36 fhandler_tty_master (tty.cc)
38 fhandler_console Out with ansi control. (console.cc)
40 fhandler_windows Windows messages I/O (fhandler_windows.cc)
42 fhandler_dev_random /dev/[u]random implementation (fhandler_random.cc)
44 fhandler_dev_mem /dev/mem implementation (fhandler_mem.cc)
46 fhandler_proc Interesting possibility, not implemented yet
51 FH_RBINARY = 0x00001000, /* binary read mode */
52 FH_WBINARY = 0x00002000, /* binary write mode */
53 FH_CLOEXEC = 0x00004000, /* close-on-exec */
54 FH_RBINSET = 0x00008000, /* binary read mode has been explicitly set */
55 FH_WBINSET = 0x00010000, /* binary write mode has been explicitly set */
56 FH_APPEND = 0x00020000, /* always append */
57 FH_ASYNC = 0x00040000, /* async I/O */
58 FH_HADEOF = 0x00080000, /* EOF seen */
60 FH_SYMLINK = 0x00100000, /* is a symlink */
61 FH_EXECABL = 0x00200000, /* file looked like it would run:
62 * ends in .exe or .bat or begins with #! */
63 FH_W95LSBUG= 0x00400000, /* set when lseek is called as a flag that
64 * _write should check if we've moved beyond
65 * EOF, zero filling if so. */
66 FH_NOFRNAME= 0x00800000, /* Set if shouldn't free unix_path_name_ and
67 windows_path_name_ on destruction. */
68 FH_NOEINTR = 0x01000000, /* Set if I/O should be uninterruptible. */
69 FH_FFIXUP = 0x02000000, /* Set if need to fixup after fork. */
70 FH_LOCAL = 0x04000000, /* File is unix domain socket */
71 FH_FIFO = 0x08000000, /* File is FIFO */
72 FH_HASACLS = 0x40000000, /* True if fs of file has ACLS */
77 FH_CONSOLE = 0x00000001, /* is a console */
78 FH_CONIN = 0x00000002, /* console input */
79 FH_CONOUT = 0x00000003, /* console output */
80 FH_TTYM = 0x00000004, /* is a tty master */
81 FH_TTYS = 0x00000005, /* is a tty slave */
82 FH_PTYM = 0x00000006, /* is a pty master */
83 FH_SERIAL = 0x00000007, /* is a serial port */
84 FH_PIPE = 0x00000008, /* is a pipe */
85 FH_PIPER = 0x00000009, /* read end of a pipe */
86 FH_PIPEW = 0x0000000a, /* write end of a pipe */
87 FH_SOCKET = 0x0000000b, /* is a socket */
88 FH_WINDOWS = 0x0000000c, /* is a window */
90 FH_SLOW = 0x00000010, /* "slow" device if below this */
93 FH_DISK = 0x00000010, /* is a disk */
94 FH_FLOPPY = 0x00000011, /* is a floppy */
95 FH_TAPE = 0x00000012, /* is a tape */
96 FH_NULL = 0x00000013, /* is the null device */
97 FH_ZERO = 0x00000014, /* is the zero device */
98 FH_RANDOM = 0x00000015, /* is a random device */
99 FH_MEM = 0x00000016, /* is a mem device */
101 FH_NDEV = 0x00000017, /* Maximum number of devices */
102 FH_DEVMASK = 0x00000fff, /* devices live here */
106 #define FHDEVN(n) ((n) & FH_DEVMASK)
107 #define FHISSETF(x) __ISSETF (this, x, FH)
108 #define FHSETF(x) __SETF (this, x, FH)
109 #define FHCLEARF(x) __CLEARF (this, x, FH)
110 #define FHCONDSETF(n, x) __CONDSETF(n, this, x, FH)
114 extern const char *windows_device_names[];
115 extern struct __cygwin_perfile *perfile_table;
116 #define __fmode (*(user_data->fmode_ptr))
120 class fhandler_disk_file;
132 unsigned long namehash_; /* hashed filename, used as inode num */
134 /* Full unix path name of this file */
135 /* File open flags from open () and fcntl () calls */
139 char *rabuf; /* used for crlf conversion in text files */
145 char *unix_path_name_;
146 char *win32_path_name_;
149 void set_name (const char * unix_path, const char * win32_path = NULL,
152 virtual fhandler_base& operator =(fhandler_base &x);
153 fhandler_base (DWORD dev, const char *name = 0, int unit = 0);
154 virtual ~fhandler_base ();
156 /* Non-virtual simple accessor functions. */
157 void set_io_handle (HANDLE);
159 void set_cb (size_t size) { cb = size; }
160 DWORD get_device () { return status & FH_DEVMASK; }
161 virtual int get_unit () { return 0; }
162 virtual BOOL is_slow () { return get_device () < FH_SLOW; }
164 int get_access () { return access_; }
165 void set_access (int x) { access_ = x; }
167 int get_async () { return FHISSETF (ASYNC); }
168 void set_async (int x) { FHCONDSETF (x, ASYNC); }
170 int get_flags () { return openflags_; }
171 void set_flags (int x) { openflags_ = x; }
173 int get_w_binary () { return FHISSETF (WBINARY); }
174 int get_r_binary () { return FHISSETF (RBINARY); }
176 int get_w_binset () { return FHISSETF (WBINSET); }
177 int get_r_binset () { return FHISSETF (RBINSET); }
179 void set_w_binary (int b) { FHCONDSETF (b, WBINARY); FHSETF (WBINSET); }
180 void set_r_binary (int b) { FHCONDSETF (b, RBINARY); FHSETF (RBINSET); }
182 int get_default_fmode (int flags);
184 int get_r_no_interrupt () { return FHISSETF (NOEINTR); }
185 void set_r_no_interrupt (int b) { FHCONDSETF (b, NOEINTR); }
187 int get_close_on_exec () { return FHISSETF (CLOEXEC); }
188 int set_close_on_exec_flag (int b) { return FHCONDSETF (b, CLOEXEC); }
190 void set_check_win95_lseek_bug (int b = 1) { FHCONDSETF (b, W95LSBUG); }
191 int get_check_win95_lseek_bug () { return FHISSETF (W95LSBUG); }
193 int get_need_fork_fixup () { return FHISSETF (FFIXUP); }
194 void set_need_fork_fixup () { FHSETF (FFIXUP); }
196 virtual void set_close_on_exec (int val);
197 virtual void fixup_after_fork (HANDLE parent);
199 int get_symlink_p () { return FHISSETF (SYMLINK); }
200 void set_symlink_p (int val) { FHCONDSETF (val, SYMLINK); }
201 void set_symlink_p () { FHSETF (SYMLINK); }
203 int get_socket_p () { return FHISSETF (LOCAL); }
204 void set_socket_p (int val) { FHCONDSETF (val, LOCAL); }
205 void set_socket_p () { FHSETF (LOCAL); }
207 int get_execable_p () { return FHISSETF (EXECABL); }
208 void set_execable_p (int val) { FHCONDSETF (val, EXECABL); }
209 void set_execable_p () { FHSETF (EXECABL); }
211 int get_append_p () { return FHISSETF (APPEND); }
212 void set_append_p (int val) { FHCONDSETF (val, APPEND); }
213 void set_append_p () { FHSETF (APPEND); }
215 int get_readahead_valid () { return raixget < ralen; }
216 int puts_readahead (const char *s, size_t len = (size_t) -1);
217 int put_readahead (char value);
219 int get_readahead ();
220 int peek_readahead (int queryput = 0);
222 int eat_readahead (int n);
224 void set_readahead_valid (int val, int ch = -1);
226 int get_readahead_into_buffer (char *buf, size_t buflen);
228 int has_acls () { return FHISSETF (HASACLS); }
229 void set_has_acls (int val) { FHCONDSETF (val, HASACLS); }
231 int no_free_names () { return FHISSETF (NOFRNAME); }
232 void set_no_free_names (int val) { FHCONDSETF (val, NOFRNAME); }
233 void set_no_free_names () { FHSETF (NOFRNAME); }
235 const char *get_name () { return unix_path_name_; }
236 const char *get_win32_name () { return win32_path_name_; }
237 unsigned long get_namehash () { return namehash_; }
239 virtual void hclose (HANDLE h) {CloseHandle (h);}
240 virtual void set_inheritance (HANDLE &h, int not_inheriting,
241 const char *name = NULL);
243 /* fixup fd possibly non-inherited handles after fork */
244 void fork_fixup (HANDLE parent, HANDLE &h, const char *name);
246 /* Potentially overridden virtual functions. */
247 virtual int open (const char *, int flags, mode_t mode = 0)
249 return open (flags, mode);
251 virtual int open (int flags, mode_t mode = 0);
252 virtual int close ();
253 virtual int fstat (struct stat *buf);
254 virtual int ioctl (unsigned int cmd, void *);
255 virtual char const * ttyname () { return get_name(); }
256 virtual int read (void *ptr, size_t len);
257 virtual int write (const void *ptr, size_t len);
258 virtual off_t lseek (off_t offset, int whence);
259 virtual int lock (int, struct flock *);
260 virtual void dump ();
261 virtual int dup (fhandler_base *child);
263 virtual HANDLE mmap (caddr_t *addr, size_t len, DWORD access,
264 int flags, off_t off);
265 virtual int munmap (HANDLE h, caddr_t addr, size_t len);
266 virtual int msync (HANDLE h, caddr_t addr, size_t len, int flags);
268 void *operator new (size_t, void *p) {return p;}
270 virtual void init (HANDLE, DWORD, mode_t);
272 virtual int tcflush (int);
273 virtual int tcsendbreak (int);
274 virtual int tcdrain ();
275 virtual int tcflow (int);
276 virtual int tcsetattr (int a, const struct termios *t);
277 virtual int tcgetattr (struct termios *t);
278 virtual int tcsetpgrp (const pid_t pid);
279 virtual int tcgetpgrp ();
280 virtual int is_tty () { return 0; }
281 virtual BOOL is_device () { return TRUE; }
282 virtual char *ptsname () { return NULL;}
283 virtual class fhandler_socket *is_socket () { return 0; }
284 virtual class fhandler_console *is_console () { return 0; }
285 virtual int is_windows () {return 0; }
287 virtual int raw_read (void *ptr, size_t ulen);
288 virtual int raw_write (const void *ptr, size_t ulen);
290 virtual void fixup_after_exec (HANDLE) {}
292 /* Virtual accessor functions to hide the fact
293 that some fd's have two handles. */
294 virtual HANDLE get_handle () const { return io_handle; }
295 virtual HANDLE get_io_handle () const { return io_handle; }
296 virtual HANDLE get_output_handle () const { return io_handle; }
297 virtual BOOL hit_eof () {return FALSE;}
298 virtual select_record *select_read (select_record *s);
299 virtual select_record *select_write (select_record *s);
300 virtual select_record *select_except (select_record *s);
301 virtual int ready_for_read (int fd, DWORD howlong, int ignra);
302 virtual const char * get_native_name ()
304 return windows_device_names[FHDEVN (status)];
306 virtual int bg_check (int) {return 1;}
307 void clear_readahead ()
309 raixput = raixget = ralen = rabuflen = 0;
312 void operator delete (void *);
315 class fhandler_socket: public fhandler_base
320 fhandler_socket (const char *name = 0);
321 fhandler_socket (unsigned int, const char *name = 0);
322 int get_socket () const { return (int) get_handle(); }
323 fhandler_socket * is_socket () { return this; }
324 int write (const void *ptr, size_t len);
325 int read (void *ptr, size_t len);
326 int ioctl (unsigned int cmd, void *);
327 off_t lseek (off_t, int) { return 0; }
329 void hclose (HANDLE) {close ();}
331 select_record *select_read (select_record *s);
332 select_record *select_write (select_record *s);
333 select_record *select_except (select_record *s);
334 int ready_for_read (int fd, DWORD howlong, int ignra);
335 int get_addr_family () {return addr_family;}
336 void set_addr_family (int af) {addr_family = af;}
339 class fhandler_pipe: public fhandler_base
342 fhandler_pipe (const char *name = 0, DWORD devtype = FH_PIPE);
343 off_t lseek (off_t offset, int whence);
344 /* This strange test is due to the fact that we can't rely on
345 Windows shells to "do the right thing" with pipes. Apparently
346 the can keep one end of the pipe open when it shouldn't be. */
347 BOOL is_slow () {return os_being_run == winNT;}
348 select_record *select_read (select_record *s);
349 select_record *select_write (select_record *s);
350 select_record *select_except (select_record *s);
351 int ready_for_read (int fd, DWORD howlong, int ignra);
354 class fhandler_dev_raw: public fhandler_base
361 int eom_detected : 1;
362 int eof_detected : 1;
363 int lastblk_to_read : 1;
369 virtual void clear (void);
370 virtual int writebuf (void);
372 /* returns not null, if `win_error' determines an end of media condition */
373 virtual int is_eom(int win_error) = 0;
374 /* returns not null, if `win_error' determines an end of file condition */
375 virtual int is_eof(int win_error) = 0;
377 fhandler_dev_raw (DWORD dev, const char *name, int unit);
380 ~fhandler_dev_raw (void);
382 int open (const char *path, int flags, mode_t mode = 0);
385 int raw_read (void *ptr, size_t ulen);
386 int raw_write (const void *ptr, size_t ulen);
388 int fstat (struct stat *buf);
390 int dup (fhandler_base *child);
392 int ioctl (unsigned int cmd, void *buf);
395 class fhandler_dev_floppy: public fhandler_dev_raw
398 virtual int is_eom (int win_error);
399 virtual int is_eof (int win_error);
402 fhandler_dev_floppy (const char *name, int unit);
404 virtual int open (const char *path, int flags, mode_t mode = 0);
405 virtual int close (void);
407 virtual off_t lseek (off_t offset, int whence);
409 virtual int ioctl (unsigned int cmd, void *buf);
412 class fhandler_dev_tape: public fhandler_dev_raw
418 virtual void clear (void);
420 virtual int is_eom (int win_error);
421 virtual int is_eof (int win_error);
424 fhandler_dev_tape (const char *name, int unit);
426 virtual int open (const char *path, int flags, mode_t mode = 0);
427 virtual int close (void);
429 virtual off_t lseek (off_t offset, int whence);
431 virtual int fstat (struct stat *buf);
433 virtual int dup (fhandler_base *child);
435 virtual int ioctl (unsigned int cmd, void *buf);
438 int tape_write_marks (int marktype, DWORD len);
439 int tape_get_pos (unsigned long *ret);
440 int tape_set_pos (int mode, long count, BOOLEAN sfm_func = FALSE);
441 int tape_erase (int mode);
442 int tape_prepare (int action);
443 BOOLEAN tape_get_feature (DWORD parm);
444 int tape_get_blocksize (long *min, long *def, long *max, long *cur);
445 int tape_set_blocksize (long count);
446 int tape_status (struct mtget *get);
447 int tape_compression (long count);
450 /* Standard disk file */
452 class fhandler_disk_file: public fhandler_base
455 int check_execable_p (const char *path);
458 fhandler_disk_file (const char *name);
460 int open (const char *path, int flags, mode_t mode = 0);
461 int open (path_conv& real_path, int flags, mode_t mode);
463 int lock (int, struct flock *);
464 BOOL is_device () { return FALSE; }
465 int fstat (struct stat *buf);
467 HANDLE mmap (caddr_t *addr, size_t len, DWORD access, int flags, off_t off);
468 int munmap (HANDLE h, caddr_t addr, size_t len);
469 int msync (HANDLE h, caddr_t addr, size_t len, int flags);
472 class fhandler_serial: public fhandler_base
475 unsigned int vmin_; /* from termios */
476 unsigned int vtime_; /* from termios */
480 int overlapped_armed;
481 OVERLAPPED io_status;
484 fhandler_serial (const char *name, DWORD devtype = FH_SERIAL, int unit = 0);
486 int open (const char *path, int flags, mode_t mode);
488 void init (HANDLE h, DWORD a, mode_t flags);
489 void overlapped_setup ();
490 int dup (fhandler_base *child);
491 int raw_read (void *ptr, size_t ulen);
492 int raw_write (const void *ptr, size_t ulen);
493 int tcsendbreak (int);
496 int tcsetattr (int a, const struct termios *t);
497 int tcgetattr (struct termios *t);
498 off_t lseek (off_t, int) { return 0; }
501 int is_tty () { return 1; }
502 void fixup_after_fork (HANDLE parent);
503 void fixup_after_exec (HANDLE);
505 /* We maintain a pgrp so that tcsetpgrp and tcgetpgrp work, but we
506 don't use it for permissions checking. fhandler_tty_slave does
507 permission checking on pgrps. */
508 virtual int tcgetpgrp () { return pgrp_; }
509 virtual int tcsetpgrp (const pid_t pid) { pgrp_ = pid; return 0; }
510 select_record *select_read (select_record *s);
511 select_record *select_write (select_record *s);
512 select_record *select_except (select_record *s);
513 int ready_for_read (int fd, DWORD howlong, int ignra);
516 #define acquire_output_mutex(ms) \
517 __acquire_output_mutex (__PRETTY_FUNCTION__, __LINE__, ms);
519 #define release_output_mutex() \
520 __release_output_mutex (__PRETTY_FUNCTION__, __LINE__);
524 class fhandler_termios: public fhandler_base
527 HANDLE output_handle;
528 virtual void doecho (const void *, DWORD) {};
529 virtual int accept_input () {return 1;};
532 fhandler_termios (DWORD dev, const char *name = 0, int unit = 0) :
533 fhandler_base (dev, name, unit)
537 HANDLE get_output_handle () const { return output_handle; }
538 int line_edit (const char *rptr, int nread, int always_accept = 0);
539 void set_output_handle (HANDLE h) { output_handle = h; }
540 void tcinit (tty_min *this_tc, int force = FALSE);
541 virtual int is_tty () { return 1; }
543 int tcsetpgrp (int pid);
544 void set_ctty (int ttynum, int flags);
545 int bg_check (int sig);
546 virtual DWORD __acquire_output_mutex (const char *fn, int ln, DWORD ms) {return 1;}
547 virtual void __release_output_mutex (const char *fn, int ln) {}
550 /* This is a input and output console handle */
551 class fhandler_console: public fhandler_termios
557 // enum {normal, gotesc, gotsquare, gotarg1, gotcommand} state;
576 void clear_screen (int, int, int, int);
577 void scroll_screen (int, int, int, int, int, int);
578 void cursor_set (BOOL, int, int);
579 void cursor_get (int *, int *);
580 void cursor_rel (int, int);
581 const unsigned char * write_normal (unsigned const char*, unsigned const char *);
582 void char_command (char);
583 int output_tcsetattr (int a, const struct termios *t);
586 int igncr_enabled ();
587 int input_tcsetattr (int a, const struct termios *t);
588 void set_cursor_maybe ();
592 fhandler_console (const char *name);
594 fhandler_console* is_console () { return this; }
596 int open (const char *path, int flags, mode_t mode = 0);
598 int write (const void *ptr, size_t len);
599 void doecho (const void *str, DWORD len) { (void) write (str, len); }
600 int read (void *ptr, size_t len);
604 int tcsetattr (int a, const struct termios *t);
605 int tcgetattr (struct termios *t);
607 int tcsetpgrp (const pid_t pid);
609 /* Special dup as we must dup two handles */
610 int dup (fhandler_base *child);
612 int ioctl (unsigned int cmd, void *);
613 void init (HANDLE, DWORD, mode_t);
615 select_record *select_read (select_record *s);
616 select_record *select_write (select_record *s);
617 select_record *select_except (select_record *s);
618 int ready_for_read (int fd, DWORD howlong, int ignra);
619 void fixup_after_exec (HANDLE);
620 void set_close_on_exec (int val);
621 void fixup_after_fork (HANDLE parent);
622 void set_input_state ();
625 class fhandler_tty_common: public fhandler_termios
628 fhandler_tty_common (DWORD dev, const char *name = 0, int unit = 0) :
629 fhandler_termios (dev, name, unit),
634 HANDLE output_done_event; // Raised by master when tty's output buffer
635 // written. Write status in tty::write_retval.
636 HANDLE ioctl_request_event; // Raised by slave to perform ioctl() request.
637 // Ioctl() request in tty::cmd/arg.
638 HANDLE ioctl_done_event; // Raised by master on ioctl() completion.
639 // Ioctl() status in tty::ioctl_retval.
641 HANDLE inuse; // used to indicate that a tty is in use
644 DWORD __acquire_output_mutex (const char *fn, int ln, DWORD ms);
645 void __release_output_mutex (const char *fn, int ln);
647 int ttynum; // Master tty num.
648 virtual int dup (fhandler_base *child);
650 tty *get_ttyp () { return (tty *)tc; }
651 int get_unit () { return ttynum; }
654 void set_close_on_exec (int val);
655 void fixup_after_fork (HANDLE parent);
656 select_record *select_read (select_record *s);
657 select_record *select_write (select_record *s);
658 select_record *select_except (select_record *s);
659 int ready_for_read (int fd, DWORD howlong, int ignra);
662 class fhandler_tty_slave: public fhandler_tty_common
666 fhandler_tty_slave (const char *name);
667 fhandler_tty_slave (int, const char *name);
669 int open (const char *path, int flags, mode_t mode = 0);
670 int write (const void *ptr, size_t len);
671 int read (void *ptr, size_t len);
672 void init (HANDLE, DWORD, mode_t);
674 int tcsetattr (int a, const struct termios *t);
675 int tcgetattr (struct termios *t);
677 int ioctl (unsigned int cmd, void *);
679 off_t lseek (off_t, int) { return 0; }
682 class fhandler_pty_master: public fhandler_tty_common
684 int pktmode; // non-zero if pty in a packet mode.
686 int need_nl; // Next read should start with \n
689 fhandler_pty_master (const char *name, DWORD devtype = FH_PTYM, int unit = -1);
691 int process_slave_output (char *buf, size_t len, int pktmode_on);
692 void doecho (const void *str, DWORD len);
694 int open (const char *path, int flags, mode_t mode = 0);
695 int write (const void *ptr, size_t len);
696 int read (void *ptr, size_t len);
699 int tcsetattr (int a, const struct termios *t);
700 int tcgetattr (struct termios *t);
702 int ioctl (unsigned int cmd, void *);
704 off_t lseek (off_t, int) { return 0; }
707 void set_close_on_exec (int val);
711 class fhandler_tty_master: public fhandler_pty_master
715 fhandler_tty_master (const char *name, int unit);
716 fhandler_console *console; // device handler to perform real i/o.
717 HANDLE hThread; // process_output thread handle.
721 void fixup_after_fork (HANDLE parent);
722 void fixup_after_exec (HANDLE);
725 class fhandler_dev_null: public fhandler_base
728 fhandler_dev_null (const char *name);
731 select_record *select_read (select_record *s);
732 select_record *select_write (select_record *s);
733 select_record *select_except (select_record *s);
736 class fhandler_dev_zero: public fhandler_base
739 fhandler_dev_zero (const char *name);
740 int open (const char *path, int flags, mode_t mode = 0);
741 int write (const void *ptr, size_t len);
742 int read (void *ptr, size_t len);
743 off_t lseek (off_t offset, int whence);
749 class fhandler_dev_random: public fhandler_base
753 HCRYPTPROV crypt_prov;
756 BOOL crypt_gen_random (void *ptr, size_t len);
757 int pseudo_write (const void *ptr, size_t len);
758 int pseudo_read (void *ptr, size_t len);
761 fhandler_dev_random (const char *name, int unit);
762 int get_unit () { return unit; }
763 int open (const char *path, int flags, mode_t mode = 0);
764 int write (const void *ptr, size_t len);
765 int read (void *ptr, size_t len);
766 off_t lseek (off_t offset, int whence);
768 int dup (fhandler_base *child);
773 class fhandler_dev_mem: public fhandler_base
781 fhandler_dev_mem (const char *name, int unit);
782 ~fhandler_dev_mem (void);
784 int open (const char *path, int flags, mode_t mode = 0);
785 int write (const void *ptr, size_t ulen);
786 int read (void *ptr, size_t ulen);
787 off_t lseek (off_t offset, int whence);
789 int fstat (struct stat *buf);
790 int dup (fhandler_base *child);
792 HANDLE mmap (caddr_t *addr, size_t len, DWORD access, int flags, off_t off);
793 int munmap (HANDLE h, caddr_t addr, size_t len);
794 int msync (HANDLE h, caddr_t addr, size_t len, int flags);
799 class fhandler_windows: public fhandler_base
802 HWND hWnd_; // the window whose messages are to be retrieved by read() call
803 int method_; // write method (Post or Send)
805 fhandler_windows (const char *name = 0);
806 int is_windows (void) { return 1; }
807 int open (const char *path, int flags, mode_t mode = 0);
808 int write (const void *ptr, size_t len);
809 int read (void *ptr, size_t len);
810 int ioctl (unsigned int cmd, void *);
811 off_t lseek (off_t, int) { return 0; }
812 int close (void) { return 0; }
814 void set_close_on_exec (int val);
815 void fixup_after_fork (HANDLE parent);
816 select_record *select_read (select_record *s);
817 select_record *select_write (select_record *s);
818 select_record *select_except (select_record *s);
819 int ready_for_read (int fd, DWORD howlong, int ignra);
823 /* You can't do this */
826 fhandler_normal normal;
827 fhandler_dev_null dev_null;
832 #define fhandler_union fhandler_console
841 BOOL read_ready, write_ready, except_ready;
842 BOOL read_selected, write_selected, except_selected;
843 int (*startup) (select_record *me, class select_stuff *stuff);
844 int (*poll) (select_record *me, fd_set *readfds, fd_set *writefds,
846 int (*verify) (select_record *me, fd_set *readfds, fd_set *writefds,
848 void (*cleanup) (select_record *me, class select_stuff *stuff);
849 struct select_record *next;
851 select_record (fhandler_base *in_fh = NULL) : fd (0), h (NULL),
852 fh (in_fh), saw_error (0), windows_handle (0),
853 read_ready (0), write_ready (0), except_ready (0),
854 read_selected (0), write_selected (0), except_selected (0),
855 startup (NULL), poll (NULL), verify (NULL), cleanup (NULL),
863 select_stuff (): always_ready (0), windows_used (0), start (0)
865 memset (device_specific, 0, sizeof (device_specific));
867 BOOL always_ready, windows_used;
869 void *device_specific[FH_NDEV];
871 int test_and_set (int i, fd_set *readfds, fd_set *writefds,
873 int poll (fd_set *readfds, fd_set *writefds, fd_set *exceptfds);
874 int wait (fd_set *readfds, fd_set *writefds, fd_set *exceptfds, DWORD ms);
877 uid_t __stdcall get_file_owner (int, const char *);
878 gid_t __stdcall get_file_group (int, const char *);
879 int __stdcall set_console_state_for_spawn ();
881 #endif /* _FHANDLER_H_ */