user-0 提问: c 怎么读取一个不断增加的文件

回复:
user: user-0
content: 我这个是linux下的啊

user: user-1
content: _sopen, _wsopen Open a file for sharing.  int _sopen( const char *filename, int oflag, int shflag [, int pmode ] );  int _wsopen( const wchar_t *filename, int oflag, int shflag [, int pmode ] );  Routine Required Header Optional Headers Compatibility  _sopen <io.h> <fcntl.h>, <sys/types.h>, <sys/stat.h>, <share.h> Win 95, Win NT  _wsopen <io.h> or <wchar.h> <fcntl.h>, <sys/types.h>, <sys/stat.h>, <share.h> Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  Each of these functions returns a file handle for the opened file. A return value of –1 indicates an error, in which case errno is set to one of the following values:  EACCES  Given path is a directory, or file is read-only, but an open-for-writing operation was attempted.  EEXIST  _O_CREAT and _O_EXCL flags were specified, but filename already exists.  EINVAL  Invalid oflag or shflag argument.  EMFILE  No more file handles available.  ENOENT  File or path not found.  Parameters  filename  Filename  oflag  Type of operations allowed  shflag  Type of sharing allowed  pmode  Permission setting  Remarks  The _sopen function opens the file specified by filename and prepares the file for shared reading or writing, as defined by oflag and shflag. _wsopen is a wide-character version of _sopen; the filename argument to _wsopen is a wide-character string. _wsopen and _sopen behave identically otherwise.  Generic-Text Routine Mappings  TCHAR.H Routine  _UNICODE & _MBCS Not Defined _MBCS Defined _UNICODE Defined  _tsopen _sopen _sopen _wsopen    The integer expression oflag is formed by combining one or more of the following manifest constants, defined in the file FCNTL.H. When two or more constants form the argument oflag, they are combined with the bitwise-OR operator ( | ).  _O_APPEND  Repositions file pointer to end of file before every write operation.  _O_BINARY  Opens file in binary (untranslated) mode. (See fopen for a description of binary mode.)  _O_CREAT  Creates and opens new file for writing. Has no effect if file specified by filename exists. The pmode argument is required when _O_CREAT is specified.  _O_CREAT | _O_SHORT_LIVED  Create file as temporary and if possible do not flush to disk. The pmode argument is required when _O_CREAT is specified.  _O_CREAT | _O_TEMPORARY  Create file as temporary; file is deleted when last file handle is closed. The pmode argument is required when _O_CREAT is specified.   _O_CREAT | _O_EXCL  Returns error value if file specified by filename exists. Applies only when used with _O_CREAT.  _O_NOINHERIT  Prevents creation of a shared file handle.  _O_RANDOM  Specifies primarily random access from disk.  _O_RDONLY  Opens file for reading only; cannot be specified with _O_RDWR or _O_WRONLY.  _O_RDWR  Opens file for both reading and writing; cannot be specified with _O_RDONLY or _O_WRONLY.  _O_SEQUENTIAL  Specifies primarily sequential access from disk  _O_TEXT  Opens file in text (translated) mode. (For more information, see Text and Binary Mode File I/O and fopen.)  _O_TRUNC  Opens file and truncates it to zero length; the file must have write permission. You cannot specify this flag with _O_RDONLY. _O_TRUNC used with _O_CREAT opens an existing file or creates a new file.  Warning   The _O_TRUNC flag destroys the contents of the specified file.  _O_WRONLY  Opens file for writing only; cannot be specified with _O_RDONLY or _O_RDWR.  To specify the file access mode, you must specify either _O_RDONLY, _O_RDWR, or _O_WRONLY. There is no default value for the access mode.  The argument shflag is a constant expression consisting of one of the following manifest constants, defined in SHARE.H.  _SH_DENYRW  Denies read and write access to file  _SH_DENYWR  Denies write access to file  _SH_DENYRD  Denies read access to file  _SH_DENYNO  Permits read and write access  The pmode argument is required only when you specify _O_CREAT. If the file does not exist, pmode specifies the file’s permission settings, which are set when the new file is closed the first time. Otherwise pmode is ignored. pmode is an integer expression that contains one or both of the manifest constants _S_IWRITE and _S_IREAD, defined in SYS\STAT.H. When both constants are given, they are combined with the bitwise-OR operator. The meaning of pmode is as follows:  _S_IWRITE  Writing permitted  _S_IREAD  Reading permitted  _S_IREAD | _S_IWRITE  Reading and writing permitted  If write permission is not given, the file is read-only. Under Windows NT and Windows 95, all files are readable; it is not possible to give write-only permission. Thus the modes _S_IWRITE and _S_IREAD | _S_IWRITE are equivalent.  _sopen applies the current file-permission mask to pmode before setting the permissions (see _umask).  Example  /* LOCKING.C: This program opens a file with sharing. It locks  * some bytes before reading them, then unlocks them. Note that the  * program works correctly only if the file exists.  */  #include <io.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/locking.h> #include <share.h> #include <fcntl.h> #include <stdio.h> #include <stdlib.h>  void main( void ) {    int  fh, numread;    char buffer[40];     /* Quit if can't open file or system doesn't      * support sharing.      */    fh = _sopen( "locking.c", _O_RDWR, _SH_DENYNO,                   _S_IREAD | _S_IWRITE );    if( fh == -1 )       exit( 1 );     /* Lock some bytes and read them. Then unlock. */    if( _locking( fh, LK_NBLCK, 30L ) != -1 )    {       printf( "No one can change these bytes while I'm reading them\n" );       numread = _read( fh, buffer, 30 );       printf( "%d bytes read: %.30s\n", numread, buffer );       lseek( fh, 0L, SEEK_SET );      _locking( fh, LK_UNLCK, 30L );       printf( "Now I'm done. Do what you will with them\n" );    }    else       perror( "Locking failed\n" );     _close( fh ); }   Output  No one can change these bytes while I'm reading them 30 bytes read: /* LOCKING.C: This program ope Now I'm done. Do what you will with them   Low-level I/O Routines  See Also   _close, _creat, fopen, _fsopen, _open

