(ftruncate64): Ditto.
(lseek64): Ditto.
(lstat64): Ditto.
(mmap64): Ditto.
(seekdir64): Ditto.
(stat64): Ditto.
(telldir64): Ditto.
(truncate64): Ditto.
* dir.cc (telldir64): New function.
(telldir): Call telldir64().
(seekdir64): New function.
(seekdir): Call seekdir64().
* fhandler.h: Redefine all methods using __off32_t to use __off64_t.
* fhandler.cc: Use __off64_t and struct __stat64 throughout.
* fhandler_clipboard.cc: Ditto.
* fhandler_disk_file.cc: Ditto.
* fhandler_dsp.cc: Ditto.
* fhandler_floppy.cc: Ditto.
* fhandler_mem.cc: Ditto.
* fhandler_random.cc: Ditto.
* fhandler_socket.cc: Ditto.
* fhandler_tape.cc: Ditto.
* fhandler_zero.cc: Ditto.
* pipe.cc: Ditto.
* glob.c: Ditto, call lstat64 and stat64 in Cygwin.
* mmap.cc: Use __off64_t throughout.
(mmap64): New function.
* sec_acl.cc (acl_worker): Use struct __stat64, call stat64 and lstat64.
* syscalls.cc (lseek64): New function.
(stat64_to_stat32): Ditto.
(fstat64): Ditto.
(stat64): Ditto.
(lstat64): Ditto.
(ftruncate64): Ditto.
(truncate64): Ditto.
(_fstat): Call fstat64.
(_stat): Call stat64.
(cygwin_lstat): Rename to avoid declaration problem. Call lstat64.
(stat_worker): Use struct __stat64.
(access): Ditto.
(ftruncate): Call ftruncate64.
(truncate): Call truncate64.
* wincap.cc: Set flag has_64bit_file_access appropriately.
* wincap.h: Add flag has_64bit_file_access.
* winsup.h (ILLEGAL_SEEK): Define as __off64_t.
(stat_dev): Declare using struct __stat64.
(stat_worker): Ditto.
* include/cygwin/stat.h (struct __stat32): Define if compiling Cygwin.
(struct __stat64): Ditto.
(struct stat): Revert definition with explicitly sized datatypes.
Eliminate sized field names.
* include/cygwin/types.h (blksize_t): New type.
(__blkcnt32_t): Ditto.
(__blkcnt64_t): Ditto.
(blkcnt_t): Ditto.
+2002-02-23 Corinna Vinschen <corinna@vinschen.de>
+
+ * cygwin.din (fstat64): New symbol.
+ (ftruncate64): Ditto.
+ (lseek64): Ditto.
+ (lstat64): Ditto.
+ (mmap64): Ditto.
+ (seekdir64): Ditto.
+ (stat64): Ditto.
+ (telldir64): Ditto.
+ (truncate64): Ditto.
+ * dir.cc (telldir64): New function.
+ (telldir): Call telldir64().
+ (seekdir64): New function.
+ (seekdir): Call seekdir64().
+ * fhandler.h: Redefine all methods using __off32_t to use __off64_t.
+ * fhandler.cc: Use __off64_t and struct __stat64 throughout.
+ * fhandler_clipboard.cc: Ditto.
+ * fhandler_disk_file.cc: Ditto.
+ * fhandler_dsp.cc: Ditto.
+ * fhandler_floppy.cc: Ditto.
+ * fhandler_mem.cc: Ditto.
+ * fhandler_random.cc: Ditto.
+ * fhandler_socket.cc: Ditto.
+ * fhandler_tape.cc: Ditto.
+ * fhandler_zero.cc: Ditto.
+ * pipe.cc: Ditto.
+ * glob.c: Ditto, call lstat64 and stat64 in Cygwin.
+ * mmap.cc: Use __off64_t throughout.
+ (mmap64): New function.
+ * sec_acl.cc (acl_worker): Use struct __stat64, call stat64 and lstat64.
+ * syscalls.cc (lseek64): New function.
+ (stat64_to_stat32): Ditto.
+ (fstat64): Ditto.
+ (stat64): Ditto.
+ (lstat64): Ditto.
+ (ftruncate64): Ditto.
+ (truncate64): Ditto.
+ (_fstat): Call fstat64.
+ (_stat): Call stat64.
+ (cygwin_lstat): Rename to avoid declaration problem. Call lstat64.
+ (stat_worker): Use struct __stat64.
+ (access): Ditto.
+ (ftruncate): Call ftruncate64.
+ (truncate): Call truncate64.
+ * wincap.cc: Set flag has_64bit_file_access appropriately.
+ * wincap.h: Add flag has_64bit_file_access.
+ * winsup.h (ILLEGAL_SEEK): Define as __off64_t.
+ (stat_dev): Declare using struct __stat64.
+ (stat_worker): Ditto.
+ * include/cygwin/stat.h (struct __stat32): Define if compiling Cygwin.
+ (struct __stat64): Ditto.
+ (struct stat): Revert definition with explicitly sized datatypes.
+ Eliminate sized field names.
+ * include/cygwin/types.h (blksize_t): New type.
+ (__blkcnt32_t): Ditto.
+ (__blkcnt64_t): Ditto.
+ (blkcnt_t): Ditto.
+
2002-02-22 Christopher Faylor <cgf@redhat.com>
* sync.h (new_muto): Just accept an argument which denotes the name of
_fsetpos = fsetpos
fstat
_fstat = fstat
+fstat64
fstatfs
_fstatfs = fstatfs
fsync
_ftime = ftime
ftruncate
_ftruncate = ftruncate
+ftruncate64
fwrite
_fwrite = fwrite
gamma
_longjmp = longjmp
lseek
_lseek = lseek
-lstat
-_lstat = lstat
+lseek64
+lstat = cygwin_lstat
+_lstat = cygwin_lstat
+lstat64
malloc = export_malloc
_malloc = export_malloc
matherr
mktime
_mktime = mktime
mmap
+mmap64
mprotect
msync
munmap
scanf_r = _scanf_r
seekdir
_seekdir = seekdir
+seekdir64
setbuf
_setbuf = setbuf
setdtablesize
sscanf_r = _sscanf_r
stat
_stat = stat
+stat64
statfs
_statfs = statfs
strcasecmp
_tcsetpgrp = tcsetpgrp
telldir
_telldir = telldir
+telldir64
tempnam
_tempnam = tempnam
time
_toupper = toupper
truncate
_truncate = truncate
+truncate64
ttyname
_ttyname = ttyname
tzset
return ((fhandler_base *) dir->__d_u.__d_data.__fh)->readdir (dir);
}
-/* telldir */
-extern "C" __off32_t
-telldir (DIR *dir)
+extern "C" __off64_t
+telldir64 (DIR *dir)
{
if (check_null_invalid_struct_errno (dir))
return -1;
return ((fhandler_base *) dir->__d_u.__d_data.__fh)->telldir (dir);
}
-/* seekdir */
+/* telldir */
+extern "C" __off32_t
+telldir (DIR *dir)
+{
+ return telldir64 (dir);
+}
+
extern "C" void
-seekdir (DIR *dir, __off32_t loc)
+seekdir64 (DIR *dir, __off64_t loc)
{
if (check_null_invalid_struct_errno (dir))
return;
return ((fhandler_base *) dir->__d_u.__d_data.__fh)->seekdir (dir, loc);
}
+/* seekdir */
+extern "C" void
+seekdir (DIR *dir, __off32_t loc)
+{
+ seekdir64 (dir, (__off64_t)loc);
+}
+
/* rewinddir: POSIX 5.1.2.1 */
extern "C" void
rewinddir (DIR *dir)
#include "sigproc.h"
#include "pinfo.h"
#include <assert.h>
+#include <limits.h>
static NO_COPY const int CHUNK_SIZE = 1024; /* Used for crlf conversions */
return res;
}
-__off32_t
-fhandler_base::lseek (__off32_t offset, int whence)
+__off64_t
+fhandler_base::lseek (__off64_t offset, int whence)
{
- __off32_t res;
+ __off64_t res;
+
+ /* 9x/Me doesn't support 64bit offsets. We trap that here and return
+ EINVAL. It doesn't make sense to simulate bigger offsets by a
+ SetFilePointer sequence since FAT and FAT32 don't support file
+ size >= 4GB anyway. */
+ if (!wincap.has_64bit_file_access ()
+ && (offset < LONG_MIN || offset > LONG_MAX))
+ {
+ debug_printf ("Win9x, offset not 32 bit.");
+ set_errno (EINVAL);
+ return (__off64_t)-1;
+ }
/* Seeks on text files is tough, we rewind and read till we get to the
right place. */
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 */
+ debug_printf ("lseek (%s, %D, %d)", unix_path_name, offset, whence);
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)
+ LONG off_low = offset & 0xffffffff;
+ LONG off_high = wincap.has_64bit_file_access () ? offset >> 32 : 0;
+
+ res = SetFilePointer (get_handle(), off_low, &off_high, win32_whence);
+ if (res == INVALID_SET_FILE_POINTER && GetLastError ())
{
__seterrno ();
}
}
int __stdcall
-fhandler_base::fstat (struct stat *buf, path_conv *)
+fhandler_base::fstat (struct __stat64 *buf, path_conv *)
{
switch (get_device ())
{
return NULL;
}
-__off32_t
+__off64_t
fhandler_base::telldir (DIR *)
{
set_errno (ENOTDIR);
}
void
-fhandler_base::seekdir (DIR *, __off32_t)
+fhandler_base::seekdir (DIR *, __off64_t)
{
set_errno (ENOTDIR);
return;
virtual int open (path_conv * real_path, int flags, mode_t mode = 0);
virtual int close ();
- virtual int __stdcall fstat (struct stat *buf, path_conv *) __attribute__ ((regparm (3)));
+ virtual int __stdcall fstat (struct __stat64 *buf, path_conv *) __attribute__ ((regparm (3)));
virtual int ioctl (unsigned int cmd, void *);
virtual int fcntl (int cmd, void *);
virtual char const * ttyname () { return get_name(); }
virtual int __stdcall read (void *ptr, size_t len) __attribute__ ((regparm (3)));
virtual int write (const void *ptr, size_t len);
- virtual __off32_t lseek (__off32_t offset, int whence);
+ virtual __off64_t lseek (__off64_t offset, int whence);
virtual int lock (int, struct flock *);
virtual void dump ();
virtual int dup (fhandler_base *child);
virtual HANDLE mmap (caddr_t *addr, size_t len, DWORD access,
- int flags, __off32_t off);
+ int flags, __off64_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,
virtual void set_eof () {}
virtual DIR *opendir (path_conv& pc);
virtual dirent *readdir (DIR *);
- virtual __off32_t telldir (DIR *);
- virtual void seekdir (DIR *, __off32_t);
+ virtual __off64_t telldir (DIR *);
+ virtual void seekdir (DIR *, __off64_t);
virtual void rewinddir (DIR *);
virtual int closedir (DIR *);
};
int ioctl (unsigned int cmd, void *);
int fcntl (int cmd, void *);
- __off32_t lseek (__off32_t, int) { return 0; }
+ __off64_t lseek (__off64_t, int) { return 0; }
int close ();
void hclose (HANDLE) {close ();}
int dup (fhandler_base *child);
int check_peer_secret_event (struct sockaddr_in *peer, int *secret = NULL);
void signal_secret_event ();
void close_secret_event ();
- int __stdcall fstat (struct stat *buf, path_conv *) __attribute__ ((regparm (3)));
+ int __stdcall fstat (struct __stat64 *buf, path_conv *) __attribute__ ((regparm (3)));
};
class fhandler_pipe: public fhandler_base
unsigned id;
public:
fhandler_pipe (DWORD devtype);
- __off32_t lseek (__off32_t offset, int whence);
+ __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);
virtual int open (path_conv *, int flags, mode_t mode = 0);
virtual int close (void);
- virtual __off32_t lseek (__off32_t offset, int whence);
+ virtual __off64_t lseek (__off64_t offset, int whence);
virtual int ioctl (unsigned int cmd, void *buf);
};
int open (path_conv *, int flags, mode_t mode = 0);
int close (void);
- __off32_t lseek (__off32_t offset, int whence);
+ __off64_t lseek (__off64_t offset, int whence);
- int __stdcall fstat (struct stat *buf, path_conv *) __attribute__ ((regparm (3)));
+ int __stdcall fstat (struct __stat64 *buf, path_conv *) __attribute__ ((regparm (3)));
int dup (fhandler_base *child);
int close ();
int lock (int, struct flock *);
BOOL is_device () { return FALSE; }
- int __stdcall fstat (struct stat *buf, path_conv *pc) __attribute__ ((regparm (3)));
- int __stdcall fstat_helper (struct stat *buf) __attribute__ ((regparm (2)));
+ int __stdcall fstat (struct __stat64 *buf, path_conv *pc) __attribute__ ((regparm (3)));
+ int __stdcall fstat_helper (struct __stat64 *buf) __attribute__ ((regparm (2)));
- HANDLE mmap (caddr_t *addr, size_t len, DWORD access, int flags, __off32_t off);
+ HANDLE mmap (caddr_t *addr, size_t len, DWORD access, int flags, __off64_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);
DIR *opendir (path_conv& pc);
struct dirent *readdir (DIR *);
- __off32_t telldir (DIR *);
- void seekdir (DIR *, __off32_t);
+ __off64_t telldir (DIR *);
+ void seekdir (DIR *, __off64_t);
void rewinddir (DIR *);
int closedir (DIR *);
};
fhandler_cygdrive (int unit);
DIR *opendir (path_conv& pc);
struct dirent *readdir (DIR *);
- __off32_t telldir (DIR *);
- void seekdir (DIR *, __off32_t);
+ __off64_t telldir (DIR *);
+ void seekdir (DIR *, __off64_t);
void rewinddir (DIR *);
int closedir (DIR *);
- int __stdcall fstat (struct stat *buf, path_conv *pc) __attribute__ ((regparm (3)));
+ int __stdcall fstat (struct __stat64 *buf, path_conv *pc) __attribute__ ((regparm (3)));
};
class fhandler_serial: public fhandler_base
int tcflow (int);
int tcsetattr (int a, const struct termios *t);
int tcgetattr (struct termios *t);
- __off32_t lseek (__off32_t, int) { return 0; }
+ __off64_t lseek (__off64_t, int) { return 0; }
int tcflush (int);
void dump ();
int is_tty () { return 1; }
int tcflush (int);
int ioctl (unsigned int cmd, void *);
- __off32_t lseek (__off32_t, int) { return 0; }
+ __off64_t lseek (__off64_t, int) { return 0; }
select_record *select_read (select_record *s);
int ready_for_read (int fd, DWORD howlong);
};
int tcflush (int);
int ioctl (unsigned int cmd, void *);
- __off32_t lseek (__off32_t, int) { return 0; }
+ __off64_t lseek (__off64_t, int) { return 0; }
char *ptsname ();
void set_close_on_exec (int val);
int open (path_conv *, int flags, mode_t mode = 0);
int write (const void *ptr, size_t len);
int __stdcall read (void *ptr, size_t len) __attribute__ ((regparm (3)));
- __off32_t lseek (__off32_t offset, int whence);
+ __off64_t lseek (__off64_t offset, int whence);
int close (void);
void dump ();
int open (path_conv *, int flags, mode_t mode = 0);
int write (const void *ptr, size_t len);
int __stdcall read (void *ptr, size_t len) __attribute__ ((regparm (3)));
- __off32_t lseek (__off32_t offset, int whence);
+ __off64_t lseek (__off64_t offset, int whence);
int close (void);
int dup (fhandler_base *child);
protected:
int unit;
DWORD mem_size;
- DWORD pos;
+ __off64_t pos;
public:
fhandler_dev_mem (int unit);
int open (path_conv *, int flags, mode_t mode = 0);
int write (const void *ptr, size_t ulen);
int __stdcall read (void *ptr, size_t len) __attribute__ ((regparm (3)));
- __off32_t lseek (__off32_t offset, int whence);
+ __off64_t lseek (__off64_t offset, int whence);
int close (void);
- int __stdcall fstat (struct stat *buf, path_conv *) __attribute__ ((regparm (3)));
+ int __stdcall fstat (struct __stat64 *buf, path_conv *) __attribute__ ((regparm (3)));
int dup (fhandler_base *child);
- HANDLE mmap (caddr_t *addr, size_t len, DWORD access, int flags, __off32_t off);
+ HANDLE mmap (caddr_t *addr, size_t len, DWORD access, int flags, __off64_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,
int open (path_conv *, int flags, mode_t mode = 0);
int write (const void *ptr, size_t len);
int __stdcall read (void *ptr, size_t len) __attribute__ ((regparm (3)));
- __off32_t lseek (__off32_t offset, int whence);
+ __off64_t lseek (__off64_t offset, int whence);
int close (void);
int dup (fhandler_base *child);
void dump ();
private:
- __off32_t pos;
+ __off64_t pos;
void *membuffer;
size_t msize;
bool eof;
int write (const void *ptr, size_t len);
int __stdcall read (void *ptr, size_t len) __attribute__ ((regparm (3)));
int ioctl (unsigned int cmd, void *);
- __off32_t lseek (__off32_t, int) { return 0; }
+ __off64_t lseek (__off64_t, int) { return 0; }
int close (void) { return 0; }
void set_close_on_exec (int val);
int write (const void *ptr, size_t len);
int __stdcall read (void *ptr, size_t len) __attribute__ ((regparm (3)));
int ioctl (unsigned int cmd, void *);
- __off32_t lseek (__off32_t, int);
+ __off64_t lseek (__off64_t, int);
int close (void);
int dup (fhandler_base * child);
void dump (void);
}
}
-__off32_t
-fhandler_dev_clipboard::lseek (__off32_t offset, int whence)
+__off64_t
+fhandler_dev_clipboard::lseek (__off64_t offset, int whence)
{
/* On reads we check this at read time, not seek time.
* On writes we use this to decide how to write - empty and write, or open, copy, empty
}
int
-fhandler_disk_file::fstat (struct stat *buf, path_conv *pc)
+fhandler_disk_file::fstat (struct __stat64 *buf, path_conv *pc)
{
int res = -1;
int oret;
buf->st_mode = S_IFREG;
if (!pc->has_acls ()
|| get_file_attribute (TRUE, pc->get_win32 (),
- &buf->st_mode,
- &buf->st_uid, &buf->st_gid))
+ &buf->st_mode, &uid, &gid))
{
buf->st_mode |= STD_RBITS | STD_XBITS;
if (!(pc->has_attribute (FILE_ATTRIBUTE_READONLY)))
buf->st_mode |= STD_WBITS;
if (pc->issymlink ())
buf->st_mode |= S_IRWXU | S_IRWXG | S_IRWXO;
- get_file_attribute (FALSE, pc->get_win32 (),
- NULL, &buf->st_uid, &buf->st_gid);
+ get_file_attribute (FALSE, pc->get_win32 (), NULL, &uid, &gid);
}
+ buf->st_uid = uid;
+ buf->st_gid = gid;
if ((handle = FindFirstFile (pc->get_win32 (), &wfd))
!= INVALID_HANDLE_VALUE)
{
buf->st_mtime = to_time_t (&wfd.ftLastWriteTime);
buf->st_ctime = to_time_t (&wfd.ftCreationTime);
buf->st_size = wfd.nFileSizeLow;
+ buf->st_size = ((__off64_t)wfd.nFileSizeHigh << 32)
+ + wfd.nFileSizeLow;
buf->st_blksize = S_BLKSIZE;
- buf->st_blocks = ((unsigned long) buf->st_size +
- S_BLKSIZE-1) / S_BLKSIZE;
+ buf->st_blocks = (buf->st_size + S_BLKSIZE-1) / S_BLKSIZE;
FindClose (handle);
}
res = 0;
}
int
-fhandler_disk_file::fstat_helper (struct stat *buf)
+fhandler_disk_file::fstat_helper (struct __stat64 *buf)
{
int res = 0; // avoid a compiler warning
BY_HANDLE_FILE_INFORMATION local;
if (lsize == 0xffffffff && GetLastError () != NO_ERROR)
buf->st_mode = S_IFCHR;
else
- buf->st_size = lsize;
+ buf->st_size = ((__off64_t)hsize << 32) + lsize;
/* We expect these to fail! */
buf->st_mode |= STD_RBITS | STD_WBITS;
buf->st_blksize = S_BLKSIZE;
buf->st_ctime = to_time_t (&local.ftCreationTime);
buf->st_nlink = local.nNumberOfLinks;
buf->st_dev = local.dwVolumeSerialNumber;
- buf->st_size = local.nFileSizeLow;
+ buf->st_size = ((__off64_t)local.nFileSizeHigh << 32)
+ + local.nFileSizeLow;
/* Allocate some place to determine the root directory. Need to allocate
enough so that rootdir can add a trailing slash if path starts with \\. */
}
buf->st_blksize = S_BLKSIZE;
- buf->st_blocks = ((unsigned long) buf->st_size + S_BLKSIZE-1) / S_BLKSIZE;
+ buf->st_blocks = (buf->st_size + S_BLKSIZE-1) / S_BLKSIZE;
buf->st_mode = 0;
/* Using a side effect: get_file_attibutes checks for
buf->st_mode = S_IFLNK;
else if (get_socket_p ())
buf->st_mode = S_IFSOCK;
+ __uid16_t uid;
+ __gid16_t gid;
if (get_file_attribute (has_acls (), get_win32_name (), &buf->st_mode,
- &buf->st_uid, &buf->st_gid) == 0)
+ &uid, &gid) == 0)
{
/* If read-only attribute is set, modify ntsec return value */
if ((local.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
if (!(buf->st_mode & S_IFMT))
buf->st_mode |= S_IFREG;
+
+ buf->st_uid = uid;
+ buf->st_gid = gid;
}
else
{
}
}
- syscall_printf ("0 = fstat (, %p) st_atime=%x st_size=%d, st_mode=%p, st_ino=%d, sizeof=%d",
+ 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));
int
fhandler_disk_file::lock (int cmd, struct flock *fl)
{
- int win32_start;
+ __off64_t win32_start;
int win32_len;
DWORD win32_upper;
- DWORD startpos;
+ __off64_t startpos;
/*
* We don't do getlck calls yet.
startpos = 0;
break;
case SEEK_CUR:
- if ((__off32_t) (startpos = lseek (0, SEEK_CUR)) == ILLEGAL_SEEK)
+ if ((startpos = lseek (0, SEEK_CUR)) == ILLEGAL_SEEK)
return -1;
break;
case SEEK_END:
__seterrno ();
return -1;
}
- startpos = finfo.nFileSizeLow; /* Nowhere to keep high word */
+ startpos = ((__off64_t)finfo.nFileSizeHigh << 32)
+ + finfo.nFileSizeLow;
break;
}
default:
return res;
}
-__off32_t
+__off64_t
fhandler_disk_file::telldir (DIR *dir)
{
return dir->__d_position;
}
void
-fhandler_disk_file::seekdir (DIR *dir, __off32_t loc)
+fhandler_disk_file::seekdir (DIR *dir, __off64_t loc)
{
rewinddir (dir);
while (loc > dir->__d_position)
}
int
-fhandler_cygdrive::fstat (struct stat *buf, path_conv *pc)
+fhandler_cygdrive::fstat (struct __stat64 *buf, path_conv *pc)
{
if (!iscygdrive_root ())
return fhandler_disk_file::fstat (buf, pc);
return dir->__d_dirent;
}
-__off32_t
+__off64_t
fhandler_cygdrive::telldir (DIR *dir)
{
return fhandler_disk_file::telldir (dir);
}
void
-fhandler_cygdrive::seekdir (DIR *dir, __off32_t loc)
+fhandler_cygdrive::seekdir (DIR *dir, __off64_t loc)
{
if (!iscygdrive_root ())
return fhandler_disk_file::seekdir (dir, loc);
return len;
}
-__off32_t
-fhandler_dev_dsp::lseek (__off32_t offset, int whence)
+__off64_t
+fhandler_dev_dsp::lseek (__off64_t offset, int whence)
{
return 0;
}
return fhandler_dev_raw::close ();
}
-__off32_t
-fhandler_dev_floppy::lseek (__off32_t offset, int whence)
+__off64_t
+fhandler_dev_floppy::lseek (__off64_t offset, int whence)
{
int ret;
char buf[512];
- long long drive_size = 0;
- long long lloffset = offset;
- long long current_position;
- __off32_t sector_aligned_offset;
- __off32_t bytes_left;
+ __off64_t drive_size = 0;
+ __off64_t lloffset = offset;
+ __off64_t current_position;
+ __off64_t sector_aligned_offset;
+ __off64_t bytes_left;
DWORD low;
LONG high = 0;
debug_printf ("partition info: %ld (%ld)",
pi.StartingOffset.LowPart,
pi.PartitionLength.LowPart);
- drive_size = (long long) pi.PartitionLength.QuadPart;
+ drive_size = pi.PartitionLength.QuadPart;
}
else
{
- drive_size = (long long) di.Cylinders.QuadPart * di.TracksPerCylinder *
+ drive_size = di.Cylinders.QuadPart * di.TracksPerCylinder *
di.SectorsPerTrack * di.BytesPerSector;
}
debug_printf ("drive size: %ld", drive_size);
__seterrno ();
return -1;
}
- current_position = (long long) low + ((long long) high << 32);
+ current_position = low + ((__off64_t) high << 32);
if (is_writing)
current_position += devbufend - devbufstart;
else
set_errno (EINVAL);
return -1;
}
- high = lloffset >> 32;
- low = lloffset & 0xffffffff;
- if (high || (__off32_t) low < 0)
- {
- set_errno (EFBIG);
- return -1;
- }
- offset = (__off32_t) low;
/* FIXME: sector can possibly be not 512 bytes long */
- sector_aligned_offset = (offset / 512) * 512;
- bytes_left = offset - sector_aligned_offset;
+ sector_aligned_offset = (lloffset / 512) * 512;
+ bytes_left = lloffset - sector_aligned_offset;
if (whence == SEEK_SET)
{
return ret;
devbufstart = devbufend = 0;
- if (SetFilePointer (get_handle (), sector_aligned_offset, NULL, FILE_BEGIN)
- == INVALID_SET_FILE_POINTER)
+ low = sector_aligned_offset & 0xffffffff;
+ high = sector_aligned_offset >> 32;
+ if (SetFilePointer (get_handle (), low, &high, FILE_BEGIN)
+ == INVALID_SET_FILE_POINTER && GetLastError ())
{
__seterrno ();
return -1;
return fhandler_base::close ();
}
-__off32_t
-fhandler_dev_mem::lseek (__off32_t offset, int whence)
+__off64_t
+fhandler_dev_mem::lseek (__off64_t offset, int whence)
{
switch (whence)
{
HANDLE
fhandler_dev_mem::mmap (caddr_t *addr, size_t len, DWORD access,
- int flags, __off32_t off)
+ int flags, __off64_t off)
{
- if ((DWORD) off >= mem_size
+ if (off >= mem_size
|| (DWORD) len >= mem_size
- || (DWORD) off + len >= mem_size)
+ || off + len >= mem_size)
{
set_errno (EINVAL);
syscall_printf ("-1 = mmap(): illegal parameter, set EINVAL");
}
int
-fhandler_dev_mem::fstat (struct stat *buf, path_conv *pc)
+fhandler_dev_mem::fstat (struct __stat64 *buf, path_conv *pc)
{
this->fhandler_base::fstat (buf, pc);
buf->st_mode = S_IFCHR;
return -1;
}
-__off32_t
-fhandler_dev_random::lseek (__off32_t, int)
+__off64_t
+fhandler_dev_random::lseek (__off64_t, int)
{
return 0;
}
}
int __stdcall
-fhandler_socket::fstat (struct stat *buf, path_conv *pc)
+fhandler_socket::fstat (struct __stat64 *buf, path_conv *pc)
{
fhandler_disk_file fh;
fh.set_name (get_name (), get_win32_name ());
}
int
-fhandler_dev_tape::fstat (struct stat *buf, path_conv *pc)
+fhandler_dev_tape::fstat (struct __stat64 *buf, path_conv *pc)
{
int ret;
return ret;
}
-__off32_t
-fhandler_dev_tape::lseek (__off32_t offset, int whence)
+__off64_t
+fhandler_dev_tape::lseek (__off64_t offset, int whence)
{
struct mtop op;
struct mtpos pos;
return len;
}
-__off32_t
-fhandler_dev_zero::lseek (__off32_t, int)
+__off64_t
+fhandler_dev_zero::lseek (__off64_t, int)
{
return 0;
}
#ifdef __LIBC12_SOURCE__
#define STAT stat12
#else
+#if defined (__INSIDE_CYGWIN__)
+#define STAT __stat64
+#else
#define STAT stat
#endif
+#endif
#define DOLLAR '$'
#define DOT '.'
g_Ctoc(fn, buf);
if (pglob->gl_flags & GLOB_ALTDIRFUNC)
return((*pglob->gl_lstat)(buf, sb));
+#ifdef __INSIDE_CYGWIN__
+ return(lstat64(buf, sb));
+#else
return(lstat(buf, sb));
+#endif
}
static int
g_Ctoc(fn, buf);
if (pglob->gl_flags & GLOB_ALTDIRFUNC)
return((*pglob->gl_stat)(buf, sb));
+#ifdef __INSIDE_CYGWIN__
+ return(stat64(buf, sb));
+#else
return(stat(buf, sb));
+#endif
}
static Char *
extern "C" {
#endif
-struct stat
-{
- dev_t st_dev;
- ino_t st_ino;
- mode_t st_mode;
- nlink_t st_nlink;
- __uid16_t __st_uid16;
- __gid16_t __st_gid16;
- dev_t st_rdev;
- __off32_t __st_size32;
- time_t st_atime;
- __uid32_t __st_uid32;
- time_t st_mtime;
- __uid32_t __st_gid32;
- time_t st_ctime;
- long st_spare3;
- long st_blksize;
- long st_blocks;
- __off64_t __st_size64;
+#ifdef __INSIDE_CYGWIN__
+struct __stat32
+{
+ dev_t st_dev;
+ ino_t st_ino;
+ mode_t st_mode;
+ nlink_t st_nlink;
+ __uid16_t st_uid;
+ __gid16_t st_gid;
+ dev_t st_rdev;
+ __off32_t st_size;
+ time_t st_atime;
+ long st_spare1;
+ time_t st_mtime;
+ long st_spare2;
+ time_t st_ctime;
+ long st_spare3;
+ blksize_t st_blksize;
+ __blkcnt32_t st_blocks;
+ long st_spare4[2];
+};
+
+struct __stat64
+{
+ dev_t st_dev;
+ ino_t st_ino;
+ mode_t st_mode;
+ nlink_t st_nlink;
+ __uid32_t st_uid;
+ __gid32_t st_gid;
+ dev_t st_rdev;
+ __off64_t st_size;
+ time_t st_atime;
+ long st_spare1;
+ time_t st_mtime;
+ long st_spare2;
+ time_t st_ctime;
+ long st_spare3;
+ blksize_t st_blksize;
+ __blkcnt64_t st_blocks;
+ long st_spare4[2];
};
-#ifdef __CYGWIN_USE_BIG_TYPES__
-#define st_uid __st_uid32
-#define st_gid __st_gid32
-#define st_size __st_size64
-#else
-#define st_uid __st_uid16
-#define st_gid __st_gid16
-#define st_size __st_size32
-#endif /* __CYGWIN_USE_BIG_TYPES__ */
+extern int fstat64 (int fd, struct __stat64 *buf);
+extern int stat64 (const char *file_name, struct __stat64 *buf);
+extern int lstat64 (const char *file_name, struct __stat64 *buf);
+
+#endif
+
+struct stat
+{
+ dev_t st_dev;
+ ino_t st_ino;
+ mode_t st_mode;
+ nlink_t st_nlink;
+ uid_t st_uid;
+ gid_t st_gid;
+ dev_t st_rdev;
+ off_t st_size;
+ time_t st_atime;
+ long st_spare1;
+ time_t st_mtime;
+ long st_spare2;
+ time_t st_ctime;
+ long st_spare3;
+ blksize_t st_blksize;
+ blkcnt_t st_blocks;
+ long st_spare4[2];
+};
#ifdef __cplusplus
}
typedef __off32_t off_t;
#endif
+typedef long blksize_t;
+
+typedef long __blkcnt32_t;
+typedef long long __blkcnt64_t;
+#ifdef __CYGWIN_USE_BIG_TYPES__
+typedef __blkcnt64_t blkcnt_t;
+#else
+typedef __blkcnt32_t blkcnt_t;
+#endif
+
typedef unsigned short __uid16_t;
typedef unsigned short __gid16_t;
typedef unsigned long __uid32_t;
HANDLE mapping_handle_;
int devtype_;
DWORD access_mode_;
- DWORD offset_;
+ __off64_t offset_;
DWORD size_to_map_;
caddr_t base_address_;
DWORD *map_map_;
public:
- mmap_record (int fd, HANDLE h, DWORD ac, DWORD o, DWORD s, caddr_t b) :
+ mmap_record (int fd, HANDLE h, DWORD ac, __off64_t o, DWORD s, caddr_t b) :
fdesc_ (fd),
mapping_handle_ (h),
devtype_ (0),
void free_map () { if (map_map_) free (map_map_); }
DWORD find_empty (DWORD pages);
- DWORD map_map (DWORD off, DWORD len);
+ __off64_t map_map (__off64_t off, DWORD len);
BOOL unmap_map (caddr_t addr, DWORD len);
void fixup_map (void);
return (DWORD)-1;
}
-DWORD
-mmap_record::map_map (DWORD off, DWORD len)
+__off64_t
+mmap_record::map_map (__off64_t off, DWORD len)
{
DWORD prot, old_prot;
switch (access_mode_)
~list ();
mmap_record *add_record (mmap_record r);
void erase (int i);
- mmap_record *match (DWORD off, DWORD len);
- __off32_t match (caddr_t addr, DWORD len, __off32_t start);
+ mmap_record *match (__off64_t off, DWORD len);
+ long match (caddr_t addr, DWORD len, long start);
};
list::list ()
/* Used in mmap() */
mmap_record *
-list::match (DWORD off, DWORD len)
+list::match (__off64_t off, DWORD len)
{
if (fd == -1 && !off)
{
}
/* Used in munmap() */
-__off32_t
+long
list::match (caddr_t addr, DWORD len, __off32_t start)
{
for (int i = start + 1; i < nrecs; ++i)
if (addr >= recs[i].get_address ()
&& addr + len <= recs[i].get_address () + recs[i].get_size ())
return i;
- return ILLEGAL_SEEK;
+ return -1;
}
void
extern "C"
caddr_t
-mmap (caddr_t addr, size_t len, int prot, int flags, int fd, __off32_t off)
+mmap64 (caddr_t addr, size_t len, int prot, int flags, int fd, __off64_t off)
{
- syscall_printf ("addr %x, len %d, prot %x, flags %x, fd %d, off %d",
+ syscall_printf ("addr %x, len %d, prot %x, flags %x, fd %d, off %D",
addr, len, prot, flags, fd, off);
static DWORD granularity;
fd = -1;
/* Map always in multipliers of `granularity'-sized chunks. */
- DWORD gran_off = off & ~(granularity - 1);
+ __off64_t gran_off = off & ~(granularity - 1);
DWORD gran_len = howmany (len, granularity) * granularity;
fhandler_base *fh;
fh = cfd;
if (fh->get_device () == FH_DISK)
{
- DWORD fsiz = GetFileSize (fh->get_handle (), NULL);
+ DWORD high;
+ DWORD low = GetFileSize (fh->get_handle (), &high);
+ __off64_t fsiz = ((__off64_t)high << 32) + low;
fsiz -= gran_off;
if (gran_len > fsiz)
gran_len = fsiz;
return ret;
}
+extern "C"
+caddr_t
+mmap (caddr_t addr, size_t len, int prot, int flags, int fd, __off32_t off)
+{
+ return mmap64 (addr, len, prot, flags, fd, (__off64_t)off);
+}
+
/* munmap () removes an mmapped area. It insists that base area
requested is the same as that mmapped, error if not. */
list *l = mmapped_areas->lists[it];
if (l)
{
- __off32_t li = ILLEGAL_SEEK;
+ long li = -1;
if ((li = l->match(addr, len, li)) >= 0)
{
mmap_record *rec = l->recs + li;
*/
HANDLE
fhandler_base::mmap (caddr_t *addr, size_t len, DWORD access,
- int flags, __off32_t off)
+ int flags, __off64_t off)
{
set_errno (ENODEV);
return INVALID_HANDLE_VALUE;
/* Implementation for disk files. */
HANDLE
fhandler_disk_file::mmap (caddr_t *addr, size_t len, DWORD access,
- int flags, __off32_t off)
+ int flags, __off64_t off)
{
DWORD protect;
return INVALID_HANDLE_VALUE;
}
- void *base = MapViewOfFileEx (h, access, 0, off, len,
+ DWORD high = off >> 32, low = off & 0xffffffff;
+ void *base = MapViewOfFileEx (h, access, high, low, len,
(flags & MAP_FIXED) ? *addr : NULL);
- debug_printf ("%x = MapViewOfFileEx (h:%x, access:%x, 0, off:%d, len:%d, addr:%x)", base, h, access, off, len, (flags & MAP_FIXED) ? *addr : NULL);
+ debug_printf ("%x = MapViewOfFileEx (h:%x, access:%x, 0, off:%D, len:%d, addr:%x)", base, h, access, off, len, (flags & MAP_FIXED) ? *addr : NULL);
if (!base || ((flags & MAP_FIXED) && base != *addr))
{
if (!base)
{
}
-__off32_t
-fhandler_pipe::lseek (__off32_t offset, int whence)
+__off64_t
+fhandler_pipe::lseek (__off64_t offset, int whence)
{
debug_printf ("(%d, %d)", offset, whence);
set_errno (ESPIPE);
}
if (!real_path.has_acls ())
{
- struct stat st;
+ struct __stat64 st;
int ret = -1;
switch (cmd)
case GETACL:
if (nentries < 1)
set_errno (EINVAL);
- else if ((nofollow && !lstat (path, &st))
- || (!nofollow && !stat (path, &st)))
+ else if ((nofollow && !lstat64 (path, &st))
+ || (!nofollow && !stat64 (path, &st)))
{
__aclent16_t lacl[4];
if (nentries > 0)
return res;
}
-extern "C" __off32_t
-_lseek (int fd, __off32_t pos, int dir)
+extern "C" __off64_t
+lseek64 (int fd, __off64_t pos, int dir)
{
- __off32_t res;
+ __off64_t res;
sigframe thisframe (mainthread);
if (dir != SEEK_SET && dir != SEEK_CUR && dir != SEEK_END)
else
res = -1;
}
- syscall_printf ("%d = lseek (%d, %d, %d)", res, fd, pos, dir);
+ syscall_printf ("%d = lseek (%d, %D, %d)", res, fd, pos, dir);
return res;
}
+extern "C" __off32_t
+_lseek (int fd, __off32_t pos, int dir)
+{
+ return lseek64 (fd, (__off64_t) pos, dir);
+}
+
extern "C" int
_close (int fd)
{
return chmod (path, mode);
}
+static void
+stat64_to_stat32 (struct __stat64 *src, struct __stat32 *dst)
+{
+ dst->st_dev = src->st_dev;
+ dst->st_ino = src->st_ino;
+ dst->st_mode = src->st_mode;
+ dst->st_nlink = src->st_nlink;
+ dst->st_uid = src->st_uid;
+ dst->st_gid = src->st_gid;
+ dst->st_rdev = src->st_rdev;
+ dst->st_size = src->st_size;
+ dst->st_atime = src->st_atime;
+ dst->st_mtime = src->st_mtime;
+ dst->st_ctime = src->st_ctime;
+ dst->st_blksize = src->st_blksize;
+ dst->st_blocks = src->st_blocks;
+}
+
extern "C" int
-_fstat (int fd, struct stat *buf)
+fstat64 (int fd, struct __stat64 *buf)
{
int res;
sigframe thisframe (mainthread);
res = -1;
else
{
- memset (buf, 0, sizeof (struct stat));
+ memset (buf, 0, sizeof (struct __stat64));
res = cfd->fstat (buf, NULL);
}
return res;
}
+extern "C" int
+_fstat (int fd, struct __stat32 *buf)
+{
+ struct __stat64 buf64;
+ int ret = fstat64 (fd, &buf64);
+ if (!ret)
+ stat64_to_stat32 (&buf64, buf);
+ return ret;
+}
+
/* fsync: P96 6.6.1.1 */
extern "C" int
fsync (int fd)
/* Cygwin internal */
int __stdcall
-stat_worker (const char *name, struct stat *buf, int nofollow, path_conv *pc)
+stat_worker (const char *name, struct __stat64 *buf, int nofollow,
+ path_conv *pc)
{
int res = -1;
path_conv real_path;
{
debug_printf ("(%s, %p, %d, %p), file_attributes %d", name, buf, nofollow,
pc, (DWORD) real_path);
- memset (buf, 0, sizeof (struct stat));
+ memset (buf, 0, sizeof (struct __stat64));
res = fh->fstat (buf, pc);
}
}
extern "C" int
-_stat (const char *name, struct stat *buf)
+stat64 (const char *name, struct __stat64 *buf)
{
sigframe thisframe (mainthread);
syscall_printf ("entering");
return stat_worker (name, buf, 0);
}
+extern "C" int
+_stat (const char *name, struct __stat32 *buf)
+{
+ struct __stat64 buf64;
+ int ret = stat64 (name, &buf64);
+ if (!ret)
+ stat64_to_stat32 (&buf64, buf);
+ return ret;
+}
+
/* lstat: Provided by SVR4 and 4.3+BSD, POSIX? */
extern "C" int
-lstat (const char *name, struct stat *buf)
+lstat64 (const char *name, struct __stat64 *buf)
{
sigframe thisframe (mainthread);
syscall_printf ("entering");
return stat_worker (name, buf, 1);
}
+/* lstat: Provided by SVR4 and 4.3+BSD, POSIX? */
+extern "C" int
+cygwin_lstat (const char *name, struct __stat32 *buf)
+{
+ struct __stat64 buf64;
+ int ret = lstat64 (name, &buf64);
+ if (!ret)
+ stat64_to_stat32 (&buf64, buf);
+ return ret;
+}
+
extern int acl_access (const char *, int);
extern "C" int
if (allow_ntsec)
return acl_access (fn, flags);
- struct stat st;
+ struct __stat64 st;
int r = stat_worker (fn, &st, 0);
if (r)
return -1;
return res;
}
-/* ftruncate: P96 5.6.7.1 */
extern "C" int
-ftruncate (int fd, __off32_t length)
+ftruncate64 (int fd, __off64_t length)
{
sigframe thisframe (mainthread);
int res = -1;
if (cfd->get_handle ())
{
/* remember curr file pointer location */
- __off32_t prev_loc = cfd->lseek (0, SEEK_CUR);
+ __off64_t prev_loc = cfd->lseek (0, SEEK_CUR);
cfd->lseek (length, SEEK_SET);
if (!SetEndOfFile (h))
res = 0;
/* restore original file pointer location */
- cfd->lseek (prev_loc, 0);
+ cfd->lseek (prev_loc, SEEK_SET);
}
}
}
return res;
}
+/* ftruncate: P96 5.6.7.1 */
+extern "C" int
+ftruncate (int fd, __off32_t length)
+{
+ return ftruncate64 (fd, (__off64_t)length);
+}
+
/* truncate: Provided by SVR4 and 4.3+BSD. Not part of POSIX.1 or XPG3 */
extern "C" int
-truncate (const char *pathname, __off32_t length)
+truncate64 (const char *pathname, __off64_t length)
{
sigframe thisframe (mainthread);
int fd;
return res;
}
+/* truncate: Provided by SVR4 and 4.3+BSD. Not part of POSIX.1 or XPG3 */
+extern "C" int
+truncate (const char *pathname, __off32_t length)
+{
+ return truncate64 (pathname, (__off64_t)length);
+}
+
extern "C" long
get_osfhandle (int fd)
{
{
struct utmp *ut;
struct utmp ut_buf[100];
+ /* FIXME: utmp file access is not 64 bit clean for now. */
__off32_t pos = 0; /* Position in file */
DWORD rd;
has_try_enter_critical_section:false,
has_raw_devices:false,
has_valid_processorlevel:false,
+ has_64bit_file_access:false,
};
static NO_COPY wincaps wincap_95 = {
has_try_enter_critical_section:false,
has_raw_devices:false,
has_valid_processorlevel:false,
+ has_64bit_file_access:false,
};
static NO_COPY wincaps wincap_95osr2 = {
has_try_enter_critical_section:false,
has_raw_devices:false,
has_valid_processorlevel:false,
+ has_64bit_file_access:false,
};
static NO_COPY wincaps wincap_98 = {
has_try_enter_critical_section:false,
has_raw_devices:false,
has_valid_processorlevel:true,
+ has_64bit_file_access:false,
};
static NO_COPY wincaps wincap_98se = {
has_try_enter_critical_section:false,
has_raw_devices:false,
has_valid_processorlevel:true,
+ has_64bit_file_access:false,
};
static NO_COPY wincaps wincap_me = {
has_try_enter_critical_section:false,
has_raw_devices:false,
has_valid_processorlevel:true,
+ has_64bit_file_access:false,
};
static NO_COPY wincaps wincap_nt3 = {
has_try_enter_critical_section:false,
has_raw_devices:true,
has_valid_processorlevel:true,
+ has_64bit_file_access:true,
};
static NO_COPY wincaps wincap_nt4 = {
has_try_enter_critical_section:true,
has_raw_devices:true,
has_valid_processorlevel:true,
+ has_64bit_file_access:true,
};
static NO_COPY wincaps wincap_nt4sp4 = {
has_try_enter_critical_section:true,
has_raw_devices:true,
has_valid_processorlevel:true,
+ has_64bit_file_access:true,
};
static NO_COPY wincaps wincap_2000 = {
has_try_enter_critical_section:true,
has_raw_devices:true,
has_valid_processorlevel:true,
+ has_64bit_file_access:true,
};
static NO_COPY wincaps wincap_xp = {
has_try_enter_critical_section:true,
has_raw_devices:true,
has_valid_processorlevel:true,
+ has_64bit_file_access:true,
};
wincapc NO_COPY wincap;
unsigned has_try_enter_critical_section : 1;
unsigned has_raw_devices : 1;
unsigned has_valid_processorlevel : 1;
+ unsigned has_64bit_file_access : 1;
};
class wincapc
bool IMPLEMENT (has_try_enter_critical_section)
bool IMPLEMENT (has_raw_devices)
bool IMPLEMENT (has_valid_processorlevel)
+ bool IMPLEMENT (has_64bit_file_access)
#undef IMPLEMENT
};
#define ILLEGAL_UID ((__uid16_t)-1)
#define ILLEGAL_GID ((__gid16_t)-1)
-#define ILLEGAL_SEEK ((__off32_t)-1)
+#define ILLEGAL_SEEK ((__off64_t)-1)
/* various events */
void events_init (void);
void __stdcall set_std_handle (int);
int __stdcall writable_directory (const char *file);
-int __stdcall stat_dev (DWORD, int, unsigned long, struct stat *);
+int __stdcall stat_dev (DWORD, int, unsigned long, struct __stat64 *);
extern BOOL allow_ntsec;
unsigned long __stdcall hash_path_name (unsigned long hash, const char *name) __attribute__ ((regparm(2)));
extern "C" void __malloc_unlock (struct _reent *);
class path_conv;
-int __stdcall stat_worker (const char *name, struct stat *buf, int nofollow,
+int __stdcall stat_worker (const char *name, struct __stat64 *buf, int nofollow,
path_conv *pc = NULL) __attribute__ ((regparm (3)));
/**************************** Exports ******************************/
OSDN Git Service
