81.3.3.4. API РАБОТЫ С ФАЙЛАМИ

		 File API
	       /         \
	    by handle    by name


				by handle	by name
 -----------------------------------------------------------
Открытие/Создание		n/a		yes
Чтение/Письмо                   yes		---
Установка/запрос позиции        yes             ---
Установка/запрос размера	yes             ---
Сброс данных на диск		yes		---
Установка/запрос аттрибутов	yes		yes
Установка/запрос времен		yes		yes
Установка/запрос владельцев	yes		yes
Удаление      			sometimes	yes
Переименование                  ---		yes
Создание ссылки			---		yes
 -----------------------------------------------------------


Операции с файлами
    эти операции как правило по handle



  
  Open/Create 
 
	открыть/создать
		режим открытия
			для чтения
			для записи
			для чтения/записи
			для добавления (Append)
		режим совместного доступа
			share read
			share write
			share all
			share delete			
		поведение при открытии

Режим открытия:
Права доступа к файлу проверяются именно при открытии. То есть в процессе работы
они уже не проверяются (практически всегда).

Совершенно особенный режим открытия Append. Другая семантика поведения.
В этом случае позиция в файле игнорируется и запись всегда ведется в самый конец файла 
(что удобно если есть несколько паралельных программ пишущих в него - например если 
это файл системного log).

Поведение при открытии:

Ситуация		Действие
Файл не существует	Вернуть ошибку
			Создать новый файл (естественно нулевой длинны)
Файл существует		Вернуть ошибку
			Открыть файл
			Урезать файл до нулевой длинны




int	open(const char* name, int flags)
int	open(const char* name, int flags, mode_t mode)    
	O_APPEND
	O_ASYNC
	O_CREAT
	O_DIRECT
	O_DIRECTORY
	O_EXCL			return error if file exist
	O_LARGEFILE
	O_NOCTTY
	O_NONBLOCK
	O_SYNC		O_DSYNC		O_RSYNC
	O_TRUNC

	S_IRWXU
	S_IRUSR
	S_IWUSR
	S_IXUSR
	S_IRWXG
	S_IRGRP
	S_IWGRP
	S_IXGRP
	S_IRWXO
	S_IROTH
	S_IWOTH
	S_IXOTH

int	creat(const char* name, mode_t mode)

mode_t	umask(mode_t cmask)
	open(pathname, O_CREAT, mode) = open(pathname, O_CREAT, (~mask) & mode);

int	mkstemp(char* template)			// stdlib.h



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


	FILE_SHARE_READ
	FILE_SHARE_WRITE
	FILE_SHARE_DELETE

	CREATE_ALWAYS
	CREATE_NEW
	OPEN_ALWAYS
	OPEN_EXISTING
	TRUNCATE_EXISTING







  
  Input/Output 
 

	
Ранние системы например CP/M не позволяли обращаться к файлу по номеру байта,
они позволяли обмениваться только записями фиксированной длинны (например 128 байт,
соответсвенно выровненными). И даже длинна файла в директории была выражена не в
байтах а в записях. Поэтому текстовые файлы кончались символом с кодом EOF (26h),
что бы можно было понять где он кончился в блоке.
Остатки этого были и в ранних версиях UNIX - системный вызов seek().


	читать/писать
		последовательно
			указатель тек позиции
			seek
			проверка на конец файла
		случайный доступ
			указатель позиции включается
	запрос длинны файла


ssize_t	read(int fd, void* buf, size_t len)
ssize_t write(int fd, void* buf, size_t len)

off_t	lseek(int fd, off_t pos, int origin)
		SEEK_SET
		SEEK_CUR
		SEEK_END

ssize_t	pread(int fd, void* buf, size_t count, off_t pos)
ssize_t pwrite(int fd, const void* buf, size_t count, off_t pos)

ssize_t readv(int fd, const struct iovec* iov, int count)
ssize_t	writev(int fd, const struct iovec* iov, int count)

struct	iovec
{
	void*	iov_base;
	size_t	iov_len;
}

int	aio_read(struct aiocb* aicocbp)
int	aio_write(struct aiocb* aiocbp)
int	aio_error(const struct aiocb* aiocbp)
ssize_t	aio_return(struct aiocb* aiocbp)
int	aio_cancel(int fd, struct aiocb* aiocbp)
int	aio_fsync(int op, struct aiocb* aiocbp)
int	aio_suspend(const struct aiocb* const list[], int cbcnt, const struct timespec* timeout)



struct	aiocb
{
	int	  aio_fildes;
	off_t	  aio_offset;
	void*	  aio_buf;
	size_t	  aio_nbytes;
	int	  aio_reqprio;
struct	sigevent  aio_sigevent;
	int	  aio_lio_code;
}


	установка длинны файла

