7 #ifndef __STDC_FORMAT_MACROS
9 #define __STDC_FORMAT_MACROS
12 #include "cvmfs_config.h"
15 #include <arpa/inet.h>
20 #include <netinet/in.h>
25 #include <sys/resource.h>
26 #include <sys/socket.h>
29 #include <sys/mount.h>
31 #include <sys/statfs.h>
34 #include <sys/types.h>
36 #include <sys/utsname.h>
41 #ifdef HAS_VALGRIND_HEADERS
42 #include <valgrind/valgrind.h>
71 #define CVMFS_HAS_STATFS_F_FLAGS
73 #ifdef __GLIBC_MINOR__
74 #if __GLIBC_MINOR__ < 12
75 #undef CVMFS_HAS_STATFS_F_FLAGS
83 extern char **environ;
87 #ifdef CVMFS_NAMESPACE_GUARD
88 namespace CVMFS_NAMESPACE_GUARD {
98 if (path.length() == 0)
return path;
100 if (path[path.length()-1] ==
'/') {
101 return path.substr(0, path.length()-1);
113 const std::string &path,
114 std::string *dirname,
115 std::string *filename)
117 size_t dir_sep = path.rfind(
'/');
118 if (dir_sep != std::string::npos) {
119 *dirname = path.substr(0, dir_sep);
120 *filename = path.substr(dir_sep+1);
132 const std::string::size_type idx = path.find_last_of(
'/');
133 if (idx != std::string::npos) {
134 return path.substr(0, idx);
145 const std::string::size_type idx = path.find_last_of(
'/');
146 if (idx != std::string::npos) {
147 return path.substr(idx+1);
155 return (!path.empty() && path[0] ==
'/');
168 if (path.length() < 7) {
172 std::string prefix = path.substr(0, 8);
173 std::transform(prefix.begin(), prefix.end(), prefix.begin(), ::tolower);
175 return prefix.substr(0, 7) ==
"http://" || prefix ==
"https://";
183 int retval = statfs(path.c_str(), &info);
187 switch (info.f_type) {
204 #ifdef CVMFS_HAS_STATFS_F_FLAGS
209 retval = access(path.c_str(), W_OK);
221 char buf[PATH_MAX + 1];
222 ssize_t nchars = readlink(path.c_str(), buf, PATH_MAX);
225 return std::string(buf);
236 if (path.empty() || (path ==
"/"))
239 std::string result = name;
243 result = parent + (parent ==
"/" ?
"" :
"/") + name;
245 char *real_result = realpath(result.c_str(), NULL);
247 result = real_result;
251 char buf[PATH_MAX + 1];
252 ssize_t nchars = readlink(result.c_str(), buf, PATH_MAX);
265 for (
unsigned i = 0; i < mount_list.size(); ++i) {
266 if (mount_list[i] == resolved_path)
277 const std::string &path,
279 const bool ignore_failure)
281 int fd = open(path.c_str(), O_CREAT, mode);
296 struct sockaddr_un sock_addr;
297 unsigned max_length =
sizeof(sock_addr.sun_path);
301 if (tmp_path.empty())
303 std::string link = tmp_path +
"/l";
305 if (result.length() >= max_length) {
306 rmdir(tmp_path.c_str());
311 rmdir(tmp_path.c_str());
319 unlink(link.c_str());
328 std::string short_path(path);
329 struct sockaddr_un sock_addr;
330 if (path.length() >=
sizeof(sock_addr.sun_path)) {
334 if (short_path.empty())
337 sock_addr.sun_family = AF_UNIX;
338 strncpy(sock_addr.sun_path, short_path.c_str(),
339 sizeof(sock_addr.sun_path));
341 const int socket_fd = socket(AF_UNIX, SOCK_STREAM, 0);
347 if (fchmod(socket_fd, mode) != 0)
348 goto make_socket_failure;
351 if (bind(socket_fd, reinterpret_cast<struct sockaddr *>(&sock_addr),
352 sizeof(sock_addr.sun_family) +
sizeof(sock_addr.sun_path)) < 0)
354 if ((errno == EADDRINUSE) && (unlink(path.c_str()) == 0)) {
356 if (bind(socket_fd, reinterpret_cast<struct sockaddr *>(&sock_addr),
357 sizeof(sock_addr.sun_family) +
sizeof(sock_addr.sun_path)) < 0)
360 goto make_socket_failure;
364 goto make_socket_failure;
368 if (short_path != path)
375 if (short_path != path)
386 const int socket_fd = socket(AF_INET, SOCK_STREAM, 0);
389 int retval = setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &on,
sizeof(on));
392 struct sockaddr_in endpoint_addr;
393 memset(&endpoint_addr, 0,
sizeof(endpoint_addr));
394 endpoint_addr.sin_family = AF_INET;
395 if (ipv4_address.empty()) {
396 endpoint_addr.sin_addr.s_addr = INADDR_ANY;
398 retval = inet_aton(ipv4_address.c_str(), &(endpoint_addr.sin_addr));
405 endpoint_addr.sin_port = htons(portno);
407 retval = bind(socket_fd, reinterpret_cast<struct sockaddr *>(&endpoint_addr),
408 sizeof(endpoint_addr));
424 std::string short_path(path);
425 struct sockaddr_un sock_addr;
426 if (path.length() >=
sizeof(sock_addr.sun_path)) {
430 if (short_path.empty())
433 sock_addr.sun_family = AF_UNIX;
434 strncpy(sock_addr.sun_path, short_path.c_str(),
sizeof(sock_addr.sun_path));
436 const int socket_fd = socket(AF_UNIX, SOCK_STREAM, 0);
440 connect(socket_fd, reinterpret_cast<struct sockaddr *>(&sock_addr),
441 sizeof(sock_addr.sun_family) +
sizeof(sock_addr.sun_path));
442 if (short_path != path)
458 const int socket_fd = socket(AF_INET, SOCK_STREAM, 0);
461 struct sockaddr_in endpoint_addr;
462 memset(&endpoint_addr, 0,
sizeof(endpoint_addr));
463 endpoint_addr.sin_family = AF_INET;
464 int retval = inet_aton(ipv4_address.c_str(), &(endpoint_addr.sin_addr));
470 endpoint_addr.sin_port = htons(portno);
473 connect(socket_fd, reinterpret_cast<struct sockaddr *>(&endpoint_addr),
474 sizeof(endpoint_addr));
489 int retval = pipe(pipe_fd);
500 num_bytes = write(fd, buf, nbyte);
501 }
while ((num_bytes < 0) && (errno == EINTR));
502 assert((num_bytes >= 0) && (static_cast<size_t>(num_bytes) == nbyte));
512 num_bytes = read(fd, buf, nbyte);
513 }
while ((num_bytes < 0) && (errno == EINTR));
514 assert((num_bytes >= 0) && (static_cast<size_t>(num_bytes) == nbyte));
524 unsigned backoff_ms = 1;
525 const unsigned max_backoff_ms = 256;
529 num_bytes = read(fd, buf, nbyte);
530 if ((num_bytes < 0) && (errno == EINTR))
534 if ((i > 3000) && (num_bytes == 0)) {
537 if (backoff_ms < max_backoff_ms) backoff_ms *= 2;
539 }
while (num_bytes == 0);
540 assert((num_bytes >= 0) && (static_cast<size_t>(num_bytes) == nbyte));
557 bool DiffTree(
const std::string &path_a,
const std::string &path_b) {
559 std::vector<std::string> ls_a;
560 std::vector<std::string> ls_b;
561 std::vector<std::string> subdirs;
563 DIR *dirp_a = opendir(path_a.c_str());
564 if (dirp_a == NULL)
return false;
565 DIR *dirp_b = opendir(path_b.c_str());
566 if (dirp_b == NULL) {
573 const std::string name(dirent->d_name);
574 if ((name ==
".") || (name ==
".."))
576 const std::string path = path_a +
"/" + name;
577 ls_a.push_back(path);
586 if (S_ISDIR(info.st_mode)) subdirs.push_back(name);
589 const std::string name(dirent->d_name);
590 if ((name ==
".") || (name ==
".."))
592 const std::string path = path_b +
"/" + name;
593 ls_b.push_back(path);
598 sort(ls_a.begin(), ls_a.end());
599 sort(ls_b.begin(), ls_b.end());
600 if (ls_a.size() != ls_b.size())
602 for (
unsigned i = 0; i < ls_a.size(); ++i) {
607 if (retval != 0)
return false;
609 if (retval != 0)
return false;
610 if ((info_a.st_mode != info_b.st_mode) ||
611 (info_a.st_uid != info_b.st_uid) ||
612 (info_a.st_gid != info_b.st_gid) ||
613 ((info_a.st_size != info_b.st_size) && !S_ISDIR(info_a.st_mode)))
619 for (
unsigned i = 0; i < subdirs.size(); ++i) {
620 bool retval_subtree =
DiffTree(path_a +
"/" + subdirs[i],
621 path_b +
"/" + subdirs[i]);
622 if (!retval_subtree)
return false;
633 int flags = fcntl(filedes, F_GETFL);
635 int retval = fcntl(filedes, F_SETFL, flags & ~O_NONBLOCK);
644 int flags = fcntl(filedes, F_GETFL);
646 int retval = fcntl(filedes, F_SETFL, flags | O_NONBLOCK);
667 struct cmsghdr align;
669 unsigned char buf[CMSG_SPACE(
sizeof(
int))];
672 memset(ctrl_msg.buf, 0,
sizeof(ctrl_msg.buf));
675 msgh.msg_name = NULL;
676 msgh.msg_namelen = 0;
678 unsigned char dummy = 0;
680 iov.iov_base = &dummy;
685 msgh.msg_control = ctrl_msg.buf;
686 msgh.msg_controllen =
sizeof(ctrl_msg.buf);
687 struct cmsghdr *cmsgp = CMSG_FIRSTHDR(&msgh);
688 cmsgp->cmsg_len = CMSG_LEN(
sizeof(
int));
689 cmsgp->cmsg_level = SOL_SOCKET;
690 cmsgp->cmsg_type = SCM_RIGHTS;
691 memcpy(CMSG_DATA(cmsgp), &passing_fd,
sizeof(
int));
693 ssize_t retval = sendmsg(socket_fd, &msgh, 0);
694 return (retval != -1);
707 struct cmsghdr align;
709 unsigned char buf[CMSG_SPACE(
sizeof(
int))];
712 memset(ctrl_msg.buf, 0,
sizeof(ctrl_msg.buf));
715 msgh.msg_name = NULL;
716 msgh.msg_namelen = 0;
720 iov.iov_base = &dummy;
725 msgh.msg_control = ctrl_msg.buf;
726 msgh.msg_controllen =
sizeof(ctrl_msg.buf);
728 ssize_t retval = recvmsg(msg_fd, &msgh, 0);
732 struct cmsghdr *cmsgp = CMSG_FIRSTHDR(&msgh);
734 if (cmsgp->cmsg_len != CMSG_LEN(
sizeof(
int)))
736 assert(cmsgp->cmsg_level == SOL_SOCKET);
737 assert(cmsgp->cmsg_type == SCM_RIGHTS);
740 memcpy(&passing_fd, CMSG_DATA(cmsgp),
sizeof(
int));
758 const bool temporarily)
761 "euid %d egid %d, switching to %d %d (temp: %d)",
762 getuid(), getgid(), geteuid(), getegid(), uid, gid, temporarily);
765 if (gid != getegid())
766 retval = setegid(gid);
767 if ((retval == 0) && (uid != geteuid()))
768 retval = seteuid(uid);
771 if ((getuid() == 0) && (getuid() != geteuid())) {
776 retval = setgid(gid) || setuid(uid);
790 S_ISREG(info.st_mode));
812 S_ISDIR(info.st_mode));
822 S_ISLNK(info.st_mode));
830 int retval = unlink(dest.c_str());
831 if ((retval != 0) && (errno != ENOENT))
833 retval = symlink(src.c_str(), dest.c_str());
843 const std::string &path,
845 bool verify_writable)
847 if (path ==
"")
return false;
849 int retval = mkdir(path.c_str(), mode);
850 if (retval == 0)
return true;
852 if ((errno == ENOENT) &&
855 return MkdirDeep(path, mode, verify_writable);
858 if (errno == EEXIST) {
860 if ((
platform_stat(path.c_str(), &info) == 0) && S_ISDIR(info.st_mode)) {
861 if (verify_writable) {
862 retval = utimes(path.c_str(), NULL);
881 std::string this_path = canonical_path +
"/quarantaine";
882 if (!
MkdirDeep(this_path, mode,
false))
return false;
884 this_path = canonical_path +
"/ff";
888 this_path = canonical_path +
"/txn";
891 for (
int i = 0; i <= 0xff; i++) {
893 snprintf(hex,
sizeof(hex),
"%02x", i);
894 this_path = canonical_path +
"/" + std::string(hex);
910 const int fd_lockfile = open(path.c_str(), O_RDONLY | O_CREAT, 0600);
914 if (flock(fd_lockfile, LOCK_EX | LOCK_NB) != 0) {
916 if (errno != EWOULDBLOCK)
932 const int fd = open(path.c_str(), O_CREAT | O_RDWR, 0600);
935 if (flock(fd, LOCK_EX | LOCK_NB) != 0) {
937 if (errno != EWOULDBLOCK)
943 int flags = fcntl(fd, F_GETFD);
946 flags = fcntl(fd, F_SETFD, flags);
951 snprintf(buf,
sizeof(buf),
"%" PRId64
"\n", static_cast<uint64_t>(getpid()));
953 (ftruncate(fd, 0) == 0) &&
SafeWrite(fd, buf, strlen(buf));
968 const int fd_lockfile = open(path.c_str(), O_RDONLY | O_CREAT, 0600);
973 if (flock(fd_lockfile, LOCK_EX | LOCK_NB) != 0) {
974 if (errno != EWOULDBLOCK) {
980 if (flock(fd_lockfile, LOCK_EX) != 0) {
992 int retval = flock(filedes, LOCK_UN);
1002 const char *open_flags, std::string *final_path)
1004 *final_path = path_prefix +
".XXXXXX";
1005 char *tmp_file =
strdupa(final_path->c_str());
1006 int tmp_fd = mkstemp(tmp_file);
1010 if (fchmod(tmp_fd, mode) != 0) {
1015 *final_path = tmp_file;
1016 FILE *tmp_fp = fdopen(tmp_fd, open_flags);
1044 std::string dir = path_prefix +
".XXXXXX";
1045 char *tmp_dir =
strdupa(dir.c_str());
1046 tmp_dir = mkdtemp(tmp_dir);
1047 if (tmp_dir == NULL)
1049 return std::string(tmp_dir);
1058 return (getcwd(cwd,
sizeof(cwd)) != NULL) ? std::string(cwd) : std::string();
1071 void RemoveFile(
const std::string &parent_path,
const std::string &name) {
1072 int retval = unlink((parent_path +
"/" + name).c_str());
1076 void RemoveDir(
const std::string &parent_path,
const std::string &name) {
1077 int retval = rmdir((parent_path +
"/" + name).c_str());
1081 bool TryRemoveDir(
const std::string &parent_path,
const std::string &name) {
1082 int retval = rmdir((parent_path +
"/" + name).c_str());
1083 return (retval != 0);
1095 return errno == ENOENT;
1096 if (!S_ISDIR(info.st_mode))
1110 bool result = remove_tree_helper->
success;
1111 delete remove_tree_helper;
1121 const std::string &dir,
1122 const std::string &suffix)
1124 std::vector<std::string> result;
1125 DIR *dirp = opendir(dir.c_str());
1131 const std::string name(dirent->d_name);
1132 if ((name.length() >= suffix.length()) &&
1133 (name.substr(name.length()-suffix.length()) == suffix))
1135 result.push_back(dir +
"/" + name);
1139 std::sort(result.begin(), result.end());
1148 const std::string &dir,
1149 const std::string &prefix)
1151 std::vector<std::string> result;
1152 DIR *dirp = opendir(dir.c_str());
1158 const std::string name(dirent->d_name);
1159 if ((name.length() >= prefix.length()) &&
1160 (name.substr(0, prefix.length()) == prefix))
1162 result.push_back(dir +
"/" + name);
1166 std::sort(result.begin(), result.end());
1176 std::vector<std::string> result;
1177 DIR *dirp = opendir(parent_dir.c_str());
1183 const std::string name(dirent->d_name);
1184 if ((name ==
".") || (name ==
".."))
1186 const std::string path = parent_dir +
"/" + name;
1192 if (S_ISDIR(info.st_mode))
1193 result.push_back(path);
1196 sort(result.begin(), result.end());
1205 std::vector<std::string> *names,
1206 std::vector<mode_t> *modes)
1208 DIR *dirp = opendir(directory.c_str());
1214 const std::string name(dirent->d_name);
1215 if ((name ==
".") || (name ==
".."))
1217 const std::string path = directory +
"/" + name;
1226 names->push_back(name);
1227 modes->push_back(info.st_mode);
1244 std::vector<std::string> search_paths;
1245 if (exe[0] ==
'/') {
1248 char *path_env = getenv(
"PATH");
1254 for (
unsigned i = 0; i < search_paths.size(); ++i) {
1255 if (search_paths[i].empty())
1257 if (search_paths[i][0] !=
'/')
1260 std::string path = search_paths[i] +
"/" +
GetFileName(exe);
1265 if (!S_ISREG(info.st_mode))
1267 retval = access(path.c_str(), X_OK);
1280 struct passwd *result = NULL;
1281 int bufsize = 16 * 1024;
1282 char *buf =
static_cast<char *
>(smalloc(bufsize));
1283 while (getpwuid_r(geteuid(), &pwd, buf, bufsize, &result) == ERANGE) {
1285 buf =
static_cast<char *
>(srealloc(buf, bufsize));
1287 if (result == NULL) {
1291 std::string user_name = pwd.pw_name;
1298 struct passwd *result = NULL;
1299 int bufsize = 16 * 1024;
1300 char *buf =
static_cast<char *
>(smalloc(bufsize));
1301 while (getpwuid_r(geteuid(), &pwd, buf, bufsize, &result) == ERANGE) {
1303 buf =
static_cast<char *
>(srealloc(buf, bufsize));
1305 if (result == NULL) {
1309 std::string shell = pwd.pw_shell;
1319 struct passwd *result = NULL;
1320 int bufsize = 16 * 1024;
1321 char *buf =
static_cast<char *
>(smalloc(bufsize));
1322 while (getpwuid_r(uid, &pwd, buf, bufsize, &result) == ERANGE) {
1324 buf =
static_cast<char *
>(srealloc(buf, bufsize));
1326 if (result == NULL) {
1331 *username = result->pw_name;
1340 bool GetUidOf(
const std::string &username, uid_t *uid, gid_t *main_gid) {
1342 struct passwd *result = NULL;
1343 int bufsize = 16 * 1024;
1344 char *buf =
static_cast<char *
>(smalloc(bufsize));
1345 while (getpwnam_r(username.c_str(), &pwd, buf, bufsize, &result) == ERANGE) {
1347 buf =
static_cast<char *
>(srealloc(buf, bufsize));
1349 if (result == NULL) {
1353 *uid = result->pw_uid;
1354 *main_gid = result->pw_gid;
1363 bool GetGidOf(
const std::string &groupname, gid_t *gid) {
1365 struct group *result = NULL;
1366 int bufsize = 16 * 1024;
1367 char *buf =
static_cast<char *
>(smalloc(bufsize));
1368 while (getgrnam_r(groupname.c_str(), &grp, buf, bufsize, &result) == ERANGE) {
1370 buf =
static_cast<char *
>(srealloc(buf, bufsize));
1372 if (result == NULL) {
1376 *gid = result->gr_gid;
1388 const mode_t my_umask = umask(0);
1398 int ngroups = getgroups(0, NULL);
1401 gid_t *groups =
static_cast<gid_t *
>(smalloc((ngroups+1) *
sizeof(gid_t)));
1402 int retval = getgroups(ngroups, groups);
1407 for (
int i = 0; i < ngroups; ++i) {
1408 if (groups[i] == gid) {
1413 groups[ngroups] = gid;
1414 retval = setgroups(ngroups+1, groups);
1421 uid_t uid = getuid();
1423 struct passwd *result = NULL;
1424 int bufsize = 16 * 1024;
1425 char *buf =
static_cast<char *
>(smalloc(bufsize));
1426 while (getpwuid_r(uid, &pwd, buf, bufsize, &result) == ERANGE) {
1428 buf =
static_cast<char *
>(srealloc(buf, bufsize));
1430 if (result == NULL) {
1434 std::string home_dir = result->pw_dir;
1443 struct utsname info;
1444 int retval = uname(&info);
1446 return info.machine;
1456 memset(&rpl, 0,
sizeof(rpl));
1457 getrlimit(RLIMIT_NOFILE, &rpl);
1458 if (rpl.rlim_max < limit_nofile)
1459 rpl.rlim_max = limit_nofile;
1460 rpl.rlim_cur = limit_nofile;
1461 int retval = setrlimit(RLIMIT_NOFILE, &rpl);
1465 #ifdef HAS_VALGRIND_HEADERS
1466 return RUNNING_ON_VALGRIND ? -2 : -1;
1481 memset(&rpl, 0,
sizeof(rpl));
1482 getrlimit(RLIMIT_NOFILE, &rpl);
1483 *soft_limit = rpl.rlim_cur;
1486 int value = sysconf(_SC_OPEN_MAX);
1488 *hard_limit = value;
1490 *hard_limit = rpl.rlim_max;
1495 std::vector<LsofEntry>
Lsof(
const std::string &path) {
1496 std::vector<LsofEntry> result;
1498 std::vector<std::string> proc_names;
1499 std::vector<mode_t> proc_modes;
1502 for (
unsigned i = 0; i < proc_names.size(); ++i) {
1503 if (!S_ISDIR(proc_modes[i]))
1505 if (proc_names[i].find_first_not_of(
"1234567890") != std::string::npos)
1508 std::vector<std::string> fd_names;
1509 std::vector<mode_t> fd_modes;
1510 std::string proc_dir =
"/proc/" + proc_names[i];
1511 std::string fd_dir = proc_dir +
"/fd";
1519 proc_uid = info.st_uid;
1522 if (
HasPrefix(cwd +
"/", path +
"/",
false )) {
1525 entry.
owner = proc_uid;
1529 result.push_back(entry);
1533 for (
unsigned j = 0; j < fd_names.size(); ++j) {
1534 if (!S_ISLNK(fd_modes[j]))
1536 if (fd_names[j].find_first_not_of(
"1234567890") != std::string::npos)
1539 std::string target =
ReadSymlink(fd_dir +
"/" + fd_names[j]);
1540 if (!
HasPrefix(target +
"/", path +
"/",
false ))
1545 entry.
owner = proc_uid;
1546 entry.
read_only = !((fd_modes[j] & S_IWUSR) == S_IWUSR);
1548 entry.
path = target;
1549 result.push_back(entry);
1559 int retval = kill(pid, 0);
1562 return (errno != ESRCH);
1571 int retval = sigemptyset(&sigset);
1573 retval = sigaddset(&sigset, signum);
1575 retval = pthread_sigmask(SIG_BLOCK, &sigset, NULL);
1588 }
while ((retval != signum) && (errno == EINTR));
1589 assert(retval == signum);
1602 pid_t retval = waitpid(pid, &statloc, 0);
1607 "waitpid failed with errno %d", errno);
1612 if (WIFEXITED(statloc))
1613 return WEXITSTATUS(statloc);
1614 if (WIFSIGNALED(statloc) && (std::find(sig_ok.begin(), sig_ok.end(),
1615 WTERMSIG(statloc)) != sig_ok.end()))
1627 if ((pid = fork()) == 0) {
1628 int retval = setsid();
1630 if ((pid = fork()) == 0) {
1631 int null_read = open(
"/dev/null", O_RDONLY);
1632 int null_write = open(
"/dev/null", O_WRONLY);
1633 assert((null_read >= 0) && (null_write >= 0));
1634 retval = dup2(null_read, 0);
1636 retval = dup2(null_write, 1);
1638 retval = dup2(null_write, 2);
1649 waitpid(pid, &statloc, 0);
1659 const std::string &binary_path,
1660 const std::vector<std::string> &argv,
1661 const bool double_fork,
1671 std::set<int> preserve_fildes;
1672 preserve_fildes.insert(0);
1673 preserve_fildes.insert(1);
1674 preserve_fildes.insert(2);
1675 std::map<int, int> map_fildes;
1676 map_fildes[pipe_stdin[0]] = 0;
1677 map_fildes[pipe_stdout[1]] = 1;
1678 map_fildes[pipe_stderr[1]] = 2;
1679 std::vector<std::string> cmd_line;
1680 cmd_line.push_back(binary_path);
1681 cmd_line.insert(cmd_line.end(), argv.begin(), argv.end());
1697 close(pipe_stdin[0]);
1698 close(pipe_stdout[1]);
1699 close(pipe_stderr[1]);
1700 *fd_stdin = pipe_stdin[1];
1701 *fd_stdout = pipe_stdout[0];
1702 *fd_stderr = pipe_stderr[0];
1711 bool Shell(
int *fd_stdin,
int *fd_stdout,
int *fd_stderr) {
1712 const bool double_fork =
true;
1713 return ExecuteBinary(fd_stdin, fd_stdout, fd_stderr,
"/bin/sh",
1714 std::vector<std::string>(), double_fork);
1732 return "Sending PID";
1736 return "Unknown Status";
1738 return "Duplicate File Descriptor";
1740 return "Close File Descriptors";
1741 case kFailGetFdFlags:
1742 return "Read File Descriptor Flags";
1743 case kFailSetFdFlags:
1744 return "Set File Descriptor Flags";
1745 case kFailDropCredentials:
1746 return "Lower User Permissions";
1748 return "Invoking execvp()";
1757 const std::set<int> &preserve_fildes,
1760 for (
int fd = 0; fd < max_fd; fd++) {
1761 if (preserve_fildes.count(fd) == 0) {
1774 DIR *dirp = opendir(
"/proc/self/fd");
1781 const std::string name(dirent->d_name);
1782 uint64_t name_uint64;
1789 int fd =
static_cast<int>(name_uint64);
1790 if (preserve_fildes.count(fd)) {
1808 int max_fd =
static_cast<int>(sysconf(_SC_OPEN_MAX));
1815 #else // ifdef __APPLE__
1816 if (max_fd > 100000) {
1823 #endif // #ifdef __APPLE__
1840 const std::set<int> &preserve_fildes,
1841 const std::map<int, int> &map_fildes,
1842 const bool drop_credentials,
1843 const bool clear_env,
1844 const bool double_fork,
1847 assert(command_line.size() >= 1);
1853 pid_t pid_grand_child;
1857 std::set<int> skip_fds = preserve_fildes;
1858 skip_fds.insert(pipe_fork.write_end);
1864 int retval = clearenv();
1869 const char *argv[command_line.size() + 1];
1870 for (
unsigned i = 0; i < command_line.size(); ++i)
1871 argv[i] = command_line[i].c_str();
1872 argv[command_line.size()] = NULL;
1875 for (std::map<int, int>::const_iterator i = map_fildes.begin(),
1876 iEnd = map_fildes.end(); i != iEnd; ++i)
1878 int retval = dup2(i->first, i->second);
1893 pid_grand_child = fork();
1894 assert(pid_grand_child >= 0);
1895 if (pid_grand_child != 0) _exit(0);
1898 fd_flags = fcntl(pipe_fork.write_end, F_GETFD);
1903 fd_flags |= FD_CLOEXEC;
1904 if (fcntl(pipe_fork.write_end, F_SETFD, fd_flags) < 0) {
1910 assert(setenv(
"__CVMFS_DEBUG_MODE__",
"yes", 1) == 0);
1919 pid_grand_child = getpid();
1921 pipe_fork.Write(&failed,
sizeof(failed));
1922 pipe_fork.Write(pid_grand_child);
1924 execvp(command_line[0].c_str(), const_cast<char **>(argv));
1929 pipe_fork.Write(&failed,
sizeof(failed));
1934 waitpid(pid, &statloc, 0);
1937 close(pipe_fork.write_end);
1941 bool retcode = pipe_fork.Read(&status_code,
sizeof(status_code));
1944 close(pipe_fork.read_end);
1952 pid_t buf_child_pid = 0;
1953 pipe_fork.Read(&buf_child_pid);
1954 if (child_pid != NULL)
1955 *child_pid = buf_child_pid;
1956 close(pipe_fork.read_end);
1958 command_line[0].c_str(),
1959 static_cast<int>(buf_child_pid));
1969 struct timeval wait_for;
1970 wait_for.tv_sec = ms / 1000;
1971 wait_for.tv_usec = (ms % 1000) * 1000;
1972 select(0, NULL, NULL, NULL, &wait_for);
1981 ssize_t retval = write(fd, buf, nbyte);
1987 assert(static_cast<size_t>(retval) <= nbyte);
1988 buf =
reinterpret_cast<const char *
>(buf) + retval;
1998 unsigned nbytes = 0;
1999 for (
unsigned i = 0; i < iovcnt; ++i)
2000 nbytes += iov[i].iov_len;
2001 unsigned iov_idx = 0;
2005 writev(fd, &iov[iov_idx], static_cast<int>(iovcnt - iov_idx));
2011 assert(static_cast<size_t>(retval) <= nbytes);
2014 unsigned sum_written_blocks = 0;
2015 while ((sum_written_blocks + iov[iov_idx].iov_len) <=
2016 static_cast<size_t>(retval))
2018 sum_written_blocks += iov[iov_idx].iov_len;
2020 if (iov_idx == iovcnt) {
2021 assert(sum_written_blocks == static_cast<size_t>(retval));
2025 unsigned offset = retval - sum_written_blocks;
2026 iov[iov_idx].iov_len -= offset;
2027 iov[iov_idx].iov_base =
2028 reinterpret_cast<char *
>(iov[iov_idx].iov_base) + offset;
2039 ssize_t total_bytes = 0;
2041 ssize_t retval = read(fd, buf, nbyte);
2046 }
else if (retval == 0) {
2049 assert(static_cast<size_t>(retval) <= nbyte);
2050 buf =
reinterpret_cast<char *
>(buf) + retval;
2052 total_bytes += retval;
2062 if (!final_result) {
return false;}
2064 std::string tmp_result;
2065 static const int buf_size = 4096;
2067 ssize_t total_bytes = -1;
2069 total_bytes =
SafeRead(fd, buf, buf_size);
2070 if (total_bytes < 0) {
return false;}
2071 tmp_result.append(buf, total_bytes);
2072 }
while (total_bytes == buf_size);
2073 final_result->swap(tmp_result);
2078 const std::string &path,
2080 int fd = open(path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, mode);
2081 if (fd < 0)
return false;
2082 bool retval =
SafeWrite(fd, content.data(), content.size());
2088 #ifdef CVMFS_NAMESPACE_GUARD
bool MakeCacheDirectories(const std::string &path, const mode_t mode)
#define LogCvmfs(source, mask,...)
static bool CloseAllFildesInProcSelfFd(const std::set< int > &preserve_fildes)
void RemoveFile(const std::string &parent_path, const std::string &name)
int MakeSocket(const std::string &path, const int mode)
bool SymlinkForced(const std::string &src, const std::string &dest)
NameString GetFileName(const PathString &path)
int MakeTcpEndpoint(const std::string &ipv4_address, int portno)
std::string GetUserName()
VoidCallback fn_new_symlink
VoidCallback fn_new_character_dev
void Recurse(const std::string &dir_path) const
void CreateFile(const std::string &path, const int mode, const bool ignore_failure)
bool GetUserNameOf(uid_t uid, std::string *username)
FILE * CreateTempFile(const std::string &path_prefix, const int mode, const char *open_flags, std::string *final_path)
int ConnectTcpEndpoint(const std::string &ipv4_address, int portno)
void RemoveDir(const std::string &parent_path, const std::string &name)
bool Shell(int *fd_stdin, int *fd_stdout, int *fd_stderr)
bool IsHttpUrl(const std::string &path)
bool ManagedExec(const std::vector< std::string > &command_line, const std::set< int > &preserve_fildes, const std::map< int, int > &map_fildes, const bool drop_credentials, const bool clear_env, const bool double_fork, pid_t *child_pid)
static void RemoveShortSocketLink(const std::string &short_path)
static pthread_mutex_t getumask_mutex
std::string CreateTempPath(const std::string &path_prefix, const int mode)
A simple recursion engine to abstract the recursion of directories. It provides several callback hook...
bool SafeWrite(int fd, const void *buf, size_t nbyte)
void SendMsg2Socket(const int fd, const std::string &msg)
assert((mem||(size==0))&&"Out Of Memory")
bool SafeWriteToFile(const std::string &content, const std::string &path, int mode)
std::string FindExecutable(const std::string &exe)
bool SendFd2Socket(int socket_fd, int passing_fd)
VoidCallback fn_leave_dir
int WaitForChild(pid_t pid, const std::vector< int > &sig_ok)
bool TryRemoveDir(const std::string &parent_path, const std::string &name)
bool AddGroup2Persona(const gid_t gid)
void MakePipe(int pipe_fd[2])
std::vector< std::string > FindDirectories(const std::string &parent_dir)
bool String2Uint64Parse(const std::string &value, uint64_t *result)
int SetLimitNoFile(unsigned limit_nofile)
bool SymlinkExists(const std::string &path)
static bool CloseAllFildesUntilMaxFD(const std::set< int > &preserve_fildes, int max_fd)
bool FileExists(const std::string &path)
std::string GetAbsolutePath(const std::string &path)
void SplitPath(const std::string &path, std::string *dirname, std::string *filename)
std::string GetHostname()
void GetLimitNoFile(unsigned *soft_limit, unsigned *hard_limit)
void ReadHalfPipe(int fd, void *buf, size_t nbyte)
ssize_t SafeRead(int fd, void *buf, size_t nbyte)
vector< string > SplitString(const string &str, char delim)
FileSystemInfo GetFileSystemInfo(const std::string &path)
void Nonblock2Block(int filedes)
static std::string MakeShortSocketLink(const std::string &path)
int TryLockFile(const std::string &path)
bool MkdirDeep(const std::string &path, const mode_t mode, bool verify_writable)
int LockFile(const std::string &path)
string ResolvePath(const std::string &path)
std::string GetHomeDirectory()
void WaitForSignal(int signum)
bool GetGidOf(const std::string &groupname, gid_t *gid)
std::string CreateTempDir(const std::string &path_prefix)
bool HasPrefix(const string &str, const string &prefix, const bool ignore_case)
bool DirectoryExists(const std::string &path)
bool ExecuteBinary(int *fd_stdin, int *fd_stdout, int *fd_stderr, const std::string &binary_path, const std::vector< std::string > &argv, const bool double_fork, pid_t *child_pid)
bool RemoveTree(const std::string &path)
bool SafeReadToString(int fd, std::string *final_result)
bool CloseAllFildes(const std::set< int > &preserve_fildes)
int WritePidFile(const std::string &path)
int ConnectSocket(const std::string &path)
uint64_t String2Uint64(const string &value)
VoidCallback fn_new_socket
bool GetUidOf(const std::string &username, uid_t *uid, gid_t *main_gid)
std::vector< std::string > FindFilesByPrefix(const std::string &dir, const std::string &prefix)
bool SwitchCredentials(const uid_t uid, const gid_t gid, const bool temporarily)
std::string ReadSymlink(const std::string &path)
PathString GetParentPath(const PathString &path)
std::vector< LsofEntry > Lsof(const std::string &path)
BoolCallback fn_new_dir_prefix
bool ListDirectory(const std::string &directory, std::vector< std::string > *names, std::vector< mode_t > *modes)
int64_t GetFileSize(const std::string &path)
void SafeSleepMs(const unsigned ms)
bool DiffTree(const std::string &path_a, const std::string &path_b)
void SortTeam(std::vector< T > *tractor, std::vector< U > *towed)
static std::string ToString(const Names name)
void Block2Nonblock(int filedes)
bool IsAbsolutePath(const std::string &path)
bool ProcessExists(pid_t pid)
std::string MakeCanonicalPath(const std::string &path)
const char * c_str() const
void WritePipe(int fd, const void *buf, size_t nbyte)
std::string GetCurrentWorkingDirectory()
void ReadPipe(int fd, void *buf, size_t nbyte)
std::vector< std::string > FindFilesBySuffix(const std::string &dir, const std::string &suffix)
void ClosePipe(int pipe_fd[2])
bool IsMountPoint(const std::string &path)
int RecvFdFromSocket(int msg_fd)
bool SafeWriteV(int fd, struct iovec *iov, unsigned iovcnt)
void UnlockFile(const int filedes)
void BlockSignal(int signum)