/* Die with an error message if we can't spawn a child process. */ pid_t FAST_FUNC xspawn(char **argv) { pid_t pid = spawn(argv); if (pid < 0) bb_simple_perror_msg_and_die(*argv); return pid; }
int setarch_main(int argc ATTRIBUTE_UNUSED, char **argv) { int pers = -1; /* Figure out what personality we are supposed to switch to ... * we can be invoked as either: * argv[0],argv[1] -> "setarch","personality" * argv[0] -> "personality" */ retry: if (argv[0][5] == '6') /* linux64 */ pers = PER_LINUX; else if (argv[0][5] == '3') /* linux32 */ pers = PER_LINUX32; else if (pers == -1 && argv[1] != NULL) { pers = PER_LINUX32; ++argv; goto retry; } /* make user actually gave us something to do */ ++argv; if (argv[0] == NULL) bb_show_usage(); /* Try to set personality */ if (personality(pers) >= 0) { /* Try to execute the program */ BB_EXECVP(argv[0], argv); } bb_simple_perror_msg_and_die(argv[0]); }
int mesg_main(int argc, char **argv) { struct stat sb; const char *tty; char c = 0; if (--argc == 0 || (argc == 1 && ((c = **++argv) == 'y' || c == 'n')) ) { tty = xmalloc_ttyname(STDERR_FILENO); if (tty == NULL) { tty = "ttyname"; } else if (stat(tty, &sb) == 0) { mode_t m; if (argc == 0) { puts((sb.st_mode & (S_IWGRP|S_IWOTH)) ? "is y" : "is n"); return EXIT_SUCCESS; } m = (c == 'y') ? sb.st_mode | S_IWGRP_OR_S_IWOTH : sb.st_mode & ~(S_IWGRP|S_IWOTH); if (chmod(tty, m) == 0) { return EXIT_SUCCESS; } } bb_simple_perror_msg_and_die(tty); } bb_show_usage(); }
/* if fn is NULL then input is stdin and output is stdout */ static void convert(char *fn, int conv_type) { FILE *in, *out; int ch; char *temp_fn = temp_fn; /* for compiler */ char *resolved_fn = resolved_fn; in = stdin; out = stdout; if (fn != NULL) { struct stat st; int fd; resolved_fn = xmalloc_follow_symlinks(fn); if (resolved_fn == NULL) bb_simple_perror_msg_and_die(fn); in = xfopen_for_read(resolved_fn); xfstat(fileno(in), &st, resolved_fn); temp_fn = xasprintf("%sXXXXXX", resolved_fn); fd = xmkstemp(temp_fn); if (fchmod(fd, st.st_mode) == -1) bb_simple_perror_msg_and_die(temp_fn); fchown(fd, st.st_uid, st.st_gid); out = xfdopen_for_write(fd); } while ((ch = fgetc(in)) != EOF) { if (ch == '\r') continue; if (ch == '\n') if (conv_type == CT_UNIX2DOS) fputc('\r', out); fputc(ch, out); } if (fn != NULL) { if (fclose(in) < 0 || fclose(out) < 0) { unlink(temp_fn); bb_perror_nomsg_and_die(); } xrename(temp_fn, resolved_fn); free(temp_fn); free(resolved_fn); } }
int env_main(int argc UNUSED_PARAM, char **argv) { char **ep; unsigned opt; llist_t *unset_env = NULL; opt_complementary = "u::"; #if ENABLE_FEATURE_ENV_LONG_OPTIONS applet_long_options = env_longopts; #endif opt = getopt32(argv, "+iu:", &unset_env); argv += optind; if (*argv && LONE_DASH(argv[0])) { opt |= 1; ++argv; } if (opt & 1) { clearenv(); } while (unset_env) { char *var = llist_pop(&unset_env); /* This does not handle -uVAR=VAL * (coreutils _sets_ the variable in that case): */ /*unsetenv(var);*/ /* This does, but uses somewhan undocumented feature that * putenv("name_without_equal_sign") unsets the variable: */ putenv(var); } while (*argv && (strchr(*argv, '=') != NULL)) { if (putenv(*argv) < 0) { bb_perror_msg_and_die("putenv"); } ++argv; } if (*argv) { BB_EXECVP(*argv, argv); /* SUSv3-mandated exit codes. */ xfunc_error_retval = (errno == ENOENT) ? 127 : 126; bb_simple_perror_msg_and_die(*argv); } for (ep = environ; *ep; ep++) { puts(*ep); } fflush_stdout_and_exit(EXIT_SUCCESS); }
static void do_skip(priv_dumper_t *dumper, const char *fname, int statok) { struct stat sbuf; if (statok) { if (fstat(STDIN_FILENO, &sbuf)) { bb_simple_perror_msg_and_die(fname); } if (!(S_ISCHR(sbuf.st_mode) || S_ISBLK(sbuf.st_mode) || S_ISFIFO(sbuf.st_mode)) && dumper->pub.dump_skip >= sbuf.st_size ) { /* If bb_dump_size valid and pub.dump_skip >= size */ dumper->pub.dump_skip -= sbuf.st_size; dumper->address += sbuf.st_size; return; } } if (fseek(stdin, dumper->pub.dump_skip, SEEK_SET)) { bb_simple_perror_msg_and_die(fname); } dumper->address += dumper->pub.dump_skip; dumper->savaddress = dumper->address; dumper->pub.dump_skip = 0; }
int env_main(int argc ATTRIBUTE_UNUSED, char **argv) { /* cleanenv was static - why? */ char *cleanenv[1]; char **ep; unsigned opt; llist_t *unset_env = NULL; opt_complementary = "u::"; #if ENABLE_FEATURE_ENV_LONG_OPTIONS applet_long_options = env_longopts; #endif opt = getopt32(argv, "+iu:", &unset_env); argv += optind; if (*argv && LONE_DASH(argv[0])) { opt |= 1; ++argv; } if (opt & 1) { cleanenv[0] = NULL; environ = cleanenv; } else { while (unset_env) { unsetenv(unset_env->data); unset_env = unset_env->link; } } while (*argv && (strchr(*argv, '=') != NULL)) { if (putenv(*argv) < 0) { bb_perror_msg_and_die("putenv"); } ++argv; } if (*argv) { BB_EXECVP(*argv, argv); /* SUSv3-mandated exit codes. */ xfunc_error_retval = (errno == ENOENT) ? 127 : 126; bb_simple_perror_msg_and_die(*argv); } for (ep = environ; *ep; ep++) { puts(*ep); } fflush_stdout_and_exit(0); }
int nohup_main(int argc UNUSED_PARAM, char **argv) { const char *nohupout; char *home; xfunc_error_retval = 127; if (!argv[1]) { bb_show_usage(); } /* If stdin is a tty, detach from it. */ if (isatty(STDIN_FILENO)) { /* bb_error_msg("ignoring input"); */ close(STDIN_FILENO); xopen(bb_dev_null, O_RDONLY); /* will be fd 0 (STDIN_FILENO) */ } nohupout = "nohup.out"; /* Redirect stdout to nohup.out, either in "." or in "$HOME". */ if (isatty(STDOUT_FILENO)) { close(STDOUT_FILENO); if (open(nohupout, O_CREAT|O_WRONLY|O_APPEND, S_IRUSR|S_IWUSR) < 0) { home = getenv("HOME"); if (home) { nohupout = concat_path_file(home, nohupout); xopen3(nohupout, O_CREAT|O_WRONLY|O_APPEND, S_IRUSR|S_IWUSR); } else { xopen(bb_dev_null, O_RDONLY); /* will be fd 1 */ } } bb_error_msg("appending output to %s", nohupout); } /* If we have a tty on stderr, redirect to stdout. */ if (isatty(STDERR_FILENO)) { /* if (stdout_wasnt_a_tty) bb_error_msg("redirecting stderr to stdout"); */ dup2(STDOUT_FILENO, STDERR_FILENO); } signal(SIGHUP, SIG_IGN); BB_EXECVP(argv[1], argv+1); bb_simple_perror_msg_and_die(argv[1]); }
int setsid_main(int argc UNUSED_PARAM, char **argv) { if (!argv[1]) bb_show_usage(); /* setsid() is allowed only when we are not a process group leader. * Otherwise our PID serves as PGID of some existing process group * and cannot be used as PGID of a new process group. */ if (getpgrp() == getpid()) if (fork_or_rexec(argv)) exit(EXIT_SUCCESS); /* parent */ setsid(); /* no error possible */ BB_EXECVP(argv[1], argv + 1); bb_simple_perror_msg_and_die(argv[1]); }
int nohup_main(int argc, char **argv) { int nullfd; const char *nohupout; char *home = NULL; xfunc_error_retval = 127; if (argc < 2) bb_show_usage(); nullfd = xopen(bb_dev_null, O_WRONLY|O_APPEND); /* If stdin is a tty, detach from it. */ if (isatty(STDIN_FILENO)) dup2(nullfd, STDIN_FILENO); nohupout = "nohup.out"; /* Redirect stdout to nohup.out, either in "." or in "$HOME". */ if (isatty(STDOUT_FILENO)) { close(STDOUT_FILENO); if (open(nohupout, O_CREAT|O_WRONLY|O_APPEND, S_IRUSR|S_IWUSR) < 0) { home = getenv("HOME"); if (home) { nohupout = concat_path_file(home, nohupout); xopen3(nohupout, O_CREAT|O_WRONLY|O_APPEND, S_IRUSR|S_IWUSR); } } } else dup2(nullfd, STDOUT_FILENO); /* If we have a tty on stderr, announce filename and redirect to stdout. * Else redirect to /dev/null. */ if (isatty(STDERR_FILENO)) { bb_error_msg("appending to %s", nohupout); dup2(STDOUT_FILENO, STDERR_FILENO); } else dup2(nullfd, STDERR_FILENO); if (nullfd > 2) close(nullfd); signal(SIGHUP, SIG_IGN); BB_EXECVP(argv[1], argv+1); if (ENABLE_FEATURE_CLEAN_UP && home) free((char*)nohupout); bb_simple_perror_msg_and_die(argv[1]); }
static int write_ar_archive(archive_handle_t *handle) { struct stat st; archive_handle_t *out_handle; if (fstat(handle->src_fd, &st) == -1) bb_simple_perror_msg_and_die(handle->ar__name); /* if archive exists, create a new handle for output. * we create it in place of the old one. */ if (st.st_size != 0) { out_handle = init_handle(); xunlink(handle->ar__name); out_handle->src_fd = xopen(handle->ar__name, O_WRONLY | O_CREAT | O_TRUNC); out_handle->accept = handle->accept; } else { out_handle = handle; } handle->ar__out = out_handle; xwrite(out_handle->src_fd, AR_MAGIC "\n", AR_MAGIC_LEN + 1); out_handle->offset += AR_MAGIC_LEN + 1; /* skip to the end of the archive if we have to append stuff */ if (st.st_size != 0) { handle->filter = filter_replaceable; handle->action_data = copy_data; unpack_ar_archive(handle); } while (write_ar_header(out_handle) == 0) continue; /* optional, since we exit right after we return */ if (ENABLE_FEATURE_CLEAN_UP) { close(handle->src_fd); if (out_handle->src_fd != handle->src_fd) close(out_handle->src_fd); } return EXIT_SUCCESS; }
int mknod_main(int argc, char **argv) { mode_t mode; dev_t dev; const char *name; mode = getopt_mk_fifo_nod(argv); argv += optind; argc -= optind; if (argc >= 2) { name = strchr(modes_chars, argv[1][0]); if (name != NULL) { mode |= modes_cubp[(int)(name[4])]; dev = 0; if (*name != 'p') { argc -= 2; if (argc == 2) { /* Autodetect what the system supports; these macros should * optimize out to two constants. */ dev = makedev(xatoul_range(argv[2], 0, major(UINT_MAX)), xatoul_range(argv[3], 0, minor(UINT_MAX))); } } if (argc == 2) { name = *argv; if (mknod(name, mode, dev) == 0) { return EXIT_SUCCESS; } bb_simple_perror_msg_and_die(name); } } } bb_show_usage(); }
/* * Execute a particular fsck program, and link it into the list of * child processes we are waiting for. */ static int execute(const char *type, const char *device, const char *mntpt, int interactive) { char *s, *argv[80]; char *prog; int argc, i; struct fsck_instance *inst, *p; pid_t pid; inst = malloc(sizeof(struct fsck_instance)); if (!inst) return ENOMEM; memset(inst, 0, sizeof(struct fsck_instance)); prog = xasprintf("fsck.%s", type); argv[0] = prog; argc = 1; for (i=0; i <num_args; i++) argv[argc++] = string_copy(args[i]); if (progress && !progress_active()) { if ((strcmp(type, "ext2") == 0) || (strcmp(type, "ext3") == 0)) { char tmp[80]; snprintf(tmp, 80, "-C%d", progress_fd); argv[argc++] = string_copy(tmp); inst->flags |= FLAG_PROGRESS; } } argv[argc++] = string_copy(device); argv[argc] = 0; s = find_fsck(prog); if (s == NULL) { bb_error_msg("%s: not found", prog); return ENOENT; } if (verbose || noexecute) { printf("[%s (%d) -- %s] ", s, num_running, mntpt ? mntpt : device); for (i=0; i < argc; i++) printf("%s ", argv[i]); bb_putchar('\n'); } /* Fork and execute the correct program. */ if (noexecute) pid = -1; else if ((pid = fork()) < 0) { perror("fork"); return errno; } else if (pid == 0) { if (!interactive) close(0); (void) execv(s, argv); bb_simple_perror_msg_and_die(argv[0]); } for (i = 1; i < argc; i++) free(argv[i]); free(s); inst->pid = pid; inst->prog = prog; inst->type = string_copy(type); inst->device = string_copy(device); inst->base_device = base_device(device); inst->start_time = time(0); inst->next = NULL; /* * Find the end of the list, so we add the instance on at the end. */ for (p = instance_list; p && p->next; p = p->next); if (p) p->next = inst; else instance_list = inst; return 0; }
/* Return value will become exit code. * It's ok to exit instead of return. */ static NOINLINE int cpio_o(void) { static const char trailer[] ALIGN1 = "TRAILER!!!"; struct name_s { struct name_s *next; char name[1]; }; struct inodes_s { struct inodes_s *next; struct name_s *names; struct stat st; }; struct inodes_s *links = NULL; off_t bytes = 0; /* output bytes count */ while (1) { const char *name; char *line; struct stat st; line = (option_mask32 & CPIO_OPT_NUL_TERMINATED) ? bb_get_chunk_from_file(stdin, NULL) : xmalloc_fgetline(stdin); if (line) { /* Strip leading "./[./]..." from the filename */ name = line; while (name[0] == '.' && name[1] == '/') { while (*++name == '/') continue; } if (!*name) { /* line is empty */ free(line); continue; } if ((option_mask32 & CPIO_OPT_DEREF) ? stat(name, &st) : lstat(name, &st) ) { abort_cpio_o: bb_simple_perror_msg_and_die(name); } if (!(S_ISLNK(st.st_mode) || S_ISREG(st.st_mode))) st.st_size = 0; /* paranoia */ /* Store hardlinks for later processing, dont output them */ if (!S_ISDIR(st.st_mode) && st.st_nlink > 1) { struct name_s *n; struct inodes_s *l; /* Do we have this hardlink remembered? */ l = links; while (1) { if (l == NULL) { /* Not found: add new item to "links" list */ l = xzalloc(sizeof(*l)); l->st = st; l->next = links; links = l; break; } if (l->st.st_ino == st.st_ino) { /* found */ break; } l = l->next; } /* Add new name to "l->names" list */ n = xmalloc(sizeof(*n) + strlen(name)); strcpy(n->name, name); n->next = l->names; l->names = n; free(line); continue; } } else { /* line == NULL: EOF */ next_link: if (links) { /* Output hardlink's data */ st = links->st; name = links->names->name; links->names = links->names->next; /* GNU cpio is reported to emit file data * only for the last instance. Mimic that. */ if (links->names == NULL) links = links->next; else st.st_size = 0; /* NB: we leak links->names and/or links, * this is intended (we exit soon anyway) */ } else { /* If no (more) hardlinks to output, * output "trailer" entry */ name = trailer; /* st.st_size == 0 is a must, but for uniformity * in the output, we zero out everything */ memset(&st, 0, sizeof(st)); /* st.st_nlink = 1; - GNU cpio does this */ } } bytes += printf("070701" "%08X%08X%08X%08X%08X%08X%08X" "%08X%08X%08X%08X" /* GNU cpio uses uppercase hex */ /* strlen+1: */ "%08X" /* chksum: */ "00000000" /* (only for "070702" files) */ /* name,NUL: */ "%s%c", (unsigned)(uint32_t) st.st_ino, (unsigned)(uint32_t) st.st_mode, (unsigned)(uint32_t) st.st_uid, (unsigned)(uint32_t) st.st_gid, (unsigned)(uint32_t) st.st_nlink, (unsigned)(uint32_t) st.st_mtime, (unsigned)(uint32_t) st.st_size, (unsigned)(uint32_t) major(st.st_dev), (unsigned)(uint32_t) minor(st.st_dev), (unsigned)(uint32_t) major(st.st_rdev), (unsigned)(uint32_t) minor(st.st_rdev), (unsigned)(strlen(name) + 1), name, '\0'); bytes = cpio_pad4(bytes); if (st.st_size) { if (S_ISLNK(st.st_mode)) { char *lpath = xmalloc_readlink_or_warn(name); if (!lpath) goto abort_cpio_o; bytes += printf("%s", lpath); free(lpath); } else { /* S_ISREG */ int fd = xopen(name, O_RDONLY); fflush_all(); /* We must abort if file got shorter too! */ bb_copyfd_exact_size(fd, STDOUT_FILENO, st.st_size); bytes += st.st_size; close(fd); } bytes = cpio_pad4(bytes); } if (!line) { if (name != trailer) goto next_link; /* TODO: GNU cpio pads trailer to 512 bytes, do we want that? */ return EXIT_SUCCESS; } free(line); } /* end of "while (1)" */ }
int script_main(int argc ATTRIBUTE_UNUSED, char **argv) { int opt; int mode; int child_pid; int attr_ok; /* NB: 0: ok */ int winsz_ok; int pty; char pty_line[GETPTY_BUFSIZE]; struct termios tt, rtt; struct winsize win; const char *fname = "typescript"; const char *shell; char shell_opt[] = "-i"; char *shell_arg = NULL; #if ENABLE_GETOPT_LONG static const char getopt_longopts[] ALIGN1 = "append\0" No_argument "a" "command\0" Required_argument "c" "flush\0" No_argument "f" "quiet\0" No_argument "q" ; applet_long_options = getopt_longopts; #endif opt_complementary = "?1"; /* max one arg */ opt = getopt32(argv, "ac:fq", &shell_arg); //argc -= optind; argv += optind; if (argv[0]) { fname = argv[0]; } mode = O_CREAT|O_TRUNC|O_WRONLY; if (opt & 1) { mode = O_CREAT|O_APPEND|O_WRONLY; } if (opt & 2) { shell_opt[1] = 'c'; } if (!(opt & 8)) { /* not -q */ printf("Script started, file is %s\n", fname); } shell = getenv("SHELL"); if (shell == NULL) { shell = DEFAULT_SHELL; } pty = getpty(pty_line); if (pty < 0) { bb_perror_msg_and_die("can't get pty"); } /* get current stdin's tty params */ attr_ok = tcgetattr(0, &tt); winsz_ok = ioctl(0, TIOCGWINSZ, (char *)&win); rtt = tt; cfmakeraw(&rtt); rtt.c_lflag &= ~ECHO; tcsetattr(0, TCSAFLUSH, &rtt); /* "script" from util-linux exits when child exits, * we wouldn't wait for EOF from slave pty * (output may be produced by grandchildren of child) */ signal(SIGCHLD, handle_sigchld); /* TODO: SIGWINCH? pass window size changes down to slave? */ child_pid = vfork(); if (child_pid < 0) { bb_perror_msg_and_die("vfork"); } if (child_pid) { /* parent */ #define buf bb_common_bufsiz1 struct pollfd pfd[2]; struct pollfd *ppfd = pfd; int outfd, count, loop; outfd = xopen(fname, mode); pfd[0].fd = 0; pfd[0].events = POLLIN; pfd[1].fd = pty; pfd[1].events = POLLIN; ndelay_on(pty); /* this descriptor is not shared, can do this */ /* ndelay_on(0); - NO, stdin can be shared! Pity :( */ /* copy stdin to pty master input, * copy pty master output to stdout and file */ /* TODO: don't use full_write's, use proper write buffering */ while (fd_count) { /* not safe_poll! we want SIGCHLD to EINTR poll */ poll(ppfd, fd_count, -1); if (pfd[0].revents) { count = safe_read(0, buf, sizeof(buf)); if (count <= 0) { /* err/eof: don't read anymore */ pfd[0].revents = 0; ppfd++; fd_count--; } else { full_write(pty, buf, count); } } if (pfd[1].revents) { errno = 0; count = safe_read(pty, buf, sizeof(buf)); if (count <= 0 && errno != EAGAIN) { /* err/eof: don't read anymore */ pfd[1].revents = 0; fd_count--; } if (count > 0) { full_write(1, buf, count); full_write(outfd, buf, count); if (opt & 4) { /* -f */ fsync(outfd); } } } } /* If loop was exited because SIGCHLD handler set fd_count to 0, * there still can be some buffered output. But not loop forever: * we won't pump orphaned grandchildren's output indefinitely. * Testcase: running this in script: * exec dd if=/dev/zero bs=1M count=1 * must have "1+0 records in, 1+0 records out" captured too. * (util-linux's script doesn't do this. buggy :) */ loop = 999; /* pty is in O_NONBLOCK mode, we exit as soon as buffer is empty */ while (--loop && (count = safe_read(pty, buf, sizeof(buf))) > 0) { full_write(1, buf, count); full_write(outfd, buf, count); } if (attr_ok == 0) tcsetattr(0, TCSAFLUSH, &tt); if (!(opt & 8)) /* not -q */ printf("Script done, file is %s\n", fname); return EXIT_SUCCESS; } /* child: make pty slave to be input, output, error; run shell */ close(pty); /* close pty master */ /* open pty slave to fd 0,1,2 */ close(0); xopen(pty_line, O_RDWR); /* uses fd 0 */ xdup2(0, 1); xdup2(0, 2); /* copy our original stdin tty's parameters to pty */ if (attr_ok == 0) tcsetattr(0, TCSAFLUSH, &tt); if (winsz_ok == 0) ioctl(0, TIOCSWINSZ, (char *)&win); /* set pty as a controlling tty */ setsid(); ioctl(0, TIOCSCTTY, 0 /* 0: don't forcibly steal */); /* signal(SIGCHLD, SIG_DFL); - exec does this for us */ execl(shell, shell, shell_opt, shell_arg, NULL); bb_simple_perror_msg_and_die(shell); }
int dd_main(int argc UNUSED_PARAM, char **argv) { enum { /* Must be in the same order as OP_conv_XXX! */ /* (see "flags |= (1 << what)" below) */ FLAG_NOTRUNC = 1 << 0, FLAG_SYNC = 1 << 1, FLAG_NOERROR = 1 << 2, FLAG_FSYNC = 1 << 3, /* end of conv flags */ FLAG_TWOBUFS = 1 << 4, FLAG_COUNT = 1 << 5, }; static const char keywords[] ALIGN1 = "bs\0""count\0""seek\0""skip\0""if\0""of\0" #if ENABLE_FEATURE_DD_IBS_OBS "ibs\0""obs\0""conv\0" #endif ; #if ENABLE_FEATURE_DD_IBS_OBS static const char conv_words[] ALIGN1 = "notrunc\0""sync\0""noerror\0""fsync\0"; #endif enum { OP_bs = 0, OP_count, OP_seek, OP_skip, OP_if, OP_of, #if ENABLE_FEATURE_DD_IBS_OBS OP_ibs, OP_obs, OP_conv, /* Must be in the same order as FLAG_XXX! */ OP_conv_notrunc = 0, OP_conv_sync, OP_conv_noerror, OP_conv_fsync, /* Unimplemented conv=XXX: */ //nocreat do not create the output file //excl fail if the output file already exists //fdatasync physically write output file data before finishing //swab swap every pair of input bytes //lcase change upper case to lower case //ucase change lower case to upper case //block pad newline-terminated records with spaces to cbs-size //unblock replace trailing spaces in cbs-size records with newline //ascii from EBCDIC to ASCII //ebcdic from ASCII to EBCDIC //ibm from ASCII to alternate EBCDIC #endif }; int exitcode = EXIT_FAILURE; size_t ibs = 512, obs = 512; ssize_t n, w; char *ibuf, *obuf; /* And these are all zeroed at once! */ struct { int flags; size_t oc; off_t count; off_t seek, skip; const char *infile, *outfile; } Z; #define flags (Z.flags ) #define oc (Z.oc ) #define count (Z.count ) #define seek (Z.seek ) #define skip (Z.skip ) #define infile (Z.infile ) #define outfile (Z.outfile) memset(&Z, 0, sizeof(Z)); INIT_G(); //fflush(NULL); - is this needed because of NOEXEC? #if ENABLE_FEATURE_DD_SIGNAL_HANDLING signal_SA_RESTART_empty_mask(SIGUSR1, dd_output_status); #endif for (n = 1; argv[n]; n++) { int what; char *val; char *arg = argv[n]; #if ENABLE_DESKTOP /* "dd --". NB: coreutils 6.9 will complain if they see * more than one of them. We wouldn't. */ if (arg[0] == '-' && arg[1] == '-' && arg[2] == '\0') continue; #endif val = strchr(arg, '='); if (val == NULL) bb_show_usage(); *val = '\0'; what = index_in_strings(keywords, arg); if (what < 0) bb_show_usage(); /* *val = '='; - to preserve ps listing? */ val++; #if ENABLE_FEATURE_DD_IBS_OBS if (what == OP_ibs) { /* Must fit into positive ssize_t */ ibs = xatoul_range_sfx(val, 1, ((size_t)-1L)/2, dd_suffixes); /*continue;*/ } if (what == OP_obs) { obs = xatoul_range_sfx(val, 1, ((size_t)-1L)/2, dd_suffixes); /*continue;*/ } if (what == OP_conv) { while (1) { /* find ',', replace them with NUL so we can use val for * index_in_strings() without copying. * We rely on val being non-null, else strchr would fault. */ arg = strchr(val, ','); if (arg) *arg = '\0'; what = index_in_strings(conv_words, val); if (what < 0) bb_error_msg_and_die(bb_msg_invalid_arg, val, "conv"); flags |= (1 << what); if (!arg) /* no ',' left, so this was the last specifier */ break; /* *arg = ','; - to preserve ps listing? */ val = arg + 1; /* skip this keyword and ',' */ } continue; /* we trashed 'what', can't fall through */ } #endif if (what == OP_bs) { ibs = obs = xatoul_range_sfx(val, 1, ((size_t)-1L)/2, dd_suffixes); /*continue;*/ } /* These can be large: */ if (what == OP_count) { flags |= FLAG_COUNT; count = XATOU_SFX(val, dd_suffixes); /*continue;*/ } if (what == OP_seek) { seek = XATOU_SFX(val, dd_suffixes); /*continue;*/ } if (what == OP_skip) { skip = XATOU_SFX(val, dd_suffixes); /*continue;*/ } if (what == OP_if) { infile = val; /*continue;*/ } if (what == OP_of) { outfile = val; /*continue;*/ } } /* end of "for (argv[n])" */ //XXX:FIXME for huge ibs or obs, malloc'ing them isn't the brightest idea ever ibuf = obuf = xmalloc(ibs); if (ibs != obs) { flags |= FLAG_TWOBUFS; obuf = xmalloc(obs); } if (infile != NULL) xmove_fd(xopen(infile, O_RDONLY), ifd); else { infile = bb_msg_standard_input; } if (outfile != NULL) { int oflag = O_WRONLY | O_CREAT; if (!seek && !(flags & FLAG_NOTRUNC)) oflag |= O_TRUNC; xmove_fd(xopen(outfile, oflag), ofd); if (seek && !(flags & FLAG_NOTRUNC)) { if (ftruncate(ofd, seek * obs) < 0) { struct stat st; if (fstat(ofd, &st) < 0 || S_ISREG(st.st_mode) || S_ISDIR(st.st_mode)) goto die_outfile; } } } else { outfile = bb_msg_standard_output; } if (skip) { if (lseek(ifd, skip * ibs, SEEK_CUR) < 0) { while (skip-- > 0) { n = safe_read(ifd, ibuf, ibs); if (n < 0) goto die_infile; if (n == 0) break; } } } if (seek) { if (lseek(ofd, seek * obs, SEEK_CUR) < 0) goto die_outfile; } while (!(flags & FLAG_COUNT) || (G.in_full + G.in_part != count)) { if (flags & FLAG_NOERROR) /* Pre-zero the buffer if conv=noerror */ memset(ibuf, 0, ibs); n = safe_read(ifd, ibuf, ibs); if (n == 0) break; if (n < 0) { if (!(flags & FLAG_NOERROR)) goto die_infile; n = ibs; bb_simple_perror_msg(infile); } if ((size_t)n == ibs) G.in_full++; else { G.in_part++; if (flags & FLAG_SYNC) { memset(ibuf + n, '\0', ibs - n); n = ibs; } } if (flags & FLAG_TWOBUFS) { char *tmp = ibuf; while (n) { size_t d = obs - oc; if (d > (size_t)n) d = n; memcpy(obuf + oc, tmp, d); n -= d; tmp += d; oc += d; if (oc == obs) { if (write_and_stats(obuf, obs, obs, outfile)) goto out_status; oc = 0; } } } else if (write_and_stats(ibuf, n, obs, outfile)) goto out_status; if (flags & FLAG_FSYNC) { if (fsync(ofd) < 0) goto die_outfile; } } if (ENABLE_FEATURE_DD_IBS_OBS && oc) { w = full_write_or_warn(obuf, oc, outfile); if (w < 0) goto out_status; if (w > 0) G.out_part++; } if (close(ifd) < 0) { die_infile: bb_simple_perror_msg_and_die(infile); } if (close(ofd) < 0) { die_outfile: bb_simple_perror_msg_and_die(outfile); } exitcode = EXIT_SUCCESS; out_status: dd_output_status(0); return exitcode; }
int script_main(int argc UNUSED_PARAM, char **argv) { int opt; int mode; int child_pid; int attr_ok; /* NB: 0: ok */ int winsz_ok; int pty; char pty_line[GETPTY_BUFSIZE]; struct termios tt, rtt; struct winsize win; const char *fname = "typescript"; const char *shell; char shell_opt[] = "-i"; char *shell_arg = NULL; enum { OPT_a = (1 << 0), OPT_c = (1 << 1), OPT_f = (1 << 2), OPT_q = (1 << 3), OPT_t = (1 << 4), }; #if ENABLE_LONG_OPTS static const char getopt_longopts[] ALIGN1 = "append\0" No_argument "a" "command\0" Required_argument "c" "flush\0" No_argument "f" "quiet\0" No_argument "q" IF_SCRIPTREPLAY("timing\0" No_argument "t") ; applet_long_options = getopt_longopts; #endif opt_complementary = "?1"; /* max one arg */ opt = getopt32(argv, "ac:fq" IF_SCRIPTREPLAY("t") , &shell_arg); //argc -= optind; argv += optind; if (argv[0]) { fname = argv[0]; } mode = O_CREAT|O_TRUNC|O_WRONLY; if (opt & OPT_a) { mode = O_CREAT|O_APPEND|O_WRONLY; } if (opt & OPT_c) { shell_opt[1] = 'c'; } if (!(opt & OPT_q)) { printf("Script started, file is %s\n", fname); } shell = get_shell_name(); /* Some people run "script ... 0>&-". * Our code assumes that STDIN_FILENO != pty. * Ensure STDIN_FILENO is not closed: */ bb_sanitize_stdio(); pty = xgetpty(pty_line); /* get current stdin's tty params */ attr_ok = tcgetattr(0, &tt); winsz_ok = ioctl(0, TIOCGWINSZ, (char *)&win); rtt = tt; cfmakeraw(&rtt); rtt.c_lflag &= ~ECHO; tcsetattr(0, TCSAFLUSH, &rtt); /* "script" from util-linux exits when child exits, * we wouldn't wait for EOF from slave pty * (output may be produced by grandchildren of child) */ signal(SIGCHLD, record_signo); /* TODO: SIGWINCH? pass window size changes down to slave? */ child_pid = xvfork(); if (child_pid) { /* parent */ #define buf bb_common_bufsiz1 struct pollfd pfd[2]; int outfd, count, loop; double oldtime = ENABLE_SCRIPTREPLAY ? time(NULL) : 0; smallint fd_count = 2; outfd = xopen(fname, mode); pfd[0].fd = pty; pfd[0].events = POLLIN; pfd[1].fd = STDIN_FILENO; pfd[1].events = POLLIN; ndelay_on(pty); /* this descriptor is not shared, can do this */ /* ndelay_on(STDIN_FILENO); - NO, stdin can be shared! Pity :( */ /* copy stdin to pty master input, * copy pty master output to stdout and file */ /* TODO: don't use full_write's, use proper write buffering */ while (fd_count && !bb_got_signal) { /* not safe_poll! we want SIGCHLD to EINTR poll */ if (poll(pfd, fd_count, -1) < 0 && errno != EINTR) { /* If child exits too quickly, we may get EIO: * for example, try "script -c true" */ break; } if (pfd[0].revents) { errno = 0; count = safe_read(pty, buf, sizeof(buf)); if (count <= 0 && errno != EAGAIN) { /* err/eof from pty: exit */ goto restore; } if (count > 0) { if (ENABLE_SCRIPTREPLAY && (opt & OPT_t)) { struct timeval tv; double newtime; gettimeofday(&tv, NULL); newtime = tv.tv_sec + (double) tv.tv_usec / 1000000; fprintf(stderr, "%f %u\n", newtime - oldtime, count); oldtime = newtime; } full_write(STDOUT_FILENO, buf, count); full_write(outfd, buf, count); if (opt & OPT_f) { fsync(outfd); } } } if (pfd[1].revents) { count = safe_read(STDIN_FILENO, buf, sizeof(buf)); if (count <= 0) { /* err/eof from stdin: don't read stdin anymore */ pfd[1].revents = 0; fd_count--; } else { full_write(pty, buf, count); } } } /* If loop was exited because SIGCHLD handler set bb_got_signal, * there still can be some buffered output. But dont loop forever: * we won't pump orphaned grandchildren's output indefinitely. * Testcase: running this in script: * exec dd if=/dev/zero bs=1M count=1 * must have "1+0 records in, 1+0 records out" captured too. * (util-linux's script doesn't do this. buggy :) */ loop = 999; /* pty is in O_NONBLOCK mode, we exit as soon as buffer is empty */ while (--loop && (count = safe_read(pty, buf, sizeof(buf))) > 0) { full_write(STDOUT_FILENO, buf, count); full_write(outfd, buf, count); } restore: if (attr_ok == 0) tcsetattr(0, TCSAFLUSH, &tt); if (!(opt & OPT_q)) printf("Script done, file is %s\n", fname); return EXIT_SUCCESS; } /* child: make pty slave to be input, output, error; run shell */ close(pty); /* close pty master */ /* open pty slave to fd 0,1,2 */ close(0); xopen(pty_line, O_RDWR); /* uses fd 0 */ xdup2(0, 1); xdup2(0, 2); /* copy our original stdin tty's parameters to pty */ if (attr_ok == 0) tcsetattr(0, TCSAFLUSH, &tt); if (winsz_ok == 0) ioctl(0, TIOCSWINSZ, (char *)&win); /* set pty as a controlling tty */ setsid(); ioctl(0, TIOCSCTTY, 0 /* 0: don't forcibly steal */); /* Non-ignored signals revert to SIG_DFL on exec anyway */ /*signal(SIGCHLD, SIG_DFL);*/ execl(shell, shell, shell_opt, shell_arg, (char *) NULL); bb_simple_perror_msg_and_die(shell); }
int setfont_main(int argc UNUSED_PARAM, char **argv) { size_t len; unsigned opts; int fd; unsigned char *buffer; char *mapfilename; const char *tty_name = CURRENT_TTY; opt_complementary = "=1"; opts = getopt32(argv, "m:C:", &mapfilename, &tty_name); argv += optind; fd = xopen_nonblocking(tty_name); if (sizeof(CONFIG_DEFAULT_SETFONT_DIR) > 1) { // if not "" if (*argv[0] != '/') { // goto default fonts location. don't die if doesn't exist chdir(CONFIG_DEFAULT_SETFONT_DIR "/consolefonts"); } } // load font len = 32*1024; // can't be larger buffer = xmalloc_open_zipped_read_close(*argv, &len); if (!buffer) bb_simple_perror_msg_and_die(*argv); do_load(fd, buffer, len); // load the screen map, if any if (opts & 1) { // -m unsigned mode = PIO_SCRNMAP; void *map; if (sizeof(CONFIG_DEFAULT_SETFONT_DIR) > 1) { // if not "" if (mapfilename[0] != '/') { // goto default keymaps location chdir(CONFIG_DEFAULT_SETFONT_DIR "/consoletrans"); } } // fetch keymap map = xmalloc_open_zipped_read_close(mapfilename, &len); if (!map) bb_simple_perror_msg_and_die(mapfilename); // file size is 256 or 512 bytes? -> assume binary map if (len == E_TABSZ || len == 2*E_TABSZ) { if (len == 2*E_TABSZ) mode = PIO_UNISCRNMAP; } #if ENABLE_FEATURE_SETFONT_TEXTUAL_MAP // assume textual Unicode console maps: // 0x00 U+0000 # NULL (NUL) // 0x01 U+0001 # START OF HEADING (SOH) // 0x02 U+0002 # START OF TEXT (STX) // 0x03 U+0003 # END OF TEXT (ETX) else { int i; char *token[2]; parser_t *parser; if (ENABLE_FEATURE_CLEAN_UP) free(map); map = xmalloc(E_TABSZ * sizeof(unsigned short)); #define unicodes ((unsigned short *)map) // fill vanilla map for (i = 0; i < E_TABSZ; i++) unicodes[i] = 0xf000 + i; parser = config_open(mapfilename); while (config_read(parser, token, 2, 2, "# \t", PARSE_NORMAL | PARSE_MIN_DIE)) { // parse code/value pair int a = ctoi(token[0]); int b = ctoi(token[1]); if (a < 0 || a >= E_TABSZ || b < 0 || b > 65535 ) { bb_error_msg_and_die("map format"); } // patch map unicodes[a] = b; // unicode character is met? if (b > 255) mode = PIO_UNISCRNMAP; } if (ENABLE_FEATURE_CLEAN_UP) config_close(parser); if (mode != PIO_UNISCRNMAP) { #define asciis ((unsigned char *)map) for (i = 0; i < E_TABSZ; i++) asciis[i] = unicodes[i]; #undef asciis } #undef unicodes } #endif // ENABLE_FEATURE_SETFONT_TEXTUAL_MAP // do set screen map xioctl(fd, mode, map); if (ENABLE_FEATURE_CLEAN_UP) free(map); } return EXIT_SUCCESS; }
int chrt_main(int argc, char **argv) { pid_t pid = 0; unsigned opt; struct sched_param sp; char *p_opt = NULL, *priority = NULL; const char *state = "current\0new"; int prio = 0, policy = SCHED_RR; opt_complementary = "r--fo:f--ro:r--fo"; /* only one policy accepted */ opt = getopt32(argv, "+mp:rfo", &p_opt); if (opt & OPT_r) policy = SCHED_RR; if (opt & OPT_f) policy = SCHED_FIFO; if (opt & OPT_o) policy = SCHED_OTHER; if (opt & OPT_m) { /* print min/max */ show_min_max(SCHED_FIFO); show_min_max(SCHED_RR); show_min_max(SCHED_OTHER); fflush_stdout_and_exit(EXIT_SUCCESS); } if (opt & OPT_p) { if (argc == optind+1) { /* -p <priority> <pid> */ priority = p_opt; p_opt = argv[optind]; } argv += optind; /* me -p <arg> */ pid = xatoul_range(p_opt, 1, ULONG_MAX); /* -p <pid> */ } else { argv += optind; /* me -p <arg> */ priority = *argv; } if (priority) { /* from the manpage of sched_getscheduler: [...] sched_priority can have a value in the range 0 to 99. [...] SCHED_OTHER or SCHED_BATCH must be assigned the static priority 0. [...] SCHED_FIFO or SCHED_RR can have a static priority in the range 1 to 99. */ prio = xstrtol_range(priority, 0, policy == SCHED_OTHER ? 0 : 1, 99); } if (opt & OPT_p) { int pol = 0; print_rt_info: pol = sched_getscheduler(pid); if (pol < 0) bb_perror_msg_and_die("failed to %cet pid %d's policy", 'g', pid); printf("pid %d's %s scheduling policy: %s\n", pid, state, policies[pol].name); if (sched_getparam(pid, &sp)) bb_perror_msg_and_die("failed to get pid %d's attributes", pid); printf("pid %d's %s scheduling priority: %d\n", pid, state, sp.sched_priority); if (!*argv) /* no new prio given or we did print already, done. */ return EXIT_SUCCESS; } sp.sched_priority = prio; if (sched_setscheduler(pid, policy, &sp) < 0) bb_perror_msg_and_die("failed to %cet pid %d's policy", 's', pid); if (opt & OPT_p) { state += 8; ++argv; goto print_rt_info; } ++argv; BB_EXECVP(*argv, argv); bb_simple_perror_msg_and_die(*argv); }
int losetup_main(int argc, char **argv) { char dev[] = LOOP_NAME"0"; unsigned opt; char *opt_o; char *s; unsigned long long offset = 0; /* max 2 args, all opts are mutually exclusive */ opt_complementary = "?2:d--of:o--df:f-do"; opt = getopt32(argv, "do:f", &opt_o); argc -= optind; argv += optind; if (opt == 0x2) // -o offset = xatoull(opt_o); if (opt == 0x4 && argc) // -f does not take any argument bb_show_usage(); if (opt == 0x1) { // -d /* detach takes exactly one argument */ if (argc != 1) bb_show_usage(); if (del_loop(argv[0])) bb_simple_perror_msg_and_die(argv[0]); return EXIT_SUCCESS; } if (argc == 2) { /* -o or no option */ if (set_loop(&argv[0], argv[1], offset) < 0) bb_simple_perror_msg_and_die(argv[0]); return EXIT_SUCCESS; } if (argc == 1) { /* -o or no option */ s = query_loop(argv[0]); if (!s) bb_simple_perror_msg_and_die(argv[0]); printf("%s: %s\n", argv[0], s); if (ENABLE_FEATURE_CLEAN_UP) free(s); return EXIT_SUCCESS; } /* -o, -f or no option */ while (1) { s = query_loop(dev); if (!s) { if (opt == 0x4) { puts(dev); return EXIT_SUCCESS; } } else { if (opt != 0x4) printf("%s: %s\n", dev, s); if (ENABLE_FEATURE_CLEAN_UP) free(s); } if (++dev[sizeof(dev) - 2] > '9') break; } return EXIT_SUCCESS; }
int split_main(int argc UNUSED_PARAM, char **argv) { unsigned suffix_len = 2; char *pfx; char *count_p; const char *sfx; off_t cnt = 1000; off_t remaining = 0; unsigned opt; ssize_t bytes_read, to_write; char *src; opt_complementary = "?2:a+"; /* max 2 args; -a N */ opt = getopt32(argv, "l:b:a:", &count_p, &count_p, &suffix_len); if (opt & SPLIT_OPT_l) cnt = XATOOFF(count_p); if (opt & SPLIT_OPT_b) // FIXME: also needs XATOOFF cnt = xatoull_sfx(count_p, IF_FEATURE_SPLIT_FANCY(split_suffixes) IF_NOT_FEATURE_SPLIT_FANCY(km_suffixes) ); sfx = "x"; argv += optind; if (argv[0]) { int fd; if (argv[1]) sfx = argv[1]; fd = xopen_stdin(argv[0]); xmove_fd(fd, STDIN_FILENO); } else { argv[0] = (char *) bb_msg_standard_input; } if (NAME_MAX < strlen(sfx) + suffix_len) bb_error_msg_and_die("suffix too long"); { char *char_p = xzalloc(suffix_len + 1); memset(char_p, 'a', suffix_len); pfx = xasprintf("%s%s", sfx, char_p); if (ENABLE_FEATURE_CLEAN_UP) free(char_p); } while (1) { bytes_read = safe_read(STDIN_FILENO, read_buffer, READ_BUFFER_SIZE); if (!bytes_read) break; if (bytes_read < 0) bb_simple_perror_msg_and_die(argv[0]); src = read_buffer; do { if (!remaining) { if (!pfx) bb_error_msg_and_die("suffixes exhausted"); xmove_fd(xopen(pfx, O_WRONLY | O_CREAT | O_TRUNC), 1); pfx = next_file(pfx, suffix_len); remaining = cnt; } if (opt & SPLIT_OPT_b) { /* split by bytes */ to_write = (bytes_read < remaining) ? bytes_read : remaining; remaining -= to_write; } else { /* split by lines */ /* can be sped up by using _memrchr_ * and writing many lines at once... */ char *end = memchr(src, '\n', bytes_read); if (end) { --remaining; to_write = end - src + 1; } else { to_write = bytes_read; } } xwrite(STDOUT_FILENO, src, to_write); bytes_read -= to_write; src += to_write; } while (bytes_read); } return EXIT_SUCCESS; }
int acpid_main(int argc UNUSED_PARAM, char **argv) { int nfd; int opts; struct pollfd *pfd; const char *opt_dir = "/etc/acpi"; const char *opt_input = "/dev/input/event"; const char *opt_logfile = "/var/log/acpid.log"; const char *opt_action = "/etc/acpid.conf"; const char *opt_map = "/etc/acpi.map"; #if ENABLE_FEATURE_PIDFILE const char *opt_pidfile = "/var/run/acpid.pid"; #endif INIT_G(); opt_complementary = "df:e--e"; opts = getopt32(argv, "c:de:fl:a:M:" IF_FEATURE_PIDFILE("p:") IF_FEATURE_ACPID_COMPAT("g:m:s:S:v"), &opt_dir, &opt_input, &opt_logfile, &opt_action, &opt_map IF_FEATURE_PIDFILE(, &opt_pidfile) IF_FEATURE_ACPID_COMPAT(, NULL, NULL, NULL, NULL) ); if (!(opts & OPT_f)) { /* No -f "Foreground", we go to background */ bb_daemonize_or_rexec(DAEMON_CLOSE_EXTRA_FDS, argv); } if (!(opts & OPT_d)) { /* No -d "Debug", we log to log file. * This includes any output from children. */ xmove_fd(xopen(opt_logfile, O_WRONLY | O_CREAT | O_TRUNC), STDOUT_FILENO); xdup2(STDOUT_FILENO, STDERR_FILENO); /* Also, acpid's messages (but not children) will go to syslog too */ openlog(applet_name, LOG_PID, LOG_DAEMON); logmode = LOGMODE_SYSLOG | LOGMODE_STDIO; } /* else: -d "Debug", log is not redirected */ parse_conf_file(opt_action); parse_map_file(opt_map); xchdir(opt_dir); bb_signals((1 << SIGCHLD), SIG_IGN); bb_signals(BB_FATAL_SIGS, record_signo); pfd = NULL; nfd = 0; while (1) { int fd; char *dev_event; dev_event = xasprintf((opts & OPT_e) ? "%s" : "%s%u", opt_input, nfd); fd = open(dev_event, O_RDONLY | O_NONBLOCK); if (fd < 0) { if (nfd == 0) bb_simple_perror_msg_and_die(dev_event); break; } free(dev_event); pfd = xrealloc_vector(pfd, 1, nfd); pfd[nfd].fd = fd; pfd[nfd].events = POLLIN; nfd++; } write_pidfile(opt_pidfile); while (safe_poll(pfd, nfd, -1) > 0) { int i; for (i = 0; i < nfd; i++) { const char *event; if (!(pfd[i].revents & POLLIN)) { if (pfd[i].revents == 0) continue; /* this fd has nothing */ /* Likely POLLERR, POLLHUP, POLLNVAL. * Do not listen on this fd anymore. */ close(pfd[i].fd); nfd--; for (; i < nfd; i++) pfd[i].fd = pfd[i + 1].fd; break; /* do poll() again */ } event = NULL; if (option_mask32 & OPT_e) { char *buf; int len; buf = xmalloc_reads(pfd[i].fd, NULL); /* buf = "button/power PWRB 00000080 00000000" */ len = strlen(buf) - 9; if (len >= 0) buf[len] = '\0'; event = find_action(NULL, buf); free(buf); } else { struct input_event ev; if (sizeof(ev) != full_read(pfd[i].fd, &ev, sizeof(ev))) continue; if (ev.value != 1 && ev.value != 0) continue; event = find_action(&ev, NULL); } if (!event) continue; // spawn event handler process_event(event); } } if (ENABLE_FEATURE_CLEAN_UP) { while (nfd--) close(pfd[nfd].fd); free(pfd); } remove_pidfile(opt_pidfile); return EXIT_SUCCESS; }