int
mkdirp(const char *path, mode_t mode, mode_t pmode)
{
char tmp[PATH_MAX], *p;
struct stat st;
if (stat(path, &st) == 0) {
if (S_ISDIR(st.st_mode))
return 0;
errno = ENOTDIR;
weprintf("%s:", path);
return -1;
}
estrlcpy(tmp, path, sizeof(tmp));
for (p = tmp + (tmp[0] == '/'); *p; p++) {
if (*p != '/')
continue;
*p = '\0';
if (mkdir(tmp, pmode) < 0 && errno != EEXIST) {
weprintf("mkdir %s:", tmp);
return -1;
}
*p = '/';
}
if (mkdir(tmp, mode) < 0 && errno != EEXIST) {
weprintf("mkdir %s:", tmp);
return -1;
}
return 0;
}
int
main(int argc, char *argv[])
{
mode_t mode = 0, mask;
int mflag = 0, ret = 0;
ARGBEGIN {
case 'm':
mflag = 1;
mask = getumask();
mode = parsemode(EARGF(usage()), mode, mask);
break;
default:
usage();
} ARGEND;
if (!argc)
usage();
for (; *argv; argc--, argv++) {
if (mkfifo(*argv, S_IRUSR | S_IWUSR | S_IRGRP |
S_IWGRP | S_IROTH | S_IWOTH) < 0) {
weprintf("mkfifo %s:", *argv);
ret = 1;
} else if (mflag) {
if (chmod(*argv, mode) < 0) {
weprintf("chmod %s:", *argv);
ret = 1;
}
}
}
return ret;
}
void setup_signal_handlers()
{
struct sigaction feh_sh;
sigset_t feh_ss;
if (
(sigemptyset(&feh_ss) == -1) ||
(sigaddset(&feh_ss, SIGUSR1) == -1) ||
(sigaddset(&feh_ss, SIGUSR2) == -1))
{
weprintf("Failed to set up signal mask, SIGUSR1/2 won't work");
return;
}
feh_sh.sa_handler = feh_handle_signal;
feh_sh.sa_mask = feh_ss;
feh_sh.sa_flags = 0;
if (
(sigaction(SIGUSR1, &feh_sh, NULL) == -1) ||
(sigaction(SIGUSR2, &feh_sh, NULL) == -1))
{
weprintf("Failed to set up signal handler, SIGUSR1/2 won't work");
return;
}
return;
}
static int
mounted(const char *dir)
{
FILE *fp;
struct mntent *me, mebuf;
struct stat st1, st2;
char linebuf[256];
if (stat(dir, &st1) < 0) {
weprintf("stat %s:", dir);
return 0;
}
if (!(fp = setmntent("/proc/mounts", "r")))
eprintf("setmntent %s:", "/proc/mounts");
while ((me = getmntent_r(fp, &mebuf, linebuf, sizeof(linebuf)))) {
if (stat(me->mnt_dir, &st2) < 0) {
weprintf("stat %s:", me->mnt_dir);
continue;
}
if (st1.st_dev == st2.st_dev &&
st1.st_ino == st2.st_ino)
return 1;
}
endmntent(fp);
return 0;
}
static int
pri_exec(struct arg *arg)
{
int status;
size_t len;
pid_t pid;
char **sp, ***brace;
struct execarg *e = arg->extra.p;
if (e->isplus) {
len = strlen(arg->path) + 1;
/* if we reached ARG_MAX, fork, exec, wait, free file names, reset list */
if (len + e->u.p.arglen + e->u.p.filelen + envlen > argmax) {
e->argv[e->u.p.next] = NULL;
switch((pid = fork())) {
case -1:
eprintf("fork:");
case 0:
execvp(*e->argv, e->argv);
weprintf("exec %s failed:", *e->argv);
_exit(1);
}
waitpid(pid, &status, 0);
gflags.ret = gflags.ret || status;
for (sp = e->argv + e->u.p.first; *sp; sp++)
free(*sp);
e->u.p.next = e->u.p.first;
e->u.p.filelen = 0;
}
/* if we have too many files, realloc (with space for NULL termination) */
if (e->u.p.next + 1 == e->u.p.cap)
e->argv = ereallocarray(e->argv, e->u.p.cap *= 2, sizeof(*e->argv));
e->argv[e->u.p.next++] = estrdup(arg->path);
e->u.p.filelen += len + sizeof(arg->path);
return 1;
} else {
/* insert path everywhere user gave us {} */
for (brace = e->u.s.braces; *brace; brace++)
**brace = arg->path;
switch((pid = fork())) {
case -1:
eprintf("fork:");
case 0:
execvp(*e->argv, e->argv);
weprintf("exec %s failed:", *e->argv);
_exit(1);
}
/* FIXME: propper course of action for all waitpid() on EINTR? */
waitpid(pid, &status, 0);
return !!status;
}
}
static int
mounthelper(const char *fsname, const char *dir, const char *fstype)
{
pid_t pid;
char eprog[PATH_MAX];
char const *eargv[10];
int status, i;
pid = fork();
switch(pid) {
case -1:
break;
case 0:
snprintf(eprog, sizeof(eprog), "mount.%s", fstype);
i = 0;
eargv[i++] = eprog;
if (argflags & MS_BIND)
eargv[i++] = "-B";
if (argflags & MS_MOVE)
eargv[i++] = "-M";
if (argflags & MS_REC)
eargv[i++] = "-R";
if (argopts) {
eargv[i++] = "-o";
eargv[i++] = argopts;
}
eargv[i++] = fsname;
eargv[i++] = dir;
eargv[i] = NULL;
execvp(eprog, (char * const *)eargv);
if (errno == ENOENT)
_exit(1);
weprintf("execvp:");
_exit(1);
break;
default:
if (waitpid(pid, &status, 0) < 0) {
weprintf("waitpid:");
return -1;
}
if (WIFEXITED(status))
return WEXITSTATUS(status);
else if (WIFSIGNALED(status))
return 1;
break;
}
return 0;
}
int resolve_v6name(const char *name, in6_addr *v6addr)
{
in_addr v4addr;
// if the name is just an address, convert it to binary
if (inet_pton(AF_INET6, name, v6addr))
return 0;
else if (inet_pton(AF_INET, name, &v4addr)) {
to_v6addr(v4addr.s_addr, v6addr);
return 0;
}
// otherwise, resolve the name
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET6; // accept v6 addrs
struct addrinfo *result;
if (getaddrinfo(name, NULL, NULL, &result) != 0) {
weprintf("getaddrinfo(%s) failed:", name);
return -1;
}
if (result->ai_family == AF_INET)
to_v6addr(((struct sockaddr_in *)result->ai_addr)->sin_addr.s_addr,
v6addr);
else
v6_addr_copy(v6addr,
&((struct sockaddr_in6 *)result->ai_addr)->sin6_addr);
freeaddrinfo(result);
return 0;
}
static void check_options(void)
{
int i;
for (i = 0; i < 10; i++) {
if (opt.actions[i] && !opt.hold_actions[i] && (opt.actions[i][0] == ';')) {
opt.hold_actions[i] = 1;
opt.actions[i] = &opt.actions[i][1];
}
}
if ((opt.index + opt.collage) > 1) {
weprintf("you can't use collage mode and index mode together.\n"
" I'm going with index");
opt.collage = 0;
}
if (opt.full_screen && opt.multiwindow) {
eprintf("You cannot combine --fullscreen with --multiwindow");
}
if (opt.list && (opt.multiwindow || opt.index || opt.collage)) {
eprintf("You cannot combine --list with other modes");
}
if (opt.loadables && opt.unloadables) {
eprintf("You cannot combine --loadable with --unloadable");
}
return;
}
static int
mnt_show(const char *fsname, const char *dir)
{
struct statvfs s;
unsigned long long total, used, avail;
int capacity = 0;
int bs;
if (statvfs(dir, &s) < 0) {
weprintf("statvfs %s:", dir);
return -1;
}
bs = s.f_frsize / blksize;
total = s.f_blocks * bs;
avail = s.f_bfree * bs;
used = total - avail;
if (used + avail) {
capacity = (used * 100) / (used + avail);
if (used * 100 != capacity * (used + avail))
capacity++;
}
if (hflag)
print_human(fsname, total, used, avail, capacity, dir);
else
printf("%-12s %9llu %9llu %9llu %7d%% %s\n",
fsname, total, used, avail, capacity, dir);
return 0;
}
int
main(int argc, char *argv[])
{
char *path;
int found = 0, foundall = 1;
ARGBEGIN {
case 'a':
aflag = 1;
break;
default:
usage();
} ARGEND
if (!argc)
usage();
if (!(path = getenv("PATH")))
enprintf(3, "$PATH is not set\n");
for (; *argv; argc--, argv++) {
if (which(path, *argv)) {
found = 1;
} else {
weprintf("%s: command not found.\n", *argv);
foundall = 0;
}
}
return found ? foundall ? 0 : 1 : 2;
}
static void feh_set_parse_bb_partial(fehbutton *button, char *binding)
{
char *cur = binding;
int mod = 0;
if (!*binding) {
button->button = 0;
return;
}
while (cur[1] == '-') {
switch (cur[0]) {
case 'C':
mod |= ControlMask;
break;
case 'S':
mod |= ShiftMask;
break;
case '1':
mod |= Mod1Mask;
break;
case '4':
mod |= Mod4Mask;
break;
default:
weprintf("buttons: invalid modifier %c in \"%s\"", cur[0], binding);
break;
}
cur += 2;
}
button->button = atoi(cur);
button->modifier = mod;
}
int
main(int argc, char *argv[])
{
int savederrno;
ARGBEGIN {
case 'i':
if (environ)
*environ = NULL;
break;
case 'u':
unsetenv(EARGF(usage()));
break;
default:
usage();
} ARGEND;
for (; *argv && strchr(*argv, '='); argc--, argv++)
putenv(*argv);
if (*argv) {
execvp(*argv, argv);
savederrno = errno;
weprintf("execvp %s:", *argv);
_exit(126 + (savederrno == EEXIST));
}
for (; environ && *environ; environ++)
puts(*environ);
return fshut(stdout, "<stdout>");
}
char *feh_http_load_image(char *url)
{
weprintf(
"Cannot load image %s\n Please recompile with libcurl support",
url
);
return NULL;
}
void *wemalloc(size_t n)
{
void *p;
p = malloc(n);
if (p == NULL)
weprintf("malloc of %u bytes failed:", n);
return p;
}
void *werealloc(void *vp, size_t n)
{
void *p;
p = realloc(vp, n);
if (p == NULL)
weprintf("realloc of %u bytes failed:", n);
return p;
}
char *westrdup(const char *s)
{
char *t;
t = malloc((strlen(s)+1)*sizeof(char));
if (t == NULL)
weprintf("estrdup(\"%.20s\") failed:", s);
strcpy(t, s);
return t;
}
int
main(int argc, char *argv[])
{
int i;
int ret = 0;
int all = 0;
struct mntent *me;
FILE *fp;
ARGBEGIN {
case 'a':
all = 1;
break;
default:
usage();
} ARGEND;
if ((!all && argc < 1) || (all && argc > 0))
usage();
if (all) {
fp = setmntent("/etc/fstab", "r");
if (!fp)
eprintf("setmntent %s:", "/etc/fstab");
while ((me = getmntent(fp)) != NULL) {
if (strcmp(me->mnt_type, MNTTYPE_SWAP) == 0) {
if (swapoff(me->mnt_fsname) < 0) {
weprintf("swapoff %s:", me->mnt_fsname);
ret = 1;
}
}
}
endmntent(fp);
} else {
for (i = 0; i < argc; i++) {
if (swapoff(argv[i]) < 0) {
weprintf("swapoff %s:", argv[i]);
ret = 1;
}
}
}
return ret;
}
/* handle_packet: snarf packet from network and dispatch */
void
handle_packet(int network)
{
int packet_len, from_len;
struct sockaddr_in from;
byte buf[BUFSIZE];
from_len = sizeof(from);
packet_len = recvfrom(network, buf, sizeof(buf), 0,
(struct sockaddr *) &from, &from_len);
if (packet_len < 0) {
if (errno != EAGAIN) {
weprintf("recvfrom failed:"); /* ignore errors for now */
return;
}
weprintf("handle_packet: EAGAIN");
return; /* pick up this packet later */
}
dispatch(&srv, packet_len, buf);
}
static int
parsepair(char *pair)
{
char *p;
char *variable;
char *value;
for (p = pair; *p; p++) {
if (p[0] == '.' && p[1] == '.') {
weprintf("malformed input: %s\n", pair);
return -1;
}
}
p = strchr(pair, '=');
if (p) {
if (p[1] == '\0') {
weprintf("malformed input: %s\n", pair);
return -1;
}
*p = '\0';
value = &p[1];
} else {
value = NULL;
}
variable = pair;
if (value) {
if (setsysctl(variable, value) < 0) {
weprintf("failed to set sysctl for %s\n", variable);
return -1;
}
} else {
if (getsysctl(variable, &value) < 0) {
weprintf("failed to get sysctl for %s\n", variable);
return -1;
}
printf("%s = %s\n", variable, value);
free(value);
}
return 0;
}
void send_raw_v6(int sock, in6_addr *addr, in_port_t port, int n, uchar *buf)
{
struct sockaddr_in6 dest;
memset(&dest, 0, sizeof(dest));
dest.sin6_family = AF_INET6;
dest.sin6_port = htons(port);
v6_addr_copy(&dest.sin6_addr, addr);
if (sendto(sock, buf, n, 0, (struct sockaddr *)&dest, sizeof(dest)) < 0)
weprintf("sendto failed:");
}
void send_raw_v4(int sock, in6_addr *addr, in_port_t port, int n, uchar *buf)
{
struct sockaddr_in dest;
assert(V4_MAPPED(addr));
memset(&dest, 0, sizeof(dest));
dest.sin_family = AF_INET;
dest.sin_port = htons(port);
dest.sin_addr.s_addr = to_v4addr(addr);
if (sendto(sock, buf, n, 0, (struct sockaddr *)&dest, sizeof(dest)) < 0)
weprintf("sendto failed:");
}
void setup_signal_handlers()
{
reload_signal_flag = 0;
struct sigaction feh_sh;
sigset_t feh_ss;
if (
(sigemptyset(&feh_ss) == -1) ||
(sigaddset(&feh_ss, SIGUSR1) == -1) ||
(sigaddset(&feh_ss, SIGUSR2) == -1) ||
(sigaddset(&feh_ss, SIGALRM) == -1) ||
(sigaddset(&feh_ss, SIGTERM) == -1) ||
(sigaddset(&feh_ss, SIGQUIT) == -1) ||
(sigaddset(&feh_ss, SIGINT) == -1) ||
(sigaddset(&feh_ss, SIGURG) == -1))
{
weprintf("Failed to set up signal masks");
return;
}
feh_sh.sa_handler = feh_handle_signal;
feh_sh.sa_mask = feh_ss;
feh_sh.sa_flags = 0;
if (
(sigaction(SIGUSR1, &feh_sh, NULL) == -1) ||
(sigaction(SIGUSR2, &feh_sh, NULL) == -1) ||
(sigaction(SIGALRM, &feh_sh, NULL) == -1) ||
(sigaction(SIGTERM, &feh_sh, NULL) == -1) ||
(sigaction(SIGQUIT, &feh_sh, NULL) == -1) ||
(sigaction(SIGINT, &feh_sh, NULL) == -1) ||
(sigaction(SIGURG, &feh_sh, NULL) == -1))
{
weprintf("Failed to set up signal handler");
return;
}
return;
}
static void feh_set_parse_kb_partial(fehkey *key, int index, char *ks) {
char *cur = ks;
int mod = 0;
if (!*ks) {
key->keysyms[index] = 0;
return;
}
while (cur[1] == '-') {
switch (cur[0]) {
case 'C':
mod |= ControlMask;
break;
case 'S':
mod |= ShiftMask;
break;
case '1':
mod |= Mod1Mask;
break;
case '4':
mod |= Mod4Mask;
break;
default:
weprintf("keys: invalid modifier %c in \"%s\"", cur[0], ks);
break;
}
cur += 2;
}
key->keysyms[index] = XStringToKeysym(cur);
if (isascii(key->keysyms[index]))
mod &= ~ShiftMask;
key->keystates[index] = mod;
if (key->keysyms[index] == NoSymbol)
weprintf("keys: Invalid keysym: %s", cur);
}
/* grep main: search for regexp in files */
int main(int argc, char *argv[])
{
int i, o, nmatch;
struct re *regexp;
FILE *f;
setprogname("grep");
while ((o = getopt(argc, argv, "cnv")) != -1) {
switch (o) {
case 'c':
count_only = 1;
break;
case 'n':
line_numbers = 1;
break;
case 'v':
invert = 1;
break;
case '?':
default:
/* getopt prints an error message */
exit(2);
break;
}
}
if (optind == argc)
eprintf("usage: grep regexp [file ...]");
nmatch = 0;
regexp = compile(argv[optind]);
if (regexp == NULL)
eprintf("can't compile regular expression");
if (argc - optind == 1) {
if (grep(regexp, stdin, NULL))
nmatch++;
} else {
for (i = optind + 1; i < argc; i++) {
f = fopen(argv[i], "r");
if (f == NULL) {
weprintf("can't open %s:", argv[i]);
continue;
}
if (grep(regexp, f, argc - optind>2 ? argv[i] : NULL) > 0)
nmatch++;
fclose(f);
}
}
freeregexp(regexp);
return nmatch == 0;
}
void feh_event_handle_stdin()
{
char stdin_buf[2];
static char is_esc = 0;
KeySym keysym = NoSymbol;
if (read(STDIN_FILENO, &stdin_buf, 1) == -1) {
control_via_stdin = 0;
if (isatty(STDIN_FILENO) && getpgrp() == (tcgetpgrp(STDIN_FILENO))) {
weprintf("reading a command from stdin failed - disabling control via stdin");
restore_stdin();
}
return;
}
stdin_buf[1] = '\0';
// escape?
if (stdin_buf[0] == 0x1b) {
is_esc = 1;
return;
}
if ((is_esc == 1) && (stdin_buf[0] == '[')) {
is_esc = 2;
return;
}
if (stdin_buf[0] == ' ')
keysym = XK_space;
else if (stdin_buf[0] == '\n')
keysym = XK_Return;
else if ((stdin_buf[0] == '\b') || (stdin_buf[0] == 127))
keysym = XK_BackSpace;
else if (is_esc == 2) {
if (stdin_buf[0] == 'A')
keysym = XK_Up;
else if (stdin_buf[0] == 'B')
keysym = XK_Down;
else if (stdin_buf[0] == 'C')
keysym = XK_Right;
else if (stdin_buf[0] == 'D')
keysym = XK_Left;
is_esc = 0;
}
else
keysym = XStringToKeysym(stdin_buf);
if (window_num)
feh_event_handle_generic(windows[0], is_esc * Mod1Mask, keysym, 0);
is_esc = 0;
}
int
main(int argc, char *argv[])
{
int cflag = 0, sflag = 0;
int fd, i, ret = 0;
long size = 0;
ARGBEGIN {
case 's':
sflag = 1;
size = estrtol(EARGF(usage()), 10);
break;
case 'c':
cflag = 1;
break;
default:
usage();
} ARGEND;
if (argc < 1 || sflag == 0)
usage();
for (i = 0; i < argc; i++) {
fd = open(argv[i], O_WRONLY | (cflag ? 0 : O_CREAT), 0644);
if (fd < 0) {
weprintf("open: cannot open `%s' for writing:", argv[i]);
ret = 1;
continue;
}
if (ftruncate(fd, size) < 0) {
weprintf("ftruncate: cannot open `%s' for writing:", argv[i]);
ret = 1;
}
close(fd);
}
return ret;
}
void feh_edit_inplace_lossless(winwidget w, int op)
{
char *filename = FEH_FILE(w->file->data)->filename;
int len = strlen(filename) + 1;
char *file_str = emalloc(len);
int pid, status;
int devnull = -1;
char op_name[] = "rotate"; /* message */
char op_op[] = "-rotate"; /* jpegtran option */
char op_value[] = "horizontal"; /* jpegtran option's value */
if (op == INPLACE_EDIT_FLIP) {
sprintf(op_name, "flip");
sprintf(op_op, "-flip");
sprintf(op_value, "vertical");
} else if (op == INPLACE_EDIT_MIRROR) {
sprintf(op_name, "mirror");
sprintf(op_op, "-flip");
} else
snprintf(op_value, 4, "%d", 90 * op);
snprintf(file_str, len, "%s", filename);
if ((pid = fork()) < 0) {
im_weprintf(w, "lossless %s: fork failed:", op_name);
free(file_str);
return;
}
else if (pid == 0) {
execlp("jpegtran", "jpegtran", "-copy", "all", op_op, op_value,
"-outfile", file_str, file_str, NULL);
weprintf("lossless %s: Is 'jpegtran' installed? Failed to exec:", op_name);
_exit(1);
}
else {
waitpid(pid, &status, 0);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
im_weprintf(w,
"lossless %s: Got exitcode %d from jpegtran."
" Commandline was: "
"jpegtran -copy all %s %s -outfile %s %s",
op_name, status >> 8, op_op, op_value, file_str, file_str);
free(file_str);
return;
}
}
int
fshut(FILE *fp, const char *fname)
{
int ret = 0;
/* fflush() is undefined for input streams by ISO C,
* but not POSIX 2008 if you ignore ISO C overrides.
* Leave it unchecked an rely on the following
* functions to detect errors.
*/
fflush(fp);
if (ferror(fp) && !ret) {
weprintf("ferror %s:", fname);
ret = 1;
}
if (fclose(fp) && !ret) {
weprintf("fclose %s:", fname);
ret = 1;
}
return ret;
}
static void who_am_i (kbicho_s *b)
{
bicho_msg_s m;
int rc;
m.m_method = BICHO_WHO_AM_I;
rc = call_tau(b->kb_key, &m);
if (rc) {
weprintf("who_am_i failed %d", rc);
return;
}
strlcpy(b->kb_name, m.bi_name, TAU_NAME);
uuid_copy(b->kb_id, m.bi_id);
PRs(b->kb_name);
}
/***************************************************************************
*
* Purpose: Get IP address of local machine by uname/gethostbyname
*
* Return: As an unsigned long in network byte order
*
**************************************************************************/
static uint32_t get_local_addr_uname()
{
struct utsname myname;
uint32_t addr;
if (uname(&myname) < 0)
weprintf("uname failed:");
else
addr = name_to_addr(myname.nodename);
if (addr == 0)
return inet_addr(TRIVIAL_LOCAL_ADDR);
else
return addr;
}
