version 1.13, 2017/02/04 12:03:07 |
version 1.25, 2025/06/29 23:21:07 |
|
|
*/ |
*/ |
#include "config.h" |
#include "config.h" |
|
|
|
#if NEED_XPG4_2 |
|
#define _XPG4_2 |
|
#endif |
|
|
#include <sys/types.h> |
#include <sys/types.h> |
#include <sys/socket.h> |
#include <sys/socket.h> |
#include <sys/stat.h> |
#include <sys/stat.h> |
|
|
#if HAVE_ERR |
#if HAVE_ERR |
#include <err.h> |
#include <err.h> |
#endif |
#endif |
|
#include <errno.h> |
#include <fcntl.h> |
#include <fcntl.h> |
#if HAVE_FTS |
#if HAVE_FTS |
#include <fts.h> |
#include <fts.h> |
|
|
#include <stdio.h> |
#include <stdio.h> |
#include <stdlib.h> |
#include <stdlib.h> |
#include <string.h> |
#include <string.h> |
|
#include <time.h> |
#include <unistd.h> |
#include <unistd.h> |
|
|
int process_manpage(int, int, const char *); |
int process_manpage(int, int, const char *); |
int process_tree(int, int); |
int process_tree(int, int); |
void run_mandocd(int, const char *) __attribute__((noreturn)); |
void run_mandocd(int, const char *, const char *) |
|
__attribute__((__noreturn__)); |
ssize_t sock_fd_write(int, int, int, int); |
ssize_t sock_fd_write(int, int, int, int); |
void usage(void) __attribute__((noreturn)); |
void usage(void) __attribute__((__noreturn__)); |
|
|
|
|
void |
void |
run_mandocd(int sockfd, const char *outtype) |
run_mandocd(int sockfd, const char *outtype, const char* defos) |
{ |
{ |
char sockfdstr[10]; |
char sockfdstr[10]; |
|
int len; |
|
|
if (snprintf(sockfdstr, sizeof(sockfdstr), "%d", sockfd) == -1) |
len = snprintf(sockfdstr, sizeof(sockfdstr), "%d", sockfd); |
|
if (len >= (int)sizeof(sockfdstr)) { |
|
errno = EOVERFLOW; |
|
len = -1; |
|
} |
|
if (len < 0) |
err(1, "snprintf"); |
err(1, "snprintf"); |
execlp("mandocd", "mandocd", "-T", outtype, sockfdstr, NULL); |
if (defos == NULL) |
err(1, "exec"); |
execlp("mandocd", "mandocd", "-T", outtype, |
|
sockfdstr, (char *)NULL); |
|
else |
|
execlp("mandocd", "mandocd", "-T", outtype, |
|
"-I", defos, sockfdstr, (char *)NULL); |
|
err(1, "exec(mandocd)"); |
} |
} |
|
|
ssize_t |
ssize_t |
sock_fd_write(int fd, int fd0, int fd1, int fd2) |
sock_fd_write(int fd, int fd0, int fd1, int fd2) |
{ |
{ |
|
const struct timespec timeout = { 0, 10000000 }; /* 0.01 s */ |
struct msghdr msg; |
struct msghdr msg; |
struct iovec iov; |
struct iovec iov; |
union { |
union { |
Line 64 sock_fd_write(int fd, int fd0, int fd1, int fd2) |
|
Line 83 sock_fd_write(int fd, int fd0, int fd1, int fd2) |
|
} cmsgu; |
} cmsgu; |
struct cmsghdr *cmsg; |
struct cmsghdr *cmsg; |
int *walk; |
int *walk; |
|
ssize_t sz; |
unsigned char dummy[1] = {'\0'}; |
unsigned char dummy[1] = {'\0'}; |
|
|
iov.iov_base = dummy; |
iov.iov_base = dummy; |
Line 87 sock_fd_write(int fd, int fd0, int fd1, int fd2) |
|
Line 107 sock_fd_write(int fd, int fd0, int fd1, int fd2) |
|
*(walk++) = fd1; |
*(walk++) = fd1; |
*(walk++) = fd2; |
*(walk++) = fd2; |
|
|
return sendmsg(fd, &msg, 0); |
/* |
|
* It appears that on some systems, sendmsg(3) |
|
* may return EAGAIN even in blocking mode. |
|
* Seen for example on Oracle Solaris 11.2. |
|
* The sleeping time was chosen by experimentation, |
|
* to neither cause more than a handful of retries |
|
* in normal operation nor unnecessary delays. |
|
*/ |
|
while ((sz = sendmsg(fd, &msg, 0)) == -1) { |
|
if (errno != EAGAIN) { |
|
warn("FATAL: sendmsg"); |
|
break; |
|
} |
|
nanosleep(&timeout, NULL); |
|
} |
|
return sz; |
} |
} |
|
|
int |
int |
process_manpage(int srv_fd, int dstdir_fd, const char *path) |
process_manpage(int srv_fd, int dstdir_fd, const char *path) |
{ |
{ |
int in_fd, out_fd; |
int in_fd, out_fd; |
|
int irc; |
|
|
if ((in_fd = open(path, O_RDONLY)) == -1) { |
if ((in_fd = open(path, O_RDONLY)) == -1) { |
warn("open(%s)", path); |
warn("open %s for reading", path); |
return -1; |
fflush(stderr); |
|
return 0; |
} |
} |
|
|
if ((out_fd = openat(dstdir_fd, path, |
if ((out_fd = openat(dstdir_fd, path, |
O_WRONLY | O_NOFOLLOW | O_CREAT | O_TRUNC, |
O_WRONLY | O_NOFOLLOW | O_CREAT | O_TRUNC, |
S_IRUSR | S_IWUSR | S_IRGRP | S_IRWXO)) == -1) { |
S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) == -1) { |
warn("openat(%s)", path); |
warn("openat %s for writing", path); |
|
fflush(stderr); |
close(in_fd); |
close(in_fd); |
return -1; |
return 0; |
} |
} |
|
|
if (sock_fd_write(srv_fd, in_fd, out_fd, STDERR_FILENO) < 0) { |
irc = sock_fd_write(srv_fd, in_fd, out_fd, STDERR_FILENO); |
warn("sendmsg"); |
|
return -1; |
|
} |
|
|
|
close(in_fd); |
close(in_fd); |
close(out_fd); |
close(out_fd); |
return 0; |
|
|
return irc; |
} |
} |
|
|
int |
int |
Line 125 process_tree(int srv_fd, int dstdir_fd) |
|
Line 161 process_tree(int srv_fd, int dstdir_fd) |
|
FTSENT *entry; |
FTSENT *entry; |
const char *argv[2]; |
const char *argv[2]; |
const char *path; |
const char *path; |
|
int fatal; |
|
int gooddirs, baddirs, goodfiles, badfiles; |
|
|
argv[0] = "."; |
argv[0] = "."; |
argv[1] = (char *)NULL; |
argv[1] = (char *)NULL; |
Line 135 process_tree(int srv_fd, int dstdir_fd) |
|
Line 173 process_tree(int srv_fd, int dstdir_fd) |
|
return -1; |
return -1; |
} |
} |
|
|
while ((entry = fts_read(ftsp)) != NULL) { |
fatal = 0; |
|
gooddirs = baddirs = goodfiles = badfiles = 0; |
|
while (fatal == 0 && (entry = fts_read(ftsp)) != NULL) { |
path = entry->fts_path + 2; |
path = entry->fts_path + 2; |
switch (entry->fts_info) { |
switch (entry->fts_info) { |
case FTS_F: |
case FTS_F: |
process_manpage(srv_fd, dstdir_fd, path); |
switch (process_manpage(srv_fd, dstdir_fd, path)) { |
|
case -1: |
|
fatal = errno; |
|
break; |
|
case 0: |
|
badfiles++; |
|
break; |
|
default: |
|
goodfiles++; |
|
break; |
|
} |
break; |
break; |
case FTS_D: |
case FTS_D: |
|
if (*path != '\0' && |
|
mkdirat(dstdir_fd, path, S_IRWXU | S_IRGRP | |
|
S_IXGRP | S_IROTH | S_IXOTH) == -1 && |
|
errno != EEXIST) { |
|
warn("mkdirat %s", path); |
|
fflush(stderr); |
|
(void)fts_set(ftsp, entry, FTS_SKIP); |
|
baddirs++; |
|
} else |
|
gooddirs++; |
|
break; |
case FTS_DP: |
case FTS_DP: |
break; |
break; |
|
case FTS_DNR: |
|
warnx("directory %s unreadable: %s", |
|
path, strerror(entry->fts_errno)); |
|
fflush(stderr); |
|
baddirs++; |
|
break; |
|
case FTS_DC: |
|
warnx("directory %s causes cycle", path); |
|
fflush(stderr); |
|
baddirs++; |
|
break; |
|
case FTS_ERR: |
|
case FTS_NS: |
|
warnx("file %s: %s", |
|
path, strerror(entry->fts_errno)); |
|
fflush(stderr); |
|
badfiles++; |
|
break; |
default: |
default: |
warnx("%s: not a regular file", path); |
warnx("file %s: not a regular file", path); |
|
fflush(stderr); |
|
badfiles++; |
break; |
break; |
} |
} |
} |
} |
|
if (fatal == 0 && (fatal = errno) != 0) |
|
warn("FATAL: fts_read"); |
|
|
fts_close(ftsp); |
fts_close(ftsp); |
|
if (baddirs > 0) |
|
warnx("skipped %d %s due to errors", baddirs, |
|
baddirs == 1 ? "directory" : "directories"); |
|
if (badfiles > 0) |
|
warnx("skipped %d %s due to errors", badfiles, |
|
badfiles == 1 ? "file" : "files"); |
|
if (fatal != 0) { |
|
warnx("processing aborted due to fatal error, " |
|
"results are probably incomplete"); |
|
} |
return 0; |
return 0; |
} |
} |
|
|
int |
int |
main(int argc, char **argv) |
main(int argc, char **argv) |
{ |
{ |
const char *outtype; |
const char *defos, *outtype; |
int srv_fds[2]; |
int srv_fds[2]; |
int dstdir_fd; |
int dstdir_fd; |
int opt; |
int opt; |
pid_t pid; |
pid_t pid; |
|
|
|
defos = NULL; |
outtype = "ascii"; |
outtype = "ascii"; |
while ((opt = getopt(argc, argv, "T:")) != -1) { |
while ((opt = getopt(argc, argv, "I:T:")) != -1) { |
switch (opt) { |
switch (opt) { |
|
case 'I': |
|
defos = optarg; |
|
break; |
case 'T': |
case 'T': |
outtype = optarg; |
outtype = optarg; |
break; |
break; |
Line 178 main(int argc, char **argv) |
|
Line 275 main(int argc, char **argv) |
|
argc -= optind; |
argc -= optind; |
argv += optind; |
argv += optind; |
} |
} |
if (argc != 2) |
if (argc != 2) { |
|
switch (argc) { |
|
case 0: |
|
warnx("missing arguments: srcdir and dstdir"); |
|
break; |
|
case 1: |
|
warnx("missing argument: dstdir"); |
|
break; |
|
default: |
|
warnx("too many arguments: %s", argv[2]); |
|
break; |
|
} |
usage(); |
usage(); |
|
} |
|
|
if (socketpair(AF_LOCAL, SOCK_STREAM, AF_UNSPEC, srv_fds) == -1) |
if (socketpair(AF_LOCAL, SOCK_STREAM, AF_UNSPEC, srv_fds) == -1) |
err(1, "socketpair"); |
err(1, "socketpair"); |
Line 190 main(int argc, char **argv) |
|
Line 299 main(int argc, char **argv) |
|
err(1, "fork"); |
err(1, "fork"); |
case 0: |
case 0: |
close(srv_fds[0]); |
close(srv_fds[0]); |
run_mandocd(srv_fds[1], outtype); |
run_mandocd(srv_fds[1], outtype, defos); |
default: |
default: |
break; |
break; |
} |
} |
close(srv_fds[1]); |
close(srv_fds[1]); |
|
|
if ((dstdir_fd = open(argv[1], O_RDONLY | O_DIRECTORY)) == -1) |
if ((dstdir_fd = open(argv[1], O_RDONLY | O_DIRECTORY)) == -1) |
err(1, "open(%s)", argv[1]); |
err(1, "open destination %s", argv[1]); |
|
|
if (chdir(argv[0]) == -1) |
if (chdir(argv[0]) == -1) |
err(1, "chdir(%s)", argv[0]); |
err(1, "chdir to source %s", argv[0]); |
|
|
return process_tree(srv_fds[0], dstdir_fd) == -1 ? 1 : 0; |
return process_tree(srv_fds[0], dstdir_fd) == -1 ? 1 : 0; |
} |
} |
Line 208 main(int argc, char **argv) |
|
Line 317 main(int argc, char **argv) |
|
void |
void |
usage(void) |
usage(void) |
{ |
{ |
fprintf(stderr, "usage: catman [-T output] srcdir dstdir\n"); |
fprintf(stderr, "usage: %s [-I os=name] [-T output] " |
|
"srcdir dstdir\n", BINM_CATMAN); |
exit(1); |
exit(1); |
} |
} |