aboutsummaryrefslogtreecommitdiff
path: root/runcap.c
diff options
context:
space:
mode:
authorSergey Poznyakoff <gray@gnu.org.ua>2017-07-19 11:29:27 +0300
committerSergey Poznyakoff <gray@gnu.org.ua>2017-07-19 11:29:27 +0300
commit651babfefa21536112cbcd799932b3595aeb2da4 (patch)
tree6922b7ea70642f4ce7a8cb97f01e62115e97d940 /runcap.c
parent3e59cfb01443a14962547ed75bbbaaefa25a7633 (diff)
downloadruncap-651babfefa21536112cbcd799932b3595aeb2da4.tar.gz
runcap-651babfefa21536112cbcd799932b3595aeb2da4.tar.bz2
Rename struct filecapture to stream_capture; portability fixes
Diffstat (limited to 'runcap.c')
-rw-r--r--runcap.c232
1 files changed, 116 insertions, 116 deletions
diff --git a/runcap.c b/runcap.c
index 9abc492..de2f3a6 100644
--- a/runcap.c
+++ b/runcap.c
@@ -27,66 +27,66 @@
#include "runcap.h"
static int
-filecapture_alloc(struct filecapture *fc, size_t size)
+stream_capture_alloc(struct stream_capture *cap, size_t size)
{
if (size) {
- fc->fc_base = malloc(size);
- if (!fc->fc_base)
+ cap->sc_base = malloc(size);
+ if (!cap->sc_base)
return -1;
} else
- fc->fc_base = NULL;
- fc->fc_size = size;
- fc->fc_leng = 0;
- fc->fc_level = 0;
- fc->fc_nlines = 0;
- fc->fc_cur = 0;
- fc->fc_tmpfd = -1;
- fc->fc_fd = -1;
+ cap->sc_base = NULL;
+ cap->sc_size = size;
+ cap->sc_leng = 0;
+ cap->sc_level = 0;
+ cap->sc_nlines = 0;
+ cap->sc_cur = 0;
+ cap->sc_storfd = -1;
+ cap->sc_fd = -1;
return 0;
}
int
-filecapture_init(struct filecapture *fc, size_t size)
+stream_capture_init(struct stream_capture *cap, size_t size)
{
- if (!fc) {
+ if (!cap) {
errno = EINVAL;
return -1;
}
- if (filecapture_alloc(fc, size))
+ if (stream_capture_alloc(cap, size))
return -1;
return 0;
}
static void
-filecapture_reset(struct filecapture *fc)
+stream_capture_reset(struct stream_capture *cap)
{
- fc->fc_leng = 0;
- fc->fc_level = 0;
- fc->fc_nlines = 0;
- fc->fc_cur = 0;
-
- if (fc->fc_tmpfd >= 0) {
- close(fc->fc_tmpfd);
- fc->fc_tmpfd = -1;
+ cap->sc_leng = 0;
+ cap->sc_level = 0;
+ cap->sc_nlines = 0;
+ cap->sc_cur = 0;
+
+ if (cap->sc_storfd >= 0) {
+ close(cap->sc_storfd);
+ cap->sc_storfd = -1;
}
- if (fc->fc_fd >= 0) {
- close(fc->fc_fd);
- fc->fc_fd = -1;
+ if (cap->sc_fd >= 0) {
+ close(cap->sc_fd);
+ cap->sc_fd = -1;
}
}
void
-filecapture_free(struct filecapture *fc)
+stream_capture_free(struct stream_capture *cap)
{
- filecapture_reset(fc);
- free(fc->fc_base);
- fc->fc_base = NULL;
- fc->fc_size = 0;
+ stream_capture_reset(cap);
+ free(cap->sc_base);
+ cap->sc_base = NULL;
+ cap->sc_size = 0;
- fc->fc_linemon = NULL;
- fc->fc_monarg = NULL;
+ cap->sc_linemon = NULL;
+ cap->sc_monarg = NULL;
}
static int
@@ -107,41 +107,41 @@ full_write(int fd, char *buf, size_t size)
}
static int
-filecapture_flush(struct filecapture *fc)
+stream_capture_flush(struct stream_capture *cap)
{
int res;
- if (fc->fc_level == 0)
+ if (cap->sc_level == 0)
return 0;
- if (fc->fc_tmpfd == -1) {
+ if (cap->sc_storfd == -1) {
int fd;
char tmpl[] = "/tmp/rcXXXXXX";
fd = mkstemp(tmpl);
if (fd == -1)
return -1;
unlink(tmpl);
- fc->fc_tmpfd = fd;
+ cap->sc_storfd = fd;
}
- res = full_write(fc->fc_tmpfd, fc->fc_base, fc->fc_level);
+ res = full_write(cap->sc_storfd, cap->sc_base, cap->sc_level);
if (res)
return -1;
- fc->fc_level = 0;
- fc->fc_cur = 0;
+ cap->sc_level = 0;
+ cap->sc_cur = 0;
return 0;
}
static int
-filecapture_get(struct filecapture *fc, int *feof)
+stream_capture_get(struct stream_capture *cap, int *feof)
{
char c;
int rc;
- if (fc->fc_level == fc->fc_size) {
- if (filecapture_flush(fc))
+ if (cap->sc_level == cap->sc_size) {
+ if (stream_capture_flush(cap))
return -1;
}
- rc = read(fc->fc_fd, &c, 1);
+ rc = read(cap->sc_fd, &c, 1);
if (rc == -1)
return -1;
if (rc == 0) {
@@ -149,43 +149,43 @@ filecapture_get(struct filecapture *fc, int *feof)
return 0;
} else
*feof = 0;
- fc->fc_base[fc->fc_level] = c;
- fc->fc_level++;
- fc->fc_leng++;
+ cap->sc_base[cap->sc_level] = c;
+ cap->sc_level++;
+ cap->sc_leng++;
if (c == '\n') {
- if (fc->fc_linemon)
- fc->fc_linemon(fc->fc_base + fc->fc_cur,
- fc->fc_level - fc->fc_cur,
- fc->fc_monarg);
- fc->fc_cur = fc->fc_level;
- fc->fc_nlines++;
+ if (cap->sc_linemon)
+ cap->sc_linemon(cap->sc_base + cap->sc_cur,
+ cap->sc_level - cap->sc_cur,
+ cap->sc_monarg);
+ cap->sc_cur = cap->sc_level;
+ cap->sc_nlines++;
}
return 0;
}
static int
-filecapture_put(struct filecapture *fc, int *feof)
+stream_capture_put(struct stream_capture *cap, int *feof)
{
- if (fc->fc_cur < fc->fc_level) {
- int n = write(fc->fc_fd, &fc->fc_base[fc->fc_cur], 1);
+ if (cap->sc_cur < cap->sc_level) {
+ int n = write(cap->sc_fd, &cap->sc_base[cap->sc_cur], 1);
if (n == -1)
return -1;
if (n == 0) {
errno = ENOSPC;
return -1;
}
- fc->fc_cur++;
+ cap->sc_cur++;
}
- *feof = fc->fc_cur == fc->fc_level;
+ *feof = cap->sc_cur == cap->sc_level;
return 0;
}
void
runcap_free(struct runcap *rc)
{
- filecapture_free(&rc->rc_cap[RUNCAP_STDIN]);
- filecapture_free(&rc->rc_cap[RUNCAP_STDOUT]);
- filecapture_free(&rc->rc_cap[RUNCAP_STDERR]);
+ stream_capture_free(&rc->rc_cap[RUNCAP_STDIN]);
+ stream_capture_free(&rc->rc_cap[RUNCAP_STDOUT]);
+ stream_capture_free(&rc->rc_cap[RUNCAP_STDERR]);
}
static inline int
@@ -219,7 +219,7 @@ runcap_start(struct runcap *rc)
int i;
for (i = 0; i < RUNCAP_NBUF; i++)
- if (rc->rc_cap[i].fc_size) {
+ if (rc->rc_cap[i].sc_size) {
if (pipe(p[i])) {
goto err;
}
@@ -230,8 +230,8 @@ runcap_start(struct runcap *rc)
if (p[RUNCAP_STDIN][0] >= 0) {
dup2(p[RUNCAP_STDIN][0], RUNCAP_STDIN);
close(p[RUNCAP_STDIN][1]);
- } else if (rc->rc_cap[RUNCAP_STDIN].fc_fd >= 0) {
- dup2(rc->rc_cap[RUNCAP_STDIN].fc_fd, RUNCAP_STDIN);
+ } else if (rc->rc_cap[RUNCAP_STDIN].sc_fd >= 0) {
+ dup2(rc->rc_cap[RUNCAP_STDIN].sc_fd, RUNCAP_STDIN);
}
if (p[RUNCAP_STDOUT][0] >= 0) {
@@ -263,15 +263,15 @@ runcap_start(struct runcap *rc)
default:
if (p[RUNCAP_STDIN][0] >= 0) {
close(p[RUNCAP_STDIN][0]);
- rc->rc_cap[RUNCAP_STDIN].fc_fd = p[RUNCAP_STDIN][1];
+ rc->rc_cap[RUNCAP_STDIN].sc_fd = p[RUNCAP_STDIN][1];
}
if (p[RUNCAP_STDOUT][0] >= 0) {
close(p[RUNCAP_STDOUT][1]);
- rc->rc_cap[RUNCAP_STDOUT].fc_fd = p[RUNCAP_STDOUT][0];
+ rc->rc_cap[RUNCAP_STDOUT].sc_fd = p[RUNCAP_STDOUT][0];
}
if (p[RUNCAP_STDERR][0] >= 0) {
close(p[RUNCAP_STDERR][1]);
- rc->rc_cap[RUNCAP_STDERR].fc_fd = p[RUNCAP_STDERR][0];
+ rc->rc_cap[RUNCAP_STDERR].sc_fd = p[RUNCAP_STDERR][0];
}
return 0;
}
@@ -302,20 +302,20 @@ runcap_loop(struct runcap *rc)
FD_ZERO(&rds);
FD_ZERO(&wrs);
- if (rc->rc_cap[RUNCAP_STDIN].fc_size
- && rc->rc_cap[RUNCAP_STDIN].fc_fd >= 0) {
- nfd = rc->rc_cap[RUNCAP_STDIN].fc_fd;
- FD_SET(rc->rc_cap[RUNCAP_STDIN].fc_fd, &wrs);
+ if (rc->rc_cap[RUNCAP_STDIN].sc_size
+ && rc->rc_cap[RUNCAP_STDIN].sc_fd >= 0) {
+ nfd = rc->rc_cap[RUNCAP_STDIN].sc_fd;
+ FD_SET(rc->rc_cap[RUNCAP_STDIN].sc_fd, &wrs);
}
- if (rc->rc_cap[RUNCAP_STDOUT].fc_fd >= 0) {
- if (rc->rc_cap[RUNCAP_STDOUT].fc_fd > nfd)
- nfd = rc->rc_cap[RUNCAP_STDOUT].fc_fd;
- FD_SET(rc->rc_cap[RUNCAP_STDOUT].fc_fd, &rds);
+ if (rc->rc_cap[RUNCAP_STDOUT].sc_fd >= 0) {
+ if (rc->rc_cap[RUNCAP_STDOUT].sc_fd > nfd)
+ nfd = rc->rc_cap[RUNCAP_STDOUT].sc_fd;
+ FD_SET(rc->rc_cap[RUNCAP_STDOUT].sc_fd, &rds);
}
- if (rc->rc_cap[RUNCAP_STDERR].fc_fd >= 0) {
- if (rc->rc_cap[RUNCAP_STDERR].fc_fd > nfd)
- nfd = rc->rc_cap[RUNCAP_STDERR].fc_fd;
- FD_SET(rc->rc_cap[RUNCAP_STDERR].fc_fd, &rds);
+ if (rc->rc_cap[RUNCAP_STDERR].sc_fd >= 0) {
+ if (rc->rc_cap[RUNCAP_STDERR].sc_fd > nfd)
+ nfd = rc->rc_cap[RUNCAP_STDERR].sc_fd;
+ FD_SET(rc->rc_cap[RUNCAP_STDERR].sc_fd, &rds);
}
nfd++;
@@ -369,39 +369,39 @@ runcap_loop(struct runcap *rc)
continue;
}
- if (rc->rc_cap[RUNCAP_STDIN].fc_fd >= 0
- && FD_ISSET(rc->rc_cap[RUNCAP_STDIN].fc_fd, &wrs)) {
- if (filecapture_put(&rc->rc_cap[RUNCAP_STDIN], &eof)) {
+ if (rc->rc_cap[RUNCAP_STDIN].sc_fd >= 0
+ && FD_ISSET(rc->rc_cap[RUNCAP_STDIN].sc_fd, &wrs)) {
+ if (stream_capture_put(&rc->rc_cap[RUNCAP_STDIN], &eof)) {
rc->rc_errno = errno;
break;
}
if (eof) {
/* FIXME: */
- close(rc->rc_cap[RUNCAP_STDIN].fc_fd);
- rc->rc_cap[RUNCAP_STDIN].fc_fd = -1;
+ close(rc->rc_cap[RUNCAP_STDIN].sc_fd);
+ rc->rc_cap[RUNCAP_STDIN].sc_fd = -1;
}
}
- if (rc->rc_cap[RUNCAP_STDOUT].fc_fd >= 0
- && FD_ISSET(rc->rc_cap[RUNCAP_STDOUT].fc_fd, &rds)) {
- if (filecapture_get(&rc->rc_cap[RUNCAP_STDOUT], &eof)) {
+ if (rc->rc_cap[RUNCAP_STDOUT].sc_fd >= 0
+ && FD_ISSET(rc->rc_cap[RUNCAP_STDOUT].sc_fd, &rds)) {
+ if (stream_capture_get(&rc->rc_cap[RUNCAP_STDOUT], &eof)) {
rc->rc_errno = errno;
break;
}
if (eof) {
- close(rc->rc_cap[RUNCAP_STDOUT].fc_fd);
- rc->rc_cap[RUNCAP_STDOUT].fc_fd = -1;
+ close(rc->rc_cap[RUNCAP_STDOUT].sc_fd);
+ rc->rc_cap[RUNCAP_STDOUT].sc_fd = -1;
}
}
- if (rc->rc_cap[RUNCAP_STDERR].fc_fd >= 0
- && FD_ISSET(rc->rc_cap[RUNCAP_STDERR].fc_fd, &rds)) {
- if (filecapture_get(&rc->rc_cap[RUNCAP_STDERR], &eof)) {
+ if (rc->rc_cap[RUNCAP_STDERR].sc_fd >= 0
+ && FD_ISSET(rc->rc_cap[RUNCAP_STDERR].sc_fd, &rds)) {
+ if (stream_capture_get(&rc->rc_cap[RUNCAP_STDERR], &eof)) {
rc->rc_errno = errno;
break;
}
if (eof) {
- close(rc->rc_cap[RUNCAP_STDERR].fc_fd);
- rc->rc_cap[RUNCAP_STDERR].fc_fd = -1;
+ close(rc->rc_cap[RUNCAP_STDERR].sc_fd);
+ rc->rc_cap[RUNCAP_STDERR].sc_fd = -1;
}
}
}
@@ -423,41 +423,41 @@ runcap_init(struct runcap *rc, int flags)
if (!(flags & RCF_TIMEOUT))
rc->rc_timeout = 0;
if (flags & RCF_STDIN) {
- if (rc->rc_cap[RUNCAP_STDIN].fc_size > 0
- && rc->rc_cap[RUNCAP_STDIN].fc_fd != -1) {
+ if (rc->rc_cap[RUNCAP_STDIN].sc_size > 0
+ && rc->rc_cap[RUNCAP_STDIN].sc_fd != -1) {
errno = EINVAL;
return -1;
}
- rc->rc_cap[RUNCAP_STDIN].fc_level =
- rc->rc_cap[RUNCAP_STDIN].fc_size;
- rc->rc_cap[RUNCAP_STDIN].fc_cur = 0;
- } else if (filecapture_init(&rc->rc_cap[RUNCAP_STDIN], 0))
+ rc->rc_cap[RUNCAP_STDIN].sc_level =
+ rc->rc_cap[RUNCAP_STDIN].sc_size;
+ rc->rc_cap[RUNCAP_STDIN].sc_cur = 0;
+ } else if (stream_capture_init(&rc->rc_cap[RUNCAP_STDIN], 0))
return -1;
if (flags & RCF_STDOUT_SIZE)
- res = filecapture_alloc(&rc->rc_cap[RUNCAP_STDOUT],
- rc->rc_cap[RUNCAP_STDOUT].fc_size);
+ res = stream_capture_alloc(&rc->rc_cap[RUNCAP_STDOUT],
+ rc->rc_cap[RUNCAP_STDOUT].sc_size);
else
- res = filecapture_init(&rc->rc_cap[RUNCAP_STDOUT], FC_BUFSIZE);
+ res = stream_capture_init(&rc->rc_cap[RUNCAP_STDOUT], STRCAP_BUFSIZE);
if (res)
return res;
if (!(flags & RCF_STDOUT_LINEMON)) {
- rc->rc_cap[RUNCAP_STDOUT].fc_linemon = NULL;
- rc->rc_cap[RUNCAP_STDOUT].fc_monarg = NULL;
+ rc->rc_cap[RUNCAP_STDOUT].sc_linemon = NULL;
+ rc->rc_cap[RUNCAP_STDOUT].sc_monarg = NULL;
}
if (flags & RCF_STDERR_SIZE)
- res = filecapture_alloc(&rc->rc_cap[RUNCAP_STDERR],
- rc->rc_cap[RUNCAP_STDERR].fc_size);
+ res = stream_capture_alloc(&rc->rc_cap[RUNCAP_STDERR],
+ rc->rc_cap[RUNCAP_STDERR].sc_size);
else
- res = filecapture_init(&rc->rc_cap[RUNCAP_STDERR], FC_BUFSIZE);
+ res = stream_capture_init(&rc->rc_cap[RUNCAP_STDERR], STRCAP_BUFSIZE);
if (res)
return res;
if (!(flags & RCF_STDERR_LINEMON)) {
- rc->rc_cap[RUNCAP_STDERR].fc_linemon = NULL;
- rc->rc_cap[RUNCAP_STDERR].fc_monarg = NULL;
+ rc->rc_cap[RUNCAP_STDERR].sc_linemon = NULL;
+ rc->rc_cap[RUNCAP_STDERR].sc_monarg = NULL;
}
rc->rc_pid = (pid_t) -1;
@@ -516,13 +516,13 @@ runcap(struct runcap *rc, int flags)
runcap_loop(rc);
restore_signals(NUMSIGNALS, sig, oldact);
if (rc->rc_errno == 0) {
- if (rc->rc_cap[RUNCAP_STDOUT].fc_tmpfd != -1) {
- filecapture_flush(&rc->rc_cap[RUNCAP_STDOUT]);
- lseek(rc->rc_cap[RUNCAP_STDOUT].fc_tmpfd, 0, SEEK_SET);
+ if (rc->rc_cap[RUNCAP_STDOUT].sc_storfd != -1) {
+ stream_capture_flush(&rc->rc_cap[RUNCAP_STDOUT]);
+ lseek(rc->rc_cap[RUNCAP_STDOUT].sc_storfd, 0, SEEK_SET);
}
- if (rc->rc_cap[RUNCAP_STDERR].fc_tmpfd != -1) {
- filecapture_flush(&rc->rc_cap[RUNCAP_STDERR]);
- lseek(rc->rc_cap[RUNCAP_STDERR].fc_tmpfd, 0, SEEK_SET);
+ if (rc->rc_cap[RUNCAP_STDERR].sc_storfd != -1) {
+ stream_capture_flush(&rc->rc_cap[RUNCAP_STDERR]);
+ lseek(rc->rc_cap[RUNCAP_STDERR].sc_storfd, 0, SEEK_SET);
}
}
return rc->rc_errno == 0 ? 0 : -1;

Return to:

Send suggestions and report system problems to the System administrator.