int main(int argc, char **argv)
{
int ch, ret;
static const struct option longopts[] = {
{"version", no_argument, NULL, 'V'},
{"help", no_argument, NULL, 'h'},
{NULL, 0, NULL, 0}
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
close_stdout_atexit();
while ((ch = getopt_long(argc, argv, "Vh", longopts, NULL)) != -1)
switch (ch) {
case 'V':
print_version(EXIT_SUCCESS);
case 'h':
usage();
default:
errtryhelp(EXIT_FAILURE);
}
if (argc < 2)
ret = get_cad();
else
ret = set_cad(argv[1]);
return ret;
}
static void argscan(char *s)
{
int seen_num = 0;
while (*s != '\0') {
switch (*s) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (!seen_num) {
dlines = 0;
seen_num = 1;
}
dlines = dlines * 10 + *s - '0';
break;
case 'd':
dum_opt = 1;
break;
case 'l':
stop_opt = 0;
break;
case 'f':
fold_opt = 0;
break;
case 'p':
noscroll++;
break;
case 'c':
clreol++;
break;
case 's':
ssp_opt = 1;
break;
case 'u':
ul_opt = 0;
break;
case '-':
case ' ':
case '\t':
break;
case 'V':
printf(UTIL_LINUX_VERSION);
exit(EXIT_SUCCESS);
break;
default:
warnx(_("unknown option -%s"), s);
errtryhelp(EXIT_FAILURE);
break;
}
s++;
}
}
int main(int argc, char *argv[])
{
struct passwd *pw_entry;
struct group *gr_entry;
char *shell;
int ch;
static const struct option longopts[] = {
{"version", no_argument, NULL, 'V'},
{"help", no_argument, NULL, 'h'},
{NULL, 0, NULL, 0}
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
close_stdout_atexit();
while ((ch = getopt_long(argc, argv, "Vh", longopts, NULL)) != -1)
switch (ch) {
case 'V':
print_version(EXIT_SUCCESS);
case 'h':
usage();
default:
errtryhelp(EXIT_FAILURE);
}
if (!(pw_entry = getpwuid(getuid())))
err(EXIT_FAILURE, _("who are you?"));
if (argc < 2) {
if (setgid(pw_entry->pw_gid) < 0)
err(EXIT_FAILURE, _("setgid failed"));
} else {
errno = 0;
if (!(gr_entry = getgrnam(argv[1]))) {
if (errno)
err(EXIT_FAILURE, _("no such group"));
else
errx(EXIT_FAILURE, _("no such group"));
}
if (!allow_setgid(pw_entry, gr_entry))
errx(EXIT_FAILURE, _("permission denied"));
if (setgid(gr_entry->gr_gid) < 0)
err(EXIT_FAILURE, _("setgid failed"));
}
if (setuid(getuid()) < 0)
err(EXIT_FAILURE, _("setuid failed"));
fflush(NULL);
shell = (pw_entry->pw_shell && *pw_entry->pw_shell ?
pw_entry->pw_shell : _PATH_BSHELL);
execl(shell, shell, (char *)0);
errexec(shell);
}
int main(int argc, char **argv)
{
int c, fd, partno;
const char *wholedisk;
uint64_t start;
static const struct option longopts[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{NULL, no_argument, 0, '0'},
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while ((c = getopt_long(argc, argv, "Vh", longopts, NULL)) != -1)
switch (c) {
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
case 'h':
usage(stdout);
default:
errtryhelp(EXIT_FAILURE);
}
if (argc != 4)
usage(stderr);
wholedisk = argv[1];
partno = strtou32_or_err(argv[2], _("invalid partition number argument"));
if ((fd = open(wholedisk, O_RDONLY)) < 0)
err(EXIT_FAILURE, _("cannot open %s"), wholedisk);
if (get_partition_start(fd, partno, &start))
err(EXIT_FAILURE, _("%s: failed to get start of the partition number %s"),
wholedisk, argv[2]);
if (partx_resize_partition(fd, partno, start,
strtou64_or_err(argv[3], _("invalid length argument"))))
err(EXIT_FAILURE, _("failed to resize partition"));
if (close_fd(fd) != 0)
err(EXIT_FAILURE, _("write failed"));
return 0;
}
int main(int argc, char **argv)
{
int j, ct, opt, xflag = 0;
long divisor = 0;
static const struct option longopts[] = {
{"divisor", required_argument, NULL, 'd'},
{"sectors", no_argument, NULL, 'x'},
{"version", no_argument, NULL, 'V'},
{"help", no_argument, NULL, 'h'},
{NULL, 0, NULL, 0}
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while ((opt = getopt_long(argc, argv, "d:xVh", longopts, NULL)) != -1)
switch (opt) {
case 'd':
divisor =
strtol_or_err(optarg,
_("invalid divisor argument"));
break;
case 'x':
xflag = 1;
break;
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
case 'h':
usage(stdout);
default:
errtryhelp(EXIT_FAILURE);
}
ct = argc - optind;
if (ct <= 0)
usage(stderr);
for (j = optind; j < argc; j++)
isosize(ct, argv[j], xflag, divisor);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
struct setterm_control ctl = { NULL };
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
if (argc < 2) {
warnx(_("bad usage"));
errtryhelp(EXIT_FAILURE);
}
parse_option(&ctl, argc, argv);
init_terminal(&ctl);
perform_sequence(&ctl);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
unsigned long first = 0, last = 0;
int opt;
static const struct option longopts[] = {
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{NULL, 0, 0, 0}
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while ((opt =
getopt_long(argc, argv, "bfhl:pxVH", longopts,
NULL)) != -1)
switch (opt) {
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
case 'h':
usage(stdout);
default:
errtryhelp(EXIT_FAILURE);
}
if (argc > 1)
first = strtoul_or_err(*++argv, _("first argument"));
if (argc > 2)
last = strtoul_or_err(*++argv, _("second argument"));
while (process_input(first, last))
;
fflush(stdout);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
char *dev;
int c;
static const struct option longopts[] = {
{"version", no_argument, NULL, 'V'},
{"help", no_argument, NULL, 'h'},
{NULL, 0, NULL, 0}
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
if (argc != 2)
/* we return '2' for backward compatibility
* with version from e2fsprogs */
usage(FINDFS_USAGE_ERROR);
while ((c = getopt_long(argc, argv, "Vh", longopts, NULL)) != -1)
switch (c) {
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
case 'h':
usage(FINDFS_SUCCESS);
default:
errtryhelp(EXIT_FAILURE);
}
dev = blkid_evaluate_tag(argv[1], NULL, NULL);
if (!dev)
errx(FINDFS_NOT_FOUND, _("unable to resolve '%s'"), argv[1]);
puts(dev);
return FINDFS_SUCCESS;
}
int main(int argc, char **argv)
{
int c, fd;
static const struct option longopts[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{NULL, no_argument, 0, '0'},
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
while ((c = getopt_long(argc, argv, "Vh", longopts, NULL)) != -1)
switch (c) {
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
case 'h':
usage(stdout);
default:
errtryhelp(EXIT_FAILURE);
}
if (argc != 3)
usage(stderr);
if ((fd = open(argv[1], O_RDONLY)) < 0)
err(EXIT_FAILURE, _("cannot open %s"), argv[1]);
if (partx_del_partition(fd,
strtou32_or_err(argv[2], _("invalid partition number argument"))))
err(EXIT_FAILURE, _("failed to remove partition"));
return EXIT_SUCCESS;
}
static int set_sched_one_by_setscheduler(struct chrt_ctl *ctl, pid_t pid)
{
struct sched_param sp = { .sched_priority = ctl->priority };
int policy = ctl->policy;
errno = 0;
# ifdef SCHED_RESET_ON_FORK
if (ctl->reset_on_fork)
policy |= SCHED_RESET_ON_FORK;
# endif
return sched_setscheduler(pid, policy, &sp);
}
#ifndef HAVE_SCHED_SETATTR
static int set_sched_one(struct chrt_ctl *ctl, pid_t pid)
{
return set_sched_one_by_setscheduler(ctl, pid);
}
#else /* !HAVE_SCHED_SETATTR */
static int set_sched_one(struct chrt_ctl *ctl, pid_t pid)
{
struct sched_attr sa = { .size = sizeof(struct sched_attr) };
/* old API is good enough for non-deadline */
if (ctl->policy != SCHED_DEADLINE)
return set_sched_one_by_setscheduler(ctl, pid);
/* no changeed by chrt, follow the current setting */
sa.sched_nice = getpriority(PRIO_PROCESS, pid);
/* use main() to check if the setting makes sense */
sa.sched_policy = ctl->policy;
sa.sched_priority = ctl->priority;
sa.sched_runtime = ctl->runtime;
sa.sched_period = ctl->period;
sa.sched_deadline = ctl->deadline;
# ifdef SCHED_RESET_ON_FORK
if (ctl->reset_on_fork)
sa.sched_flags |= SCHED_RESET_ON_FORK;
# endif
errno = 0;
return sched_setattr(pid, &sa, 0);
}
#endif /* HAVE_SCHED_SETATTR */
static void set_sched(struct chrt_ctl *ctl)
{
if (ctl->all_tasks) {
pid_t tid;
struct proc_tasks *ts = proc_open_tasks(ctl->pid);
if (!ts)
err(EXIT_FAILURE, _("cannot obtain the list of tasks"));
while (!proc_next_tid(ts, &tid))
if (set_sched_one(ctl, tid) == -1)
err(EXIT_FAILURE, _("failed to set tid %d's policy"), tid);
proc_close_tasks(ts);
} else if (set_sched_one(ctl, ctl->pid) == -1)
err(EXIT_FAILURE, _("failed to set pid %d's policy"), ctl->pid);
ctl->altered = 1;
}
int main(int argc, char **argv)
{
struct chrt_ctl _ctl = { .pid = -1, .policy = SCHED_RR }, *ctl = &_ctl;
int c;
static const struct option longopts[] = {
{ "all-tasks", no_argument, NULL, 'a' },
{ "batch", no_argument, NULL, 'b' },
{ "deadline", no_argument, NULL, 'd' },
{ "fifo", no_argument, NULL, 'f' },
{ "idle", no_argument, NULL, 'i' },
{ "pid", no_argument, NULL, 'p' },
{ "help", no_argument, NULL, 'h' },
{ "max", no_argument, NULL, 'm' },
{ "other", no_argument, NULL, 'o' },
{ "rr", no_argument, NULL, 'r' },
{ "sched-runtime", required_argument, NULL, 'T' },
{ "sched-period", required_argument, NULL, 'P' },
{ "sched-deadline", required_argument, NULL, 'D' },
{ "reset-on-fork", no_argument, NULL, 'R' },
{ "verbose", no_argument, NULL, 'v' },
{ "version", no_argument, NULL, 'V' },
{ NULL, no_argument, NULL, 0 }
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while((c = getopt_long(argc, argv, "+abdD:fiphmoP:T:rRvV", longopts, NULL)) != -1)
{
switch (c) {
case 'a':
ctl->all_tasks = 1;
break;
case 'b':
#ifdef SCHED_BATCH
ctl->policy = SCHED_BATCH;
#endif
break;
case 'd':
#ifdef SCHED_DEADLINE
ctl->policy = SCHED_DEADLINE;
#endif
break;
case 'f':
ctl->policy = SCHED_FIFO;
break;
case 'R':
ctl->reset_on_fork = 1;
break;
case 'i':
#ifdef SCHED_IDLE
ctl->policy = SCHED_IDLE;
#endif
break;
case 'm':
show_min_max();
return EXIT_SUCCESS;
case 'o':
ctl->policy = SCHED_OTHER;
break;
case 'p':
errno = 0;
ctl->pid = strtos32_or_err(argv[argc - 1], _("invalid PID argument"));
break;
case 'r':
ctl->policy = SCHED_RR;
break;
case 'v':
ctl->verbose = 1;
break;
case 'T':
ctl->runtime = strtou64_or_err(optarg, _("invalid runtime argument"));
break;
case 'P':
ctl->period = strtou64_or_err(optarg, _("invalid period argument"));
break;
case 'D':
ctl->deadline = strtou64_or_err(optarg, _("invalid deadline argument"));
break;
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
case 'h':
show_usage(EXIT_SUCCESS);
default:
errtryhelp(EXIT_FAILURE);
}
}
if (((ctl->pid > -1) && argc - optind < 1) ||
((ctl->pid == -1) && argc - optind < 2))
show_usage(EXIT_FAILURE);
if ((ctl->pid > -1) && (ctl->verbose || argc - optind == 1)) {
show_sched_info(ctl);
if (argc - optind == 1)
return EXIT_SUCCESS;
}
errno = 0;
ctl->priority = strtos32_or_err(argv[optind], _("invalid priority argument"));
#ifdef SCHED_RESET_ON_FORK
if (ctl->reset_on_fork && ctl->policy != SCHED_FIFO && ctl->policy != SCHED_RR)
errx(EXIT_FAILURE, _("--reset-on-fork option is supported for "
"SCHED_FIFO and SCHED_RR policies only"));
#endif
#ifdef SCHED_DEADLINE
if ((ctl->runtime || ctl->deadline || ctl->period) && ctl->policy != SCHED_DEADLINE)
errx(EXIT_FAILURE, _("--sched-{runtime,deadline,period} options "
"are supported for SCHED_DEADLINE only"));
if (ctl->policy == SCHED_DEADLINE) {
/* The basic rule is runtime <= deadline <= period, so we can
* make deadline and runtime optional on command line. Note we
* don't check any values or set any defaults, it's kernel
* responsibility.
*/
if (ctl->deadline == 0)
ctl->deadline = ctl->period;
if (ctl->runtime == 0)
ctl->runtime = ctl->deadline;
}
#else
if (ctl->runtime || ctl->deadline || ctl->period)
errx(EXIT_FAILURE, _("SCHED_DEADLINE is unsupported"));
#endif
if (ctl->pid == -1)
ctl->pid = 0;
if (ctl->priority < sched_get_priority_min(ctl->policy) ||
sched_get_priority_max(ctl->policy) < ctl->priority)
errx(EXIT_FAILURE,
_("unsupported priority value for the policy: %d: see --max for valid range"),
ctl->priority);
set_sched(ctl);
if (ctl->verbose)
show_sched_info(ctl);
if (!ctl->pid) {
argv += optind + 1;
execvp(argv[0], argv);
err(EXIT_FAILURE, _("failed to execute %s"), argv[0]);
}
return EXIT_SUCCESS;
}
int
main(int argc, char *argv[])
{
FILE *tfile, *sfile;
const char *sname = NULL, *tname = NULL;
double divi = 1, maxdelay = 0;
int c, diviopt = FALSE, maxdelayopt = FALSE, idx;
unsigned long line;
int ch;
static const struct option longopts[] = {
{ "timing", required_argument, 0, 't' },
{ "typescript", required_argument, 0, 's' },
{ "divisor", required_argument, 0, 'd' },
{ "maxdelay", required_argument, 0, 'm' },
{ "version", no_argument, 0, 'V' },
{ "help", no_argument, 0, 'h' },
{ NULL, 0, 0, 0 }
};
/* Because we use space as a separator, we can't afford to use any
* locale which tolerates a space in a number. In any case, script.c
* sets the LC_NUMERIC locale to C, anyway.
*/
setlocale(LC_ALL, "");
setlocale(LC_NUMERIC, "C");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while ((ch = getopt_long(argc, argv, "t:s:d:m:Vh", longopts, NULL)) != -1)
switch(ch) {
case 't':
tname = optarg;
break;
case 's':
sname = optarg;
break;
case 'd':
diviopt = TRUE;
divi = getnum(optarg);
break;
case 'm':
maxdelayopt = TRUE;
maxdelay = getnum(optarg);
break;
case 'V':
printf(UTIL_LINUX_VERSION);
exit(EXIT_SUCCESS);
case 'h':
usage(stdout);
default:
errtryhelp(EXIT_FAILURE);
}
argc -= optind;
argv += optind;
idx = 0;
if ((argc < 1 && !tname) || argc > 3) {
warnx(_("wrong number of arguments"));
errtryhelp(EXIT_FAILURE);
}
if (!tname)
tname = argv[idx++];
if (!sname)
sname = idx < argc ? argv[idx++] : "typescript";
if (!diviopt)
divi = idx < argc ? getnum(argv[idx]) : 1;
if (maxdelay < 0)
maxdelay = 0;
tfile = fopen(tname, "r");
if (!tfile)
err(EXIT_FAILURE, _("cannot open %s"), tname);
sfile = fopen(sname, "r");
if (!sfile)
err(EXIT_FAILURE, _("cannot open %s"), sname);
/* ignore the first typescript line */
while((c = fgetc(sfile)) != EOF && c != '\n');
for(line = 1; ; line++) {
double delay;
size_t blk;
char nl;
if (fscanf(tfile, "%lf %zu%c\n", &delay, &blk, &nl) != 3 ||
nl != '\n') {
if (feof(tfile))
break;
if (ferror(tfile))
err(EXIT_FAILURE,
_("failed to read timing file %s"), tname);
errx(EXIT_FAILURE,
_("timing file %s: line %lu: unexpected format"),
tname, line);
}
delay /= divi;
if (maxdelayopt && delay > maxdelay)
delay = maxdelay;
if (delay > SCRIPT_MIN_DELAY)
delay_for(delay);
emit(sfile, sname, blk);
}
fclose(sfile);
fclose(tfile);
printf("\n");
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
char *from, *to;
int i, c, ret = 0, verbose = 0, noact = 0, nooverwrite = 0, interactive = 0;
struct termios tio;
int (*do_rename)(char *from, char *to, char *s, int verbose, int noact,
int nooverwrite, int interactive) = do_file;
static const struct option longopts[] = {
{"verbose", no_argument, NULL, 'v'},
{"version", no_argument, NULL, 'V'},
{"help", no_argument, NULL, 'h'},
{"no-act", no_argument, NULL, 'n'},
{"no-overwrite", no_argument, NULL, 'o'},
{"interactive", no_argument, NULL, 'i'},
{"symlink", no_argument, NULL, 's'},
{NULL, 0, NULL, 0}
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while ((c = getopt_long(argc, argv, "vsVhnoi", longopts, NULL)) != -1)
switch (c) {
case 'n':
noact = 1;
break;
case 'v':
verbose = 1;
break;
case 'o':
nooverwrite = 1;
interactive = 0;
break;
case 'i':
interactive = 1;
nooverwrite = 0;
break;
case 's':
do_rename = do_symlink;
break;
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
case 'h':
usage();
default:
errtryhelp(EXIT_FAILURE);
}
argc -= optind;
argv += optind;
if (argc < 3) {
warnx(_("not enough arguments"));
errtryhelp(EXIT_FAILURE);
}
from = argv[0];
to = argv[1];
if (!strcmp(from, to))
return RENAME_EXIT_NOTHING;
tty_cbreak = 0;
if (interactive && isatty(STDIN_FILENO) != 0) {
if (tcgetattr(STDIN_FILENO, &tio) != 0)
warn(_("failed to get terminal attributes"));
else if (!(tio.c_lflag & ICANON) && tio.c_cc[VMIN] == 1)
tty_cbreak = 1;
}
for (i = 2; i < argc; i++)
ret |= do_rename(from, to, argv[i], verbose, noact, nooverwrite, interactive);
switch (ret) {
case 0:
return RENAME_EXIT_NOTHING;
case 1:
return EXIT_SUCCESS;
case 2:
return EXIT_FAILURE;
case 3:
return RENAME_EXIT_SOMEOK;
default:
return RENAME_EXIT_UNEXPLAINED;
}
}
int main(int argc, char **argv)
{
int tty_fd;
struct termios ts;
int speed = 0, bits = '-', parity = '-', stop = '-';
int set_iflag = 0, clr_iflag = 0;
int ldisc;
int optc;
char *dev;
int intropause = 1;
char *introparm = NULL;
static const struct option opttbl[] = {
{"speed", required_argument, NULL, 's'},
{"sevenbits", no_argument, NULL, '7'},
{"eightbits", no_argument, NULL, '8'},
{"noparity", no_argument, NULL, 'n'},
{"evenparity", no_argument, NULL, 'e'},
{"oddparity", no_argument, NULL, 'o'},
{"onestopbit", no_argument, NULL, '1'},
{"twostopbits", no_argument, NULL, '2'},
{"iflag", required_argument, NULL, 'i'},
{"help", no_argument, NULL, 'h'},
{"version", no_argument, NULL, 'V'},
{"debug", no_argument, NULL, 'd'},
{"intro-command", no_argument, NULL, 'c'},
{"pause", no_argument, NULL, 'p'},
{NULL, 0, NULL, 0}
};
signal(SIGKILL, handler);
signal(SIGINT, handler);
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
/* parse options */
if (argc == 0)
errx(EXIT_FAILURE, _("bad usage"));
while ((optc =
getopt_long(argc, argv, "dhV78neo12s:i:c:p:", opttbl,
NULL)) >= 0) {
switch (optc) {
case 'd':
debug = 1;
break;
case '1':
case '2':
stop = optc;
break;
case '7':
case '8':
bits = optc;
break;
case 'n':
case 'e':
case 'o':
parity = optc;
break;
case 's':
speed = strtos32_or_err(optarg, _("invalid speed argument"));
break;
case 'p':
intropause = strtou32_or_err(optarg, _("invalid pause argument"));
if (intropause > 10)
errx(EXIT_FAILURE, "invalid pause: %s", optarg);
break;
case 'c':
introparm = optarg;
break;
case 'i':
parse_iflag(optarg, &set_iflag, &clr_iflag);
break;
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
case 'h':
usage();
default:
errtryhelp(EXIT_FAILURE);
}
}
if (argc - optind != 2) {
warnx(_("not enough arguments"));
errtryhelp(EXIT_FAILURE);
}
/* parse line discipline specification */
ldisc = lookup_table(ld_discs, argv[optind]);
if (ldisc < 0)
ldisc = strtos32_or_err(argv[optind], _("invalid line discipline argument"));
/* ldisc specific option settings */
if (ldisc == N_GIGASET_M101) {
/* device specific defaults for line speed and data format */
if (speed == 0)
speed = 115200;
if (bits == '-')
bits = '8';
if (parity == '-')
parity = 'n';
if (stop == '-')
stop = '1';
}
/* open device */
dev = argv[optind + 1];
if ((tty_fd = open(dev, O_RDWR | O_NOCTTY)) < 0)
err(EXIT_FAILURE, _("cannot open %s"), dev);
if (!isatty(tty_fd))
errx(EXIT_FAILURE, _("%s is not a serial line"), dev);
dbg("opened %s", dev);
/* set line speed and format */
if (tcgetattr(tty_fd, &ts) < 0)
err(EXIT_FAILURE,
_("cannot get terminal attributes for %s"), dev);
cfmakeraw(&ts);
if (speed && my_cfsetspeed(&ts, speed) < 0)
errx(EXIT_FAILURE, _("speed %d unsupported"), speed);
switch (stop) {
case '1':
ts.c_cflag &= ~CSTOPB;
break;
case '2':
ts.c_cflag |= CSTOPB;
break;
case '-':
break;
default:
abort();
}
switch (bits) {
case '7':
ts.c_cflag = (ts.c_cflag & ~CSIZE) | CS7;
break;
case '8':
ts.c_cflag = (ts.c_cflag & ~CSIZE) | CS8;
break;
case '-':
break;
default:
abort();
}
switch (parity) {
case 'n':
ts.c_cflag &= ~(PARENB | PARODD);
break;
case 'e':
ts.c_cflag |= PARENB;
ts.c_cflag &= ~PARODD;
break;
case 'o':
ts.c_cflag |= (PARENB | PARODD);
break;
case '-':
break;
default:
abort();
}
ts.c_cflag |= CREAD; /* just to be on the safe side */
ts.c_iflag |= set_iflag;
ts.c_iflag &= ~clr_iflag;
if (tcsetattr(tty_fd, TCSAFLUSH, &ts) < 0)
err(EXIT_FAILURE,
_("cannot set terminal attributes for %s"), dev);
dbg("set to raw %d %c%c%c: cflag=0x%x",
speed, bits, parity, stop, ts.c_cflag);
if (introparm && *introparm)
{
dbg("intro command is '%s'", introparm);
if (write_all(tty_fd, introparm, strlen(introparm)) != 0)
err(EXIT_FAILURE,
_("cannot write intro command to %s"), dev);
if (intropause) {
dbg("waiting for %d seconds", intropause);
sleep(intropause);
}
}
/* Attach the line discipline. */
if (ioctl(tty_fd, TIOCSETD, &ldisc) < 0)
err(EXIT_FAILURE, _("cannot set line discipline"));
dbg("line discipline set to %d", ldisc);
/* ldisc specific post-attach actions */
if (ldisc == N_GSM0710)
gsm0710_set_conf(tty_fd);
/* Go into background if not in debug mode. */
if (!debug && daemon(0, 0) < 0)
err(EXIT_FAILURE, _("cannot daemonize"));
/* Sleep to keep the line discipline active. */
pause();
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
cpu_set_t *new_set;
pid_t pid = 0;
int c, all_tasks = 0;
int ncpus;
size_t new_setsize, nbits;
struct taskset ts;
static const struct option longopts[] = {
{ "all-tasks", 0, NULL, 'a' },
{ "pid", 0, NULL, 'p' },
{ "cpu-list", 0, NULL, 'c' },
{ "help", 0, NULL, 'h' },
{ "version", 0, NULL, 'V' },
{ NULL, 0, NULL, 0 }
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
memset(&ts, 0, sizeof(ts));
while ((c = getopt_long(argc, argv, "+apchV", longopts, NULL)) != -1) {
switch (c) {
case 'a':
all_tasks = 1;
break;
case 'p':
pid = strtos32_or_err(argv[argc - 1],
_("invalid PID argument"));
break;
case 'c':
ts.use_list = 1;
break;
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
case 'h':
usage(stdout);
break;
default:
errtryhelp(EXIT_FAILURE);
}
}
if ((!pid && argc - optind < 2)
|| (pid && (argc - optind < 1 || argc - optind > 2)))
usage(stderr);
ncpus = get_max_number_of_cpus();
if (ncpus <= 0)
errx(EXIT_FAILURE, _("cannot determine NR_CPUS; aborting"));
/*
* the ts->set is always used for the sched_getaffinity call
* On the sched_getaffinity the kernel demands a user mask of
* at least the size of its own cpumask_t.
*/
ts.set = cpuset_alloc(ncpus, &ts.setsize, &nbits);
if (!ts.set)
err(EXIT_FAILURE, _("cpuset_alloc failed"));
/* buffer for conversion from mask to string */
ts.buflen = 7 * nbits;
ts.buf = xmalloc(ts.buflen);
/*
* new_set is always used for the sched_setaffinity call
* On the sched_setaffinity the kernel will zero-fill its
* cpumask_t if the user's mask is shorter.
*/
new_set = cpuset_alloc(ncpus, &new_setsize, NULL);
if (!new_set)
err(EXIT_FAILURE, _("cpuset_alloc failed"));
if (argc - optind == 1)
ts.get_only = 1;
else if (ts.use_list) {
if (cpulist_parse(argv[optind], new_set, new_setsize, 0))
errx(EXIT_FAILURE, _("failed to parse CPU list: %s"),
argv[optind]);
} else if (cpumask_parse(argv[optind], new_set, new_setsize)) {
errx(EXIT_FAILURE, _("failed to parse CPU mask: %s"),
argv[optind]);
}
if (all_tasks && pid) {
struct proc_tasks *tasks = proc_open_tasks(pid);
while (!proc_next_tid(tasks, &ts.pid))
do_taskset(&ts, new_setsize, new_set);
proc_close_tasks(tasks);
} else {
ts.pid = pid;
do_taskset(&ts, new_setsize, new_set);
}
free(ts.buf);
cpuset_free(ts.set);
cpuset_free(new_set);
if (!pid) {
argv += optind + 1;
execvp(argv[0], argv);
err(EXIT_FAILURE, _("failed to execute %s"), argv[0]);
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
struct wh_dirlist *ls = NULL;
int want = ALL_DIRS;
int i, want_resetable = 0, opt_f_missing = 0;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
close_stdout_atexit();
if (argc <= 1) {
warnx(_("not enough arguments"));
errtryhelp(EXIT_FAILURE);
} else {
/* first arg may be one of our standard longopts */
if (!strcmp(argv[1], "--help"))
usage();
if (!strcmp(argv[1], "--version"))
print_version(EXIT_SUCCESS);
}
whereis_init_debug();
construct_dirlist(&ls, BIN_DIR, bindirs);
construct_dirlist_from_env("PATH", &ls, BIN_DIR);
construct_dirlist(&ls, MAN_DIR, mandirs);
construct_dirlist_from_env("MANPATH", &ls, MAN_DIR);
construct_dirlist(&ls, SRC_DIR, srcdirs);
for (i = 1; i < argc; i++) {
const char *arg = argv[i];
int arg_i = i;
DBG(ARGV, ul_debug("argv[%d]: %s", i, arg));
if (*arg != '-') {
lookup(arg, ls, want);
/*
* The lookup mask ("want") is cumulative and it's
* resettable only when it has been already used.
*
* whereis -b -m foo :'foo' mask=BIN|MAN
* whereis -b foo bar :'foo' and 'bar' mask=BIN|MAN
* whereis -b foo -m bar :'foo' mask=BIN; 'bar' mask=MAN
*/
want_resetable = 1;
continue;
}
for (++arg; arg && *arg; arg++) {
DBG(ARGV, ul_debug(" arg: %s", arg));
switch (*arg) {
case 'f':
opt_f_missing = 0;
break;
case 'u':
uflag = 1;
opt_f_missing = 0;
break;
case 'B':
if (*(arg + 1)) {
warnx(_("bad usage"));
errtryhelp(EXIT_FAILURE);
}
i++;
free_dirlist(&ls, BIN_DIR);
construct_dirlist_from_argv(
&ls, &i, argc, argv, BIN_DIR);
opt_f_missing = 1;
break;
case 'M':
if (*(arg + 1)) {
warnx(_("bad usage"));
errtryhelp(EXIT_FAILURE);
}
i++;
free_dirlist(&ls, MAN_DIR);
construct_dirlist_from_argv(
&ls, &i, argc, argv, MAN_DIR);
opt_f_missing = 1;
break;
case 'S':
if (*(arg + 1)) {
warnx(_("bad usage"));
errtryhelp(EXIT_FAILURE);
}
i++;
free_dirlist(&ls, SRC_DIR);
construct_dirlist_from_argv(
&ls, &i, argc, argv, SRC_DIR);
opt_f_missing = 1;
break;
case 'b':
if (want_resetable) {
want = ALL_DIRS;
want_resetable = 0;
}
want = want == ALL_DIRS ? BIN_DIR : want | BIN_DIR;
opt_f_missing = 0;
break;
case 'm':
if (want_resetable) {
want = ALL_DIRS;
want_resetable = 0;
}
want = want == ALL_DIRS ? MAN_DIR : want | MAN_DIR;
opt_f_missing = 0;
break;
case 's':
if (want_resetable) {
want = ALL_DIRS;
want_resetable = 0;
}
want = want == ALL_DIRS ? SRC_DIR : want | SRC_DIR;
opt_f_missing = 0;
break;
case 'l':
list_dirlist(ls);
break;
case 'V':
print_version(EXIT_SUCCESS);
case 'h':
usage();
default:
warnx(_("bad usage"));
errtryhelp(EXIT_FAILURE);
}
if (arg_i < i) /* moved to the next argv[] item */
break;
}
}
free_dirlist(&ls, ALL_DIRS);
if (opt_f_missing)
errx(EXIT_FAILURE, _("option -f is missing"));
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
int c;
int fd;
int mode = 0;
int dig = 0;
int posix = 0;
loff_t length = -2LL;
loff_t offset = 0;
static const struct option longopts[] = {
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, 'V' },
{ "keep-size", no_argument, NULL, 'n' },
{ "punch-hole", no_argument, NULL, 'p' },
{ "collapse-range", no_argument, NULL, 'c' },
{ "dig-holes", no_argument, NULL, 'd' },
{ "insert-range", no_argument, NULL, 'i' },
{ "zero-range", no_argument, NULL, 'z' },
{ "offset", required_argument, NULL, 'o' },
{ "length", required_argument, NULL, 'l' },
{ "posix", no_argument, NULL, 'x' },
{ "verbose", no_argument, NULL, 'v' },
{ NULL, 0, NULL, 0 }
};
static const ul_excl_t excl[] = { /* rows and cols in ASCII order */
{ 'c', 'd', 'p', 'z' },
{ 'c', 'n' },
{ 'x', 'c', 'd', 'i', 'n', 'p', 'z'},
{ 0 }
};
int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while ((c = getopt_long(argc, argv, "hvVncpdizxl:o:", longopts, NULL))
!= -1) {
err_exclusive_options(c, longopts, excl, excl_st);
switch(c) {
case 'h':
usage();
break;
case 'c':
mode |= FALLOC_FL_COLLAPSE_RANGE;
break;
case 'd':
dig = 1;
break;
case 'i':
mode |= FALLOC_FL_INSERT_RANGE;
break;
case 'l':
length = cvtnum(optarg);
break;
case 'n':
mode |= FALLOC_FL_KEEP_SIZE;
break;
case 'o':
offset = cvtnum(optarg);
break;
case 'p':
mode |= FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE;
break;
case 'z':
mode |= FALLOC_FL_ZERO_RANGE;
break;
case 'x':
#ifdef HAVE_POSIX_FALLOCATE
posix = 1;
break;
#else
errx(EXIT_FAILURE, _("posix_fallocate support is not compiled"));
#endif
case 'v':
verbose++;
break;
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
default:
errtryhelp(EXIT_FAILURE);
}
}
if (optind == argc)
errx(EXIT_FAILURE, _("no filename specified"));
filename = argv[optind++];
if (optind != argc)
errx(EXIT_FAILURE, _("unexpected number of arguments"));
if (dig) {
/* for --dig-holes the default is analyze all file */
if (length == -2LL)
length = 0;
if (length < 0)
errx(EXIT_FAILURE, _("invalid length value specified"));
} else {
/* it's safer to require the range specification (--length --offset) */
if (length == -2LL)
errx(EXIT_FAILURE, _("no length argument specified"));
if (length <= 0)
errx(EXIT_FAILURE, _("invalid length value specified"));
}
if (offset < 0)
errx(EXIT_FAILURE, _("invalid offset value specified"));
/* O_CREAT makes sense only for the default fallocate(2) behavior
* when mode is no specified and new space is allocated */
fd = open(filename, O_RDWR | (!dig && !mode ? O_CREAT : 0),
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
if (fd < 0)
err(EXIT_FAILURE, _("cannot open %s"), filename);
if (dig)
dig_holes(fd, offset, length);
#ifdef HAVE_POSIX_FALLOCATE
else if (posix)
xposix_fallocate(fd, offset, length);
#endif
else
xfallocate(fd, mode, offset, length);
if (close_fd(fd) != 0)
err(EXIT_FAILURE, _("write failed: %s"), filename);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
int ch;
struct iovec iov;
struct utmpx *utmpptr;
char *p;
char line[sizeof(utmpptr->ut_line) + 1];
int print_banner = TRUE;
struct group_workspace *group_buf = NULL;
char *mbuf, *fname = NULL;
size_t mbufsize;
unsigned timeout = WRITE_TIME_OUT;
char **mvec = NULL;
int mvecsz = 0;
static const struct option longopts[] = {
{ "nobanner", no_argument, NULL, 'n' },
{ "timeout", required_argument, NULL, 't' },
{ "group", required_argument, NULL, 'g' },
{ "version", no_argument, NULL, 'V' },
{ "help", no_argument, NULL, 'h' },
{ NULL, 0, NULL, 0 }
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while ((ch = getopt_long(argc, argv, "nt:g:Vh", longopts, NULL)) != -1) {
switch (ch) {
case 'n':
if (geteuid() == 0)
print_banner = FALSE;
else
warnx(_("--nobanner is available only for root"));
break;
case 't':
timeout = strtou32_or_err(optarg, _("invalid timeout argument"));
if (timeout < 1)
errx(EXIT_FAILURE, _("invalid timeout argument: %s"), optarg);
break;
case 'g':
group_buf = init_group_workspace(optarg);
break;
case 'V':
printf(UTIL_LINUX_VERSION);
exit(EXIT_SUCCESS);
case 'h':
usage();
default:
errtryhelp(EXIT_FAILURE);
}
}
argc -= optind;
argv += optind;
if (argc == 1 && access(argv[0], F_OK) == 0)
fname = argv[0];
else if (argc >= 1) {
mvec = argv;
mvecsz = argc;
}
mbuf = makemsg(fname, mvec, mvecsz, &mbufsize, print_banner);
iov.iov_base = mbuf;
iov.iov_len = mbufsize;
while((utmpptr = getutxent())) {
if (!utmpptr->ut_user[0])
continue;
#ifdef USER_PROCESS
if (utmpptr->ut_type != USER_PROCESS)
continue;
#endif
/* Joey Hess reports that use-sessreg in /etc/X11/wdm/
produces ut_line entries like :0, and a write
to /dev/:0 fails. */
if (utmpptr->ut_line[0] == ':')
continue;
if (group_buf && !is_gr_member(utmpptr->ut_user, group_buf))
continue;
mem2strcpy(line, utmpptr->ut_line, sizeof(utmpptr->ut_line), sizeof(line));
if ((p = ttymsg(&iov, 1, line, timeout)) != NULL)
warnx("%s", p);
}
endutxent();
free(mbuf);
free_group_workspace(group_buf);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
cpu_set_t *cpu_set;
size_t setsize;
int cmd = -1;
int c, rc;
static const struct option longopts[] = {
{ "configure", required_argument, NULL, 'c' },
{ "deconfigure",required_argument, NULL, 'g' },
{ "disable", required_argument, NULL, 'd' },
{ "dispatch", required_argument, NULL, 'p' },
{ "enable", required_argument, NULL, 'e' },
{ "help", no_argument, NULL, 'h' },
{ "rescan", no_argument, NULL, 'r' },
{ "version", no_argument, NULL, 'V' },
{ NULL, 0, NULL, 0 }
};
static const ul_excl_t excl[] = { /* rows and cols in ASCII order */
{ 'c','d','e','g','p' },
{ 0 }
};
int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
maxcpus = get_max_number_of_cpus();
if (maxcpus < 1)
errx(EXIT_FAILURE, _("cannot determine NR_CPUS; aborting"));
if (path_exist(_PATH_SYS_CPU_ONLINE))
onlinecpus = path_read_cpulist(maxcpus, _PATH_SYS_CPU_ONLINE);
setsize = CPU_ALLOC_SIZE(maxcpus);
cpu_set = CPU_ALLOC(maxcpus);
if (!cpu_set)
err(EXIT_FAILURE, _("cpuset_alloc failed"));
while ((c = getopt_long(argc, argv, "c:d:e:g:hp:rV", longopts, NULL)) != -1) {
err_exclusive_options(c, longopts, excl, excl_st);
switch (c) {
case 'c':
cmd = CMD_CPU_CONFIGURE;
cpu_parse(argv[optind - 1], cpu_set, setsize);
break;
case 'd':
cmd = CMD_CPU_DISABLE;
cpu_parse(argv[optind - 1], cpu_set, setsize);
break;
case 'e':
cmd = CMD_CPU_ENABLE;
cpu_parse(argv[optind - 1], cpu_set, setsize);
break;
case 'g':
cmd = CMD_CPU_DECONFIGURE;
cpu_parse(argv[optind - 1], cpu_set, setsize);
break;
case 'h':
usage(stdout);
case 'p':
if (strcmp("horizontal", argv[optind - 1]) == 0)
cmd = CMD_CPU_DISPATCH_HORIZONTAL;
else if (strcmp("vertical", argv[optind - 1]) == 0)
cmd = CMD_CPU_DISPATCH_VERTICAL;
else
errx(EXIT_FAILURE, _("unsupported argument: %s"),
argv[optind -1 ]);
break;
case 'r':
cmd = CMD_CPU_RESCAN;
break;
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
default:
errtryhelp(EXIT_FAILURE);
}
}
if ((argc == 1) || (argc != optind))
usage(stderr);
switch (cmd) {
case CMD_CPU_ENABLE:
rc = cpu_enable(cpu_set, maxcpus, 1);
break;
case CMD_CPU_DISABLE:
rc = cpu_enable(cpu_set, maxcpus, 0);
break;
case CMD_CPU_CONFIGURE:
rc = cpu_configure(cpu_set, maxcpus, 1);
break;
case CMD_CPU_DECONFIGURE:
rc = cpu_configure(cpu_set, maxcpus, 0);
break;
case CMD_CPU_RESCAN:
rc = cpu_rescan();
break;
case CMD_CPU_DISPATCH_HORIZONTAL:
rc = cpu_set_dispatch(0);
break;
case CMD_CPU_DISPATCH_VERTICAL:
rc = cpu_set_dispatch(1);
break;
default:
rc = -EINVAL;
break;
}
return rc == 0 ? EXIT_SUCCESS :
rc < 0 ? EXIT_FAILURE : CHCPU_EXIT_SOMEOK;
}
int main(int argc, char **argv)
{
enum {
NNP = CHAR_MAX + 1,
RUID,
EUID,
RGID,
EGID,
REUID,
REGID,
CLEAR_GROUPS,
KEEP_GROUPS,
INIT_GROUPS,
GROUPS,
INHCAPS,
AMBCAPS,
LISTCAPS,
CAPBSET,
SECUREBITS,
PDEATHSIG,
SELINUX_LABEL,
APPARMOR_PROFILE
};
static const struct option longopts[] = {
{ "dump", no_argument, NULL, 'd' },
{ "nnp", no_argument, NULL, NNP },
{ "no-new-privs", no_argument, NULL, NNP },
{ "inh-caps", required_argument, NULL, INHCAPS },
{ "ambient-caps", required_argument, NULL, AMBCAPS },
{ "list-caps", no_argument, NULL, LISTCAPS },
{ "ruid", required_argument, NULL, RUID },
{ "euid", required_argument, NULL, EUID },
{ "rgid", required_argument, NULL, RGID },
{ "egid", required_argument, NULL, EGID },
{ "reuid", required_argument, NULL, REUID },
{ "regid", required_argument, NULL, REGID },
{ "clear-groups", no_argument, NULL, CLEAR_GROUPS },
{ "keep-groups", no_argument, NULL, KEEP_GROUPS },
{ "init-groups", no_argument, NULL, INIT_GROUPS },
{ "groups", required_argument, NULL, GROUPS },
{ "bounding-set", required_argument, NULL, CAPBSET },
{ "securebits", required_argument, NULL, SECUREBITS },
{ "pdeathsig", required_argument, NULL, PDEATHSIG, },
{ "selinux-label", required_argument, NULL, SELINUX_LABEL },
{ "apparmor-profile", required_argument, NULL, APPARMOR_PROFILE },
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, 'V' },
{ NULL, 0, NULL, 0 }
};
static const ul_excl_t excl[] = {
/* keep in same order with enum definitions */
{CLEAR_GROUPS, KEEP_GROUPS, INIT_GROUPS, GROUPS},
{0}
};
int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
int c;
struct privctx opts;
struct passwd *pw = NULL;
int dumplevel = 0;
int total_opts = 0;
int list_caps = 0;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
memset(&opts, 0, sizeof(opts));
while ((c = getopt_long(argc, argv, "+dhV", longopts, NULL)) != -1) {
err_exclusive_options(c, longopts, excl, excl_st);
total_opts++;
switch (c) {
case 'd':
dumplevel++;
break;
case NNP:
if (opts.nnp)
errx(EXIT_FAILURE,
_("duplicate --no-new-privs option"));
opts.nnp = 1;
break;
case RUID:
if (opts.have_ruid)
errx(EXIT_FAILURE, _("duplicate ruid"));
opts.have_ruid = 1;
pw = get_passwd(optarg, &opts.ruid, _("failed to parse ruid"));
if (pw) {
passwd_copy(&opts.passwd, pw);
opts.have_passwd = 1;
}
break;
case EUID:
if (opts.have_euid)
errx(EXIT_FAILURE, _("duplicate euid"));
opts.have_euid = 1;
opts.euid = get_user(optarg, _("failed to parse euid"));
break;
case REUID:
if (opts.have_ruid || opts.have_euid)
errx(EXIT_FAILURE, _("duplicate ruid or euid"));
opts.have_ruid = opts.have_euid = 1;
pw = get_passwd(optarg, &opts.ruid, _("failed to parse reuid"));
opts.euid = opts.ruid;
if (pw) {
passwd_copy(&opts.passwd, pw);
opts.have_passwd = 1;
}
break;
case RGID:
if (opts.have_rgid)
errx(EXIT_FAILURE, _("duplicate rgid"));
opts.have_rgid = 1;
opts.rgid = get_group(optarg, _("failed to parse rgid"));
break;
case EGID:
if (opts.have_egid)
errx(EXIT_FAILURE, _("duplicate egid"));
opts.have_egid = 1;
opts.egid = get_group(optarg, _("failed to parse egid"));
break;
case REGID:
if (opts.have_rgid || opts.have_egid)
errx(EXIT_FAILURE, _("duplicate rgid or egid"));
opts.have_rgid = opts.have_egid = 1;
opts.rgid = opts.egid = get_group(optarg, _("failed to parse regid"));
break;
case CLEAR_GROUPS:
if (opts.clear_groups)
errx(EXIT_FAILURE,
_("duplicate --clear-groups option"));
opts.clear_groups = 1;
break;
case KEEP_GROUPS:
if (opts.keep_groups)
errx(EXIT_FAILURE,
_("duplicate --keep-groups option"));
opts.keep_groups = 1;
break;
case INIT_GROUPS:
if (opts.init_groups)
errx(EXIT_FAILURE,
_("duplicate --init-groups option"));
opts.init_groups = 1;
break;
case GROUPS:
if (opts.have_groups)
errx(EXIT_FAILURE,
_("duplicate --groups option"));
parse_groups(&opts, optarg);
break;
case PDEATHSIG:
if (opts.pdeathsig)
errx(EXIT_FAILURE,
_("duplicate --keep-pdeathsig option"));
parse_pdeathsig(&opts, optarg);
break;
case LISTCAPS:
list_caps = 1;
break;
case INHCAPS:
if (opts.caps_to_inherit)
errx(EXIT_FAILURE,
_("duplicate --inh-caps option"));
opts.caps_to_inherit = optarg;
break;
case AMBCAPS:
if (opts.ambient_caps)
errx(EXIT_FAILURE,
_("duplicate --ambient-caps option"));
opts.ambient_caps = optarg;
break;
case CAPBSET:
if (opts.bounding_set)
errx(EXIT_FAILURE,
_("duplicate --bounding-set option"));
opts.bounding_set = optarg;
break;
case SECUREBITS:
if (opts.have_securebits)
errx(EXIT_FAILURE,
_("duplicate --securebits option"));
parse_securebits(&opts, optarg);
break;
case SELINUX_LABEL:
if (opts.selinux_label)
errx(EXIT_FAILURE,
_("duplicate --selinux-label option"));
opts.selinux_label = optarg;
break;
case APPARMOR_PROFILE:
if (opts.apparmor_profile)
errx(EXIT_FAILURE,
_("duplicate --apparmor-profile option"));
opts.apparmor_profile = optarg;
break;
case 'h':
usage();
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
default:
errtryhelp(EXIT_FAILURE);
}
}
if (dumplevel) {
if (total_opts != dumplevel || optind < argc)
errx(EXIT_FAILURE,
_("--dump is incompatible with all other options"));
dump(dumplevel);
return EXIT_SUCCESS;
}
if (list_caps) {
if (total_opts != 1 || optind < argc)
errx(EXIT_FAILURE,
_("--list-caps must be specified alone"));
list_known_caps();
return EXIT_SUCCESS;
}
if (argc <= optind)
errx(EXIT_FAILURE, _("No program specified"));
if ((opts.have_rgid || opts.have_egid)
&& !opts.keep_groups && !opts.clear_groups && !opts.init_groups
&& !opts.have_groups)
errx(EXIT_FAILURE,
_("--[re]gid requires --keep-groups, --clear-groups, --init-groups, or --groups"));
if (opts.init_groups && !opts.have_ruid)
errx(EXIT_FAILURE,
_("--init-groups requires --ruid or --reuid"));
if (opts.init_groups && !opts.have_passwd)
errx(EXIT_FAILURE,
_("uid %ld not found, --init-groups requires an user that "
"can be found on the system"),
(long) opts.ruid);
if (opts.nnp && prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) == -1)
err(EXIT_FAILURE, _("disallow granting new privileges failed"));
if (opts.selinux_label)
do_selinux_label(opts.selinux_label);
if (opts.apparmor_profile)
do_apparmor_profile(opts.apparmor_profile);
if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) == -1)
err(EXIT_FAILURE, _("keep process capabilities failed"));
/* We're going to want CAP_SETPCAP, CAP_SETUID, and CAP_SETGID if
* possible. */
bump_cap(CAP_SETPCAP);
bump_cap(CAP_SETUID);
bump_cap(CAP_SETGID);
if (capng_apply(CAPNG_SELECT_CAPS) != 0)
err(SETPRIV_EXIT_PRIVERR, _("activate capabilities"));
if (opts.have_ruid || opts.have_euid) {
do_setresuid(&opts);
/* KEEPCAPS doesn't work for the effective mask. */
if (capng_apply(CAPNG_SELECT_CAPS) != 0)
err(SETPRIV_EXIT_PRIVERR, _("reactivate capabilities"));
}
if (opts.have_rgid || opts.have_egid)
do_setresgid(&opts);
if (opts.have_groups) {
if (setgroups(opts.num_groups, opts.groups) != 0)
err(SETPRIV_EXIT_PRIVERR, _("setgroups failed"));
} else if (opts.init_groups) {
if (initgroups(opts.passwd.pw_name, opts.passwd.pw_gid) != 0)
err(SETPRIV_EXIT_PRIVERR, _("initgroups failed"));
} else if (opts.clear_groups) {
gid_t x = 0;
if (setgroups(0, &x) != 0)
err(SETPRIV_EXIT_PRIVERR, _("setgroups failed"));
}
if (opts.have_securebits && prctl(PR_SET_SECUREBITS, opts.securebits, 0, 0, 0) != 0)
err(SETPRIV_EXIT_PRIVERR, _("set process securebits failed"));
if (opts.bounding_set) {
do_caps(CAP_TYPE_BOUNDING, opts.bounding_set);
errno = EPERM; /* capng doesn't set errno if we're missing CAP_SETPCAP */
if (capng_apply(CAPNG_SELECT_BOUNDS) != 0)
err(SETPRIV_EXIT_PRIVERR, _("apply bounding set"));
}
if (opts.caps_to_inherit) {
do_caps(CAP_TYPE_INHERITABLE, opts.caps_to_inherit);
if (capng_apply(CAPNG_SELECT_CAPS) != 0)
err(SETPRIV_EXIT_PRIVERR, _("apply capabilities"));
}
if (opts.ambient_caps) {
do_caps(CAP_TYPE_AMBIENT, opts.ambient_caps);
}
/* Clear or set parent death signal */
if (opts.pdeathsig && prctl(PR_SET_PDEATHSIG, opts.pdeathsig < 0 ? 0 : opts.pdeathsig) != 0)
err(SETPRIV_EXIT_PRIVERR, _("set parent death signal failed"));
execvp(argv[optind], argv + optind);
errexec(argv[optind]);
}
int
main(int argc, char **argv)
{
struct wipe_desc *wp0 = NULL, *wp;
int c, has_offset = 0, flags = 0;
int mode = WP_MODE_PRETTY;
static const struct option longopts[] = {
{ "all", no_argument, NULL, 'a' },
{ "backup", no_argument, NULL, 'b' },
{ "force", no_argument, NULL, 'f' },
{ "help", no_argument, NULL, 'h' },
{ "no-act", no_argument, NULL, 'n' },
{ "offset", required_argument, NULL, 'o' },
{ "parsable", no_argument, NULL, 'p' },
{ "quiet", no_argument, NULL, 'q' },
{ "types", required_argument, NULL, 't' },
{ "version", no_argument, NULL, 'V' },
{ NULL, 0, NULL, 0 }
};
static const ul_excl_t excl[] = { /* rows and cols in ASCII order */
{ 'a','o' },
{ 0 }
};
int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while ((c = getopt_long(argc, argv, "abfhno:pqt:V", longopts, NULL)) != -1) {
err_exclusive_options(c, longopts, excl, excl_st);
switch(c) {
case 'a':
flags |= WP_FL_ALL;
break;
case 'b':
flags |= WP_FL_BACKUP;
break;
case 'f':
flags |= WP_FL_FORCE;
break;
case 'h':
usage(stdout);
break;
case 'n':
flags |= WP_FL_NOACT;
break;
case 'o':
wp0 = add_offset(wp0, strtosize_or_err(optarg,
_("invalid offset argument")), 1);
has_offset++;
break;
case 'p':
mode = WP_MODE_PARSABLE;
break;
case 'q':
flags |= WP_FL_QUIET;
break;
case 't':
type_pattern = optarg;
break;
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
default:
errtryhelp(EXIT_FAILURE);
}
}
if (optind == argc)
usage(stderr);
if ((flags & WP_FL_BACKUP) && !((flags & WP_FL_ALL) || has_offset))
warnx(_("The --backup option is meaningless in this context"));
if (!(flags & WP_FL_ALL) && !has_offset) {
/*
* Print only
*/
while (optind < argc) {
wp0 = read_offsets(NULL, argv[optind++]);
if (wp0)
print_all(wp0, mode);
free_wipe(wp0);
}
} else {
/*
* Erase
*/
while (optind < argc) {
wp = clone_offset(wp0);
wp = do_wipe(wp, argv[optind++], flags);
free_wipe(wp);
}
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
FILE *map;
int proFd;
char *mapFile, *proFile, *mult = NULL;
size_t len = 0, indx = 1;
unsigned long long add0 = 0;
unsigned int step;
unsigned int *buf, total, fn_len;
unsigned long long fn_add = 0, next_add; /* current and next address */
char fn_name[S_LEN], next_name[S_LEN]; /* current and next name */
char mode[8];
int c;
ssize_t rc;
int optAll = 0, optInfo = 0, optReset = 0, optVerbose = 0, optNative = 0;
int optBins = 0, optSub = 0;
char mapline[S_LEN];
int maplineno = 1;
int popenMap; /* flag to tell if popen() has been used */
int header_printed;
static const struct option longopts[] = {
{"mapfile", required_argument, NULL, 'm'},
{"profile", required_argument, NULL, 'p'},
{"multiplier", required_argument, NULL, 'M'},
{"info", no_argument, NULL, 'i'},
{"verbose", no_argument, NULL, 'v'},
{"all", no_argument, NULL, 'a'},
{"histbin", no_argument, NULL, 'b'},
{"counters", no_argument, NULL, 's'},
{"reset", no_argument, NULL, 'r'},
{"no-auto", no_argument, NULL, 'n'},
{"version", no_argument, NULL, 'V'},
{"help", no_argument, NULL, 'h'},
{NULL, 0, NULL, 0}
};
#define next (current^1)
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
close_stdout_atexit();
proFile = defaultpro;
mapFile = defaultmap;
while ((c = getopt_long(argc, argv, "m:p:M:ivabsrnVh", longopts, NULL)) != -1) {
switch (c) {
case 'm':
mapFile = optarg;
break;
case 'n':
optNative++;
break;
case 'p':
proFile = optarg;
break;
case 'a':
optAll++;
break;
case 'b':
optBins++;
break;
case 's':
optSub++;
break;
case 'i':
optInfo++;
break;
case 'M':
mult = optarg;
break;
case 'r':
optReset++;
break;
case 'v':
optVerbose++;
break;
case 'V':
print_version(EXIT_SUCCESS);
case 'h':
usage();
default:
errtryhelp(EXIT_FAILURE);
}
}
if (optReset || mult) {
int multiplier, fd, to_write;
/* When writing the multiplier, if the length of the
* write is not sizeof(int), the multiplier is not
* changed. */
if (mult) {
multiplier = strtoul(mult, NULL, 10);
to_write = sizeof(int);
} else {
multiplier = 0;
/* sth different from sizeof(int) */
to_write = 1;
}
/* try to become root, just in case */
ignore_result( setuid(0) );
fd = open(defaultpro, O_WRONLY);
if (fd < 0)
err(EXIT_FAILURE, "%s", defaultpro);
if (write(fd, &multiplier, to_write) != to_write)
err(EXIT_FAILURE, _("error writing %s"), defaultpro);
close(fd);
exit(EXIT_SUCCESS);
}
/* Use an fd for the profiling buffer, to skip stdio overhead */
if (((proFd = open(proFile, O_RDONLY)) < 0)
|| ((int)(len = lseek(proFd, 0, SEEK_END)) < 0)
|| (lseek(proFd, 0, SEEK_SET) < 0))
err(EXIT_FAILURE, "%s", proFile);
if (!len)
errx(EXIT_FAILURE, "%s: %s", proFile, _("input file is empty"));
buf = xmalloc(len);
rc = read(proFd, buf, len);
if (rc < 0 || (size_t) rc != len)
err(EXIT_FAILURE, "%s", proFile);
close(proFd);
if (!optNative) {
int entries = len / sizeof(*buf);
int big = 0, small = 0;
unsigned *p;
size_t i;
for (p = buf + 1; p < buf + entries; p++) {
if (*p & ~0U << (sizeof(*buf) * 4))
big++;
if (*p & ((1 << (sizeof(*buf) * 4)) - 1))
small++;
}
if (big > small) {
warnx(_("Assuming reversed byte order. "
"Use -n to force native byte order."));
for (p = buf; p < buf + entries; p++)
for (i = 0; i < sizeof(*buf) / 2; i++) {
unsigned char *b = (unsigned char *)p;
unsigned char tmp;
tmp = b[i];
b[i] = b[sizeof(*buf) - i - 1];
b[sizeof(*buf) - i - 1] = tmp;
}
}
}
step = buf[0];
if (optInfo) {
printf(_("Sampling_step: %u\n"), step);
exit(EXIT_SUCCESS);
}
total = 0;
map = myopen(mapFile, "r", &popenMap);
if (map == NULL && mapFile == defaultmap) {
mapFile = boot_uname_r_str();
map = myopen(mapFile, "r", &popenMap);
}
if (map == NULL)
err(EXIT_FAILURE, "%s", mapFile);
while (fgets(mapline, S_LEN, map)) {
if (sscanf(mapline, "%llx %7[^\n ] %127[^\n ]", &fn_add, mode, fn_name) != 3)
errx(EXIT_FAILURE, _("%s(%i): wrong map line"), mapFile,
maplineno);
/* only elf works like this */
if (!strcmp(fn_name, "_stext") || !strcmp(fn_name, "__stext")) {
add0 = fn_add;
break;
}
maplineno++;
}
if (!add0)
errx(EXIT_FAILURE, _("can't find \"_stext\" in %s"), mapFile);
/*
* Main loop.
*/
while (fgets(mapline, S_LEN, map)) {
unsigned int this = 0;
int done = 0;
if (sscanf(mapline, "%llx %7[^\n ] %127[^\n ]", &next_add, mode, next_name) != 3)
errx(EXIT_FAILURE, _("%s(%i): wrong map line"), mapFile,
maplineno);
header_printed = 0;
/* the kernel only profiles up to _etext */
if (!strcmp(next_name, "_etext") ||
!strcmp(next_name, "__etext"))
done = 1;
else {
/* ignore any LEADING (before a '[tT]' symbol
* is found) Absolute symbols and __init_end
* because some architectures place it before
* .text section */
if ((*mode == 'A' || *mode == '?')
&& (total == 0 || !strcmp(next_name, "__init_end")))
continue;
if (*mode != 'T' && *mode != 't' &&
*mode != 'W' && *mode != 'w')
break; /* only text is profiled */
}
if (indx >= len / sizeof(*buf))
errx(EXIT_FAILURE,
_("profile address out of range. Wrong map file?"));
while (indx < (next_add - add0) / step) {
if (optBins && (buf[indx] || optAll)) {
if (!header_printed) {
printf("%s:\n", fn_name);
header_printed = 1;
}
printf("\t%llx\t%u\n", (indx - 1) * step + add0,
buf[indx]);
}
this += buf[indx++];
}
total += this;
if (optBins) {
if (optVerbose || this > 0)
printf(" total\t\t\t\t%u\n", this);
} else if ((this || optAll) &&
(fn_len = next_add - fn_add) != 0) {
if (optVerbose)
printf("%016llx %-40s %6u %8.4f\n", fn_add,
fn_name, this, this / (double)fn_len);
else
printf("%6u %-40s %8.4f\n",
this, fn_name, this / (double)fn_len);
if (optSub) {
unsigned long long scan;
for (scan = (fn_add - add0) / step + 1;
scan < (next_add - add0) / step;
scan++) {
unsigned long long addr;
addr = (scan - 1) * step + add0;
printf("\t%#llx\t%s+%#llx\t%u\n",
addr, fn_name, addr - fn_add,
buf[scan]);
}
}
}
fn_add = next_add;
strcpy(fn_name, next_name);
maplineno++;
if (done)
break;
}
/* clock ticks, out of kernel text - probably modules */
printf("%6u %s\n", buf[len / sizeof(*buf) - 1], "*unknown*");
/* trailer */
if (optVerbose)
printf("%016x %-40s %6u %8.4f\n",
0, "total", total, total / (double)(fn_add - add0));
else
printf("%6u %-40s %8.4f\n",
total, _("total"), total / (double)(fn_add - add0));
popenMap ? pclose(map) : fclose(map);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct libscols_table *tb;
int c, n, nlines = 0;
int parent_col = -1, id_col = -1;
static const struct option longopts[] = {
{ "maxout", 0, NULL, 'm' },
{ "column", 1, NULL, 'c' },
{ "nlines", 1, NULL, 'n' },
{ "width", 1, NULL, 'w' },
{ "tree-parent-column", 1, NULL, 'p' },
{ "tree-id-column", 1, NULL, 'i' },
{ "json", 0, NULL, 'J' },
{ "raw", 0, NULL, 'r' },
{ "export", 0, NULL, 'E' },
{ "colsep", 1, NULL, 'C' },
{ "help", 0, NULL, 'h' },
{ NULL, 0, NULL, 0 },
};
static const ul_excl_t excl[] = { /* rows and cols in ASCII order */
{ 'E', 'J', 'r' },
{ 0 }
};
int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
setlocale(LC_ALL, ""); /* just to have enable UTF8 chars */
scols_init_debug(0);
tb = scols_new_table();
if (!tb)
err(EXIT_FAILURE, "failed to create output table");
while((c = getopt_long(argc, argv, "hCc:Ei:Jmn:p:rw:", longopts, NULL)) != -1) {
err_exclusive_options(c, longopts, excl, excl_st);
switch(c) {
case 'c': /* add column from file */
{
struct libscols_column *cl;
FILE *f = fopen(optarg, "r");
if (!f)
err(EXIT_FAILURE, "%s: open failed", optarg);
cl = parse_column(f);
if (cl && scols_table_add_column(tb, cl))
err(EXIT_FAILURE, "%s: failed to add column", optarg);
scols_unref_column(cl);
fclose(f);
break;
}
case 'p':
parent_col = strtou32_or_err(optarg, "failed to parse tree PARENT column");
break;
case 'i':
id_col = strtou32_or_err(optarg, "failed to parse tree ID column");
break;
case 'J':
scols_table_enable_json(tb, 1);
scols_table_set_name(tb, "testtable");
break;
case 'm':
scols_table_enable_maxout(tb, TRUE);
break;
case 'r':
scols_table_enable_raw(tb, TRUE);
break;
case 'E':
scols_table_enable_export(tb, TRUE);
break;
case 'C':
scols_table_set_column_separator(tb, optarg);
break;
case 'n':
nlines = strtou32_or_err(optarg, "failed to parse number of lines");
break;
case 'w':
scols_table_set_termforce(tb, SCOLS_TERMFORCE_ALWAYS);
scols_table_set_termwidth(tb, strtou32_or_err(optarg, "failed to parse terminal width"));
break;
case 'h':
usage();
default:
errtryhelp(EXIT_FAILURE);
}
}
if (nlines <= 0)
errx(EXIT_FAILURE, "--nlines not set");
for (n = 0; n < nlines; n++) {
struct libscols_line *ln = scols_new_line();
if (!ln || scols_table_add_line(tb, ln))
err(EXIT_FAILURE, "failed to add a new line");
scols_unref_line(ln);
}
n = 0;
while (optind < argc) {
FILE *f = fopen(argv[optind], "r");
if (!f)
err(EXIT_FAILURE, "%s: open failed", argv[optind]);
parse_column_data(f, tb, n);
optind++;
n++;
}
if (scols_table_is_tree(tb) && parent_col >= 0 && id_col >= 0)
compose_tree(tb, parent_col, id_col);
scols_table_enable_colors(tb, isatty(STDOUT_FILENO));
scols_print_table(tb);
scols_unref_table(tb);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
int permission = 0644;
int opt;
size_t size = 0;
int nsems = 0;
int ask_shm = 0, ask_msg = 0, ask_sem = 0;
static const struct option longopts[] = {
{"shmem", required_argument, NULL, 'M'},
{"semaphore", required_argument, NULL, 'S'},
{"queue", no_argument, NULL, 'Q'},
{"mode", required_argument, NULL, 'p'},
{"version", no_argument, NULL, 'V'},
{"help", no_argument, NULL, 'h'},
{NULL, 0, NULL, 0}
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while((opt = getopt_long(argc, argv, "hM:QS:p:Vh", longopts, NULL)) != -1) {
switch(opt) {
case 'M':
size = strtosize_or_err(optarg, _("failed to parse size"));
ask_shm = 1;
break;
case 'Q':
ask_msg = 1;
break;
case 'S':
nsems = strtos32_or_err(optarg, _("failed to parse elements"));
ask_sem = 1;
break;
case 'p':
permission = strtoul(optarg, NULL, 8);
break;
case 'h':
usage(stdout);
break;
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
default:
errtryhelp(EXIT_FAILURE);
}
}
if(!ask_shm && !ask_msg && !ask_sem)
usage(stderr);
if (ask_shm) {
int shmid;
if (-1 == (shmid = create_shm(size, permission)))
err(EXIT_FAILURE, _("create share memory failed"));
else
printf(_("Shared memory id: %d\n"), shmid);
}
if (ask_msg) {
int msgid;
if (-1 == (msgid = create_msg(permission)))
err(EXIT_FAILURE, _("create message queue failed"));
else
printf(_("Message queue id: %d\n"), msgid);
}
if (ask_sem) {
int semid;
if (-1 == (semid = create_sem(nsems, permission)))
err(EXIT_FAILURE, _("create semaphore failed"));
else
printf(_("Semaphore id: %d\n"), semid);
}
return EXIT_SUCCESS;
}
static void parse_option(struct setterm_control *ctl, int ac, char **av)
{
int c;
enum {
OPT_TERM = CHAR_MAX + 1,
OPT_RESET,
OPT_RESIZE,
OPT_INITIALIZE,
OPT_CURSOR,
OPT_REPEAT,
OPT_APPCURSORKEYS,
OPT_LINEWRAP,
OPT_DEFAULT,
OPT_FOREGROUND,
OPT_BACKGROUND,
OPT_ULCOLOR,
OPT_HBCOLOR,
OPT_INVERSESCREEN,
OPT_BOLD,
OPT_HALF_BRIGHT,
OPT_BLINK,
OPT_REVERSE,
OPT_UNDERLINE,
OPT_STORE,
OPT_CLEAR,
OPT_TABS,
OPT_CLRTABS,
OPT_REGTABS,
OPT_BLANK,
OPT_DUMP,
OPT_APPEND,
OPT_FILE,
OPT_MSG,
OPT_MSGLEVEL,
OPT_POWERSAVE,
OPT_POWERDOWN,
OPT_BLENGTH,
OPT_BFREQ,
OPT_VERSION,
OPT_HELP
};
static const struct option longopts[] = {
{"term", required_argument, NULL, OPT_TERM},
{"reset", no_argument, NULL, OPT_RESET},
{"resize", no_argument, NULL, OPT_RESIZE},
{"initialize", no_argument, NULL, OPT_INITIALIZE},
{"cursor", required_argument, NULL, OPT_CURSOR},
{"repeat", required_argument, NULL, OPT_REPEAT},
{"appcursorkeys", required_argument, NULL, OPT_APPCURSORKEYS},
{"linewrap", required_argument, NULL, OPT_LINEWRAP},
{"default", no_argument, NULL, OPT_DEFAULT},
{"foreground", required_argument, NULL, OPT_FOREGROUND},
{"background", required_argument, NULL, OPT_BACKGROUND},
{"ulcolor", required_argument, NULL, OPT_ULCOLOR},
{"hbcolor", required_argument, NULL, OPT_HBCOLOR},
{"inversescreen", required_argument, NULL, OPT_INVERSESCREEN},
{"bold", required_argument, NULL, OPT_BOLD},
{"half-bright", required_argument, NULL, OPT_HALF_BRIGHT},
{"blink", required_argument, NULL, OPT_BLINK},
{"reverse", required_argument, NULL, OPT_REVERSE},
{"underline", required_argument, NULL, OPT_UNDERLINE},
{"store", no_argument, NULL, OPT_STORE},
{"clear", required_argument, NULL, OPT_CLEAR},
{"tabs", optional_argument, NULL, OPT_TABS},
{"clrtabs", optional_argument, NULL, OPT_CLRTABS},
{"regtabs", optional_argument, NULL, OPT_REGTABS},
{"blank", optional_argument, NULL, OPT_BLANK},
{"dump", optional_argument, NULL, OPT_DUMP},
{"append", required_argument, NULL, OPT_APPEND},
{"file", required_argument, NULL, OPT_FILE},
{"msg", required_argument, NULL, OPT_MSG},
{"msglevel", required_argument, NULL, OPT_MSGLEVEL},
{"powersave", required_argument, NULL, OPT_POWERSAVE},
{"powerdown", optional_argument, NULL, OPT_POWERDOWN},
{"blength", optional_argument, NULL, OPT_BLENGTH},
{"bfreq", optional_argument, NULL, OPT_BFREQ},
{"version", no_argument, NULL, OPT_VERSION},
{"help", no_argument, NULL, OPT_HELP},
{NULL, 0, NULL, 0}
};
static const ul_excl_t excl[] = {
{ OPT_DEFAULT, OPT_STORE },
{ OPT_TABS, OPT_CLRTABS, OPT_REGTABS },
{ OPT_MSG, OPT_MSGLEVEL },
{ 0 }
};
int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
while ((c = getopt_long_only(ac, av, "", longopts, NULL)) != -1) {
err_exclusive_options(c, longopts, excl, excl_st);
switch (c) {
case OPT_TERM:
ctl->opt_term = set_opt_flag(ctl->opt_term);
ctl->opt_te_terminal_name = optarg;
break;
case OPT_RESET:
ctl->opt_reset = set_opt_flag(ctl->opt_reset);
break;
case OPT_RESIZE:
ctl->opt_resize = set_opt_flag(ctl->opt_resize);
break;
case OPT_INITIALIZE:
ctl->opt_initialize = set_opt_flag(ctl->opt_initialize);
break;
case OPT_CURSOR:
ctl->opt_cursor = set_opt_flag(ctl->opt_cursor);
ctl->opt_cu_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_REPEAT:
ctl->opt_repeat = set_opt_flag(ctl->opt_repeat);
ctl->opt_rep_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_APPCURSORKEYS:
ctl->opt_appcursorkeys = set_opt_flag(ctl->opt_appcursorkeys);
ctl->opt_appck_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_LINEWRAP:
ctl->opt_linewrap = set_opt_flag(ctl->opt_linewrap);
ctl->opt_li_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_DEFAULT:
ctl->opt_default = set_opt_flag(ctl->opt_default);
break;
case OPT_FOREGROUND:
ctl->opt_foreground = set_opt_flag(ctl->opt_foreground);
ctl->opt_fo_color = parse_febg_color(optarg);
break;
case OPT_BACKGROUND:
ctl->opt_background = set_opt_flag(ctl->opt_background);
ctl->opt_ba_color = parse_febg_color(optarg);
break;
case OPT_ULCOLOR:
ctl->opt_ulcolor = set_opt_flag(ctl->opt_ulcolor);
ctl->opt_ul_color = parse_ulhb_color(av, &optind);
break;
case OPT_HBCOLOR:
ctl->opt_hbcolor = set_opt_flag(ctl->opt_hbcolor);
ctl->opt_hb_color = parse_ulhb_color(av, &optind);
break;
case OPT_INVERSESCREEN:
ctl->opt_inversescreen = set_opt_flag(ctl->opt_inversescreen);
ctl->opt_invsc_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_BOLD:
ctl->opt_bold = set_opt_flag(ctl->opt_bold);
ctl->opt_bo_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_HALF_BRIGHT:
ctl->opt_halfbright = set_opt_flag(ctl->opt_halfbright);
ctl->opt_hb_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_BLINK:
ctl->opt_blink = set_opt_flag(ctl->opt_blink);
ctl->opt_bl_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_REVERSE:
ctl->opt_reverse = set_opt_flag(ctl->opt_reverse);
ctl->opt_re_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_UNDERLINE:
ctl->opt_underline = set_opt_flag(ctl->opt_underline);
ctl->opt_un_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_STORE:
ctl->opt_store = set_opt_flag(ctl->opt_store);
break;
case OPT_CLEAR:
ctl->opt_clear = set_opt_flag(ctl->opt_clear);
ctl->opt_cl_all = parse_switch(optarg, _("argument error"),
"all", "reset", NULL);
break;
case OPT_TABS:
ctl->opt_tabs = set_opt_flag(ctl->opt_tabs);
parse_tabs(av, optarg, &optind, ctl->opt_tb_array);
break;
case OPT_CLRTABS:
ctl->opt_clrtabs = set_opt_flag(ctl->opt_clrtabs);
parse_tabs(av, optarg, &optind, ctl->opt_tb_array);
break;
case OPT_REGTABS:
ctl->opt_regtabs = set_opt_flag(ctl->opt_regtabs);
ctl->opt_rt_len = parse_regtabs(av, optarg, &optind);
break;
case OPT_BLANK:
ctl->opt_blank = set_opt_flag(ctl->opt_blank);
ctl->opt_bl_min = parse_blank(av, optarg, &optind);
break;
case OPT_DUMP:
ctl->opt_snap = set_opt_flag(ctl->opt_snap);
ctl->opt_sn_num = parse_snap(av, optarg, &optind);
break;
case OPT_APPEND:
ctl->opt_append = set_opt_flag(ctl->opt_append);
ctl->opt_sn_num = parse_snap(av, optarg, &optind);
break;
case OPT_FILE:
ctl->opt_snapfile = set_opt_flag(ctl->opt_snapfile);
ctl->opt_sn_name = optarg;
break;
case OPT_MSG:
ctl->opt_msg = set_opt_flag(ctl->opt_msg);
ctl->opt_msg_on = parse_switch(optarg, _("argument error"),
"on", "off", NULL);
break;
case OPT_MSGLEVEL:
ctl->opt_msglevel = set_opt_flag(ctl->opt_msglevel);
ctl->opt_msglevel_num = parse_msglevel(optarg);
if (ctl->opt_msglevel_num == 0) {
ctl->opt_msg = set_opt_flag(ctl->opt_msg);
ctl->opt_msg_on |= 1;
}
break;
case OPT_POWERSAVE:
ctl->opt_powersave = set_opt_flag(ctl->opt_powersave);
ctl->opt_ps_mode = parse_powersave(optarg);
break;
case OPT_POWERDOWN:
ctl->opt_powerdown = set_opt_flag(ctl->opt_powerdown);
ctl->opt_pd_min = parse_blank(av, optarg, &optind);
break;
case OPT_BLENGTH:
ctl->opt_blength = set_opt_flag(ctl->opt_blength);
ctl->opt_blength_l = parse_blength(av, optarg, &optind);
break;
case OPT_BFREQ:
ctl->opt_bfreq = set_opt_flag(ctl->opt_bfreq);
ctl->opt_bfreq_f = parse_bfreq(av, optarg, &optind);
break;
case OPT_VERSION:
printf(UTIL_LINUX_VERSION);
exit(EXIT_SUCCESS);
case OPT_HELP:
usage();
default:
errtryhelp(EXIT_FAILURE);
}
}
}
int main(int argc, char *argv[])
{
char const *filename = "stdin";
wchar_t *buf;
size_t len, bufsiz = BUFSIZ;
FILE *fp = stdin;
int ch, rval = EXIT_SUCCESS;
static const struct option longopts[] = {
{ "version", no_argument, NULL, 'V' },
{ "help", no_argument, NULL, 'h' },
{ NULL, 0, NULL, 0 }
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
close_stdout_atexit();
signal(SIGINT, sig_handler);
signal(SIGTERM, sig_handler);
while ((ch = getopt_long(argc, argv, "Vh", longopts, NULL)) != -1)
switch(ch) {
case 'V':
print_version(EXIT_SUCCESS);
case 'h':
usage();
default:
errtryhelp(EXIT_FAILURE);
}
argc -= optind;
argv += optind;
buf = xmalloc(bufsiz * sizeof(wchar_t));
do {
if (*argv) {
if ((fp = fopen(*argv, "r")) == NULL) {
warn(_("cannot open %s"), *argv );
rval = EXIT_FAILURE;
++argv;
continue;
}
filename = *argv++;
}
while (fgetws(buf, bufsiz, fp)) {
len = wcslen(buf);
if (len == 0)
continue;
/* This is my hack from setpwnam.c -janl */
while (buf[len-1] != '\n' && !feof(fp)) {
/* Extend input buffer if it failed getting the whole line */
/* So now we double the buffer size */
bufsiz *= 2;
buf = xrealloc(buf, bufsiz * sizeof(wchar_t));
/* And fill the rest of the buffer */
if (!fgetws(&buf[len], bufsiz/2, fp))
break;
len = wcslen(buf);
}
if (buf[len - 1] == '\n')
buf[len--] = '\0';
reverse_str(buf, len);
fputws(buf, stdout);
}
if (ferror(fp)) {
warn("%s", filename);
rval = EXIT_FAILURE;
}
fclose(fp);
} while(*argv);
free(buf);
return rval;
}
/*
* logger -- read and log utility
*
* Reads from an input and arranges to write the result on the system
* log.
*/
int main(int argc, char **argv)
{
struct logger_ctl ctl = {
.fd = -1,
.pid = 0,
.pri = LOG_USER | LOG_NOTICE,
.prio_prefix = 0,
.tag = NULL,
.unix_socket = NULL,
.unix_socket_errors = 0,
.server = NULL,
.port = NULL,
.hdr = NULL,
.msgid = NULL,
.socket_type = ALL_TYPES,
.max_message_size = 1024,
.rfc5424_time = 1,
.rfc5424_tq = 1,
.rfc5424_host = 1,
.skip_empty_lines = 0
};
int ch;
int stdout_reopened = 0;
int unix_socket_errors_mode = AF_UNIX_ERRORS_AUTO;
#ifdef HAVE_LIBSYSTEMD
FILE *jfd = NULL;
#endif
static const struct option longopts[] = {
{ "id", optional_argument, 0, OPT_ID },
{ "stderr", no_argument, 0, 's' },
{ "file", required_argument, 0, 'f' },
{ "no-act", no_argument, 0, OPT_NOACT, },
{ "priority", required_argument, 0, 'p' },
{ "tag", required_argument, 0, 't' },
{ "socket", required_argument, 0, 'u' },
{ "socket-errors", required_argument, 0, OPT_SOCKET_ERRORS },
{ "udp", no_argument, 0, 'd' },
{ "tcp", no_argument, 0, 'T' },
{ "server", required_argument, 0, 'n' },
{ "port", required_argument, 0, 'P' },
{ "version", no_argument, 0, 'V' },
{ "help", no_argument, 0, 'h' },
{ "octet-count", no_argument, 0, OPT_OCTET_COUNT },
{ "prio-prefix", no_argument, 0, OPT_PRIO_PREFIX },
{ "rfc3164", no_argument, 0, OPT_RFC3164 },
{ "rfc5424", optional_argument, 0, OPT_RFC5424 },
{ "size", required_argument, 0, 'S' },
{ "msgid", required_argument, 0, OPT_MSGID },
{ "skip-empty", no_argument, 0, 'e' },
{ "sd-id", required_argument, 0, OPT_STRUCTURED_DATA_ID },
{ "sd-param", required_argument, 0, OPT_STRUCTURED_DATA_PARAM },
#ifdef HAVE_LIBSYSTEMD
{ "journald", optional_argument, 0, OPT_JOURNALD },
#endif
{ NULL, 0, 0, 0 }
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
INIT_LIST_HEAD(&ctl.user_sds);
INIT_LIST_HEAD(&ctl.reserved_sds);
while ((ch = getopt_long(argc, argv, "ef:ip:S:st:u:dTn:P:Vh",
longopts, NULL)) != -1) {
switch (ch) {
case 'f': /* file to log */
if (freopen(optarg, "r", stdin) == NULL)
err(EXIT_FAILURE, _("file %s"), optarg);
stdout_reopened = 1;
break;
case 'e':
ctl.skip_empty_lines = 1;
break;
case 'i': /* log process id also */
ctl.pid = logger_getpid();
break;
case OPT_ID:
if (optarg) {
const char *p = optarg;
if (*p == '=')
p++;
ctl.pid = strtoul_or_err(optarg, _("failed to parse id"));
} else
ctl.pid = logger_getpid();
break;
case 'p': /* priority */
ctl.pri = pencode(optarg);
break;
case 's': /* log to standard error */
ctl.stderr_printout = 1;
break;
case 't': /* tag */
ctl.tag = optarg;
break;
case 'u': /* unix socket */
ctl.unix_socket = optarg;
break;
case 'S': /* max message size */
ctl.max_message_size = strtosize_or_err(optarg,
_("failed to parse message size"));
break;
case 'd':
ctl.socket_type = TYPE_UDP;
break;
case 'T':
ctl.socket_type = TYPE_TCP;
break;
case 'n':
ctl.server = optarg;
break;
case 'P':
ctl.port = optarg;
break;
case 'V':
printf(UTIL_LINUX_VERSION);
exit(EXIT_SUCCESS);
case 'h':
usage(stdout);
case OPT_OCTET_COUNT:
ctl.octet_count = 1;
break;
case OPT_PRIO_PREFIX:
ctl.prio_prefix = 1;
break;
case OPT_RFC3164:
ctl.syslogfp = syslog_rfc3164_header;
break;
case OPT_RFC5424:
ctl.syslogfp = syslog_rfc5424_header;
if (optarg)
parse_rfc5424_flags(&ctl, optarg);
break;
case OPT_MSGID:
if (strchr(optarg, ' '))
errx(EXIT_FAILURE, _("--msgid cannot contain space"));
ctl.msgid = optarg;
break;
#ifdef HAVE_LIBSYSTEMD
case OPT_JOURNALD:
if (optarg) {
jfd = fopen(optarg, "r");
if (!jfd)
err(EXIT_FAILURE, _("cannot open %s"),
optarg);
} else
jfd = stdin;
break;
#endif
case OPT_SOCKET_ERRORS:
unix_socket_errors_mode = parse_unix_socket_errors_flags(optarg);
break;
case OPT_NOACT:
ctl.noact = 1;
break;
case OPT_STRUCTURED_DATA_ID:
if (!valid_structured_data_id(optarg))
errx(EXIT_FAILURE, _("invalid structured data ID: '%s'"), optarg);
add_structured_data_id(get_user_structured_data(&ctl), optarg);
break;
case OPT_STRUCTURED_DATA_PARAM:
if (!valid_structured_data_param(optarg))
errx(EXIT_FAILURE, _("invalid structured data parameter: '%s'"), optarg);
add_structured_data_param(get_user_structured_data(&ctl), optarg);
break;
default:
errtryhelp(EXIT_FAILURE);
}
}
argc -= optind;
argv += optind;
if (stdout_reopened && argc)
warnx(_("--file <file> and <message> are mutually exclusive, message is ignored"));
#ifdef HAVE_LIBSYSTEMD
if (jfd) {
int ret = journald_entry(&ctl, jfd);
if (stdin != jfd)
fclose(jfd);
if (ret)
errx(EXIT_FAILURE, _("journald entry could not be written"));
return EXIT_SUCCESS;
}
#endif
/* user overwrites build-in SD-ELEMENT */
if (has_structured_data_id(get_user_structured_data(&ctl), "timeQuality"))
ctl.rfc5424_tq = 0;
switch (unix_socket_errors_mode) {
case AF_UNIX_ERRORS_OFF:
ctl.unix_socket_errors = 0;
break;
case AF_UNIX_ERRORS_ON:
ctl.unix_socket_errors = 1;
break;
case AF_UNIX_ERRORS_AUTO:
ctl.unix_socket_errors = ctl.noact || ctl.stderr_printout;
#ifdef HAVE_LIBSYSTEMD
ctl.unix_socket_errors |= !!sd_booted();
#endif
break;
default:
abort();
}
logger_open(&ctl);
if (0 < argc)
logger_command_line(&ctl, argv);
else
/* Note. --file <arg> reopens stdin making the below
* function to be used for file inputs. */
logger_stdin(&ctl);
logger_close(&ctl);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
pid_t pid = 0;
int c, adj = 0, has_adj = 0;
static const struct option longopts[] = {
{ "adjust", required_argument, NULL, 'n' },
{ "pid", required_argument, NULL, 'p' },
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, 'V' },
{ NULL, 0, NULL, 0 }
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while ((c = getopt_long(argc, argv, "hn:p:V", longopts, NULL)) != -1) {
switch (c) {
case 'p':
pid = strtos32_or_err(optarg, _("invalid PID argument"));
break;
case 'n':
adj = strtos32_or_err(optarg, _("invalid adjust argument"));
has_adj = 1;
break;
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
case 'h':
usage();
default:
errtryhelp(EXIT_FAILURE);
}
}
if (optind < argc && pid) {
warnx(_("invalid argument: %s"), argv[optind]);
errtryhelp(EXIT_FAILURE);
}
if (!pid && argc - optind < 1) {
warnx(_("no PID or COMMAND specified"));
errtryhelp(EXIT_FAILURE);
}
if (optind < argc && !has_adj) {
warnx(_("no OOM score adjust value specified"));
errtryhelp(EXIT_FAILURE);
}
/* Show */
if (!has_adj) {
printf(_("pid %d's current OOM score: %d\n"), pid, get_score(pid));
printf(_("pid %d's current OOM score adjust value: %d\n"), pid, get_score_adj(pid));
/* Change */
} else if (pid) {
int old = get_score_adj(pid);
if (set_score_adj(pid, adj))
err(EXIT_FAILURE, _("failed to set score adjust value"));
printf(_("pid %d's OOM score adjust value changed from %d to %d\n"), pid, old, adj);
/* Start new process */
} else {
if (set_score_adj(getpid(), adj))
err(EXIT_FAILURE, _("failed to set score adjust value"));
argv += optind;
execvp(argv[0], argv);
errexec(argv[0]);
}
return EXIT_SUCCESS;
}
int
main(int argc, char *argv[])
{
struct stat sb;
int ch, fd, termchar;
char *back, *file, *front, *p;
static const struct option longopts[] = {
{"alternative", no_argument, NULL, 'a'},
{"alphanum", no_argument, NULL, 'd'},
{"ignore-case", no_argument, NULL, 'f'},
{"terminate", required_argument, NULL, 't'},
{"version", no_argument, NULL, 'V'},
{"help", no_argument, NULL, 'h'},
{NULL, 0, NULL, 0}
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
setlocale(LC_ALL, "");
if ((file = getenv("WORDLIST")) && !access(file, R_OK))
/* use the WORDLIST */;
else
file = _PATH_WORDS;
termchar = '\0';
string = NULL; /* just for gcc */
while ((ch = getopt_long(argc, argv, "adft:Vh", longopts, NULL)) != -1)
switch(ch) {
case 'a':
file = _PATH_WORDS_ALT;
break;
case 'd':
dflag = 1;
break;
case 'f':
fflag = 1;
break;
case 't':
termchar = *optarg;
break;
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
case 'h':
usage();
default:
errtryhelp(EXIT_FAILURE);
}
argc -= optind;
argv += optind;
switch (argc) {
case 2: /* Don't set -df for user. */
string = *argv++;
file = *argv;
break;
case 1: /* But set -df by default. */
dflag = fflag = 1;
string = *argv;
break;
default:
warnx(_("bad usage"));
errtryhelp(EXIT_FAILURE);
}
if (termchar != '\0' && (p = strchr(string, termchar)) != NULL)
*++p = '\0';
if ((fd = open(file, O_RDONLY, 0)) < 0 || fstat(fd, &sb))
err(EXIT_FAILURE, "%s", file);
front = mmap(NULL, (size_t) sb.st_size, PROT_READ,
MAP_SHARED, fd, (off_t) 0);
if
#ifdef MAP_FAILED
(front == MAP_FAILED)
#else
((void *)(front) <= (void *)0)
#endif
err(EXIT_FAILURE, "%s", file);
back = front + sb.st_size;
return look(front, back);
}
int main(int argc, char **argv)
{
int c;
struct mountpoint_control ctl = { NULL };
static const struct option longopts[] = {
{ "quiet", no_argument, NULL, 'q' },
{ "fs-devno", no_argument, NULL, 'd' },
{ "devno", no_argument, NULL, 'x' },
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, 'V' },
{ NULL, 0, NULL, 0 }
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
mnt_init_debug(0);
while ((c = getopt_long(argc, argv, "qdxhV", longopts, NULL)) != -1) {
switch(c) {
case 'q':
ctl.quiet = 1;
break;
case 'd':
ctl.fs_devno = 1;
break;
case 'x':
ctl.dev_devno = 1;
break;
case 'h':
usage();
break;
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
default:
errtryhelp(EXIT_FAILURE);
}
}
if (optind + 1 != argc) {
warnx(_("bad usage"));
errtryhelp(EXIT_FAILURE);
}
ctl.path = argv[optind];
if (stat(ctl.path, &ctl.st)) {
if (!ctl.quiet)
err(EXIT_FAILURE, "%s", ctl.path);
return EXIT_FAILURE;
}
if (ctl.dev_devno)
return print_devno(&ctl) ? EXIT_FAILURE : EXIT_SUCCESS;
if (dir_to_device(&ctl)) {
if (!ctl.quiet)
printf(_("%s is not a mountpoint\n"), ctl.path);
return EXIT_FAILURE;
}
if (ctl.fs_devno)
printf("%u:%u\n", major(ctl.dev), minor(ctl.dev));
else if (!ctl.quiet)
printf(_("%s is a mountpoint\n"), ctl.path);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
int c; /* for getopt */
int start = 0;
size_t length = 0;
static const struct option longopts[] = {
{"verbose", no_argument, NULL, 'v'},
{"version", no_argument, NULL, 'V'},
{"help", no_argument, NULL, 'h'},
{"blocksize", required_argument, NULL, 'b'},
{"extract", optional_argument, NULL, 'x'},
{NULL, 0, NULL, 0},
};
setlocale(LC_MESSAGES, "");
setlocale(LC_CTYPE, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
close_stdout_atexit();
strutils_set_exitcode(FSCK_EX_USAGE);
/* command line options */
while ((c = getopt_long(argc, argv, "ayvVhb:", longopts, NULL)) != EOF)
switch (c) {
case 'a': /* ignore */
case 'y':
break;
case 'h':
usage();
break;
case 'V':
print_version(FSCK_EX_OK);
case 'x':
opt_extract = 1;
if(optarg)
extract_dir = optarg;
break;
case 'v':
opt_verbose++;
break;
case 'b':
blksize = strtou32_or_err(optarg, _("invalid blocksize argument"));
break;
default:
errtryhelp(FSCK_EX_USAGE);
}
if ((argc - optind) != 1){
warnx(_("bad usage"));
errtryhelp(FSCK_EX_USAGE);
}
filename = argv[optind];
test_super(&start, &length);
test_crc(start);
if(opt_extract) {
if (blksize == 0)
blksize = getpagesize();
outbuffer = xmalloc(blksize * 2);
test_fs(start);
}
if (opt_verbose)
printf(_("%s: OK\n"), filename);
exit(FSCK_EX_OK);
}
