( )⚙ D5675 cleanup: use clang-tidy to add missing {} around one-line statements

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5675

cleanup: use clang-tidy to add missing {} around one-line statements
ClosedPublic

Authored by durin42 on Jan 24 2019, 10:22 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHG763b45bc4483: cleanup: use clang-tidy to add missing {} around one-line statements
Summary

I find this easier to read. Cleanup performed like this:

hg files 'set:(.c or .cc or **.h) and not "listfile:contrib/clang-format-ignorelist"' | while read f ; do

clang-tidy -fix -checks=readability-braces-around-statements $f -- $(python-config --cflags) -Imercurial/cext -Imercurial

done
make format-c

I had to revert chg/chg.c as it's got a construct that seems to confuse
clang-tidy, so I'll work on that file later if this change is acceptable. I
only tackle files that are under clang-format's authority because otherwise
I'd have to do a bunch of manual formatting. A few files didn't get edited
because clang-tidy couldn't find some headers. Again, I'll figure that out
later assuming this change is accepted.

No check-code rule added for now because writing the regex sounds hard. In a
perfect world I guess we could write a test that uses clang-tidy on these
files, but I think clang-tidy is pretty rarely installed. :/

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

durin42 created this revision.Jan 24 2019, 10:22 AM
durin42 edited the summary of this revision. (Show Details)Jan 24 2019, 10:27 AM
durin42 updated this revision to Diff 13395.
pulkit accepted this revision.Jan 24 2019, 11:52 AM
Closed by commit rHG763b45bc4483: cleanup: use clang-tidy to add missing {} around one-line statements (authored by durin42). · Explain WhyJan 24 2019, 12:03 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mcontrib/chg/hgclient.c (105 lines)
Mcontrib/chg/procutil.c (116 lines)
Mcontrib/chg/util.c (66 lines)
Mmercurial/bdiff.c (74 lines)
Mmercurial/mpatch.c (33 lines)
Mrust/chg/src/sighandlers.c (74 lines)

Diff 13394

contrib/chg/hgclient.c

