Windows、Linux下文件操作(写、删除)错误的产生原因、及解决方法

. 引言
. Linux平台上涉及的File IO操作
. Windows平台上涉及的File IO操作

http://www.cnblogs.com/LittleHann/p/3905608.html
http://www.cnblogs.com/LittleHann/p/4305892.html
//搜索：0x3: 权限检查

#include <sys/types.h>
#include <dirent.h>DIR * opendir(const char * name);
//返回值：成功则返回DIR* 型态的目录流, 打开失败则返回NULL

. EACCESS: 权限不足
. EMFILE: 已达到进程可同时打开的文件数上限
. ENFILE: 已达到系统可同时打开的文件数上限
. ENOTDIR: 参数name非真正的目录
. ENOENT: 参数name指定的目录不存在，或是参数name为一空字符串
. ENOMEM: 核心内存不足

. Each directory in the path name preceding the directory to be opened
) 调用opendir，如果传入路径参数的各个分量中，有一个分量没有X权限，则返回Permission denied(EACCES)错误
) 没有X权限，ll命令虽然可以列出该目录下的文件及目录，但是同样因为可执行(x)权限无法查看属性
) cd命令需要可执行(x)权限，因此无法通过cd命令切换到该目录下，子目录也是不可切换的，即便对子目录有完整权限
) 同样对于cat命令，由于缺少可执行(x)权限，该目录下的文件也是不可读的
) 对于stat系统调用和cat命令是一样的，如果缺少x权限，则stat将执行失败
) 没有x权限，目录下的文件也不能cp
) 父目录没有x权限，即使该目录下的文件可读可执行，也无法执行该目录下的文件
//需要明白的是，Linux的目录寻址定位是逐个路径分量逐段进行的，如果父目录因为没有x权限受阻了，则即使目录下的子文件权限足够，也无法正常操作. The directory to be opened
如果传入的目录路径没有R权限， 则调用opendir返回Permission denied(EACCES)错误，没有R权限导致无法读取目录inode的元信息

. 对于文件权限: 可读权限(r)是可执行(x)的基础，因为执行的前提是读取二进制数据
. 对于目录权限: 可执行(x)权限是关键，没有可执行权限意味着所有命令都不能在该目录及子目录下执行，该目录及子目录下的文件也不能被执行。这意味着我们常用的命令cd、ls、mkdir、cp、mv、rm等等在该目录下全部失效

http://c.biancheng.net/cpp/html/319.html
http://pubs.opengroup.org/onlinepubs/009695399/functions/opendir.html
http://lxr.free-electrons.com/source/include/uapi/asm-generic/errno-base.h#L16
http://axisray.me/2015/01/04/linux-dir-and-file-permission/
http://os.51cto.com/art/201003/186949.htm

#include <sys/types.h>
#include <dirent.h>struct dirent * readdir(DIR * dir);
/*
返回值
1. 成功则返回下个目录进入点
2. 有错误发生或读取到目录文件尾则返回NULL
*/

. EOVERFLOW
One of the values in the structure to be returned cannot be represented correctly.
The readdir() function may fail if:. EBADF
The dirp argument does not refer to an open directory stream.. ENOENT
The current position of the directory stream is invalid.

http://c.biancheng.net/cpp/html/320.html
http://pubs.opengroup.org/onlinepubs/7908799/xsh/readdir.html
https://www-01.ibm.com/support/knowledgecenter/ssw_ibm_i_61/apis/readdir.htm

#include <sys/stat.h>
#include <unistd.h>int stat(const char * file_name, struct stat *buf);

. ENOENT： 参数file_name指定的文件不存在
. ENOTDIR: 路径中的目录存在但却非真正的目录
. ELOOP: 欲打开的文件有过多符号连接问题，上限为16符号连接
. EFAULT: 参数buf为无效指针，指向无法存在的内存空间
. EACCESS: 存取文件时被拒绝
. ENOMEM: 核心内存不足
. ENAMETOOLONG: 参数file_name的路径名称太长

