diff options
Diffstat (limited to 'winsup/cygwin/fhandler.cc')
| -rw-r--r-- | winsup/cygwin/fhandler.cc | 1501 |
1 files changed, 1501 insertions, 0 deletions
diff --git a/winsup/cygwin/fhandler.cc b/winsup/cygwin/fhandler.cc new file mode 100644 index 000000000..58521d48b --- /dev/null +++ b/winsup/cygwin/fhandler.cc @@ -0,0 +1,1501 @@ +/* fhandler.cc. See console.cc for fhandler_console functions. + + Copyright 1996, 1997, 1998, 1999, 2000 Cygnus Solutions. + +This file is part of Cygwin. + +This software is a copyrighted work licensed under the terms of the +Cygwin license. Please consult the file "CYGWIN_LICENSE" for +details. */ + +#include <sys/fcntl.h> +#include <errno.h> +#include <unistd.h> +#include <stdlib.h> +#include "winsup.h" + +static NO_COPY const int CHUNK_SIZE = 1024; /* Used for crlf conversions */ + +static char fhandler_disk_dummy_name[] = "some disk file"; + +int +fhandler_base::puts_readahead (const char *s, size_t len = (size_t) -1) +{ + int success = 1; + while ((((len == (size_t) -1) && *s) || len--) && + (success = put_readahead (*s++) > 0)) + continue; + return success; +} + +int +fhandler_base::put_readahead (char value) +{ + char *newrabuf; + if (raixput < rabuflen) + /* Nothing to do */; + else if ((newrabuf = (char *) realloc (rabuf, rabuflen += 32))) + rabuf = newrabuf; + else + return 0; + + rabuf[raixput++] = value; + ralen++; + return 1; +} + +int +fhandler_base::get_readahead () +{ + int chret = -1; + if (raixget < ralen) + chret = ((unsigned char)rabuf[raixget++]) & 0xff; + /* FIXME - not thread safe */ + if (raixget >= ralen) + raixget = raixput = ralen = 0; + return chret; +} + +int +fhandler_base::peek_readahead (int queryput) +{ + int chret = -1; + if (!queryput && raixget < ralen) + chret = ((unsigned char) rabuf[raixget]) & 0xff; + else if (queryput && raixput > 0) + chret = ((unsigned char) rabuf[raixput - 1]) & 0xff; + return chret; +} + +void +fhandler_base::set_readahead_valid (int val, int ch = -1) +{ + if (!val) + ralen = raixget = raixput = 0; + if (ch != -1) + put_readahead(ch); +} + +int +fhandler_base::eat_readahead (int n) +{ + int oralen = ralen; + if (n < 0) + n = ralen; + if (n > 0 && ralen) + { + if ((ralen -= n) < 0) + ralen = 0; + + if (raixget >= ralen) + raixget = raixput = ralen = 0; + else if (raixput > ralen) + raixput = ralen; + } + + return oralen; +} + +uid_t __stdcall +get_file_owner (int use_ntsec, const char *filename) +{ + if (use_ntsec && allow_ntsec) + { + extern LONG ReadSD(const char *, PSECURITY_DESCRIPTOR, LPDWORD); + DWORD sd_size = 4096; + char psd_buffer[4096]; + PSECURITY_DESCRIPTOR psd = (PSECURITY_DESCRIPTOR) psd_buffer; + PSID psid; + BOOL bOwnerDefaulted = TRUE; + + if (ReadSD (filename, psd, &sd_size) <= 0) + return getuid(); + + if (!GetSecurityDescriptorOwner (psd, &psid, &bOwnerDefaulted)) + return getuid (); + + return psid ? get_uid_from_sid (psid) : getuid (); + } + + return getuid(); +} + +gid_t __stdcall +get_file_group (int use_ntsec, const char *filename) +{ + if (use_ntsec && allow_ntsec) + { + extern LONG ReadSD(const char *, PSECURITY_DESCRIPTOR, LPDWORD); + DWORD sd_size = 4096; + char psd_buffer[4096]; + PSECURITY_DESCRIPTOR psd = (PSECURITY_DESCRIPTOR) psd_buffer; + PSID psid; + BOOL bGroupDefaulted = TRUE; + + if (ReadSD (filename, psd, &sd_size) <= 0) + return getgid(); + + if (!GetSecurityDescriptorGroup (psd, &psid, &bGroupDefaulted)) + return getgid (); + + return psid ? get_gid_from_sid (psid) : getuid (); + } + + return getgid (); +} + +/**********************************************************************/ +/* fhandler_base */ + +/* Record the file name. + Filenames are used mostly for debugging messages, and it's hoped that + in cases where the name is really required, the filename wouldn't ever + be too long (e.g. devices or some such). +*/ + +void +fhandler_base::set_name (const char *unix, const char *win32, int unit) +{ + if (!no_free_names ()) + { + if (unix_path_name_ != NULL && unix_path_name_ != fhandler_disk_dummy_name) + free (unix_path_name_); + if (win32_path_name_ != NULL && unix_path_name_ != fhandler_disk_dummy_name) + free (win32_path_name_); + } + + unix_path_name_ = win32_path_name_ = NULL; + if (unix == NULL || !*unix) + return; + + unix_path_name_ = strdup (unix); + if (unix_path_name_ == NULL) + { + system_printf ("fatal error. strdup failed"); + exit (ENOMEM); + } + + if (win32) + win32_path_name_ = strdup (win32); + else + { + const char *fmt = get_native_name (); + win32_path_name_ = (char *) malloc (strlen(fmt) + 16); + __small_sprintf (win32_path_name_, fmt, unit); + } + + if (win32_path_name_ == NULL) + { + system_printf ("fatal error. strdup failed"); + exit (ENOMEM); + } +} + +/* Normal file i/o handlers. */ + +/* Cover function to ReadFile to achieve (as much as possible) Posix style + semantics and use of errno. */ +int +fhandler_base::raw_read (void *ptr, size_t ulen) +{ + DWORD bytes_read; + + if (!ReadFile (get_handle(), ptr, ulen, &bytes_read, 0)) + { + int errcode; + + /* Some errors are not really errors. Detect such cases here. */ + + errcode = GetLastError (); + switch (errcode) + { + case ERROR_BROKEN_PIPE: + /* This is really EOF. */ + bytes_read = 0; + break; + case ERROR_MORE_DATA: + /* `bytes_read' is supposedly valid. */ + break; + default: + syscall_printf ("ReadFile %s failed, %E", unix_path_name_); + __seterrno_from_win_error (errcode); + return -1; + break; + } + } + + return bytes_read; +} + +int +fhandler_base::linearize (unsigned char *buf) +{ + unsigned char *orig_buf = buf; +#define cbuf ((char *)buf) + strcpy (cbuf, get_name() ?: ""); + char *p = strcpy (strchr (cbuf, '\0') + 1, get_win32_name ()); + buf = (unsigned char *)memcpy (strchr (p, '\0') + 1, this, cb); + debug_printf ("access_ %p, status %p, io_handle %p, output_handle %p", + access_, status, get_io_handle (), get_output_handle ()); + return (buf + cb) - orig_buf; +#undef cbuf +} + +int +fhandler_base::de_linearize (const char *buf, const char *unix_name, + const char *win32_name) +{ + int thiscb = cb; + memcpy(this, buf, cb); + unix_path_name_ = win32_path_name_ = NULL; + set_name (unix_name, win32_name); + debug_printf ("access_ %p, status %p, io_handle %p, output_handle %p", + access_, status, get_io_handle (), get_output_handle ()); + if (thiscb != cb) + system_printf ("mismatch in linearize/delinearize %d != %d", thiscb, cb); + raixput = raixget = ralen = rabuflen = 0; + rabuf = NULL; + return cb; +} + +/* Cover function to WriteFile to provide Posix interface and semantics + (as much as possible). */ +int +fhandler_base::raw_write (const void *ptr, size_t len) +{ + DWORD bytes_written; + + if (!WriteFile (get_handle(), ptr, len, &bytes_written, 0)) + { + if (GetLastError () == ERROR_DISK_FULL && bytes_written > 0) + return bytes_written; + __seterrno (); + if (get_errno () == EPIPE) + raise (SIGPIPE); + return -1; + } + return bytes_written; +} + +/* Open system call handler function. + Path is now already checked for symlinks */ +int +fhandler_base::open (int flags, mode_t mode) +{ + int res = 0; + HANDLE x; + int file_attributes; + int shared; + int creation_distribution; + + syscall_printf ("(%s, %p)", get_win32_name (), flags); + + set_flags (flags); + + if (get_win32_name () == NULL) + { + set_errno (ENOENT); + goto done; + } + + if (get_device () == FH_TAPE) + { + access_ = GENERIC_READ | GENERIC_WRITE; + } + else if ((flags & (O_RDONLY | O_WRONLY | O_RDWR)) == O_RDONLY) + { + access_ = GENERIC_READ; + } + else if ((flags & (O_RDONLY | O_WRONLY | O_RDWR)) == O_WRONLY) + { + access_ = GENERIC_WRITE; + } + else + { + access_ = GENERIC_READ | GENERIC_WRITE; + } + + /* FIXME: O_EXCL handling? */ + + if ((flags & O_TRUNC) && ((flags & O_ACCMODE) != O_RDONLY)) + { + if (flags & O_CREAT) + { + creation_distribution = CREATE_ALWAYS; + } + else + { + creation_distribution = TRUNCATE_EXISTING; + } + } + else if (flags & O_CREAT) + creation_distribution = OPEN_ALWAYS; + else + creation_distribution = OPEN_EXISTING; + + if ((flags & O_EXCL) && (flags & O_CREAT)) + { + creation_distribution = CREATE_NEW; + } + + if (flags & O_APPEND) + set_append_p(); + + /* These flags are host dependent. */ + shared = host_dependent.shared; + + file_attributes = FILE_ATTRIBUTE_NORMAL; + if (flags & O_DIROPEN) + file_attributes |= FILE_FLAG_BACKUP_SEMANTICS; + if (get_device () == FH_SERIAL) + file_attributes |= FILE_FLAG_OVERLAPPED; + + x = CreateFileA (get_win32_name (), access_, shared, + &sec_none, creation_distribution, + file_attributes, + 0); + + syscall_printf ("%d = CreateFileA (%s, %p, %p, %p, %p, %p, 0)", + x, + get_win32_name (), access_, shared, + &sec_none, creation_distribution, + file_attributes); + + if (x == INVALID_HANDLE_VALUE) + { + if (GetLastError () == ERROR_INVALID_HANDLE) + set_errno (ENOENT); + else + __seterrno (); + goto done; + } + + if (flags & O_CREAT && get_device () == FH_DISK) + set_file_attribute (has_acls (), get_win32_name (), mode); + + namehash_ = hash_path_name (0, get_win32_name ()); + set_io_handle (x); + rpos_ = 0; + rsize_ = -1; + int bin; + if (flags & (O_BINARY | O_TEXT)) + bin = flags & O_TEXT ? 0 : O_BINARY; + else if (get_device () == FH_DISK) + bin = get_w_binary () || get_r_binary (); + else + bin = (__fmode & O_BINARY) || get_w_binary () || get_r_binary (); + + set_r_binary (bin); + set_w_binary (bin); + syscall_printf ("filemode set to %s", bin ? "binary" : "text"); + + if (get_device () != FH_TAPE + && get_device () != FH_FLOPPY + && get_device () != FH_SERIAL) + { + if (flags & O_APPEND) + SetFilePointer (get_handle(), 0, 0, FILE_END); + else + SetFilePointer (get_handle(), 0, 0, FILE_BEGIN); + } + + res = 1; +done: + syscall_printf ("%d = fhandler_base::open (%s, %p)", res, get_win32_name (), + flags); + return res; +} + +/* states: + open buffer in binary mode? Just do the read. + + open buffer in text mode? Scan buffer for control zs and handle + the first one found. Then scan buffer, converting every \r\n into + an \n. If last char is an \r, look ahead one more char, if \n then + modify \r, if not, remember char. +*/ +int +fhandler_base::read (void *in_ptr, size_t in_len) +{ + int len = (int) in_len; + char *ctrlzpos; + char *ptr = (char *) in_ptr; + + int c; + int copied_chars = 0; + + while (len) + if ((c = get_readahead ()) < 0) + break; + else + { + ptr[copied_chars++] = (unsigned char) (c & 0xff); + len--; + } + + if (len) + { + int readlen = raw_read (ptr + copied_chars, len); + if (copied_chars == 0) + copied_chars = readlen; /* Propagate error or EOF */ + else if (readlen > 0) /* FIXME: should flag EOF for next read */ + copied_chars += readlen; + } + + if (copied_chars <= 0 || get_r_binary ()) + return copied_chars; + + /* Scan buffer for a control-z and shorten the buffer to that length */ + + ctrlzpos = (char *) memchr ((char *) ptr, 0x1a, copied_chars); + if (ctrlzpos) + { + lseek ((ctrlzpos - ((char *) ptr + copied_chars)), SEEK_CUR); + copied_chars = ctrlzpos - (char *) ptr; + } + + if (copied_chars == 0) + return 0; + + /* Scan buffer and turn \r\n into \n */ + register char *src= (char *) ptr; + register char *dst = (char *) ptr; + register char *end = src + copied_chars - 1; + + /* Read up to the last but one char - the last char needs special handling */ + while (src < end) + { + *dst = *src++; + if (*dst != '\r' || *src != '\n') + dst++; + } + + c = *src; + /* if last char is a '\r' then read one more to see if we should + translate this one too */ + if (c == '\r') + { + char c1 = 0; + len = raw_read (&c1, 1); + if (len <= 0) + /* nothing */; + else if (c1 == '\n') + c = '\n'; + else + set_readahead_valid (1, c1); + } + + *dst++ = c; + copied_chars = dst - (char *) ptr; + + rpos_ += copied_chars; + +#ifndef NOSTRACE + if (strace_active) + { + char buf[16 * 6 + 1]; + char *p = buf; + + for (int i = 0; i < copied_chars && i < 16; ++i) + { + unsigned char c = ((unsigned char *) ptr)[i]; + /* >= 33 so space prints in hex */ + __small_sprintf (p, c >= 33 && c <= 127 ? " %c" : " %p", c); + p += strlen (p); + } + debug_printf ("read %d bytes (%s%s)", copied_chars, buf, + copied_chars > 16 ? " ..." : ""); + } +#endif + + return copied_chars; +} + +int +fhandler_base::write (const void *ptr, size_t len) +{ + int res; + + if (get_append_p ()) + SetFilePointer (get_handle(), 0, 0, FILE_END); + else if (os_being_run != winNT && get_check_win95_lseek_bug ()) + { + /* Note: this bug doesn't happen on NT4, even though the documentation + for WriteFile() says that it *may* happen on any OS. */ + int actual_length, current_position; + set_check_win95_lseek_bug (0); /* don't do it again */ + actual_length = GetFileSize (get_handle (), NULL); + current_position = SetFilePointer (get_handle (), 0, 0, FILE_CURRENT); + if (current_position > actual_length) + { + /* Oops, this is the bug case - Win95 uses whatever is on the disk + instead of some known (safe) value, so we must seek back and + fill in the gap with zeros. - DJ */ + char zeros[512]; + int number_of_zeros_to_write = current_position - actual_length; + memset(zeros, 0, 512); + SetFilePointer (get_handle (), 0, 0, FILE_END); + while (number_of_zeros_to_write > 0) + { + DWORD zeros_this_time = (number_of_zeros_to_write > 512 + ? 512 : number_of_zeros_to_write); + DWORD written; + if (!WriteFile (get_handle (), zeros, zeros_this_time, &written, + NULL)) + { + __seterrno (); + if (get_errno () == EPIPE) + raise (SIGPIPE); + /* This might fail, but it's the best we can hope for */ + SetFilePointer (get_handle (), current_position, 0, FILE_BEGIN); + return -1; + + } + if (written < zeros_this_time) /* just in case */ + { + set_errno (ENOSPC); + /* This might fail, but it's the best we can hope for */ + SetFilePointer (get_handle (), current_position, 0, FILE_BEGIN); + return -1; + } + number_of_zeros_to_write -= written; + } + } + } + + if (get_w_binary ()) + { + res = raw_write (ptr, len); + } + else + { +#ifdef NOTDEF + /* Keep track of previous \rs, we don't want to turn existing + \r\n's into \r\n\n's */ + register int pr = 0; + + /* Copy things in chunks */ + char buf[CHUNK_SIZE]; + + for (unsigned int i = 0; i < len; i += sizeof (buf) / 2) + { + register const char *src = (char *)ptr + i; + int todo; + if ((todo = len - i) > sizeof (buf) / 2) + todo = sizeof (buf) / 2; + register const char *end = src + todo; + register char *dst = buf; + while (src < end) + { + if (*src == '\n' && !pr) + { + /* Emit a cr lf here */ + *dst ++ = '\r'; + *dst ++ = '\n'; + } + else if (*src == '\r') + { + *dst ++ = '\r'; + pr = 1; + } + else + { + *dst ++ = *src; + pr = 0; + } + src++; + } + int want = dst - buf; + if ((res = raw_write (buf, want)) != want) + { + if (res == -1) + return -1; + /* FIXME: */ + /* Tricky... Didn't write everything we wanted.. How can + we work out exactly which chars were sent? We don't... + This will only happen in pretty nasty circumstances. */ + rpos_ += i; + return i; + } + } +#else + /* This is the Microsoft/DJGPP way. Still not ideal, but it's + compatible. */ + + int left_in_data = len; + char *data = (char *)ptr; + + while (left_in_data > 0) + { + char buf[CHUNK_SIZE], *buf_ptr = buf; + int left_in_buf = CHUNK_SIZE; + + while (left_in_buf > 0 && left_in_data > 0) + { + if (*data == '\n') + { + if (left_in_buf == 1) + { + /* Not enough room for \r and \n */ + break; + } + *buf_ptr++ = '\r'; + left_in_buf--; + } + *buf_ptr++ = *data++; + left_in_buf--; + left_in_data--; + } + + /* We've got a buffer-full, or we're out of data. Write it out */ + int want = buf_ptr - buf; + if ((res = raw_write (buf, want)) != want) + { + if (res == -1) + return -1; + /* FIXME: */ + /* Tricky... Didn't write everything we wanted.. How can + we work out exactly which chars were sent? We don't... + This will only happen in pretty nasty circumstances. */ + int i = (len-left_in_data) - left_in_buf; + rpos_ += i; + /* just in case the math is off, guarantee it looks like + a disk full error */ + if (i >= (int)len) + i = len-1; + if (i < 0) + i = 0; + return i; + } + } +#endif + + /* Done everything, update by the chars that the user sent */ + rpos_ += len; + /* Length of file has changed */ + rsize_ = -1; + res = len; + debug_printf ("after write, name %s, rpos %d", unix_path_name_, rpos_); + } + return res; +} + +off_t +fhandler_base::lseek (off_t offset, int whence) +{ + off_t res; + + /* Seeks on text files is tough, we rewind and read till we get to the + right place. */ + + if (whence != SEEK_CUR || offset != 0) + { + if (whence == SEEK_CUR) + offset -= ralen - raixget; + set_readahead_valid (0); + } + + debug_printf ("lseek (%s, %d, %d)", unix_path_name_, offset, whence); + +#if 0 /* lseek has no business messing about with text-mode stuff */ + + if (!get_r_binary ()) + { + int newplace; + + if (whence == 0) + { + newplace = offset; + } + else if (whence ==1) + { + newplace = rpos + offset; + } + else + { + /* Seek from the end of a file.. */ + if (rsize == -1) + { + /* Find the size of the file by reading till the end */ + + char b[CHUNK_SIZE]; + while (read (b, sizeof (b)) > 0) + ; + rsize = rpos; + } + newplace = rsize + offset; + } + + if (rpos > newplace) + { + SetFilePointer (handle, 0, 0, 0); + rpos = 0; + } + + /* You can never shrink something more than 50% by turning CRLF into LF, + so we binary chop looking for the right place */ + + while (rpos < newplace) + { + char b[CHUNK_SIZE]; + size_t span = (newplace - rpos) / 2; + if (span == 0) + span = 1; + if (span > sizeof (b)) + span = sizeof (b); + + debug_printf ("lseek (%s, %d, %d) span %d, rpos %d newplace %d", + name, offset, whence,span,rpos, newplace); + read (b, span); + } + + debug_printf ("Returning %d", newplace); + return newplace; + } +#endif /* end of deleted code dealing with text mode */ + + DWORD win32_whence = whence == SEEK_SET ? FILE_BEGIN + : (whence == SEEK_CUR ? FILE_CURRENT : FILE_END); + + res = SetFilePointer (get_handle(), offset, 0, win32_whence); + if (res == -1) + { + __seterrno (); + } + else + { + /* When next we write(), we will check to see if *this* seek went beyond + the end of the file, and back-seek and fill with zeros if so - DJ */ + set_check_win95_lseek_bug (); + + /* If this was a SEEK_CUR with offset 0, we still might have + readahead that we have to take into account when calculating + the actual position for the application. */ + if (whence == SEEK_CUR) + res -= ralen - raixget; + } + + return res; +} + +int +fhandler_base::close (void) +{ + int res = -1; + + syscall_printf ("handle %p", get_handle()); + if (CloseHandle (get_handle())) + res = 0; + else + { + paranoid_printf ("CloseHandle (%d <%s>) failed", get_handle(), + get_name ()); + + __seterrno (); + } + return res; +} + +int +fhandler_base::ioctl (unsigned int cmd, void *buf) +{ + if (cmd == FIONBIO) + syscall_printf ("ioctl (FIONBIO, %p)", buf); + else + syscall_printf ("ioctl (%x, %p)", cmd, buf); + + set_errno (EINVAL); + return -1; +} + +int +fhandler_base::lock (int, struct flock *) +{ + set_errno (ENOSYS); + return -1; +} + +int +fhandler_base::fstat (struct stat *buf) +{ + return stat_dev (get_device (), get_unit (), get_namehash (), buf); + return 0; +} + +extern "C" char * __stdcall +rootdir(char *full_path) +{ + /* Possible choices: + * d:... -> d:/ + * \\server\share... -> \\server\share\ + * else current drive. + */ + char *root=full_path; + + if (full_path[1] == ':') + strcpy (full_path + 2, "\\"); + else if (full_path[0] == '\\' && full_path[1] == '\\') + { + char *cp = full_path + 2; + while (*cp && *cp != '\\') + cp++; + if (!*cp) + { + set_errno (ENOTDIR); + return NULL; + } + cp++; + while (*cp && *cp != '\\') + cp++; + strcpy (cp, "\\"); + } + else + root = NULL; + + return root; +} + +int +fhandler_disk_file::fstat (struct stat *buf) +{ + int res = 0; // avoid a compiler warning + BY_HANDLE_FILE_INFORMATION local; + int old_errno = get_errno (); + + memset (buf, 0, sizeof (*buf)); + + if (is_device ()) + return stat_dev (get_device (), get_unit (), get_namehash (), buf); + + /* NT 3.51 seems to have a bug when attempting to get vol serial + numbers. This loop gets around this. */ + for (int i = 0; i < 2; i++) + { + if (!(res = GetFileInformationByHandle (get_handle (), &local))) + break; + if (local.dwVolumeSerialNumber && (long) local.dwVolumeSerialNumber != -1) + break; + } + debug_printf ("%d = GetFileInformationByHandle (%s, %d)", + res, get_win32_name (), get_handle ()); + if (res == 0) + { + /* GetFileInformationByHandle will fail if it's given stdin/out/err + or a pipe*/ + DWORD lsize, hsize; + + if (GetFileType (get_handle ()) != FILE_TYPE_DISK) + buf->st_mode = S_IFCHR; + + lsize = GetFileSize (get_handle (), &hsize); + if (lsize == 0xffffffff && GetLastError () != NO_ERROR) + buf->st_mode = S_IFCHR; + else + buf->st_size = lsize; + /* We expect these to fail! */ + buf->st_mode |= STD_RBITS | STD_WBITS; + buf->st_blksize = S_BLKSIZE; + buf->st_ino = get_namehash (); + syscall_printf ("0 = fstat (, %p)", buf); + return 0; + } + + if (!get_win32_name ()) + { + set_errno (ENOENT); + return -1; + } + + set_errno (old_errno); + + buf->st_atime = to_time_t (&local.ftLastAccessTime); + buf->st_mtime = to_time_t (&local.ftLastWriteTime); + buf->st_ctime = to_time_t (&local.ftCreationTime); + buf->st_nlink = local.nNumberOfLinks; + buf->st_dev = local.dwVolumeSerialNumber; + buf->st_size = local.nFileSizeLow; + + /* Allocate some place to determine the root directory. */ + char root[strlen (get_win32_name ()) + 1]; + strcpy (root, get_win32_name ()); + + /* Assume that if a drive has ACL support it MAY have valid "inodes". + It definitely does not have valid inodes if it does not have ACL + support. */ + switch (has_acls () ? GetDriveType (rootdir (root)) : DRIVE_UNKNOWN) + { + case DRIVE_FIXED: + case DRIVE_REMOVABLE: + case DRIVE_CDROM: + case DRIVE_RAMDISK: + /* Although the documentation indicates otherwise, it seems like + "inodes" on these devices are persistent, at least across reboots. */ + buf->st_ino = local.nFileIndexHigh | local.nFileIndexLow; + break; + default: + /* Either the nFileIndex* fields are unreliable or unavailable. Use the + next best alternative. */ + buf->st_ino = get_namehash (); + break; + } + + buf->st_blksize = S_BLKSIZE; + buf->st_blocks = (buf->st_size + S_BLKSIZE-1) / S_BLKSIZE; + buf->st_uid = get_file_owner (has_acls (), get_win32_name ()); + buf->st_gid = get_file_group (has_acls (), get_win32_name ()); + + /* Using a side effect: get_file_attibutes checks for + directory. This is used, to set S_ISVTX, if needed. */ + if (local.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) + buf->st_mode |= S_IFDIR; + if (! get_file_attribute (has_acls (), get_win32_name (), &buf->st_mode)) + { + buf->st_mode &= ~S_IFMT; + if (get_symlink_p ()) + buf->st_mode |= S_IFLNK; + else if (get_socket_p ()) + buf->st_mode |= S_IFSOCK; + else if (local.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) + buf->st_mode |= S_IFDIR; + else + buf->st_mode |= S_IFREG; + } + else + { + buf->st_mode = 0; + buf->st_mode |= STD_RBITS; + + if (! (local.dwFileAttributes & FILE_ATTRIBUTE_READONLY)) + buf->st_mode |= STD_WBITS; + /* | S_IWGRP | S_IWOTH; we don't give write to group etc */ + + if (get_symlink_p ()) + buf->st_mode |= S_IFLNK; + else if (get_socket_p ()) + buf->st_mode |= S_IFSOCK; + else + switch (GetFileType (get_handle ())) + { + case FILE_TYPE_CHAR: + case FILE_TYPE_UNKNOWN: + buf->st_mode |= S_IFCHR; + break; + case FILE_TYPE_DISK: + if (local.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) + buf->st_mode |= S_IFDIR | STD_XBITS; + else + { + buf->st_mode |= S_IFREG; + if (get_execable_p ()) + buf->st_mode |= STD_XBITS; + } + break; + case FILE_TYPE_PIPE: + buf->st_mode |= S_IFSOCK; + break; + } + } + + syscall_printf ("0 = fstat (, %p) st_atime=%x st_size=%d, st_mode=%p, st_ino=%d, sizeof=%d", + buf, buf->st_atime, buf->st_size, buf->st_mode, + (int) buf->st_ino, sizeof (*buf)); + + return 0; +} + +void +fhandler_base::init (HANDLE f, DWORD a, mode_t bin) +{ + set_io_handle (f); + set_r_binary (bin); + set_w_binary (bin); + access_ = a; + a &= GENERIC_READ | GENERIC_WRITE; + if (a == GENERIC_READ) + set_flags (O_RDONLY); + if (a == GENERIC_WRITE) + set_flags (O_WRONLY); + if (a == (GENERIC_READ | GENERIC_WRITE)) + set_flags (O_RDWR); + debug_printf ("created new fhandler_base for handle %p", f); +} + +void +fhandler_base::dump (void) +{ + paranoid_printf ("here"); +} + +void +fhandler_base::set_io_handle (HANDLE x) +{ + debug_printf ("set handle to %p", x); + io_handle = x; +} + +int +fhandler_base::dup (fhandler_base *child) +{ + debug_printf ("in fhandler_base dup"); + + HANDLE nh; + if (!DuplicateHandle (hMainProc, get_handle(), hMainProc, &nh, 0, TRUE, + DUPLICATE_SAME_ACCESS)) + { + system_printf ("dup(%s) failed, handle %x, %E", + get_name (), get_handle()); + __seterrno (); + return -1; + } + + child->set_io_handle (nh); + return 0; +} + +/* Base terminal handlers. These just return errors. */ + +int +fhandler_base::tcflush (int queue) +{ + set_errno (ENOTTY); + return -1; +} + +int +fhandler_base::tcsendbreak (int duration) +{ + set_errno (ENOTTY); + return -1; +} + +int +fhandler_base::tcdrain (void) +{ + set_errno (ENOTTY); + return -1; +} + +int +fhandler_base::tcflow (int action) +{ + set_errno (ENOTTY); + return -1; +} + +int +fhandler_base::tcsetattr (int a, const struct termios *t) +{ + set_errno (ENOTTY); + return -1; +} + +int +fhandler_base::tcgetattr (struct termios *t) +{ + set_errno (ENOTTY); + return -1; +} + +int +fhandler_base::tcsetpgrp (const pid_t pid) +{ + set_errno (ENOTTY); + return -1; +} + +int +fhandler_base::tcgetpgrp (void) +{ + set_errno (ENOTTY); + return -1; +} + +/* Normal I/O constructor */ +fhandler_base::fhandler_base (DWORD devtype, const char *name, int unit): + access_ (0), + io_handle (NULL), + rpos_ (0), + rsize_ (0), + namehash_ (0), + openflags_ (0), + rabuf (NULL), + ralen (0), + raixget (0), + raixput (0), + rabuflen (0) +{ + status = devtype; + int bin = __fmode & O_TEXT ? 0 : 1; + if (status != FH_DISK && status != FH_CONSOLE) + { + if (!get_r_binset ()) + set_r_binary (bin); + if (!get_w_binset ()) + set_w_binary (bin); + } + unix_path_name_ = win32_path_name_ = NULL; + set_name (name, NULL, unit); +} + +/* Normal I/O destructor */ +fhandler_base::~fhandler_base (void) +{ + if (!no_free_names ()) + { + if (unix_path_name_ != NULL && unix_path_name_ != fhandler_disk_dummy_name) + free (unix_path_name_); + if (win32_path_name_ != NULL && win32_path_name_ != fhandler_disk_dummy_name) + free (win32_path_name_); + } + unix_path_name_ = win32_path_name_ = NULL; +} + +/**********************************************************************/ +/* fhandler_disk_file */ + +fhandler_disk_file::fhandler_disk_file (const char *name) : + fhandler_base (FH_DISK, name) +{ + set_cb (sizeof *this); + set_no_free_names (); + unix_path_name_ = win32_path_name_ = fhandler_disk_dummy_name; +} + +int +fhandler_disk_file::open (const char *path, int flags, mode_t mode) +{ + syscall_printf ("(%s, %p)", path, flags); + + /* O_NOSYMLINK is an internal flag for implementing lstat, nothing more. */ + path_conv real_path (path, (flags & O_NOSYMLINK) ? SYMLINK_NOFOLLOW:SYMLINK_FOLLOW); + + if (real_path.error && + (flags & O_NOSYMLINK || real_path.error != ENOENT || !(flags & O_CREAT))) + { + set_errno (real_path.error); + syscall_printf ("0 = fhandler_disk_file::open (%s, %p)", path, flags); + return 0; + } + + set_name (path, real_path.get_win32 ()); + set_no_free_names (0); + return open (real_path, flags, mode); +} + +int +fhandler_disk_file::open (path_conv& real_path, int flags, mode_t mode) +{ + if (get_win32_name () == fhandler_disk_dummy_name) + { + win32_path_name_ = real_path.get_win32 (); + set_no_free_names (); + } + /* If necessary, do various other things to see if path is a program. */ + if (!real_path.isexec ()) + real_path.set_exec (check_execable_p (get_win32_name ())); + + if (real_path.isbinary ()) + { + set_r_binary (1); + set_w_binary (1); + } + + set_has_acls (real_path.has_acls ()); + + int res = this->fhandler_base::open (flags, mode); + + if (!res) + goto out; + + extern BOOL allow_ntea; + + if (!real_path.isexec () && !allow_ntea && + GetFileType (get_handle ()) == FILE_TYPE_DISK) + { + DWORD done; + char magic[3]; + /* FIXME should we use /etc/magic ? */ + magic[0] = magic[1] = magic[2] = '\0'; + ReadFile (get_handle (), magic, 3, &done, 0); + if ((magic[0] == ':' && magic[1] == '\n') || + (magic[0] == '#' && magic[1] == '!')) + real_path.set_exec (); + if (!(flags & O_APPEND)) + SetFilePointer (get_handle(), 0, 0, FILE_BEGIN); + } + + if (flags & O_APPEND) + SetFilePointer (get_handle(), 0, 0, FILE_END); + + set_symlink_p (real_path.issymlink ()); + set_execable_p (real_path.isexec ()); + set_socket_p (real_path.issocket ()); + +out: + syscall_printf ("%d = fhandler_disk_file::open (%s, %p)", res, + get_win32_name (), flags); + return res; +} + +int +fhandler_disk_file::close () +{ + int res; + if ((res = this->fhandler_base::close ()) == 0) + cygwin_shared->delqueue.process_queue (); + return res; +} + +/* + * FIXME !!! + * The correct way to do this to get POSIX locking + * semantics is to keep a linked list of posix lock + * requests and map them into Win32 locks. The problem + * is that Win32 does not deal correctly with overlapping + * lock requests. Also another pain is that Win95 doesn't do + * non-blocking or non exclusive locks at all. For '95 just + * convert all lock requests into blocking,exclusive locks. + * This shouldn't break many apps but denying all locking + * would. + * For now just convert to Win32 locks and hope for the best. + */ + +int +fhandler_disk_file::lock (int cmd, struct flock *fl) +{ + DWORD win32_start; + DWORD win32_len; + DWORD win32_upper; + DWORD startpos; + + /* + * We don't do getlck calls yet. + */ + + if (cmd == F_GETLK) + { + set_errno (ENOSYS); + return -1; + } + + /* + * Calculate where in the file to start from, + * then adjust this by fl->l_start. + */ + + switch (fl->l_whence) + { + case SEEK_SET: + startpos = 0; + break; + case SEEK_CUR: + if ((startpos = lseek (0, SEEK_CUR)) < 0) + return -1; + break; + case SEEK_END: + { + BY_HANDLE_FILE_INFORMATION finfo; + if (GetFileInformationByHandle (get_handle(), &finfo) == 0) + { + __seterrno (); + return -1; + } + startpos = finfo.nFileSizeLow; /* Nowhere to keep high word */ + break; + } + default: + set_errno (EINVAL); + return -1; + } + + /* + * Now the fun starts. Adjust the start and length + * fields until they make sense. + */ + + win32_start = startpos + fl->l_start; + if (fl->l_len < 0) + { + win32_start -= fl->l_len; + win32_len = -fl->l_len; + } + else + win32_len = fl->l_len; + + if (win32_start < 0) + { + win32_len -= win32_start; + if (win32_len <= 0) + { + /* Failure ! */ + set_errno (EINVAL); + return -1; + } + win32_start = 0; + } + + /* + * Special case if len == 0 for POSIX means lock + * to the end of the entire file (and all future extensions). + */ + if (win32_len == 0) + { + win32_len = 0xffffffff; + win32_upper = host_dependent.win32_upper; + } + else + win32_upper = 0; + + BOOL res; + + if (os_being_run == winNT) + { + DWORD lock_flags = (cmd == F_SETLK) ? LOCKFILE_FAIL_IMMEDIATELY : 0; + lock_flags |= (fl->l_type == F_WRLCK) ? LOCKFILE_EXCLUSIVE_LOCK : 0; + + OVERLAPPED ov; + + ov.Internal = 0; + ov.InternalHigh = 0; + ov.Offset = win32_start; + ov.OffsetHigh = 0; + ov.hEvent = (HANDLE) 0; + + if (fl->l_type == F_UNLCK) + { + res = UnlockFileEx (get_handle (), 0, win32_len, win32_upper, &ov); + } + else + { + res = LockFileEx (get_handle (), lock_flags, 0, win32_len, + win32_upper, &ov); + /* Deal with the fail immediately case. */ + /* + * FIXME !! I think this is the right error to check for + * but I must admit I haven't checked.... + */ + if ((res == 0) && (lock_flags & LOCKFILE_FAIL_IMMEDIATELY) && + (GetLastError () == ERROR_LOCK_FAILED)) + { + set_errno (EAGAIN); + return -1; + } + } + } + else + { + /* Windows 95 -- use primitive lock call */ + if (fl->l_type == F_UNLCK) + res = UnlockFile (get_handle (), win32_start, 0, win32_len, + win32_upper); + else + res = LockFile (get_handle (), win32_start, 0, win32_len, win32_upper); + } + + if (res == 0) + { + __seterrno (); + return -1; + } + + return 0; +} + +/* Perform various heuristics on PATH to see if it's a program. */ + +int +fhandler_disk_file::check_execable_p (const char *path) +{ + int len = strlen (path); + const char *ch = path + (len > 4 ? len - 4 : len); + + if (strcasematch (".exe", ch) + || strcasematch (".bat", ch) + || strcasematch (".com", ch)) + return 1; + return 0; +} + +/**********************************************************************/ +/* /dev/null */ + +fhandler_dev_null::fhandler_dev_null (const char *name) : + fhandler_base (FH_NULL, name) +{ + set_cb (sizeof *this); +} + +void +fhandler_dev_null::dump (void) +{ + paranoid_printf ("here"); +} + +/**********************************************************************/ +/* fhandler_pipe */ + +fhandler_pipe::fhandler_pipe (const char *name) : + fhandler_base (FH_PIPE, name) +{ + set_cb (sizeof *this); +} + +off_t +fhandler_pipe::lseek (off_t offset, int whence) +{ + debug_printf ("(%d, %d)", offset, whence); + set_errno (ESPIPE); + return -1; +} + +void __stdcall +set_inheritance (HANDLE &h, int not_inheriting, const char *name) +{ + HANDLE newh; + + if (!DuplicateHandle (hMainProc, h, hMainProc, &newh, 0, !not_inheriting, + DUPLICATE_SAME_ACCESS)) + debug_printf ("DuplicateHandle %E"); +#ifndef DEBUGGING + else + { + CloseHandle (h); + h = newh; + } +#else + else if (!name) + { + CloseHandle (h); + h = newh; + } + else + { + ForceCloseHandle2 (h, name); + h = newh; + ProtectHandle2 (h, name); + } +#endif +} + +void +fhandler_base::fork_fixup (HANDLE parent, HANDLE &h, const char *name) +{ + if (!DuplicateHandle (parent, h, hMainProc, &h, 0, !get_close_on_exec (), + DUPLICATE_SAME_ACCESS)) + system_printf ("%s - %E, handle %s<%p>", get_name (), name, h); +} + +void +fhandler_base::set_close_on_exec (int val) +{ + set_inheritance (io_handle, val); + set_close_on_exec_flag (val); + debug_printf ("set close_on_exec for %s to %d", get_name (), val); +} + +void +fhandler_base::fixup_after_fork (HANDLE parent) +{ + debug_printf ("inheriting '%s' from parent", get_name ()); + fork_fixup (parent, io_handle, "io_handle"); +} |