ctx->data = malloc(defaultdatasize); ctx->data = malloc(defaultdatasize);
ctx->maxdatasize = (ctx->data) ? defaultdatasize : 0; ctx->maxdatasize = (ctx->data) ? defaultdatasize : 0;
ctx->datasize = 0; ctx->datasize = 0;
debugmsg("initialize context buffer with size %zu", ctx->maxdatasize); debugmsg("initialize context buffer with size %zu", ctx->maxdatasize);
} }
static void enlargecontext(context_t *ctx, size_t newsize) static void enlargecontext(context_t *ctx, size_t newsize)
{ {
if (newsize <= ctx->maxdatasize) if (newsize <= ctx->maxdatasize) {
return; return;
}
newsize = defaultdatasize * newsize = defaultdatasize *
((newsize + defaultdatasize - 1) / defaultdatasize); ((newsize + defaultdatasize - 1) / defaultdatasize);
ctx->data = reallocx(ctx->data, newsize); ctx->data = reallocx(ctx->data, newsize);
ctx->maxdatasize = newsize; ctx->maxdatasize = newsize;
debugmsg("enlarge context buffer to %zu", ctx->maxdatasize); debugmsg("enlarge context buffer to %zu", ctx->maxdatasize);
} }
if (rsize != sizeof(hgc->ctx.ch)) { if (rsize != sizeof(hgc->ctx.ch)) {
/* server would have exception and traceback would be printed */ /* server would have exception and traceback would be printed */
debugmsg("failed to read channel"); debugmsg("failed to read channel");
exit(255); exit(255);
} }
uint32_t datasize_n; uint32_t datasize_n;
rsize = recv(hgc->sockfd, &datasize_n, sizeof(datasize_n), 0); rsize = recv(hgc->sockfd, &datasize_n, sizeof(datasize_n), 0);
if (rsize != sizeof(datasize_n)) if (rsize != sizeof(datasize_n)) {
abortmsg("failed to read data size"); abortmsg("failed to read data size");
}
/* datasize denotes the maximum size to write if input request */ /* datasize denotes the maximum size to write if input request */
hgc->ctx.datasize = ntohl(datasize_n); hgc->ctx.datasize = ntohl(datasize_n);
enlargecontext(&hgc->ctx, hgc->ctx.datasize); enlargecontext(&hgc->ctx, hgc->ctx.datasize);
if (isupper(hgc->ctx.ch) && hgc->ctx.ch != 'S') if (isupper(hgc->ctx.ch) && hgc->ctx.ch != 'S') {
return; /* assumes input request */ return; /* assumes input request */
}
size_t cursize = 0; size_t cursize = 0;
while (cursize < hgc->ctx.datasize) { while (cursize < hgc->ctx.datasize) {
rsize = recv(hgc->sockfd, hgc->ctx.data + cursize, rsize = recv(hgc->sockfd, hgc->ctx.data + cursize,
hgc->ctx.datasize - cursize, 0); hgc->ctx.datasize - cursize, 0);
if (rsize < 1) if (rsize < 1) {
abortmsg("failed to read data block"); abortmsg("failed to read data block");
}
cursize += rsize; cursize += rsize;
} }
} }
static void sendall(int sockfd, const void *data, size_t datasize) static void sendall(int sockfd, const void *data, size_t datasize)
{ {
const char *p = data; const char *p = data;
const char *const endp = p + datasize; const char *const endp = p + datasize;
while (p < endp) { while (p < endp) {
ssize_t r = send(sockfd, p, endp - p, 0); ssize_t r = send(sockfd, p, endp - p, 0);
if (r < 0) if (r < 0) {
abortmsgerrno("cannot communicate"); abortmsgerrno("cannot communicate");
}
p += r; p += r;
} }
} }
/* Write lengh-data block to cmdserver */ /* Write lengh-data block to cmdserver */
static void writeblock(const hgclient_t *hgc) static void writeblock(const hgclient_t *hgc)
{ {
assert(hgc); assert(hgc);
const char *const *const end = (argsize >= 0) ? args + argsize : NULL; const char *const *const end = (argsize >= 0) ? args + argsize : NULL;
for (const char *const *it = args; it != end && *it; ++it) { for (const char *const *it = args; it != end && *it; ++it) {
const size_t n = strlen(*it) + 1; /* include '\0' */ const size_t n = strlen(*it) + 1; /* include '\0' */
enlargecontext(ctx, ctx->datasize + n); enlargecontext(ctx, ctx->datasize + n);
memcpy(ctx->data + ctx->datasize, *it, n); memcpy(ctx->data + ctx->datasize, *it, n);
ctx->datasize += n; ctx->datasize += n;
} }
if (ctx->datasize > 0) if (ctx->datasize > 0) {
--ctx->datasize; /* strip last '\0' */ --ctx->datasize; /* strip last '\0' */
} }
}
/* Extract '\0'-separated list of args to new buffer, terminated by NULL */ /* Extract '\0'-separated list of args to new buffer, terminated by NULL */
static const char **unpackcmdargsnul(const context_t *ctx) static const char **unpackcmdargsnul(const context_t *ctx)
{ {
const char **args = NULL; const char **args = NULL;
size_t nargs = 0, maxnargs = 0; size_t nargs = 0, maxnargs = 0;
const char *s = ctx->data; const char *s = ctx->data;
const char *e = ctx->data + ctx->datasize; const char *e = ctx->data + ctx->datasize;
for (;;) { for (;;) {
if (nargs + 1 >= maxnargs) { /* including last NULL */ if (nargs + 1 >= maxnargs) { /* including last NULL */
maxnargs += 256; maxnargs += 256;
args = reallocx(args, maxnargs * sizeof(args[0])); args = reallocx(args, maxnargs * sizeof(args[0]));
} }
args[nargs] = s; args[nargs] = s;
nargs++; nargs++;
s = memchr(s, '\0', e - s); s = memchr(s, '\0', e - s);
if (!s) if (!s) {
break; break;
}
s++; s++;
} }
args[nargs] = NULL; args[nargs] = NULL;
return args; return args;
} }
static void handlereadrequest(hgclient_t *hgc) static void handlereadrequest(hgclient_t *hgc)
{ {
context_t *ctx = &hgc->ctx; context_t *ctx = &hgc->ctx;
size_t r = fread(ctx->data, sizeof(ctx->data[0]), ctx->datasize, stdin); size_t r = fread(ctx->data, sizeof(ctx->data[0]), ctx->datasize, stdin);
ctx->datasize = r; ctx->datasize = r;
writeblock(hgc); writeblock(hgc);
} }
/* Read single-line */ /* Read single-line */
static void handlereadlinerequest(hgclient_t *hgc) static void handlereadlinerequest(hgclient_t *hgc)
{ {
context_t *ctx = &hgc->ctx; context_t *ctx = &hgc->ctx;
if (!fgets(ctx->data, ctx->datasize, stdin)) if (!fgets(ctx->data, ctx->datasize, stdin)) {
ctx->data[0] = '\0'; ctx->data[0] = '\0';
}
ctx->datasize = strlen(ctx->data); ctx->datasize = strlen(ctx->data);
writeblock(hgc); writeblock(hgc);
} }
/* Execute the requested command and write exit code */ /* Execute the requested command and write exit code */
static void handlesystemrequest(hgclient_t *hgc) static void handlesystemrequest(hgclient_t *hgc)
{ {
context_t *ctx = &hgc->ctx; context_t *ctx = &hgc->ctx;
enlargecontext(ctx, ctx->datasize + 1); enlargecontext(ctx, ctx->datasize + 1);
ctx->data[ctx->datasize] = '\0'; /* terminate last string */ ctx->data[ctx->datasize] = '\0'; /* terminate last string */
const char **args = unpackcmdargsnul(ctx); const char **args = unpackcmdargsnul(ctx);
if (!args[0] || !args[1] || !args[2]) if (!args[0] || !args[1] || !args[2]) {
abortmsg("missing type or command or cwd in system request"); abortmsg("missing type or command or cwd in system request");
}
if (strcmp(args[0], "system") == 0) { if (strcmp(args[0], "system") == 0) {
debugmsg("run '%s' at '%s'", args[1], args[2]); debugmsg("run '%s' at '%s'", args[1], args[2]);
int32_t r = runshellcmd(args[1], args + 3, args[2]); int32_t r = runshellcmd(args[1], args + 3, args[2]);
free(args); free(args);
uint32_t r_n = htonl(r); uint32_t r_n = htonl(r);
memcpy(ctx->data, &r_n, sizeof(r_n)); memcpy(ctx->data, &r_n, sizeof(r_n));
ctx->datasize = sizeof(r_n); ctx->datasize = sizeof(r_n);
writeblock(hgc); writeblock(hgc);
} else if (strcmp(args[0], "pager") == 0) { } else if (strcmp(args[0], "pager") == 0) {
setuppager(args[1], args + 3); setuppager(args[1], args + 3);
if (hgc->capflags & CAP_ATTACHIO) if (hgc->capflags & CAP_ATTACHIO) {
attachio(hgc); attachio(hgc);
}
/* unblock the server */ /* unblock the server */
static const char emptycmd[] = "\n"; static const char emptycmd[] = "\n";
sendall(hgc->sockfd, emptycmd, sizeof(emptycmd) - 1); sendall(hgc->sockfd, emptycmd, sizeof(emptycmd) - 1);
} else { } else {
abortmsg("unknown type in system request: %s", args[0]); abortmsg("unknown type in system request: %s", args[0]);
} }
} }
break; break;
case 'L': case 'L':
handlereadlinerequest(hgc); handlereadlinerequest(hgc);
break; break;
case 'S': case 'S':
handlesystemrequest(hgc); handlesystemrequest(hgc);
break; break;
default: default:
if (isupper(ctx->ch)) if (isupper(ctx->ch)) {
abortmsg("cannot handle response (ch = %c)", abortmsg("cannot handle response (ch = %c)",
ctx->ch); ctx->ch);
} }
} }
} }
}
static unsigned int parsecapabilities(const char *s, const char *e) static unsigned int parsecapabilities(const char *s, const char *e)
{ {
unsigned int flags = 0; unsigned int flags = 0;
while (s < e) { while (s < e) {
const char *t = strchr(s, ' '); const char *t = strchr(s, ' ');
if (!t || t > e) if (!t || t > e) {
t = e; t = e;
}
const cappair_t *cap; const cappair_t *cap;
for (cap = captable; cap->flag; ++cap) { for (cap = captable; cap->flag; ++cap) {
size_t n = t - s; size_t n = t - s;
if (strncmp(s, cap->name, n) == 0 && if (strncmp(s, cap->name, n) == 0 &&
strlen(cap->name) == n) { strlen(cap->name) == n) {
flags |= cap->flag; flags |= cap->flag;
break; break;
} }
enlargecontext(ctx, ctx->datasize + 1); enlargecontext(ctx, ctx->datasize + 1);
ctx->data[ctx->datasize] = '\0'; ctx->data[ctx->datasize] = '\0';
debugmsg("hello received: %s (size = %zu)", ctx->data, ctx->datasize); debugmsg("hello received: %s (size = %zu)", ctx->data, ctx->datasize);
const char *s = ctx->data; const char *s = ctx->data;
const char *const dataend = ctx->data + ctx->datasize; const char *const dataend = ctx->data + ctx->datasize;
while (s < dataend) { while (s < dataend) {
const char *t = strchr(s, ':'); const char *t = strchr(s, ':');
if (!t || t[1] != ' ') if (!t || t[1] != ' ') {
break; break;
}
const char *u = strchr(t + 2, '\n'); const char *u = strchr(t + 2, '\n');
if (!u) if (!u) {
u = dataend; u = dataend;
}
if (strncmp(s, "capabilities:", t - s + 1) == 0) { if (strncmp(s, "capabilities:", t - s + 1) == 0) {
hgc->capflags = parsecapabilities(t + 2, u); hgc->capflags = parsecapabilities(t + 2, u);
} else if (strncmp(s, "pgid:", t - s + 1) == 0) { } else if (strncmp(s, "pgid:", t - s + 1) == 0) {
hgc->pgid = strtol(t + 2, NULL, 10); hgc->pgid = strtol(t + 2, NULL, 10);
} else if (strncmp(s, "pid:", t - s + 1) == 0) { } else if (strncmp(s, "pid:", t - s + 1) == 0) {
hgc->pid = strtol(t + 2, NULL, 10); hgc->pid = strtol(t + 2, NULL, 10);
} }
s = u + 1; s = u + 1;
} }
debugmsg("capflags=0x%04x, pid=%d", hgc->capflags, hgc->pid); debugmsg("capflags=0x%04x, pid=%d", hgc->capflags, hgc->pid);
} }
static void updateprocname(hgclient_t *hgc) static void updateprocname(hgclient_t *hgc)
{ {
int r = snprintf(hgc->ctx.data, hgc->ctx.maxdatasize, "chg[worker/%d]", int r = snprintf(hgc->ctx.data, hgc->ctx.maxdatasize, "chg[worker/%d]",
(int)getpid()); (int)getpid());
if (r < 0 || (size_t)r >= hgc->ctx.maxdatasize) if (r < 0 || (size_t)r >= hgc->ctx.maxdatasize) {
abortmsg("insufficient buffer to write procname (r = %d)", r); abortmsg("insufficient buffer to write procname (r = %d)", r);
}
hgc->ctx.datasize = (size_t)r; hgc->ctx.datasize = (size_t)r;
writeblockrequest(hgc, "setprocname"); writeblockrequest(hgc, "setprocname");
} }
static void attachio(hgclient_t *hgc) static void attachio(hgclient_t *hgc)
{ {
debugmsg("request attachio"); debugmsg("request attachio");
static const char chcmd[] = "attachio\n"; static const char chcmd[] = "attachio\n";
sendall(hgc->sockfd, chcmd, sizeof(chcmd) - 1); sendall(hgc->sockfd, chcmd, sizeof(chcmd) - 1);
readchannel(hgc); readchannel(hgc);
context_t *ctx = &hgc->ctx; context_t *ctx = &hgc->ctx;
if (ctx->ch != 'I') if (ctx->ch != 'I') {
abortmsg("unexpected response for attachio (ch = %c)", ctx->ch); abortmsg("unexpected response for attachio (ch = %c)", ctx->ch);
}
static const int fds[3] = {STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO}; static const int fds[3] = {STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO};
struct msghdr msgh; struct msghdr msgh;
memset(&msgh, 0, sizeof(msgh)); memset(&msgh, 0, sizeof(msgh));
struct iovec iov = {ctx->data, ctx->datasize}; /* dummy payload */ struct iovec iov = {ctx->data, ctx->datasize}; /* dummy payload */
msgh.msg_iov = &iov; msgh.msg_iov = &iov;
msgh.msg_iovlen = 1; msgh.msg_iovlen = 1;
char fdbuf[CMSG_SPACE(sizeof(fds))]; char fdbuf[CMSG_SPACE(sizeof(fds))];
msgh.msg_control = fdbuf; msgh.msg_control = fdbuf;
msgh.msg_controllen = sizeof(fdbuf); msgh.msg_controllen = sizeof(fdbuf);
struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msgh); struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msgh);
cmsg->cmsg_level = SOL_SOCKET; cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS; cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_len = CMSG_LEN(sizeof(fds)); cmsg->cmsg_len = CMSG_LEN(sizeof(fds));
memcpy(CMSG_DATA(cmsg), fds, sizeof(fds)); memcpy(CMSG_DATA(cmsg), fds, sizeof(fds));
msgh.msg_controllen = cmsg->cmsg_len; msgh.msg_controllen = cmsg->cmsg_len;
ssize_t r = sendmsg(hgc->sockfd, &msgh, 0); ssize_t r = sendmsg(hgc->sockfd, &msgh, 0);
if (r < 0) if (r < 0) {
abortmsgerrno("sendmsg failed"); abortmsgerrno("sendmsg failed");
}
handleresponse(hgc); handleresponse(hgc);
int32_t n; int32_t n;
if (ctx->datasize != sizeof(n)) if (ctx->datasize != sizeof(n)) {
abortmsg("unexpected size of attachio result"); abortmsg("unexpected size of attachio result");
}
memcpy(&n, ctx->data, sizeof(n)); memcpy(&n, ctx->data, sizeof(n));
n = ntohl(n); n = ntohl(n);
if (n != sizeof(fds) / sizeof(fds[0])) if (n != sizeof(fds) / sizeof(fds[0])) {
abortmsg("failed to send fds (n = %d)", n); abortmsg("failed to send fds (n = %d)", n);
} }
}
static void chdirtocwd(hgclient_t *hgc) static void chdirtocwd(hgclient_t *hgc)
{ {
if (!getcwd(hgc->ctx.data, hgc->ctx.maxdatasize)) if (!getcwd(hgc->ctx.data, hgc->ctx.maxdatasize)) {
abortmsgerrno("failed to getcwd"); abortmsgerrno("failed to getcwd");
}
hgc->ctx.datasize = strlen(hgc->ctx.data); hgc->ctx.datasize = strlen(hgc->ctx.data);
writeblockrequest(hgc, "chdir"); writeblockrequest(hgc, "chdir");
} }
static void forwardumask(hgclient_t *hgc) static void forwardumask(hgclient_t *hgc)
{ {
mode_t mask = umask(0); mode_t mask = umask(0);
umask(mask); umask(mask);
uint32_t data = htonl(mask); uint32_t data = htonl(mask);
enlargecontext(&hgc->ctx, sizeof(data)); enlargecontext(&hgc->ctx, sizeof(data));
memcpy(hgc->ctx.data, &data, sizeof(data)); memcpy(hgc->ctx.data, &data, sizeof(data));
hgc->ctx.datasize = sizeof(data); hgc->ctx.datasize = sizeof(data);
writeblockrequest(hgc, "setumask2"); writeblockrequest(hgc, "setumask2");
} }
/*! /*!
* Open connection to per-user cmdserver * Open connection to per-user cmdserver
* *
* If no background server running, returns NULL. * If no background server running, returns NULL.
*/ */
hgclient_t *hgc_open(const char *sockname) hgclient_t *hgc_open(const char *sockname)
{ {
int fd = socket(AF_UNIX, SOCK_STREAM, 0); int fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (fd < 0) if (fd < 0) {
abortmsgerrno("cannot create socket"); abortmsgerrno("cannot create socket");
}
/* don't keep fd on fork(), so that it can be closed when the parent /* don't keep fd on fork(), so that it can be closed when the parent
* process get terminated. */ * process get terminated. */
fsetcloexec(fd); fsetcloexec(fd);
struct sockaddr_un addr; struct sockaddr_un addr;
addr.sun_family = AF_UNIX; addr.sun_family = AF_UNIX;
/* use chdir to workaround small sizeof(sun_path) */ /* use chdir to workaround small sizeof(sun_path) */
int bakfd = -1; int bakfd = -1;
const char *basename = sockname; const char *basename = sockname;
{ {
const char *split = strrchr(sockname, '/'); const char *split = strrchr(sockname, '/');
if (split && split != sockname) { if (split && split != sockname) {
if (split[1] == '\0') if (split[1] == '\0') {
abortmsg("sockname cannot end with a slash"); abortmsg("sockname cannot end with a slash");
}
size_t len = split - sockname; size_t len = split - sockname;
char sockdir[len + 1]; char sockdir[len + 1];
memcpy(sockdir, sockname, len); memcpy(sockdir, sockname, len);
sockdir[len] = '\0'; sockdir[len] = '\0';
bakfd = open(".", O_DIRECTORY); bakfd = open(".", O_DIRECTORY);
if (bakfd == -1) if (bakfd == -1) {
abortmsgerrno("cannot open cwd"); abortmsgerrno("cannot open cwd");
}
int r = chdir(sockdir); int r = chdir(sockdir);
if (r != 0) if (r != 0) {
abortmsgerrno("cannot chdir %s", sockdir); abortmsgerrno("cannot chdir %s", sockdir);
}
basename = split + 1; basename = split + 1;
} }
} }
if (strlen(basename) >= sizeof(addr.sun_path)) if (strlen(basename) >= sizeof(addr.sun_path)) {
abortmsg("sockname is too long: %s", basename); abortmsg("sockname is too long: %s", basename);
}
strncpy(addr.sun_path, basename, sizeof(addr.sun_path)); strncpy(addr.sun_path, basename, sizeof(addr.sun_path));
addr.sun_path[sizeof(addr.sun_path) - 1] = '\0'; addr.sun_path[sizeof(addr.sun_path) - 1] = '\0';
/* real connect */ /* real connect */
int r = connect(fd, (struct sockaddr *)&addr, sizeof(addr)); int r = connect(fd, (struct sockaddr *)&addr, sizeof(addr));
if (r < 0) { if (r < 0) {
if (errno != ENOENT && errno != ECONNREFUSED) if (errno != ENOENT && errno != ECONNREFUSED) {
abortmsgerrno("cannot connect to %s", sockname); abortmsgerrno("cannot connect to %s", sockname);
} }
}
if (bakfd != -1) { if (bakfd != -1) {
fchdirx(bakfd); fchdirx(bakfd);
close(bakfd); close(bakfd);
} }
if (r < 0) { if (r < 0) {
close(fd); close(fd);
return NULL; return NULL;
} }
debugmsg("connected to %s", addr.sun_path); debugmsg("connected to %s", addr.sun_path);
hgclient_t *hgc = mallocx(sizeof(hgclient_t)); hgclient_t *hgc = mallocx(sizeof(hgclient_t));
memset(hgc, 0, sizeof(*hgc)); memset(hgc, 0, sizeof(*hgc));
hgc->sockfd = fd; hgc->sockfd = fd;
initcontext(&hgc->ctx); initcontext(&hgc->ctx);
readhello(hgc); readhello(hgc);
if (!(hgc->capflags & CAP_RUNCOMMAND)) if (!(hgc->capflags & CAP_RUNCOMMAND)) {
abortmsg("insufficient capability: runcommand"); abortmsg("insufficient capability: runcommand");
if (hgc->capflags & CAP_SETPROCNAME) }
if (hgc->capflags & CAP_SETPROCNAME) {
updateprocname(hgc); updateprocname(hgc);
if (hgc->capflags & CAP_ATTACHIO) }
if (hgc->capflags & CAP_ATTACHIO) {
attachio(hgc); attachio(hgc);
if (hgc->capflags & CAP_CHDIR) }
if (hgc->capflags & CAP_CHDIR) {
chdirtocwd(hgc); chdirtocwd(hgc);
if (hgc->capflags & CAP_SETUMASK2) }
if (hgc->capflags & CAP_SETUMASK2) {
forwardumask(hgc); forwardumask(hgc);
}
return hgc; return hgc;
} }
/*! /*!
* Close connection and free allocated memory * Close connection and free allocated memory
*/ */
void hgc_close(hgclient_t *hgc) void hgc_close(hgclient_t *hgc)
* chgserver.py for possible instruction formats. * chgserver.py for possible instruction formats.
* the list should be freed by the caller. * the list should be freed by the caller.
* the last string is guaranteed to be NULL. * the last string is guaranteed to be NULL.
*/ */
const char **hgc_validate(hgclient_t *hgc, const char *const args[], const char **hgc_validate(hgclient_t *hgc, const char *const args[],
size_t argsize) size_t argsize)
{ {
assert(hgc); assert(hgc);
if (!(hgc->capflags & CAP_VALIDATE)) if (!(hgc->capflags & CAP_VALIDATE)) {
return NULL; return NULL;
}
packcmdargs(&hgc->ctx, args, argsize); packcmdargs(&hgc->ctx, args, argsize);
writeblockrequest(hgc, "validate"); writeblockrequest(hgc, "validate");
handleresponse(hgc); handleresponse(hgc);
/* the server returns '\0' if it can handle our request */ /* the server returns '\0' if it can handle our request */
if (hgc->ctx.datasize <= 1) if (hgc->ctx.datasize <= 1) {
return NULL; return NULL;
}
/* make sure the buffer is '\0' terminated */ /* make sure the buffer is '\0' terminated */
enlargecontext(&hgc->ctx, hgc->ctx.datasize + 1); enlargecontext(&hgc->ctx, hgc->ctx.datasize + 1);
hgc->ctx.data[hgc->ctx.datasize] = '\0'; hgc->ctx.data[hgc->ctx.datasize] = '\0';
return unpackcmdargsnul(&hgc->ctx); return unpackcmdargsnul(&hgc->ctx);
} }
/*! /*!
} }
/*! /*!
* (Re-)send client's stdio channels so that the server can access to tty * (Re-)send client's stdio channels so that the server can access to tty
*/ */
void hgc_attachio(hgclient_t *hgc) void hgc_attachio(hgclient_t *hgc)
{ {
assert(hgc); assert(hgc);
if (!(hgc->capflags & CAP_ATTACHIO)) if (!(hgc->capflags & CAP_ATTACHIO)) {
return; return;
}
attachio(hgc); attachio(hgc);
} }
/*! /*!
* Update server's environment variables * Update server's environment variables
* *
* @param envp list of environment variables in "NAME=VALUE" format, * @param envp list of environment variables in "NAME=VALUE" format,
* terminated by NULL. * terminated by NULL.
*/ */
void hgc_setenv(hgclient_t *hgc, const char *const envp[]) void hgc_setenv(hgclient_t *hgc, const char *const envp[])
{ {
assert(hgc && envp); assert(hgc && envp);
if (!(hgc->capflags & CAP_SETENV)) if (!(hgc->capflags & CAP_SETENV)) {
return; return;
}
packcmdargs(&hgc->ctx, envp, /*argsize*/ -1); packcmdargs(&hgc->ctx, envp, /*argsize*/ -1);
writeblockrequest(hgc, "setenv"); writeblockrequest(hgc, "setenv");
} }

contrib/chg/procutil.c

static pid_t pagerpid = 0; static pid_t pagerpid = 0;
static pid_t peerpgid = 0; static pid_t peerpgid = 0;
static pid_t peerpid = 0; static pid_t peerpid = 0;
static void forwardsignal(int sig) static void forwardsignal(int sig)
{ {
assert(peerpid > 0); assert(peerpid > 0);
if (kill(peerpid, sig) < 0) if (kill(peerpid, sig) < 0) {
abortmsgerrno("cannot kill %d", peerpid); abortmsgerrno("cannot kill %d", peerpid);
}
debugmsg("forward signal %d", sig); debugmsg("forward signal %d", sig);
} }
static void forwardsignaltogroup(int sig) static void forwardsignaltogroup(int sig)
{ {
/* prefer kill(-pgid, sig), fallback to pid if pgid is invalid */ /* prefer kill(-pgid, sig), fallback to pid if pgid is invalid */
pid_t killpid = peerpgid > 1 ? -peerpgid : peerpid; pid_t killpid = peerpgid > 1 ? -peerpgid : peerpid;
if (kill(killpid, sig) < 0) if (kill(killpid, sig) < 0) {
abortmsgerrno("cannot kill %d", killpid); abortmsgerrno("cannot kill %d", killpid);
}
debugmsg("forward signal %d to %d", sig, killpid); debugmsg("forward signal %d to %d", sig, killpid);
} }
static void handlestopsignal(int sig) static void handlestopsignal(int sig)
{ {
sigset_t unblockset, oldset; sigset_t unblockset, oldset;
struct sigaction sa, oldsa; struct sigaction sa, oldsa;
if (sigemptyset(&unblockset) < 0) if (sigemptyset(&unblockset) < 0) {
goto error; goto error;
if (sigaddset(&unblockset, sig) < 0) }
if (sigaddset(&unblockset, sig) < 0) {
goto error; goto error;
}
memset(&sa, 0, sizeof(sa)); memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_DFL; sa.sa_handler = SIG_DFL;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigemptyset(&sa.sa_mask) < 0) if (sigemptyset(&sa.sa_mask) < 0) {
goto error; goto error;
}
forwardsignal(sig); forwardsignal(sig);
if (raise(sig) < 0) /* resend to self */ if (raise(sig) < 0) { /* resend to self */
goto error; goto error;
if (sigaction(sig, &sa, &oldsa) < 0) }
if (sigaction(sig, &sa, &oldsa) < 0) {
goto error; goto error;
if (sigprocmask(SIG_UNBLOCK, &unblockset, &oldset) < 0) }
if (sigprocmask(SIG_UNBLOCK, &unblockset, &oldset) < 0) {
goto error; goto error;
}
/* resent signal will be handled before sigprocmask() returns */ /* resent signal will be handled before sigprocmask() returns */
if (sigprocmask(SIG_SETMASK, &oldset, NULL) < 0) if (sigprocmask(SIG_SETMASK, &oldset, NULL) < 0) {
goto error; goto error;
if (sigaction(sig, &oldsa, NULL) < 0) }
if (sigaction(sig, &oldsa, NULL) < 0) {
goto error; goto error;
}
return; return;
error: error:
abortmsgerrno("failed to handle stop signal"); abortmsgerrno("failed to handle stop signal");
} }
static void handlechildsignal(int sig UNUSED_) static void handlechildsignal(int sig UNUSED_)
{ {
if (peerpid == 0 || pagerpid == 0) if (peerpid == 0 || pagerpid == 0) {
return; return;
}
/* if pager exits, notify the server with SIGPIPE immediately. /* if pager exits, notify the server with SIGPIPE immediately.
* otherwise the server won't get SIGPIPE if it does not write * otherwise the server won't get SIGPIPE if it does not write
* anything. (issue5278) */ * anything. (issue5278) */
if (waitpid(pagerpid, NULL, WNOHANG) == pagerpid) if (waitpid(pagerpid, NULL, WNOHANG) == pagerpid) {
kill(peerpid, SIGPIPE); kill(peerpid, SIGPIPE);
} }
}
void setupsignalhandler(pid_t pid, pid_t pgid) void setupsignalhandler(pid_t pid, pid_t pgid)
{ {
if (pid <= 0) if (pid <= 0) {
return; return;
}
peerpid = pid; peerpid = pid;
peerpgid = (pgid <= 1 ? 0 : pgid); peerpgid = (pgid <= 1 ? 0 : pgid);
struct sigaction sa; struct sigaction sa;
memset(&sa, 0, sizeof(sa)); memset(&sa, 0, sizeof(sa));
/* deadly signals meant to be sent to a process group: /* deadly signals meant to be sent to a process group:
* - SIGHUP: usually generated by the kernel, when termination of a * - SIGHUP: usually generated by the kernel, when termination of a
* process causes that process group to become orphaned * process causes that process group to become orphaned
* - SIGINT: usually generated by the terminal */ * - SIGINT: usually generated by the terminal */
sa.sa_handler = forwardsignaltogroup; sa.sa_handler = forwardsignaltogroup;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigemptyset(&sa.sa_mask) < 0) if (sigemptyset(&sa.sa_mask) < 0) {
goto error; goto error;
if (sigaction(SIGHUP, &sa, NULL) < 0) }
if (sigaction(SIGHUP, &sa, NULL) < 0) {
goto error; goto error;
if (sigaction(SIGINT, &sa, NULL) < 0) }
if (sigaction(SIGINT, &sa, NULL) < 0) {
goto error; goto error;
}
/* terminate frontend by double SIGTERM in case of server freeze */ /* terminate frontend by double SIGTERM in case of server freeze */
sa.sa_handler = forwardsignal; sa.sa_handler = forwardsignal;
sa.sa_flags |= SA_RESETHAND; sa.sa_flags |= SA_RESETHAND;
if (sigaction(SIGTERM, &sa, NULL) < 0) if (sigaction(SIGTERM, &sa, NULL) < 0) {
goto error; goto error;
}
/* notify the worker about window resize events */ /* notify the worker about window resize events */
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigaction(SIGWINCH, &sa, NULL) < 0) if (sigaction(SIGWINCH, &sa, NULL) < 0) {
goto error; goto error;
}
/* forward user-defined signals */ /* forward user-defined signals */
if (sigaction(SIGUSR1, &sa, NULL) < 0) if (sigaction(SIGUSR1, &sa, NULL) < 0) {
goto error; goto error;
if (sigaction(SIGUSR2, &sa, NULL) < 0) }
if (sigaction(SIGUSR2, &sa, NULL) < 0) {
goto error; goto error;
}
/* propagate job control requests to worker */ /* propagate job control requests to worker */
sa.sa_handler = forwardsignal; sa.sa_handler = forwardsignal;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigaction(SIGCONT, &sa, NULL) < 0) if (sigaction(SIGCONT, &sa, NULL) < 0) {
goto error; goto error;
}
sa.sa_handler = handlestopsignal; sa.sa_handler = handlestopsignal;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigaction(SIGTSTP, &sa, NULL) < 0) if (sigaction(SIGTSTP, &sa, NULL) < 0) {
goto error; goto error;
}
/* get notified when pager exits */ /* get notified when pager exits */
sa.sa_handler = handlechildsignal; sa.sa_handler = handlechildsignal;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigaction(SIGCHLD, &sa, NULL) < 0) if (sigaction(SIGCHLD, &sa, NULL) < 0) {
goto error; goto error;
}
return; return;
error: error:
abortmsgerrno("failed to set up signal handlers"); abortmsgerrno("failed to set up signal handlers");
} }
void restoresignalhandler(void) void restoresignalhandler(void)
{ {
struct sigaction sa; struct sigaction sa;
memset(&sa, 0, sizeof(sa)); memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_DFL; sa.sa_handler = SIG_DFL;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigemptyset(&sa.sa_mask) < 0) if (sigemptyset(&sa.sa_mask) < 0) {
goto error; goto error;
}
if (sigaction(SIGHUP, &sa, NULL) < 0) if (sigaction(SIGHUP, &sa, NULL) < 0) {
goto error; goto error;
if (sigaction(SIGTERM, &sa, NULL) < 0) }
if (sigaction(SIGTERM, &sa, NULL) < 0) {
goto error; goto error;
if (sigaction(SIGWINCH, &sa, NULL) < 0) }
if (sigaction(SIGWINCH, &sa, NULL) < 0) {
goto error; goto error;
if (sigaction(SIGCONT, &sa, NULL) < 0) }
if (sigaction(SIGCONT, &sa, NULL) < 0) {
goto error; goto error;
if (sigaction(SIGTSTP, &sa, NULL) < 0) }
if (sigaction(SIGTSTP, &sa, NULL) < 0) {
goto error; goto error;
if (sigaction(SIGCHLD, &sa, NULL) < 0) }
if (sigaction(SIGCHLD, &sa, NULL) < 0) {
goto error; goto error;
}
/* ignore Ctrl+C while shutting down to make pager exits cleanly */ /* ignore Ctrl+C while shutting down to make pager exits cleanly */
sa.sa_handler = SIG_IGN; sa.sa_handler = SIG_IGN;
if (sigaction(SIGINT, &sa, NULL) < 0) if (sigaction(SIGINT, &sa, NULL) < 0) {
goto error; goto error;
}
peerpid = 0; peerpid = 0;
return; return;
error: error:
abortmsgerrno("failed to restore signal handlers"); abortmsgerrno("failed to restore signal handlers");
} }
/* This implementation is based on hgext/pager.py (post 369741ef7253) /* This implementation is based on hgext/pager.py (post 369741ef7253)
* Return 0 if pager is not started, or pid of the pager */ * Return 0 if pager is not started, or pid of the pager */
pid_t setuppager(const char *pagercmd, const char *envp[]) pid_t setuppager(const char *pagercmd, const char *envp[])
{ {
assert(pagerpid == 0); assert(pagerpid == 0);
if (!pagercmd) if (!pagercmd) {
return 0; return 0;
}
int pipefds[2]; int pipefds[2];
if (pipe(pipefds) < 0) if (pipe(pipefds) < 0) {
return 0; return 0;
}
pid_t pid = fork(); pid_t pid = fork();
if (pid < 0) if (pid < 0) {
goto error; goto error;
}
if (pid > 0) { if (pid > 0) {
close(pipefds[0]); close(pipefds[0]);
if (dup2(pipefds[1], fileno(stdout)) < 0) if (dup2(pipefds[1], fileno(stdout)) < 0) {
goto error; goto error;
}
if (isatty(fileno(stderr))) { if (isatty(fileno(stderr))) {
if (dup2(pipefds[1], fileno(stderr)) < 0) if (dup2(pipefds[1], fileno(stderr)) < 0) {
goto error; goto error;
} }
}
close(pipefds[1]); close(pipefds[1]);
pagerpid = pid; pagerpid = pid;
return pid; return pid;
} else { } else {
dup2(pipefds[0], fileno(stdin)); dup2(pipefds[0], fileno(stdin));
close(pipefds[0]); close(pipefds[0]);
close(pipefds[1]); close(pipefds[1]);
close(pipefds[0]); close(pipefds[0]);
close(pipefds[1]); close(pipefds[1]);
abortmsgerrno("failed to prepare pager"); abortmsgerrno("failed to prepare pager");
return 0; return 0;
} }
void waitpager(void) void waitpager(void)
{ {
if (pagerpid == 0) if (pagerpid == 0) {
return; return;
}
/* close output streams to notify the pager its input ends */ /* close output streams to notify the pager its input ends */
fclose(stdout); fclose(stdout);
fclose(stderr); fclose(stderr);
while (1) { while (1) {
pid_t ret = waitpid(pagerpid, NULL, 0); pid_t ret = waitpid(pagerpid, NULL, 0);
if (ret == -1 && errno == EINTR) if (ret == -1 && errno == EINTR) {
continue; continue;
}
break; break;
} }
} }

contrib/chg/util.c

#include <unistd.h> #include <unistd.h>
#include "util.h" #include "util.h"
static int colorenabled = 0; static int colorenabled = 0;
static inline void fsetcolor(FILE *fp, const char *code) static inline void fsetcolor(FILE *fp, const char *code)
{ {
if (!colorenabled) if (!colorenabled) {
return; return;
}
fprintf(fp, "\033[%sm", code); fprintf(fp, "\033[%sm", code);
} }
static void vabortmsgerrno(int no, const char *fmt, va_list args) static void vabortmsgerrno(int no, const char *fmt, va_list args)
{ {
fsetcolor(stderr, "1;31"); fsetcolor(stderr, "1;31");
fputs("chg: abort: ", stderr); fputs("chg: abort: ", stderr);
vfprintf(stderr, fmt, args); vfprintf(stderr, fmt, args);
if (no != 0) if (no != 0) {
fprintf(stderr, " (errno = %d, %s)", no, strerror(no)); fprintf(stderr, " (errno = %d, %s)", no, strerror(no));
}
fsetcolor(stderr, ""); fsetcolor(stderr, "");
fputc('\n', stderr); fputc('\n', stderr);
exit(255); exit(255);
} }
void abortmsg(const char *fmt, ...) void abortmsg(const char *fmt, ...)
{ {
va_list args; va_list args;
void enabledebugmsg(void) void enabledebugmsg(void)
{ {
debugmsgenabled = 1; debugmsgenabled = 1;
debugstart = now(); debugstart = now();
} }
void debugmsg(const char *fmt, ...) void debugmsg(const char *fmt, ...)
{ {
if (!debugmsgenabled) if (!debugmsgenabled) {
return; return;
}
va_list args; va_list args;
va_start(args, fmt); va_start(args, fmt);
fsetcolor(stderr, "1;30"); fsetcolor(stderr, "1;30");
fprintf(stderr, "chg: debug: %4.6f ", now() - debugstart); fprintf(stderr, "chg: debug: %4.6f ", now() - debugstart);
vfprintf(stderr, fmt, args); vfprintf(stderr, fmt, args);
fsetcolor(stderr, ""); fsetcolor(stderr, "");
fputc('\n', stderr); fputc('\n', stderr);
va_end(args); va_end(args);
} }
void fchdirx(int dirfd) void fchdirx(int dirfd)
{ {
int r = fchdir(dirfd); int r = fchdir(dirfd);
if (r == -1) if (r == -1) {
abortmsgerrno("failed to fchdir"); abortmsgerrno("failed to fchdir");
} }
}
void fsetcloexec(int fd) void fsetcloexec(int fd)
{ {
int flags = fcntl(fd, F_GETFD); int flags = fcntl(fd, F_GETFD);
if (flags < 0) if (flags < 0) {
abortmsgerrno("cannot get flags of fd %d", fd); abortmsgerrno("cannot get flags of fd %d", fd);
if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) < 0) }
if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) < 0) {
abortmsgerrno("cannot set flags of fd %d", fd); abortmsgerrno("cannot set flags of fd %d", fd);
} }
}
void *mallocx(size_t size) void *mallocx(size_t size)
{ {
void *result = malloc(size); void *result = malloc(size);
if (!result) if (!result) {
abortmsg("failed to malloc"); abortmsg("failed to malloc");
}
return result; return result;
} }
void *reallocx(void *ptr, size_t size) void *reallocx(void *ptr, size_t size)
{ {
void *result = realloc(ptr, size); void *result = realloc(ptr, size);
if (!result) if (!result) {
abortmsg("failed to realloc"); abortmsg("failed to realloc");
}
return result; return result;
} }
/* /*
* Execute a shell command in mostly the same manner as system(), with the * Execute a shell command in mostly the same manner as system(), with the
* give environment variables, after chdir to the given cwd. Returns a status * give environment variables, after chdir to the given cwd. Returns a status
* code compatible with the Python subprocess module. * code compatible with the Python subprocess module.
*/ */
int runshellcmd(const char *cmd, const char *envp[], const char *cwd) int runshellcmd(const char *cmd, const char *envp[], const char *cwd)
{ {
enum { F_SIGINT = 1, F_SIGQUIT = 2, F_SIGMASK = 4, F_WAITPID = 8 }; enum { F_SIGINT = 1, F_SIGQUIT = 2, F_SIGMASK = 4, F_WAITPID = 8 };
unsigned int doneflags = 0; unsigned int doneflags = 0;
int status = 0; int status = 0;
struct sigaction newsa, oldsaint, oldsaquit; struct sigaction newsa, oldsaint, oldsaquit;
sigset_t oldmask; sigset_t oldmask;
/* block or mask signals just as system() does */ /* block or mask signals just as system() does */
memset(&newsa, 0, sizeof(newsa)); memset(&newsa, 0, sizeof(newsa));
newsa.sa_handler = SIG_IGN; newsa.sa_handler = SIG_IGN;
newsa.sa_flags = 0; newsa.sa_flags = 0;
if (sigemptyset(&newsa.sa_mask) < 0) if (sigemptyset(&newsa.sa_mask) < 0) {
goto done; goto done;
if (sigaction(SIGINT, &newsa, &oldsaint) < 0) }
if (sigaction(SIGINT, &newsa, &oldsaint) < 0) {
goto done; goto done;
}
doneflags |= F_SIGINT; doneflags |= F_SIGINT;
if (sigaction(SIGQUIT, &newsa, &oldsaquit) < 0) if (sigaction(SIGQUIT, &newsa, &oldsaquit) < 0) {
goto done; goto done;
}
doneflags |= F_SIGQUIT; doneflags |= F_SIGQUIT;
if (sigaddset(&newsa.sa_mask, SIGCHLD) < 0) if (sigaddset(&newsa.sa_mask, SIGCHLD) < 0) {
goto done; goto done;
if (sigprocmask(SIG_BLOCK, &newsa.sa_mask, &oldmask) < 0) }
if (sigprocmask(SIG_BLOCK, &newsa.sa_mask, &oldmask) < 0) {
goto done; goto done;
}
doneflags |= F_SIGMASK; doneflags |= F_SIGMASK;
pid_t pid = fork(); pid_t pid = fork();
if (pid < 0) if (pid < 0) {
goto done; goto done;
}
if (pid == 0) { if (pid == 0) {
sigaction(SIGINT, &oldsaint, NULL); sigaction(SIGINT, &oldsaint, NULL);
sigaction(SIGQUIT, &oldsaquit, NULL); sigaction(SIGQUIT, &oldsaquit, NULL);
sigprocmask(SIG_SETMASK, &oldmask, NULL); sigprocmask(SIG_SETMASK, &oldmask, NULL);
if (cwd && chdir(cwd) < 0) if (cwd && chdir(cwd) < 0) {
_exit(127); _exit(127);
}
const char *argv[] = {"sh", "-c", cmd, NULL}; const char *argv[] = {"sh", "-c", cmd, NULL};
if (envp) { if (envp) {
execve("/bin/sh", (char **)argv, (char **)envp); execve("/bin/sh", (char **)argv, (char **)envp);
} else { } else {
execv("/bin/sh", (char **)argv); execv("/bin/sh", (char **)argv);
} }
_exit(127); _exit(127);
} else { } else {
if (waitpid(pid, &status, 0) < 0) if (waitpid(pid, &status, 0) < 0) {
goto done; goto done;
}
doneflags |= F_WAITPID; doneflags |= F_WAITPID;
} }
done: done:
if (doneflags & F_SIGINT) if (doneflags & F_SIGINT) {
sigaction(SIGINT, &oldsaint, NULL); sigaction(SIGINT, &oldsaint, NULL);
if (doneflags & F_SIGQUIT) }
if (doneflags & F_SIGQUIT) {
sigaction(SIGQUIT, &oldsaquit, NULL); sigaction(SIGQUIT, &oldsaquit, NULL);
if (doneflags & F_SIGMASK) }
if (doneflags & F_SIGMASK) {
sigprocmask(SIG_SETMASK, &oldmask, NULL); sigprocmask(SIG_SETMASK, &oldmask, NULL);
}
/* no way to report other errors, use 127 (= shell termination) */ /* no way to report other errors, use 127 (= shell termination) */
if (!(doneflags & F_WAITPID)) if (!(doneflags & F_WAITPID)) {
return 127; return 127;
if (WIFEXITED(status)) }
if (WIFEXITED(status)) {
return WEXITSTATUS(status); return WEXITSTATUS(status);
if (WIFSIGNALED(status)) }
if (WIFSIGNALED(status)) {
return -WTERMSIG(status); return -WTERMSIG(status);
}
return 127; return 127;
} }

