logo

utils-std

Collection of commonly available Unix tools git clone https://anongit.hacktivis.me/git/utils-std.git/

fs.c (2720B)

    

  1. // utils-std: Collection of commonly available Unix tools
  2. // SPDX-FileCopyrightText: 2017 Haelwenn (lanodan) Monnier <contact+utils@hacktivis.me>
  3. // SPDX-License-Identifier: MPL-2.0
  5. // For copy_file_range
  6. #define _GNU_SOURCE     // musl, glibc
  7. #define _DEFAULT_SOURCE // FreeBSD
  9. #include "./fs.h"
  11. #include <errno.h>
  12. #include <stdio.h>  // BUFSIZ
  13. #include <string.h> // strrchr
  14. #include <unistd.h> // copy_file_range
  16. #ifdef HAS_SENDFILE
  17. #include <sys/sendfile.h>
  18. #endif
  20. char *
  21. static_basename(char *p)
  22. {
  23. 	if(!p || !*p) return p;
  25. 	size_t i = strlen(p) - 1;
  26. 	for(; i && p[i] == '/'; i--)
  27. 		;
  28. 	for(; i && p[i - 1] != '/'; i--)
  29. 		;
  31. 	return p + i;
  32. }
  34. char *
  35. path_split_static(char *path, bool trim)
  36. {
  37. 	char *child = NULL;
  38. 	size_t path_len = strlen(path);
  40. 	// delete trailing slashes
  41. 	if(trim)
  42. 		for(int i = path_len - 1; i > 0 && path[i] == '/'; i--)
  43. 			path[i] = 0;
  45. 	for(int i = path_len - 1; i > 0; i--)
  46. 		if(path[i] == '/')
  47. 		{
  48. 			path[i] = 0;
  49. 			child = &path[i + 1];
  50. 			break;
  51. 		}
  53. 	return child;
  54. }
  56. #ifndef MIN
  57. #define MIN(a, b) (((a) < (b)) ? (a) : (b))
  58. #endif
  60. static int
  61. file_sync(int fd)
  62. {
  63. 	errno = 0;
  65. 	int ret = fsync(fd);
  66. 	if(ret == 0) return 0;
  68. 	// Ignored cases
  69. 	if(errno == EROFS || errno == EINVAL)
  70. 	{
  71. 		errno = 0;
  72. 		return 0;
  73. 	}
  75. 	return ret;
  76. }
  78. ssize_t
  79. manual_file_copy(int fd_in, int fd_out, off_t len, int flags)
  80. {
  81. 	ssize_t wrote = 0;
  82. 	do
  83. 	{
  84. 		char buf[BUFSIZ];
  86. 		ssize_t nread = read(fd_in, buf, MIN(BUFSIZ, len));
  87. 		if(nread < 0) return nread;
  88. 		if(nread == 0) return wrote;
  90. 		ssize_t nwrite = write(fd_out, buf, (size_t)nread);
  91. 		if(nwrite < 0) return nwrite;
  93. 		len -= nwrite;
  94. 		wrote += nwrite;
  95. 	} while(len > 0);
  97. 	if(file_sync(fd_out) < 0) return -1;
  99. 	return wrote;
  100. }
  102. #ifdef HAS_COPY_FILE_RANGE
  103. ssize_t
  104. auto_file_copy(int fd_in, int fd_out, off_t len, int flags)
  105. {
  106. 	ssize_t wrote = 0;
  107. 	off_t ret = -1;
  108. 	do
  109. 	{
  110. 		ret = copy_file_range(fd_in, NULL, fd_out, NULL, len, 0);
  111. 		if(ret < 0)
  112. 		{
  113. 			if(errno == EXDEV || errno == EINVAL)
  114. 			{
  115. 				errno = 0;
  116. 				return manual_file_copy(fd_in, fd_out, len, flags);
  117. 			}
  119. 			return ret;
  120. 		}
  121. 		len -= ret;
  122. 		wrote += ret;
  123. 	} while(len > 0 && ret > 0);
  125. 	if(file_sync(fd_out) < 0) return -1;
  127. 	return wrote;
  128. }
  129. #endif
  131. #ifdef HAS_SENDFILE
  132. ssize_t
  133. auto_fd_copy(int fd_in, int fd_out, size_t len)
  134. {
  135. 	off_t *off = NULL;
  136. 	ssize_t wrote = 0;
  138. 	while(1)
  139. 	{
  140. 		ssize_t ret = sendfile(fd_out, fd_in, off, len);
  142. 		if(ret < 0)
  143. 		{
  144. 			switch(errno)
  145. 			{
  146. 			case EINVAL:
  147. 				errno = 0;
  148. 				return manual_file_copy(fd_in, fd_out, len, 0);
  149. 			case EAGAIN:
  150. 				errno = 0;
  151. 				continue;
  152. 			default:
  153. 				return ret;
  154. 			}
  155. 		}
  157. 		wrote += ret;
  158. 		len -= ret;
  160. 		if(file_sync(fd_out) < 0) return -1;
  162. 		if(ret == 0) return wrote;
  163. 	}
  165. 	return -1;
  166. }
  167. #endif // HAS_SENDFILE