. chown设置文件属性
/*
#include <sys/types.h>
#include <unistd.h>int chown(const char *path,uid_t owner, gid_t group);
int fchown(int fd, uid_t owner, gid_t group)’
int lchown(const char *path, uid_t owner,gid_t group);
文件的所有者只能改变文件的组id为其所属组中的一个，超级用户才能修改文件的所有者id，并且超级用户可以任意修改文件的用户组id
*/. truncate改变文件大小
/*
#include <sys/types.h>
#include <unistd.h>int truncate(const char *path, off_t length);
int ftruncate(int fd, off_t length);
将指定文件大小改为参数length指定的大小，如果原来的文件比参数length大，则超过的部分会被删除；如果原来的文件大小比参数length小，则文件将被扩展，扩展部分用0填充
*/. utime改变文件的st_mtime域和st_ctime域，即存取时间和修改时间
/*
#include <sys/types.h>
#include <utime.h>
int utime(const char *filename,struct utimbuf *buf);#include <sys/time.h>
int utime(char *filename,struct timeval *tvp);
如果buf是一个空指针，则存取时间和修改时间都为当前时间
*/

http://blog.csdn.net/dlutbrucezhang/article/details/8627387
http://c.biancheng.net/cpp/html/326.html
http://www.cnblogs.com/LittleHann/p/3905608.html
//搜索：3. int stat(const char * file_name, struct stat *buf);

#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);
//参数pathname指向欲打开的文件路径字符串

. EEXIST: 参数pathname所指的文件已存在，却使用了O_CREAT和O_EXCL旗标
. EACCESS: 参数pathname所指的文件不符合所要求测试的权限
. EROFS: 欲测试写入权限的文件存在于只读文件系统内
. EFAULT: 参数pathname指针超出可存取内存空间
. EINVAL: 参数mode不正确
. ENAMETOOLONG: 参数pathname太长
. ENOTDIR: 参数pathname不是目录
. ENOMEM: 核心内存不足
. ELOOP: 参数pathname有过多符号连接问题
. EIO: I/O存取错误

http://c.biancheng.net/cpp/html/238.html
http://www.cnblogs.com/LittleHann/p/3905608.html
//搜索：1. int open(const char *pathname, int flags);

#include <unistd.h>ssize_t write (int fd, const void * buf, size_t count);
//返回值: 如果顺利write()会返回实际写入的字节数. 当有错误发生时则返回-1, 错误代码存入errno中

. EINTR: 此调用被信号所中断.
. EAGAIN: 当使用不可阻断I/O 时(O_NONBLOCK)，若无数据可读取则返回此值
. EADF: 参数fd非有效的文件描述词，或该文件已关闭

http://c.biancheng.net/cpp/html/241.html

. 两个进程可以同时以写模式打开一个文件，同时向其中写入数据，这可能导致不一致情况的发生
. 两个进程可以分别以读模式、写模式打开一个文件，同时进行读/写的操作，这可能导致错误的数据读取，即脏读、幻读

. i_count: i_count的意义是当前文件使用者(或被调用)的数量
. i_nlink: i_nlink的意义是介质连接的数量(硬链接的数量)
//可以理解为i_count是内存引用计数器，i_nlink是磁盘的引用计数器，当一个文件被某一个进程引用时，对应i_count数就会增加；当创建文件的硬链接的时候，对应i_nlink数就会增加

. 劝告锁(advisory lock)
. 强制锁(mandatory lock)
/*
在Linux中，不论进程是在使用劝告锁还是强制锁，它都可以同时使用共享锁(S锁 读锁)和排他锁(X锁 写锁)
1. 多个共享锁之间不会相互干扰，多个进程在同一时刻可以对同一个文件加共享锁
2. 如果一个进程对该文件加了排他锁，那么其他进程则无权再对该文件加共享锁或者排他锁，直到该排他锁被释放
*/. 共享模式强制锁(share-mode mandatory lock)
. 租借锁(lease)

. 如果一个文件已经被加上了读锁或者共享锁，那么其他进程再对这个文件进行写操作就会被内核阻止
. 如果一个文件已经被加上了写锁或者排他锁，那么其他进程再对这个文件进行读取或者写操作就会被内核阻止