mercurial/bdiff.c

unsigned hash; unsigned hash;
int i; int i;
const char *p, *b = a; const char *p, *b = a;
const char *const plast = a + len - 1; const char *const plast = a + len - 1;
struct bdiff_line *l; struct bdiff_line *l;
/* count the lines */ /* count the lines */
i = 1; /* extra line for sentinel */ i = 1; /* extra line for sentinel */
for (p = a; p < plast; p++) for (p = a; p < plast; p++) {
if (*p == '\n') if (*p == '\n') {
i++; i++;
if (p == plast) }
}
if (p == plast) {
i++; i++;
}
*lr = l = (struct bdiff_line *)calloc(i, sizeof(struct bdiff_line)); *lr = l = (struct bdiff_line *)calloc(i, sizeof(struct bdiff_line));
if (!l) if (!l) {
return -1; return -1;
}
/* build the line array and calculate hashes */ /* build the line array and calculate hashes */
hash = 0; hash = 0;
for (p = a; p < plast; p++) { for (p = a; p < plast; p++) {
hash = HASH(hash, *p); hash = HASH(hash, *p);
if (*p == '\n') { if (*p == '\n') {
l->hash = hash; l->hash = hash;
static int equatelines(struct bdiff_line *a, int an, struct bdiff_line *b, static int equatelines(struct bdiff_line *a, int an, struct bdiff_line *b,
int bn) int bn)
{ {
int i, j, buckets = 1, t, scale; int i, j, buckets = 1, t, scale;
struct pos *h = NULL; struct pos *h = NULL;
/* build a hash table of the next highest power of 2 */ /* build a hash table of the next highest power of 2 */
while (buckets < bn + 1) while (buckets < bn + 1) {
buckets *= 2; buckets *= 2;
}
/* try to allocate a large hash table to avoid collisions */ /* try to allocate a large hash table to avoid collisions */
for (scale = 4; scale; scale /= 2) { for (scale = 4; scale; scale /= 2) {
h = (struct pos *)calloc(buckets, scale * sizeof(struct pos)); h = (struct pos *)calloc(buckets, scale * sizeof(struct pos));
if (h) if (h) {
break; break;
} }
}
if (!h) if (!h) {
return 0; return 0;
}
buckets = buckets * scale - 1; buckets = buckets * scale - 1;
/* clear the hash table */ /* clear the hash table */
for (i = 0; i <= buckets; i++) { for (i = 0; i <= buckets; i++) {
h[i].pos = -1; h[i].pos = -1;
h[i].len = 0; h[i].len = 0;
} }
/* add lines to the hash table chains */ /* add lines to the hash table chains */
for (i = 0; i < bn; i++) { for (i = 0; i < bn; i++) {
/* find the equivalence class */ /* find the equivalence class */
for (j = b[i].hash & buckets; h[j].pos != -1; for (j = b[i].hash & buckets; h[j].pos != -1;
j = (j + 1) & buckets) j = (j + 1) & buckets) {
if (!cmp(b + i, b + h[j].pos)) if (!cmp(b + i, b + h[j].pos)) {
break; break;
}
}
/* add to the head of the equivalence class */ /* add to the head of the equivalence class */
b[i].n = h[j].pos; b[i].n = h[j].pos;
b[i].e = j; b[i].e = j;
h[j].pos = i; h[j].pos = i;
h[j].len++; /* keep track of popularity */ h[j].len++; /* keep track of popularity */
} }
/* compute popularity threshold */ /* compute popularity threshold */
t = (bn >= 31000) ? bn / 1000 : 1000000 / (bn + 1); t = (bn >= 31000) ? bn / 1000 : 1000000 / (bn + 1);
/* match items in a to their equivalence class in b */ /* match items in a to their equivalence class in b */
for (i = 0; i < an; i++) { for (i = 0; i < an; i++) {
/* find the equivalence class */ /* find the equivalence class */
for (j = a[i].hash & buckets; h[j].pos != -1; for (j = a[i].hash & buckets; h[j].pos != -1;
j = (j + 1) & buckets) j = (j + 1) & buckets) {
if (!cmp(a + i, b + h[j].pos)) if (!cmp(a + i, b + h[j].pos)) {
break; break;
}
}
a[i].e = j; /* use equivalence class for quick compare */ a[i].e = j; /* use equivalence class for quick compare */
if (h[j].len <= t) if (h[j].len <= t) {
a[i].n = h[j].pos; /* point to head of match list */ a[i].n = h[j].pos; /* point to head of match list */
else } else {
a[i].n = -1; /* too popular */ a[i].n = -1; /* too popular */
} }
}
/* discard hash tables */ /* discard hash tables */
free(h); free(h);
return 1; return 1;
} }
static int longest_match(struct bdiff_line *a, struct bdiff_line *b, static int longest_match(struct bdiff_line *a, struct bdiff_line *b,
struct pos *pos, int a1, int a2, int b1, int b2, struct pos *pos, int a1, int a2, int b1, int b2,
int *omi, int *omj) int *omi, int *omj)
{ {
int mi = a1, mj = b1, mk = 0, i, j, k, half, bhalf; int mi = a1, mj = b1, mk = 0, i, j, k, half, bhalf;
/* window our search on large regions to better bound /* window our search on large regions to better bound
worst-case performance. by choosing a window at the end, we worst-case performance. by choosing a window at the end, we
reduce skipping overhead on the b chains. */ reduce skipping overhead on the b chains. */
if (a2 - a1 > 30000) if (a2 - a1 > 30000) {
a1 = a2 - 30000; a1 = a2 - 30000;
}
half = (a1 + a2 - 1) / 2; half = (a1 + a2 - 1) / 2;
bhalf = (b1 + b2 - 1) / 2; bhalf = (b1 + b2 - 1) / 2;
for (i = a1; i < a2; i++) { for (i = a1; i < a2; i++) {
/* skip all lines in b after the current block */ /* skip all lines in b after the current block */
for (j = a[i].n; j >= b2; j = b[j].n) for (j = a[i].n; j >= b2; j = b[j].n) {
; ;
}
/* loop through all lines match a[i] in b */ /* loop through all lines match a[i] in b */
for (; j >= b1; j = b[j].n) { for (; j >= b1; j = b[j].n) {
/* does this extend an earlier match? */ /* does this extend an earlier match? */
for (k = 1; j - k >= b1 && i - k >= a1; k++) { for (k = 1; j - k >= b1 && i - k >= a1; k++) {
/* reached an earlier match? */ /* reached an earlier match? */
if (pos[j - k].pos == i - k) { if (pos[j - k].pos == i - k) {
k += pos[j - k].len; k += pos[j - k].len;
break; break;
} }
/* previous line mismatch? */ /* previous line mismatch? */
if (a[i - k].e != b[j - k].e) if (a[i - k].e != b[j - k].e) {
break; break;
} }
}
pos[j].pos = i; pos[j].pos = i;
pos[j].len = k; pos[j].len = k;
/* best match so far? we prefer matches closer /* best match so far? we prefer matches closer
to the middle to balance recursion */ to the middle to balance recursion */
if (k > mk) { if (k > mk) {
/* a longer match */ /* a longer match */
} }
if (mk) { if (mk) {
mi = mi - mk + 1; mi = mi - mk + 1;
mj = mj - mk + 1; mj = mj - mk + 1;
} }
/* expand match to include subsequent popular lines */ /* expand match to include subsequent popular lines */
while (mi + mk < a2 && mj + mk < b2 && a[mi + mk].e == b[mj + mk].e) while (mi + mk < a2 && mj + mk < b2 && a[mi + mk].e == b[mj + mk].e) {
mk++; mk++;
}
*omi = mi; *omi = mi;
*omj = mj; *omj = mj;
return mk; return mk;
} }
static struct bdiff_hunk *recurse(struct bdiff_line *a, struct bdiff_line *b, static struct bdiff_hunk *recurse(struct bdiff_line *a, struct bdiff_line *b,
struct pos *pos, int a1, int a2, int b1, struct pos *pos, int a1, int a2, int b1,
int b2, struct bdiff_hunk *l) int b2, struct bdiff_hunk *l)
{ {
int i, j, k; int i, j, k;
while (1) { while (1) {
/* find the longest match in this chunk */ /* find the longest match in this chunk */
k = longest_match(a, b, pos, a1, a2, b1, b2, &i, &j); k = longest_match(a, b, pos, a1, a2, b1, b2, &i, &j);
if (!k) if (!k) {
return l; return l;
}
/* and recurse on the remaining chunks on either side */ /* and recurse on the remaining chunks on either side */
l = recurse(a, b, pos, a1, i, b1, j, l); l = recurse(a, b, pos, a1, i, b1, j, l);
if (!l) if (!l) {
return NULL; return NULL;
}
l->next = l->next =
(struct bdiff_hunk *)malloc(sizeof(struct bdiff_hunk)); (struct bdiff_hunk *)malloc(sizeof(struct bdiff_hunk));
if (!l->next) if (!l->next) {
return NULL; return NULL;
}
l = l->next; l = l->next;
l->a1 = i; l->a1 = i;
l->a2 = i + k; l->a2 = i + k;
l->b1 = j; l->b1 = j;
l->b2 = j + k; l->b2 = j + k;
l->next = NULL; l->next = NULL;
/* allocate and fill arrays */ /* allocate and fill arrays */
t = equatelines(a, an, b, bn); t = equatelines(a, an, b, bn);
pos = (struct pos *)calloc(bn ? bn : 1, sizeof(struct pos)); pos = (struct pos *)calloc(bn ? bn : 1, sizeof(struct pos));
if (pos && t) { if (pos && t) {
/* generate the matching block list */ /* generate the matching block list */
curr = recurse(a, b, pos, 0, an, 0, bn, base); curr = recurse(a, b, pos, 0, an, 0, bn, base);
if (!curr) if (!curr) {
return -1; return -1;
}
/* sentinel end hunk */ /* sentinel end hunk */
curr->next = curr->next =
(struct bdiff_hunk *)malloc(sizeof(struct bdiff_hunk)); (struct bdiff_hunk *)malloc(sizeof(struct bdiff_hunk));
if (!curr->next) if (!curr->next) {
return -1; return -1;
}
curr = curr->next; curr = curr->next;
curr->a1 = curr->a2 = an; curr->a1 = curr->a2 = an;
curr->b1 = curr->b2 = bn; curr->b1 = curr->b2 = bn;
curr->next = NULL; curr->next = NULL;
} }
free(pos); free(pos);
/* normalize the hunk list, try to push each hunk towards the end */ /* normalize the hunk list, try to push each hunk towards the end */
for (curr = base->next; curr; curr = curr->next) { for (curr = base->next; curr; curr = curr->next) {
struct bdiff_hunk *next = curr->next; struct bdiff_hunk *next = curr->next;
if (!next) if (!next) {
break; break;
}
if (curr->a2 == next->a1 || curr->b2 == next->b1) if (curr->a2 == next->a1 || curr->b2 == next->b1) {
while (curr->a2 < an && curr->b2 < bn && while (curr->a2 < an && curr->b2 < bn &&
next->a1 < next->a2 && next->b1 < next->b2 && next->a1 < next->a2 && next->b1 < next->b2 &&
!cmp(a + curr->a2, b + curr->b2)) { !cmp(a + curr->a2, b + curr->b2)) {
curr->a2++; curr->a2++;
next->a1++; next->a1++;
curr->b2++; curr->b2++;
next->b1++; next->b1++;
} }
} }
}
for (curr = base->next; curr; curr = curr->next) for (curr = base->next; curr; curr = curr->next) {
count++; count++;
}
return count; return count;
} }
/* deallocate list of hunks; l may be NULL */ /* deallocate list of hunks; l may be NULL */
void bdiff_freehunks(struct bdiff_hunk *l) void bdiff_freehunks(struct bdiff_hunk *l)
{ {
struct bdiff_hunk *n; struct bdiff_hunk *n;
for (; l; l = n) { for (; l; l = n) {
n = l->next; n = l->next;
free(l); free(l);
} }
} }

mercurial/mpatch.c

#else #else
#include <stdbool.h> #include <stdbool.h>
#endif #endif
static struct mpatch_flist *lalloc(ssize_t size) static struct mpatch_flist *lalloc(ssize_t size)
{ {
struct mpatch_flist *a = NULL; struct mpatch_flist *a = NULL;
if (size < 1) if (size < 1) {
size = 1; size = 1;
}
a = (struct mpatch_flist *)malloc(sizeof(struct mpatch_flist)); a = (struct mpatch_flist *)malloc(sizeof(struct mpatch_flist));
if (a) { if (a) {
a->base = (struct mpatch_frag *)malloc( a->base = (struct mpatch_frag *)malloc(
sizeof(struct mpatch_frag) * size); sizeof(struct mpatch_frag) * size);
if (a->base) { if (a->base) {
a->head = a->tail = a->base; a->head = a->tail = a->base;
return a; return a;
static int gather(struct mpatch_flist *dest, struct mpatch_flist *src, int cut, static int gather(struct mpatch_flist *dest, struct mpatch_flist *src, int cut,
int offset) int offset)
{ {
struct mpatch_frag *d = dest->tail, *s = src->head; struct mpatch_frag *d = dest->tail, *s = src->head;
int postend, c, l; int postend, c, l;
while (s != src->tail) { while (s != src->tail) {
int soffset = s->start; int soffset = s->start;
if (!safeadd(offset, &soffset)) if (!safeadd(offset, &soffset)) {
break; /* add would overflow, oh well */ break; /* add would overflow, oh well */
if (soffset >= cut) }
if (soffset >= cut) {
break; /* we've gone far enough */ break; /* we've gone far enough */
}
postend = offset; postend = offset;
if (!safeadd(s->start, &postend) || if (!safeadd(s->start, &postend) ||
!safeadd(s->len, &postend)) { !safeadd(s->len, &postend)) {
break; break;
} }
if (postend <= cut) { if (postend <= cut) {
/* save this hunk */ /* save this hunk */
} }
*d++ = *s++; *d++ = *s++;
} else { } else {
/* break up this hunk */ /* break up this hunk */
c = cut; c = cut;
if (!safesub(offset, &c)) { if (!safesub(offset, &c)) {
break; break;
} }
if (s->end < c) if (s->end < c) {
c = s->end; c = s->end;
}
l = cut - offset - s->start; l = cut - offset - s->start;
if (s->len < l) if (s->len < l) {
l = s->len; l = s->len;
}
offset += s->start + l - c; offset += s->start + l - c;
d->start = s->start; d->start = s->start;
d->end = c; d->end = c;
d->len = l; d->len = l;
d->data = s->data; d->data = s->data;
d++; d++;
struct mpatch_frag *s = src->head; struct mpatch_frag *s = src->head;
int postend, c, l; int postend, c, l;
while (s != src->tail) { while (s != src->tail) {
int cmpcut = s->start; int cmpcut = s->start;
if (!safeadd(offset, &cmpcut)) { if (!safeadd(offset, &cmpcut)) {
break; break;
} }
if (cmpcut >= cut) if (cmpcut >= cut) {
break; break;
}
postend = offset; postend = offset;
if (!safeadd(s->start, &postend)) { if (!safeadd(s->start, &postend)) {
break; break;
} }
if (!safeadd(s->len, &postend)) { if (!safeadd(s->len, &postend)) {
break; break;
} }
break; break;
} }
s++; s++;
} else { } else {
c = cut; c = cut;
if (!safesub(offset, &c)) { if (!safesub(offset, &c)) {
break; break;
} }
if (s->end < c) if (s->end < c) {
c = s->end; c = s->end;
}
l = cut - offset - s->start; l = cut - offset - s->start;
if (s->len < l) if (s->len < l) {
l = s->len; l = s->len;
}
offset += s->start + l - c; offset += s->start + l - c;
s->start = c; s->start = c;
s->len = s->len - l; s->len = s->len - l;
s->data = s->data + l; s->data = s->data + l;
break; break;
} }
} }
src->head = s; src->head = s;
return offset; return offset;
} }
/* combine hunk lists a and b, while adjusting b for offset changes in a/ /* combine hunk lists a and b, while adjusting b for offset changes in a/
this deletes a and b and returns the resultant list. */ this deletes a and b and returns the resultant list. */
static struct mpatch_flist *combine(struct mpatch_flist *a, static struct mpatch_flist *combine(struct mpatch_flist *a,
struct mpatch_flist *b) struct mpatch_flist *b)
{ {
struct mpatch_flist *c = NULL; struct mpatch_flist *c = NULL;
struct mpatch_frag *bh, *ct; struct mpatch_frag *bh, *ct;
int offset = 0, post; int offset = 0, post;
if (a && b) if (a && b) {
c = lalloc((lsize(a) + lsize(b)) * 2); c = lalloc((lsize(a) + lsize(b)) * 2);
}
if (c) { if (c) {
for (bh = b->head; bh != b->tail; bh++) { for (bh = b->head; bh != b->tail; bh++) {
/* save old hunks */ /* save old hunks */
offset = gather(c, a, bh->start, offset); offset = gather(c, a, bh->start, offset);
/* discard replaced hunks */ /* discard replaced hunks */
int mpatch_decode(const char *bin, ssize_t len, struct mpatch_flist **res) int mpatch_decode(const char *bin, ssize_t len, struct mpatch_flist **res)
{ {
struct mpatch_flist *l; struct mpatch_flist *l;
struct mpatch_frag *lt; struct mpatch_frag *lt;
int pos = 0; int pos = 0;
/* assume worst case size, we won't have many of these lists */ /* assume worst case size, we won't have many of these lists */
l = lalloc(len / 12 + 1); l = lalloc(len / 12 + 1);
if (!l) if (!l) {
return MPATCH_ERR_NO_MEM; return MPATCH_ERR_NO_MEM;
}
lt = l->tail; lt = l->tail;
/* We check against len-11 to ensure we have at least 12 bytes /* We check against len-11 to ensure we have at least 12 bytes
left in the patch so we can read our three be32s out of it. */ left in the patch so we can read our three be32s out of it. */
while (pos >= 0 && pos < (len - 11)) { while (pos >= 0 && pos < (len - 11)) {
lt->start = getbe32(bin + pos); lt->start = getbe32(bin + pos);
lt->end = getbe32(bin + pos + 4); lt->end = getbe32(bin + pos + 4);
lt->len = getbe32(bin + pos + 8); lt->len = getbe32(bin + pos + 8);
if (lt->start < 0 || lt->start > lt->end || lt->len < 0) if (lt->start < 0 || lt->start > lt->end || lt->len < 0) {
break; /* sanity check */ break; /* sanity check */
}
if (!safeadd(12, &pos)) { if (!safeadd(12, &pos)) {
break; break;
} }
lt->data = bin + pos; lt->data = bin + pos;
if (!safeadd(lt->len, &pos)) { if (!safeadd(lt->len, &pos)) {
break; break;
} }
lt++; lt++;

rust/chg/src/sighandlers.c

pid_t killpid = peerpgid > 1 ? -peerpgid : peerpid; pid_t killpid = peerpgid > 1 ? -peerpgid : peerpid;
(void)kill(killpid, sig); (void)kill(killpid, sig);
} }
static void handlestopsignal(int sig) static void handlestopsignal(int sig)
{ {
sigset_t unblockset, oldset; sigset_t unblockset, oldset;
struct sigaction sa, oldsa; struct sigaction sa, oldsa;
if (sigemptyset(&unblockset) < 0) if (sigemptyset(&unblockset) < 0) {
return; return;
if (sigaddset(&unblockset, sig) < 0) }
if (sigaddset(&unblockset, sig) < 0) {
return; return;
}
memset(&sa, 0, sizeof(sa)); memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_DFL; sa.sa_handler = SIG_DFL;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigemptyset(&sa.sa_mask) < 0) if (sigemptyset(&sa.sa_mask) < 0) {
return; return;
}
forwardsignal(sig); forwardsignal(sig);
if (raise(sig) < 0) /* resend to self */ if (raise(sig) < 0) { /* resend to self */
return; return;
if (sigaction(sig, &sa, &oldsa) < 0) }
if (sigaction(sig, &sa, &oldsa) < 0) {
return; return;
if (sigprocmask(SIG_UNBLOCK, &unblockset, &oldset) < 0) }
if (sigprocmask(SIG_UNBLOCK, &unblockset, &oldset) < 0) {
return; return;
}
/* resent signal will be handled before sigprocmask() returns */ /* resent signal will be handled before sigprocmask() returns */
if (sigprocmask(SIG_SETMASK, &oldset, NULL) < 0) if (sigprocmask(SIG_SETMASK, &oldset, NULL) < 0) {
return; return;
if (sigaction(sig, &oldsa, NULL) < 0) }
if (sigaction(sig, &oldsa, NULL) < 0) {
return; return;
} }
}
/* /*
* Installs signal handlers. * Installs signal handlers.
* *
* Returns 0 on success, -1 on error and errno is set appropriately. * Returns 0 on success, -1 on error and errno is set appropriately.
* Installed handlers wouldn't be cleaned up on error. * Installed handlers wouldn't be cleaned up on error.
*/ */
int setupsignalhandler(pid_t pid, pid_t pgid) int setupsignalhandler(pid_t pid, pid_t pgid)
memset(&sa, 0, sizeof(sa)); memset(&sa, 0, sizeof(sa));
/* deadly signals meant to be sent to a process group: /* deadly signals meant to be sent to a process group:
* - SIGHUP: usually generated by the kernel, when termination of a * - SIGHUP: usually generated by the kernel, when termination of a
* process causes that process group to become orphaned * process causes that process group to become orphaned
* - SIGINT: usually generated by the terminal */ * - SIGINT: usually generated by the terminal */
sa.sa_handler = forwardsignaltogroup; sa.sa_handler = forwardsignaltogroup;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigemptyset(&sa.sa_mask) < 0) if (sigemptyset(&sa.sa_mask) < 0) {
return -1; return -1;
if (sigaction(SIGHUP, &sa, NULL) < 0) }
if (sigaction(SIGHUP, &sa, NULL) < 0) {
return -1; return -1;
if (sigaction(SIGINT, &sa, NULL) < 0) }
if (sigaction(SIGINT, &sa, NULL) < 0) {
return -1; return -1;
}
/* terminate frontend by double SIGTERM in case of server freeze */ /* terminate frontend by double SIGTERM in case of server freeze */
sa.sa_handler = forwardsignal; sa.sa_handler = forwardsignal;
sa.sa_flags |= SA_RESETHAND; sa.sa_flags |= SA_RESETHAND;
if (sigaction(SIGTERM, &sa, NULL) < 0) if (sigaction(SIGTERM, &sa, NULL) < 0) {
return -1; return -1;
}
/* notify the worker about window resize events */ /* notify the worker about window resize events */
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigaction(SIGWINCH, &sa, NULL) < 0) if (sigaction(SIGWINCH, &sa, NULL) < 0) {
return -1; return -1;
}
/* forward user-defined signals */ /* forward user-defined signals */
if (sigaction(SIGUSR1, &sa, NULL) < 0) if (sigaction(SIGUSR1, &sa, NULL) < 0) {
return -1; return -1;
if (sigaction(SIGUSR2, &sa, NULL) < 0) }
if (sigaction(SIGUSR2, &sa, NULL) < 0) {
return -1; return -1;
}
/* propagate job control requests to worker */ /* propagate job control requests to worker */
sa.sa_handler = forwardsignal; sa.sa_handler = forwardsignal;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigaction(SIGCONT, &sa, NULL) < 0) if (sigaction(SIGCONT, &sa, NULL) < 0) {
return -1; return -1;
}
sa.sa_handler = handlestopsignal; sa.sa_handler = handlestopsignal;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigaction(SIGTSTP, &sa, NULL) < 0) if (sigaction(SIGTSTP, &sa, NULL) < 0) {
return -1; return -1;
}
return 0; return 0;
} }
/* /*
* Restores signal handlers to the default, and masks SIGINT. * Restores signal handlers to the default, and masks SIGINT.
* *
* Returns 0 on success, -1 on error and errno is set appropriately. * Returns 0 on success, -1 on error and errno is set appropriately.
*/ */
int restoresignalhandler(void) int restoresignalhandler(void)
{ {
struct sigaction sa; struct sigaction sa;
memset(&sa, 0, sizeof(sa)); memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_DFL; sa.sa_handler = SIG_DFL;
sa.sa_flags = SA_RESTART; sa.sa_flags = SA_RESTART;
if (sigemptyset(&sa.sa_mask) < 0) if (sigemptyset(&sa.sa_mask) < 0) {
return -1; return -1;
}
if (sigaction(SIGHUP, &sa, NULL) < 0) if (sigaction(SIGHUP, &sa, NULL) < 0) {
return -1; return -1;
if (sigaction(SIGTERM, &sa, NULL) < 0) }
if (sigaction(SIGTERM, &sa, NULL) < 0) {
return -1; return -1;
if (sigaction(SIGWINCH, &sa, NULL) < 0) }
if (sigaction(SIGWINCH, &sa, NULL) < 0) {
return -1; return -1;
if (sigaction(SIGCONT, &sa, NULL) < 0) }
if (sigaction(SIGCONT, &sa, NULL) < 0) {
return -1; return -1;
if (sigaction(SIGTSTP, &sa, NULL) < 0) }
if (sigaction(SIGTSTP, &sa, NULL) < 0) {
return -1; return -1;
}
/* ignore Ctrl+C while shutting down to make pager exits cleanly */ /* ignore Ctrl+C while shutting down to make pager exits cleanly */
sa.sa_handler = SIG_IGN; sa.sa_handler = SIG_IGN;
if (sigaction(SIGINT, &sa, NULL) < 0) if (sigaction(SIGINT, &sa, NULL) < 0) {
return -1; return -1;
}
peerpid = 0; peerpid = 0;
return 0; return 0;
} }