user: user-1
content: OPEN Section: Linux Programmer's Manual (2) Updated: 2004-12-08  --------------------------------------------------------------------------------    NAME open, creat - open and possibly create a file or device    SYNOPSIS #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h>  int open(const char *pathname, int flags); int open(const char *pathname, int flags, mode_t mode); int creat(const char *pathname, mode_t mode);     DESCRIPTION The open() system call is used to convert a pathname into a file descriptor (a small, non-negative integer for use in subsequent I/O as with read(2), write(2), etc.). When the call is successful, the file descriptor returned will be the lowest file descriptor not currently open for the process. This call creates a new open file, not shared with any other process. (But shared open files may arise via the fork(2) system call.) The new file descriptor is set to remain open across exec functions (see fcntl(2)). The file offset is set to the beginning of the file.  The parameter flags is one of O_RDONLY, O_WRONLY or O_RDWR which request opening the file read-only, write-only or read/write, respectively, bitwise-or'd with zero or more of the following:   O_APPEND  The file is opened in append mode. Before each write(), the file pointer is positioned at the end of the file, as if with lseek(). O_APPEND may lead to corrupted files on NFS file systems if more than one process appends data to a file at once. This is because NFS does not support appending to a file, so the client kernel has to simulate it, which can't be done without a race condition.  O_ASYNC  Generate a signal (SIGIO by default, but this can be changed via fcntl(2)) when input or output becomes possible on this file descriptor. This feature is only available for terminals, pseudo-terminals, and sockets. See fcntl(2) for further details.  O_CREAT  If the file does not exist it will be created. The owner (user ID) of the file is set to the effective user ID of the process. The group ownership (group ID) is set either to the effective group ID of the process or to the group ID of the parent directory (depending on filesystem type and mount options, and the mode of the parent directory, see, e.g., the mount options bsdgroups and sysvgroups of the ext2 filesystem, as described in mount(8)).  O_DIRECT  Try to minimize cache effects of the I/O to and from this file. In general this will degrade performance, but it is useful in special situations, such as when applications do their own caching. File I/O is done directly to/from user space buffers. The I/O is synchronous, i.e., at the completion of the read(2) or write(2) system call, data is guaranteed to have been transferred. Under Linux 2.4 transfer sizes, and the alignment of user buffer and file offset must all be multiples of the logical block size of the file system. Under Linux 2.6 alignment to 512-byte boundaries suffices.  A semantically similar interface for block devices is described in raw(8).  O_DIRECTORY  If pathname is not a directory, cause the open to fail. This flag is Linux-specific, and was added in kernel version 2.1.126, to avoid denial-of-service problems if opendir(3) is called on a FIFO or tape device, but should not be used outside of the implementation of opendir.  O_EXCL  When used with O_CREAT, if the file already exists it is an error and the open() will fail. In this context, a symbolic link exists, regardless of where its points to. O_EXCL is broken on NFS file systems, programs which rely on it for performing locking tasks will contain a race condition. The solution for performing atomic file locking using a lockfile is to create a unique file on the same file system (e.g., incorporating hostname and pid), use link(2) to make a link to the lockfile. If link() returns 0, the lock is successful. Otherwise, use stat(2) on the unique file to check if its link count has increased to 2, in which case the lock is also successful.  O_LARGEFILE  (LFS) Allow files whose sizes cannot be represented in an off_t (but can be represented in an off64_t) to be opened.  O_NOATIME  (Since Linux 2.6.8) Do not update the file last access time when the file is read(2). This flag is intended for use by indexing or backup programs, where its use can significantly reduce the amount of disk activity. This flag may not be effective on all filesystems. One example is NFS, where the server maintains the access time.  O_NOCTTY  If pathname refers to a terminal device - see tty(4) - it will not become the process's controlling terminal even if the process does not have one.  O_NOFOLLOW  If pathname is a symbolic link, then the open fails. This is a FreeBSD extension, which was added to Linux in version 2.1.126. Symbolic links in earlier components of the pathname will still be followed. The headers from glibc 2.0.100 and later include a definition of this flag; kernels before 2.1.126 will ignore it if used.  O_NONBLOCK or O_NDELAY  When possible, the file is opened in non-blocking mode. Neither the open() nor any subsequent operations on the file descriptor which is returned will cause the calling process to wait. For the handling of FIFOs (named pipes), see also fifo(4). This mode need not have any effect on files other than FIFOs.  O_SYNC  The file is opened for synchronous I/O. Any write()s on the resulting file descriptor will block the calling process until the data has been physically written to the underlying hardware. See RESTRICTIONS below, though.  O_TRUNC  If the file already exists and is a regular file and the open mode allows writing (i.e., is O_RDWR or O_WRONLY) it will be truncated to length 0. If the file is a FIFO or terminal device file, the O_TRUNC flag is ignored. Otherwise the effect of O_TRUNC is unspecified.  Some of these optional flags can be altered using fcntl() after the file has been opened.   The argument mode specifies the permissions to use in case a new file is created. It is modified by the process's umask in the usual way: the permissions of the created file are (mode & ~umask). Note that this mode only applies to future accesses of the newly created file; the open() call that creates a read-only file may well return a read/write file descriptor.   The following symbolic constants are provided for mode:   S_IRWXU  00700 user (file owner) has read, write and execute permission  S_IRUSR (S_IREAD)  00400 user has read permission  S_IWUSR (S_IWRITE)  00200 user has write permission  S_IXUSR (S_IEXEC)  00100 user has execute permission  S_IRWXG  00070 group has read, write and execute permission  S_IRGRP  00040 group has read permission  S_IWGRP  00020 group has write permission  S_IXGRP  00010 group has execute permission  S_IRWXO  00007 others have read, write and execute permission  S_IROTH  00004 others have read permission  S_IWOTH  00002 others have write permisson  S_IXOTH  00001 others have execute permission  mode must be specified when O_CREAT is in the flags, and is ignored otherwise.   creat() is equivalent to open() with flags equal to O_CREAT|O_WRONLY|O_TRUNC.     RETURN VALUE open() and creat() return the new file descriptor, or -1 if an error occurred (in which case, errno is set appropriately). Note that open() can open device special files, but creat() cannot create them - use mknod(2) instead.  On NFS file systems with UID mapping enabled, open may return a file descriptor but e.g. read(2) requests are denied with EACCES. This is because the client performs open by checking the permissions, but UID mapping is performed by the server upon read and write requests.   If the file is newly created, its atime, ctime, mtime fields are set to the current time, and so are the ctime and mtime fields of the parent directory. Otherwise, if the file is modified because of the O_TRUNC flag, its ctime and mtime fields are set to the current time.