. 使用 -o mand 选项来挂载文件系统。这样在执行 mount() 系统调用时，会传入 MS_MANDLOCK 标记，从而将 super_block 结构中的 s_flags 设置为 ，用来表示在这个文件系统上可以采用强制锁
*
# mount -o mand /dev/sdb7 /mnt
# mount | grep mnt
/dev/sdb7 on /mnt type ext3 (rw,mand)
*/. 修改要加强制锁的文件的权限: 设置SGID位，并清除组可执行位。这种组合通常来说是毫无意义的，系统用来表示该文件被加了强制锁。例如：
# touch /mnt/testfile
# ls -l /mnt/testfile
-rw-r--r-- root root Jun : /mnt/testfile
# chmod g+s /mnt/testfile
# chmod g-x /mnt/testfile
# ls -l /mnt/testfile
-rw-r-Sr-- root root Jun : /mnt/testfile. 使用 fcntl() 系统调用对该文件进行加锁或解锁操作

//系统默认的这段间隔时间是45秒钟
int lease_break_time = ;

# cat -n mandlock.c#include <errno.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <sys/stat.h>int lock_reg(int fd, int cmd, int type, off_t offset, int whence, off_t len)
{
struct flock lock; lock.l_type = type; /* F_RDLCK, F_WRLCK, F_UNLCK */
lock.l_start = offset; /* byte offset, relative to l_whence */
lock.l_whence = whence; /* SEEK_SET, SEEK_CUR, SEEK_END */
lock.l_len = len; /* #bytes (0 means to EOF) */ return( fcntl(fd, cmd, &lock) );
}
#define read_lock(fd, offset, whence, len) lock_reg(fd, F_SETLK, F_RDLCK, offset, whence, len)
#define write_lock(fd, offset, whence, len) lock_reg(fd, F_SETLK, F_WRLCK, offset, whence, len)
#define err_sys(x) { perror(x); exit(1); }int main(int argc, char *argv[])
{
int fd, val;
pid_t pid;
char buf[];
struct stat statbuf;
if (argc != )
{
fprintf(stderr, "usage: %s filename\n", argv[]);
exit();
}
if ((fd = open(argv[], O_RDWR | O_CREAT | O_TRUNC )) < )
err_sys("open error");
if (write(fd, "hello world", ) != )
err_sys("write error"); /* turn on set-group-ID and turn off group-execute */
if (fstat(fd, &statbuf) < )
err_sys("fstat error");
if (fchmod(fd, (statbuf.st_mode & ~S_IXGRP) | S_ISGID) < )
err_sys("fchmod error"); sleep(); if ((pid = fork()) < )
{
err_sys("fork error");
}
else if (pid > )
{ /* parent */
/* write lock entire file */
if (write_lock(fd, , SEEK_SET, ) < )
err_sys("write_lock error");
sleep(); /* wait for child to set lock and read data */ if (waitpid(pid, NULL, ) < )
err_sys("waitpid error");
}
else
{ /* child */
sleep(); /* wait for parent to set lock */ if ( (val = fcntl(fd, F_GETFL, )) < )
err_sys("fcntl F_GETFL error"); val |= O_NONBLOCK; /* turn on O_NONBLOCK flag */
if (fcntl(fd, F_SETFL, val) < )
err_sys("fcntl F_SETFL error");
/* first let's see what error we get if region is locked */
if (read_lock(fd, , SEEK_SET, ) != -) /* no wait */
err_sys("child: read_lock succeeded");
printf("read_lock of already-locked region returns %d: %s\n", errno, strerror(errno)); /* now try to read the mandatory locked file */
if (lseek(fd, , SEEK_SET) == -)
err_sys("lseek error");
if (read(fd, buf, ) < )
printf("read failed (mandatory locking works)\n");
else
printf("read OK (no mandatory locking), buf = %5.5s\n", buf);
}
exit();
}
/*
# mount | grep mnt
/dev/sdb7 on /mnt type ext3 (rw,mand)
/dev/sdb6 on /tmp/mnt type ext3 (rw)
# ./mandlock /mnt/testfile
read_lock of already-locked region returns 11: Resource temporarily unavailable
read failed (mandatory locking works)
# ./mandlock /tmp/mnt/testfile
read_lock of already-locked region returns 11: Resource temporarily unavailable
read OK (no mandatory locking), buf = hello
*/