int	ftruncate(int fd, off_t len)
int	truncate(const char* name, off_t len)





	сброс буфферов на диск (flush/commit)


int	fsync(int fd)
int	fdatasync(int fd)
void	sync(void)






  
  Атрибуты и времена 
 

	запросить аттрибуты
	установить аттрибуты
	запросить времена
	установить времена
	запрос ACL/UNIX     permissions
	установка ACL/UNIX  permissions



int	stat(const char* path, struct stat* buf)
int	fstat(int fd, stryct stat* buf)
int	lstat(const char* path, struct stat* buf)
	
struct	stat
{
	dev_t		st_dev;
	ino_t		st_ino;
	mode_t		st_mode;
				S_IFBLK
				S_IFCHR
				S_IFDIR
				S_IFIFO
				S_IFLNK
				S_IFREG
				S_IFSOCK
				
				S_ISUID
				S_ISGID
				S_ISVTX

	nlink_t		st_nlink;
	uid_t		st_uid;
	gud_t		st_gid;
	dev_t		st_rdev;
	off_t		st_size;
	blksize_t       st_blksize;
	blkcnt_t	st_blocks;
	time_t		st_atime;	last access
	time_t		st_mtime;	last modification
	time_t		st_ctime;	last metadata modification
			st_atime_nsec;	// Linux
			st_mtime_nsec;	// Linux
			st_ctime_nsec;	// Linux
}

int	chmod(const char* path, mode_t mode)
inf	fchmod(int fd, mode_t mode)

int	chown(const char * path, uid_t owner, gid_t group)
int	lchown(const char* path, uid_t owner, gid_t group)
int	fchown(int fd, uid_t owner, gid_t group)

int	utime(const char* path, const struct utimbuf* timebuf)

struct	utimbuf
{
	time_t	actime;		// access time
	time_t	modtime;	// modification time
}

int	utimes(char* filename, struct timeval tvp[2]);		// microsecond precision




Rename/Delete

   эти операции как правило по имени
	удаление файла
	переименоване файла
	



int	unlink(const char* pathname)
int	rename(const char* oldpath, const char* newpath)
int	remove(const char* path)				// file or dir


собственно для UNIX системы:

	rename - это link на новое место, а потом unlink на старое.




  
  Hard links 
 

Жесткие ссылки
	Создать жесткую ссылку
	Удалить жесткую ссылку


int	link(const char* oldpath, const char* newpath)




  
  Symbolic Links 
 

Символьные ссылки
	Создать символьную ссылку
	Прочитать символьную ссылку


int	symlink(const char* oldpath, const char* newpath)
ssize_t	readlink(const char* path, char* buf, size_t bufsize)




  
  File control 
 

Специальное управление файлом
	ioctl
	sysctl
	fsctl


int	ioctl(int fd, int request, ...)
int	fcntl(int fd, int request, ...)
		F_DUPFD
		F_GETFD
		F_SETFD
		F_GETFL
		F_SETFL
		F_GETLK
		F_SETLK			non-blocked
		F_SETLKW		blocked





  
  Handle management 
 

	dup
	dup2



int	dup(int fd);			// dup(fd) = fcntl(fd, F_DUPFD, 0)
int	dup2(int fd, int fd2);		// dup2(fd, fd2) = close(fd2), fcntl(fd, F_DUPFD, fd2)





  
  Sharing 
 

Совместный доступ
	Блокирование/разблокирование региона в файле


	fcntl
	F_XXXLK
	
struct	flock
{
	short	l_type;
			F_RDLCK
			F_WRLCK
			F_UNLCK	- remove locking
	short	l_whence;
	off_t	l_start;
	off_t	l_len;
	pid_t	l_pid;
}

int	lockf(int fd, int op, off_t len);





  
  Специальные файлы 
 


int	mknod(const char* path, mode_t perm, dev_t dev)





  
  Extended Attributes 
 



ssize_t	getxattr(const char* path, const char* key, void* value, size_t size)
ssize_t lgetxattr(const char* path, const char* key, void* value, size_t size)
ssize_t	fgetxattr(int fd, const char * key, void* value, size_t size)

int	setxattr(const char* path, const char* key, const void* value, size_t size, int flags)
int	lsetxattr(const char* path, const char* key, const void* value, size_t size, int flags)
int	fsetxattr(int fd, const char* key, const void* value, size_t size, int flags)

ssize_t	listxattr(const char* path, char* list, size_t size)
ssize_t llistxattr(const char* path, char* list, size_t size)
ssize_t flistxattr(int fd, char* list, size_t size)

int	removexattr(const char* path, const char* key)
int	lremovexattr(const char* path, const char* key)
int	fremovexattr(int fd, const char* key)