logo

utils-std

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

fs.c (2406B)

    

  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. ssize_t
  61. manual_file_copy(int fd_in, int fd_out, off_t len, int flags)
  62. {
  63. 	ssize_t wrote = 0;
  64. 	do
  65. 	{
  66. 		char buf[BUFSIZ];
  68. 		ssize_t nread = read(fd_in, buf, MIN(BUFSIZ, len));
  69. 		if(nread < 0) return nread;
  70. 		if(nread == 0) return wrote;
  72. 		ssize_t nwrite = write(fd_out, buf, (size_t)nread);
  73. 		if(nwrite < 0) return nwrite;
  75. 		len -= nwrite;
  76. 		wrote += nwrite;
  77. 	} while(len > 0);
  79. 	return wrote;
  80. }
  82. #ifdef HAS_COPY_FILE_RANGE
  83. ssize_t
  84. auto_file_copy(int fd_in, int fd_out, off_t len, int flags)
  85. {
  86. 	ssize_t wrote = 0;
  87. 	off_t ret = -1;
  88. 	do
  89. 	{
  90. 		ret = copy_file_range(fd_in, NULL, fd_out, NULL, len, 0);
  91. 		if(ret < 0)
  92. 		{
  93. 			if(errno == EXDEV || errno == EINVAL)
  94. 			{
  95. 				errno = 0;
  96. 				return manual_file_copy(fd_in, fd_out, len, flags);
  97. 			}
  99. 			return ret;
  100. 		}
  101. 		len -= ret;
  102. 		wrote += ret;
  103. 	} while(len > 0 && ret > 0);
  105. 	return wrote;
  106. }
  107. #endif
  109. #ifdef HAS_SENDFILE
  110. ssize_t
  111. auto_fd_copy(int fd_in, int fd_out, size_t len)
  112. {
  113. 	off_t *off = NULL;
  114. 	ssize_t wrote = 0;
  116. 	while(1)
  117. 	{
  118. 		ssize_t ret = sendfile(fd_out, fd_in, off, len);
  120. 		if(ret < 0)
  121. 		{
  122. 			switch(errno)
  123. 			{
  124. 			case EINVAL:
  125. 				errno = 0;
  126. 				return manual_file_copy(fd_in, fd_out, len, 0);
  127. 			case EAGAIN:
  128. 				errno = 0;
  129. 				continue;
  130. 			default:
  131. 				return ret;
  132. 			}
  133. 		}
  135. 		wrote += ret;
  136. 		len -= ret;
  138. 		if(ret == 0) return wrote;
  139. 	}
  141. 	return -1;
  142. }
  143. #endif // HAS_SENDFILE