http://blog.sina.com.cn/s/blog_4b3c1f950102uz74.html
http://www.ibm.com/developerworks/cn/linux/l-cn-filelock/

#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <strsafe.h>
#pragma comment(lib, "User32.lib")void DisplayErrorBox(LPTSTR lpszFunction);int _tmain(int argc, TCHAR *argv[])
{
WIN32_FIND_DATA ffd;
LARGE_INTEGER filesize;
TCHAR szDir[MAX_PATH];
size_t length_of_arg;
HANDLE hFind = INVALID_HANDLE_VALUE;
DWORD dwError=; // If the directory is not specified as a command-line argument,
// print usage. if(argc != )
{
_tprintf(TEXT("\nUsage: %s <directory name>\n"), argv[]);
return (-);
} // Check that the input path plus 3 is not longer than MAX_PATH.
// Three characters are for the "\*" plus NULL appended below. StringCchLength(argv[], MAX_PATH, &length_of_arg); if (length_of_arg > (MAX_PATH - ))
{
_tprintf(TEXT("\nDirectory path is too long.\n"));
return (-);
} _tprintf(TEXT("\nTarget directory is %s\n\n"), argv[]); // Prepare string for use with FindFile functions. First, copy the
// string to a buffer, then append '\*' to the directory name. StringCchCopy(szDir, MAX_PATH, argv[]);
StringCchCat(szDir, MAX_PATH, TEXT("\\*")); // Find the first file in the directory. hFind = FindFirstFile(szDir, &ffd); if (INVALID_HANDLE_VALUE == hFind)
{
DisplayErrorBox(TEXT("FindFirstFile"));
return dwError;
} // List all the files in the directory with some info about them. do
{
if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
_tprintf(TEXT(" %s <DIR>\n"), ffd.cFileName);
}
else
{
filesize.LowPart = ffd.nFileSizeLow;
filesize.HighPart = ffd.nFileSizeHigh;
_tprintf(TEXT(" %s %ld bytes\n"), ffd.cFileName, filesize.QuadPart);
}
}
while (FindNextFile(hFind, &ffd) != ); dwError = GetLastError();
if (dwError != ERROR_NO_MORE_FILES)
{
DisplayErrorBox(TEXT("FindFirstFile"));
} FindClose(hFind);
return dwError;
}void DisplayErrorBox(LPTSTR lpszFunction)
{
// Retrieve the system error message for the last-error code LPVOID lpMsgBuf;
LPVOID lpDisplayBuf;
DWORD dw = GetLastError(); FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
dw,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpMsgBuf,
, NULL ); // Display the error message and clean up lpDisplayBuf = (LPVOID)LocalAlloc(LMEM_ZEROINIT,
(lstrlen((LPCTSTR)lpMsgBuf)+lstrlen((LPCTSTR)lpszFunction)+)*sizeof(TCHAR));
StringCchPrintf((LPTSTR)lpDisplayBuf,
LocalSize(lpDisplayBuf) / sizeof(TCHAR),
TEXT("%s failed with error %d: %s"),
lpszFunction, dw, lpMsgBuf);
MessageBox(NULL, (LPCTSTR)lpDisplayBuf, TEXT("Error"), MB_OK); LocalFree(lpMsgBuf);
LocalFree(lpDisplayBuf);
}

https://msdn.microsoft.com/en-us/library/aa365200(VS.85).aspx
http://www.cnblogs.com/lanxuezaipiao/p/3420025.html
https://msdn.microsoft.com/en-us/library/aa364418(v=vs.85).aspx

SetFileAttributes function
GetFileAttributes function

int _open(
const char *filename,
int oflag [,
int pmode]
);
int _wopen(
const wchar_t *filename,
int oflag [,
int pmode]
);

//Opens a file. These functions are deprecated because more-secure versions are available; see _sopen_s, _wsopen_s

. filename: File name.
. oflag: The kind of operations allowed.
oflag is an integer expression formed from one or more of the following manifest constants or constant combinations, which are defined in <fcntl.h>.
) _O_APPEND: Moves the file pointer to the end of the file before every write operation.
) _O_BINARY: Opens the file in binary (untranslated) mode. (See fopen for a description of binary mode.)
) _O_CREAT: Creates a file and opens it for writing. Has no effect if the file specified by filename exists. The pmode argument is required when _O_CREAT is specified.
) _O_CREAT | _O_SHORT_LIVED: Creates a file as temporary and if possible does not flush to disk. The pmode argument is required when _O_CREAT is specified.
) _O_CREAT | _O_TEMPORARY: Creates a file as temporary; the file is deleted when the last file descriptor is closed. The pmode argument is required when _O_CREAT is specified.
) _O_CREAT | _O_EXCL: Returns an error value if the file specified by filename exists. Applies only when used with _O_CREAT.
) _O_NOINHERIT: Prevents creation of a shared file descriptor.
) _O_RANDOM: Specifies that caching is optimized for, but not restricted to, random access from disk.
) _O_RDONLY: Opens a 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 that caching is optimized for, but not restricted to, sequential access from disk.
) _O_TEXT: Opens a file in text (translated) mode. (For more information, see Text and Binary Mode File I/O and fopen.)
) _O_TRUNC: Opens a file and truncates it to zero length; the file must have write permission. Cannot be specified with _O_RDONLY. _O_TRUNC used with _O_CREAT opens an existing file or creates a file.
) _O_WRONLY: Opens the file for writing only. Cannot be specified with _O_RDONLY or _O_RDWR.
) _O_U16TEXT: Opens the file in Unicode UTF- mode.
) _O_U8TEXT: Opens the file in Unicode UTF- mode.
) _O_WTEXT: Opens the file in Unicode mode.. pmode: Permission mode.
The pmode argument is required only when _O_CREAT is specified. If the file already exists, pmode is ignored, Otherwise, pmode specifies the file permission setting
) _S_IREAD: Only reading permitted.
) _S_IWRITE: Writing permitted. (In effect, permits reading and writing.)
) _S_IREAD | _S_IWRITE: Reading and writing permitted.

// crt_open.c
// compile with: /W3
/* This program uses _open to open a file
* named CRT_OPEN.C for input and a file named CRT_OPEN.OUT
* for output. The files are then closed.
*/
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <io.h>
#include <stdio.h>int main( void )
{
int fh1, fh2; fh1 = _open( "CRT_OPEN.C", _O_RDONLY ); // C4996
// Note: _open is deprecated; consider using _sopen_s instead
if( fh1 == - )
perror( "Open failed on input file" );
else
{
printf( "Open succeeded on input file\n" );
_close( fh1 );
} fh2 = _open( "CRT_OPEN.OUT", _O_WRONLY | _O_CREAT, _S_IREAD |
_S_IWRITE ); // C4996
if( fh2 == - )
perror( "Open failed on output file" );
else
{
printf( "Open succeeded on output file\n" );
_close( fh2 );
}
}

https://msdn.microsoft.com/en-us/library/z0kc8e3z.aspx
https://msdn.microsoft.com/en-us/library/w64k0ytk.aspx

HANDLE CreateFile(
LPCTSTR lpFileName,
DWORD dwDesiredAccess,
DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDisposition,
DWORD dwFlagsAndAttributes,
HANDLE hTemplateFile
);

. lpFileName: 要打开的文件的名字
. dwDesiredAccess
) GENERIC_READ: 表示允许对设备进行读访问
) GENERIC_WRITE: 表示允许对设备进行写访问(可组合使用)
) GENERIC_EXECUTE: 只允许执行
) 如果为零: 表示只允许获取与一个设备有关的信息
. dwShareMode
) 零: 表示不共享
) FILE_SHARE_READ: 表示其他进程允许对这个文件发起"读请求"共享访问
) FILE_SHARE_WRITE: 表示其他进程允许对这个文件发起"写请求"共享访问
. lpSecurityAttributes: SECURITY_ATTRIBUTES
指向一个SECURITY_ATTRIBUTES结构的指针，定义了文件的安全特性(如果操作系统支持的话)
. dwCreationDisposition
) CREATE_NEW: 创建文件，如文件存在则会出错
) CREATE_ALWAYS: 创建文件，会改写前一个文件
) OPEN_EXISTING: 文件必须已经存在。由设备提出要求
) OPEN_ALWAYS: 如文件不存在则创建它
) TRUNCATE_EXISTING: 讲现有文件缩短为零长度
. dwFlagsAndAttributes
) FILE_ATTRIBUTE_ARCHIVE: 标记归档属性
) FILE_ATTRIBUTE_COMPRESSED: 将文件标记为已压缩，或者标记为文件在目录中的默认压缩方式
) FILE_ATTRIBUTE_NORMAL: 默认属性
) FILE_ATTRIBUTE_HIDDEN: 隐藏文件或目录
) FILE_ATTRIBUTE_READONLY: 文件为只读
) FILE_ATTRIBUTE_SYSTEM: 文件为系统文件
) FILE_FLAG_WRITE_THROUGH: 操作系统不得推迟对文件的写操作
) FILE_FLAG_OVERLAPPED: 允许对文件进行重叠操作
) FILE_FLAG_NO_BUFFERING: 禁止对文件进行缓冲处理。文件只能写入磁盘卷的扇区块
) FILE_FLAG_RANDOM_ACCESS: 针对随机访问对文件缓冲进行优化
) FILE_FLAG_SEQUENTIAL_SCAN: 针对连续访问对文件缓冲进行优化
) FILE_FLAG_DELETE_ON_CLOSE: 关闭了上一次打开的句柄后，将文件删除。特别适合临时文件
//也可在 Windows NT 下组合使用下述常数标记：
) SECURITY_ANONYMOUS
) SECURITY_IDENTIFICATION
) SECURITY_IMPERSONATION
) SECURITY_DELEGATION
) SECURITY_CONTEXT_TRACKING
) SECURITY_EFFECTIVE_ONLY
. hTemplateFile: 如果不为零，则指定一个文件句柄。新文件将从这个文件中复制扩展属性

https://msdn.microsoft.com/en-us/library/windows/desktop/aa363858(v=vs.85).aspx
https://msdn.microsoft.com/zh-cn/library/aa914735.aspx
http://www.cppblog.com/yishanhante/articles/19545.html

BOOL WINAPI DeleteFile(
_In_ LPCTSTR lpFileName
);

. If the function succeeds, the return value is nonzero.
. If an application attempts to delete a file that does not exist, the DeleteFile function fails with ERROR_FILE_NOT_FOUND.
. If the file is a read-only file, the function fails with ERROR_ACCESS_DENIED.

. To delete a read-only file, first you must remove the read-only attribute.
. To delete or rename a file, you must have either delete permission on the file, or delete child permission in the parent directory.
. To recursively delete the files in a directory, use the SHFileOperation function.
. To remove an empty directory, use the RemoveDirectory function.
. To close an open file, use the CloseHandle function.
. If you set up a directory with all access except delete and delete child, and the access control lists (ACL) of new files are inherited, then you can create a file without being able to delete it. However, then you can create a file, and then get all the access you request on the handle that is returned to you at the time you create the file.
. If you request delete permission at the time you create a file, you can delete or rename the file with that handle, but not with any other handle. For more information, see File Security and Access Rights.
. The DeleteFile function fails if an application attempts to delete a file that has other handles open for normal I/O or as a memory-mapped file (FILE_SHARE_DELETE must have been specified when other handles were opened).
. The DeleteFile function marks a file for deletion on close. Therefore, the file deletion does not occur until the last handle to the file is closed. Subsequent calls to CreateFile to open the file fail with ERROR_ACCESS_DENIED.

https://msdn.microsoft.com/zh-cn/library/windows/desktop/aa363915(v=vs.85).aspx