/* * 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' }, #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); 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 '?': default: usage(stderr); } } 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 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) { struct wipe_desc *wp0 = NULL, *wp; int c, all = 0, has_offset = 0, noact = 0, quiet = 0; int mode = WP_MODE_PRETTY; static const struct option longopts[] = { { "all", 0, 0, 'a' }, { "help", 0, 0, 'h' }, { "no-act", 0, 0, 'n' }, { "offset", 1, 0, 'o' }, { "parsable", 0, 0, 'p' }, { "quiet", 0, 0, 'q' }, { "types", 1, 0, 't' }, { "version", 0, 0, 'V' }, { NULL, 0, 0, 0 } }; static const ul_excl_t excl[] = { /* rows and cols in 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, "ahno:pqt:V", longopts, NULL)) != -1) { err_exclusive_options(c, longopts, excl, excl_st); switch(c) { case 'a': all++; break; case 'h': usage(stdout); break; case 'n': 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': quiet++; break; case 't': type_pattern = optarg; break; case 'V': printf(_("%s from %s\n"), program_invocation_short_name, PACKAGE_STRING); return EXIT_SUCCESS; default: usage(stderr); break; } } if (optind == argc) usage(stderr); if (!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++], noact, all, quiet); free_wipe(wp); } } 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; }
int main(int argc, char **argv) { struct loopdev_cxt lc; int act = 0, flags = 0, passfd = -1, c; char *file = NULL, *encryption = NULL; uint64_t offset = 0, sizelimit = 0; int res = 0, showdev = 0, lo_flags = 0; enum { OPT_SIZELIMIT = CHAR_MAX + 1, OPT_SHOW }; static const struct option longopts[] = { { "all", 0, 0, 'a' }, { "set-capacity", 1, 0, 'c' }, { "detach", 1, 0, 'd' }, { "detach-all", 0, 0, 'D' }, { "encryption", 1, 0, 'e' }, { "find", 0, 0, 'f' }, { "help", 0, 0, 'h' }, { "associated", 1, 0, 'j' }, { "offset", 1, 0, 'o' }, { "sizelimit", 1, 0, OPT_SIZELIMIT }, { "pass-fd", 1, 0, 'p' }, { "partscan", 0, 0, 'P' }, { "read-only", 0, 0, 'r' }, { "show", 0, 0, OPT_SHOW }, { "verbose", 0, 0, 'v' }, { "version", 0, 0, 'V' }, { NULL, 0, 0, 0 } }; setlocale(LC_ALL, ""); bindtextdomain(PACKAGE, LOCALEDIR); textdomain(PACKAGE); atexit(close_stdout); loopcxt_init(&lc, 0); loopcxt_enable_debug(&lc, getenv("LOOPDEV_DEBUG") ? TRUE : FALSE); while ((c = getopt_long(argc, argv, "ac:d:De:E:fhj:o:p:PrvV", longopts, NULL)) != -1) { if (act && strchr("acdDfj", c)) errx(EXIT_FAILURE, _("the options %s are mutually exclusive"), "--{all,associated,set-capacity,detach,detach-all,find}"); switch (c) { case 'a': act = A_SHOW; break; case 'c': act = A_SET_CAPACITY; loopcxt_set_device(&lc, optarg); break; case 'r': lo_flags |= LO_FLAGS_READ_ONLY; break; case 'd': act = A_DELETE; loopcxt_set_device(&lc, optarg); break; case 'D': act = A_DELETE_ALL; break; case 'E': case 'e': encryption = optarg; break; case 'f': act = A_FIND_FREE; break; case 'h': usage(stdout); break; case 'j': act = A_SHOW; file = optarg; break; case 'o': offset = strtosize_or_err(optarg, _("failed to parse offset")); flags |= LOOPDEV_FL_OFFSET; break; case 'p': passfd = strtou32_or_err(optarg, _("invalid passphrase file descriptor")); break; case 'P': lo_flags |= LO_FLAGS_PARTSCAN; break; case OPT_SHOW: showdev = 1; break; case 'v': verbose = 1; break; case 'V': printf(UTIL_LINUX_VERSION); return EXIT_SUCCESS; case OPT_SIZELIMIT: /* --sizelimit */ sizelimit = strtosize_or_err(optarg, _("failed to parse size")); flags |= LOOPDEV_FL_SIZELIMIT; break; default: usage(stderr); } } if (argc == 1) usage(stderr); if (act == A_FIND_FREE && optind < argc) { /* * losetup -f <backing_file> */ act = A_CREATE; file = argv[optind++]; } if (!act && optind + 1 == argc) { /* * losetup <device> */ act = A_SHOW_ONE; loopcxt_set_device(&lc, argv[optind++]); } if (!act) { /* * losetup <loopdev> <backing_file> */ act = A_CREATE; if (optind >= argc) errx(EXIT_FAILURE, _("no loop device specified")); loopcxt_set_device(&lc, argv[optind++]); if (optind >= argc) errx(EXIT_FAILURE, _("no file specified")); file = argv[optind++]; } if (act != A_CREATE && (encryption || sizelimit || passfd != -1 || lo_flags || showdev)) errx(EXIT_FAILURE, _("the options %s are allowed to loop device setup only"), "--{encryption,sizelimit,pass-fd,read-only,show}"); if ((flags & LOOPDEV_FL_OFFSET) && act != A_CREATE && (act != A_SHOW || !file)) errx(EXIT_FAILURE, _("the option --offset is not allowed in this context.")); switch (act) { case A_CREATE: { char *pass = NULL; int hasdev = loopcxt_has_device(&lc); if (encryption) { #ifdef MCL_FUTURE if(mlockall(MCL_CURRENT | MCL_FUTURE)) err(EXIT_FAILURE, _("couldn't lock into memory")); #endif pass = xgetpass(passfd, _("Password: "******"not found unused device")); break; } if (encryption && pass) loopcxt_set_encryption(&lc, encryption, pass); if (flags & LOOPDEV_FL_OFFSET) loopcxt_set_offset(&lc, offset); if (flags & LOOPDEV_FL_SIZELIMIT) loopcxt_set_sizelimit(&lc, sizelimit); if (lo_flags) loopcxt_set_flags(&lc, lo_flags); if ((res = loopcxt_set_backing_file(&lc, file))) { warn(_("%s: failed to use backing file"), file); break; } errno = 0; res = loopcxt_setup_device(&lc); if (res == 0) break; /* success */ if (errno != EBUSY) { warn(_("%s: failed to setup loop device"), hasdev && loopcxt_get_fd(&lc) < 0 ? loopcxt_get_device(&lc) : file); break; } } while (hasdev == 0); free(pass); if (showdev && res == 0) printf("%s\n", loopcxt_get_device(&lc)); break; } case A_DELETE: res = delete_loop(&lc); while (optind < argc) { loopcxt_set_device(&lc, argv[optind++]); res += delete_loop(&lc); } break; case A_DELETE_ALL: res = delete_all_loops(&lc); break; case A_FIND_FREE: if (loopcxt_find_unused(&lc)) warn(_("find unused loop device failed")); else printf("%s\n", loopcxt_get_device(&lc)); break; case A_SHOW: res = show_all_loops(&lc, file, offset, flags); break; case A_SHOW_ONE: res = printf_loopdev(&lc); if (res) warn(_("%s"), loopcxt_get_device(&lc)); break; case A_SET_CAPACITY: res = set_capacity(&lc); break; default: usage(stderr); break; } loopcxt_deinit(&lc); return res ? EXIT_FAILURE : EXIT_SUCCESS; }
int main(int argc, char **argv) { blkid_cache cache = NULL; char **devices = NULL; char *show[128] = { NULL, }; char *search_type = NULL, *search_value = NULL; char *read = NULL; int fltr_usage = 0; char **fltr_type = NULL; int fltr_flag = BLKID_FLTR_ONLYIN; unsigned int numdev = 0, numtag = 0; int version = 0; int err = BLKID_EXIT_OTHER; unsigned int i; int output_format = 0; int lookup = 0, gc = 0, lowprobe = 0, eval = 0; int c; uintmax_t offset = 0, size = 0; enum { EXCL_NONE, EXCL_NAMES, EXCL_USAGE }; int excl_opt = EXCL_NONE; show[0] = NULL; atexit(close_stdout); while ((c = getopt (argc, argv, "c:df:ghilL:n:ko:O:ps:S:t:u:U:w:v")) != EOF) switch (c) { case 'c': if (optarg && !*optarg) read = NULL; else read = optarg; break; case 'd': raw_chars = 1; break; case 'L': eval++; search_value = strdup(optarg); search_type = strdup("LABEL"); break; case 'n': exclusive_option(&excl_opt, EXCL_NAMES, "-{u,n}"); fltr_type = list_to_types(optarg, &fltr_flag); break; case 'u': exclusive_option(&excl_opt, EXCL_USAGE, "-{u,n}"); fltr_usage = list_to_usage(optarg, &fltr_flag); break; case 'U': eval++; search_value = strdup(optarg); search_type = strdup("UUID"); break; case 'i': lowprobe |= LOWPROBE_TOPOLOGY; break; case 'l': lookup++; break; case 'g': gc = 1; break; case 'k': { size_t idx = 0; const char *name = NULL; while (blkid_superblocks_get_name(idx++, &name, NULL) == 0) printf("%s\n", name); exit(EXIT_SUCCESS); } case 'o': if (!strcmp(optarg, "value")) output_format = OUTPUT_VALUE_ONLY; else if (!strcmp(optarg, "device")) output_format = OUTPUT_DEVICE_ONLY; else if (!strcmp(optarg, "list")) output_format = OUTPUT_PRETTY_LIST; /* deprecated */ else if (!strcmp(optarg, "udev")) output_format = OUTPUT_UDEV_LIST; else if (!strcmp(optarg, "export")) output_format = OUTPUT_EXPORT_LIST; else if (!strcmp(optarg, "full")) output_format = 0; else { fprintf(stderr, "Invalid output format %s. " "Choose from value,\n\t" "device, list, udev or full\n", optarg); exit(BLKID_EXIT_OTHER); } break; case 'O': offset = strtosize_or_err(optarg, "invalid offset argument"); break; case 'p': lowprobe |= LOWPROBE_SUPERBLOCKS; break; case 's': if (numtag + 1 >= sizeof(show) / sizeof(*show)) { fprintf(stderr, "Too many tags specified\n"); usage(err); } show[numtag++] = optarg; show[numtag] = NULL; break; case 'S': size = strtosize_or_err(optarg, "invalid size argument"); break; case 't': if (search_type) { fprintf(stderr, "Can only search for " "one NAME=value pair\n"); usage(err); } if (blkid_parse_tag_string(optarg, &search_type, &search_value)) { fprintf(stderr, "-t needs NAME=value pair\n"); usage(err); } break; case 'v': version = 1; break; case 'w': /* ignore - backward compatibility */ break; case 'h': err = 0; /* fallthrough */ default: usage(err); } /* The rest of the args are device names */ if (optind < argc) { devices = calloc(argc - optind, sizeof(char *)); if (!devices) { fprintf(stderr, "Failed to allocate device name array\n"); goto exit; } while (optind < argc) devices[numdev++] = argv[optind++]; } if (version) { print_version(stdout); goto exit; } /* convert LABEL/UUID lookup to evaluate request */ if (lookup && output_format == OUTPUT_DEVICE_ONLY && search_type && (!strcmp(search_type, "LABEL") || !strcmp(search_type, "UUID"))) { eval++; lookup = 0; } if (!lowprobe && !eval && blkid_get_cache(&cache, read) < 0) goto exit; if (gc) { blkid_gc_cache(cache); err = 0; goto exit; } err = BLKID_EXIT_NOTFOUND; if (eval == 0 && (output_format & OUTPUT_PRETTY_LIST)) { if (lowprobe) { fprintf(stderr, "The low-level probing mode does not " "support 'list' output format\n"); exit(BLKID_EXIT_OTHER); } pretty_print_dev(NULL); } if (lowprobe) { /* * Low-level API */ blkid_probe pr; if (!numdev) { fprintf(stderr, "The low-level probing mode " "requires a device\n"); exit(BLKID_EXIT_OTHER); } /* automatically enable 'export' format for I/O Limits */ if (!output_format && (lowprobe & LOWPROBE_TOPOLOGY)) output_format = OUTPUT_EXPORT_LIST; pr = blkid_new_probe(); if (!pr) goto exit; if (lowprobe & LOWPROBE_SUPERBLOCKS) { blkid_probe_set_superblocks_flags(pr, BLKID_SUBLKS_LABEL | BLKID_SUBLKS_UUID | BLKID_SUBLKS_TYPE | BLKID_SUBLKS_SECTYPE | BLKID_SUBLKS_USAGE | BLKID_SUBLKS_VERSION); if (fltr_usage && blkid_probe_filter_superblocks_usage( pr, fltr_flag, fltr_usage)) goto exit; else if (fltr_type && blkid_probe_filter_superblocks_type( pr, fltr_flag, fltr_type)) goto exit; } for (i = 0; i < numdev; i++) { err = lowprobe_device(pr, devices[i], lowprobe, show, output_format, (blkid_loff_t) offset, (blkid_loff_t) size); if (err) break; } blkid_free_probe(pr); } else if (eval) { /* * Evaluate API */ char *res = blkid_evaluate_tag(search_type, search_value, NULL); if (res) { err = 0; printf("%s\n", res); } } else if (lookup) { /* * Classic (cache based) API */ blkid_dev dev; if (!search_type) { fprintf(stderr, "The lookup option requires a " "search type specified using -t\n"); exit(BLKID_EXIT_OTHER); } /* Load any additional devices not in the cache */ for (i = 0; i < numdev; i++) blkid_get_dev(cache, devices[i], BLKID_DEV_NORMAL); if ((dev = blkid_find_dev_with_tag(cache, search_type, search_value))) { print_tags(dev, show, output_format); err = 0; } /* If we didn't specify a single device, show all available devices */ } else if (!numdev) { blkid_dev_iterate iter; blkid_dev dev; blkid_probe_all(cache); iter = blkid_dev_iterate_begin(cache); blkid_dev_set_search(iter, search_type, search_value); while (blkid_dev_next(iter, &dev) == 0) { dev = blkid_verify(cache, dev); if (!dev) continue; print_tags(dev, show, output_format); err = 0; } blkid_dev_iterate_end(iter); /* Add all specified devices to cache (optionally display tags) */ } else for (i = 0; i < numdev; i++) { blkid_dev dev = blkid_get_dev(cache, devices[i], BLKID_DEV_NORMAL); if (dev) { if (search_type && !blkid_dev_has_tag(dev, search_type, search_value)) continue; print_tags(dev, show, output_format); err = 0; } } exit: free(search_type); free(search_value); free_types_list(fltr_type); if (!lowprobe && !eval) blkid_put_cache(cache); free(devices); return err; }
int main(int argc, char **argv) { char *path; int c, fd, verbose = 0, secure = 0; uint64_t end, blksize, secsize, range[2]; struct stat sb; static const struct option longopts[] = { { "help", 0, 0, 'h' }, { "version", 0, 0, 'V' }, { "offset", 1, 0, 'o' }, { "length", 1, 0, 'l' }, { "secure", 0, 0, 's' }, { "verbose", 0, 0, 'v' }, { NULL, 0, 0, 0 } }; setlocale(LC_ALL, ""); bindtextdomain(PACKAGE, LOCALEDIR); textdomain(PACKAGE); atexit(close_stdout); range[0] = 0; range[1] = ULLONG_MAX; while ((c = getopt_long(argc, argv, "hVsvo:l:", longopts, NULL)) != -1) { switch(c) { case 'h': usage(stdout); break; case 'V': printf(UTIL_LINUX_VERSION); return EXIT_SUCCESS; case 'l': range[1] = strtosize_or_err(optarg, _("failed to parse length")); break; case 'o': range[0] = strtosize_or_err(optarg, _("failed to parse offset")); break; case 's': secure = 1; break; case 'v': verbose = 1; break; default: usage(stderr); break; } } if (optind == argc) errx(EXIT_FAILURE, _("no device specified")); path = argv[optind++]; if (optind != argc) { warnx(_("unexpected number of arguments")); usage(stderr); } if (stat(path, &sb) == -1) err(EXIT_FAILURE, _("stat failed %s"), path); if (!S_ISBLK(sb.st_mode)) errx(EXIT_FAILURE, _("%s: not a block device"), path); fd = open(path, O_WRONLY); if (fd < 0) err(EXIT_FAILURE, _("cannot open %s"), path); if (ioctl(fd, BLKGETSIZE64, &blksize)) err(EXIT_FAILURE, _("%s: BLKGETSIZE64 ioctl failed"), path); if (ioctl(fd, BLKSSZGET, &secsize)) err(EXIT_FAILURE, _("%s: BLKSSZGET ioctl failed"), path); /* align range to the sector size */ range[0] = (range[0] + secsize - 1) & ~(secsize - 1); range[1] &= ~(secsize - 1); /* is the range end behind the end of the device ?*/ end = range[0] + range[1]; if (end < range[0] || end > blksize) range[1] = blksize - range[0]; if (secure) { if (ioctl(fd, BLKSECDISCARD, &range)) err(EXIT_FAILURE, _("%s: BLKSECDISCARD ioctl failed"), path); } else { if (ioctl(fd, BLKDISCARD, &range)) err(EXIT_FAILURE, _("%s: BLKDISCARD ioctl failed"), path); } if (verbose) /* TRANSLATORS: The standard value here is a very large number. */ printf(_("%s: Discarded %" PRIu64 " bytes from the " "offset %" PRIu64"\n"), path, (uint64_t) range[1], (uint64_t) range[0]); close(fd); return EXIT_SUCCESS; }
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", 0, 0, 'a' }, { "backup", 0, 0, 'b' }, { "force", 0, 0, 'f' }, { "help", 0, 0, 'h' }, { "no-act", 0, 0, 'n' }, { "offset", 1, 0, 'o' }, { "parsable", 0, 0, 'p' }, { "quiet", 0, 0, 'q' }, { "types", 1, 0, 't' }, { "version", 0, 0, 'V' }, { NULL, 0, 0, 0 } }; static const ul_excl_t excl[] = { /* rows and cols in 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, "afhno: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: usage(stderr); break; } } 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) { char *path; int c, fd, verbose = 0, secure = 0, secsize; uint64_t end, blksize, step, range[2], stats[2]; struct stat sb; struct timeval now, last; static const struct option longopts[] = { { "help", 0, 0, 'h' }, { "version", 0, 0, 'V' }, { "offset", 1, 0, 'o' }, { "length", 1, 0, 'l' }, { "step", 1, 0, 'p' }, { "secure", 0, 0, 's' }, { "verbose", 0, 0, 'v' }, { NULL, 0, 0, 0 } }; setlocale(LC_ALL, ""); bindtextdomain(PACKAGE, LOCALEDIR); textdomain(PACKAGE); atexit(close_stdout); range[0] = 0; range[1] = ULLONG_MAX; step = 0; while ((c = getopt_long(argc, argv, "hVsvo:l:p:", longopts, NULL)) != -1) { switch(c) { case 'h': usage(stdout); break; case 'V': printf(UTIL_LINUX_VERSION); return EXIT_SUCCESS; case 'l': range[1] = strtosize_or_err(optarg, _("failed to parse length")); break; case 'o': range[0] = strtosize_or_err(optarg, _("failed to parse offset")); break; case 'p': step = strtosize_or_err(optarg, _("failed to parse step")); break; case 's': secure = 1; break; case 'v': verbose = 1; break; default: usage(stderr); break; } } if (optind == argc) errx(EXIT_FAILURE, _("no device specified")); path = argv[optind++]; if (optind != argc) { warnx(_("unexpected number of arguments")); usage(stderr); } fd = open(path, O_WRONLY); if (fd < 0) err(EXIT_FAILURE, _("cannot open %s"), path); if (fstat(fd, &sb) == -1) err(EXIT_FAILURE, _("stat failed %s"), path); if (!S_ISBLK(sb.st_mode)) errx(EXIT_FAILURE, _("%s: not a block device"), path); if (ioctl(fd, BLKGETSIZE64, &blksize)) err(EXIT_FAILURE, _("%s: BLKGETSIZE64 ioctl failed"), path); if (ioctl(fd, BLKSSZGET, &secsize)) err(EXIT_FAILURE, _("%s: BLKSSZGET ioctl failed"), path); /* check offset alignment to the sector size */ if (range[0] % secsize) errx(EXIT_FAILURE, _("%s: offset %" PRIu64 " is not aligned " "to sector size %i"), path, range[0], secsize); /* is the range end behind the end of the device ?*/ if (range[0] > blksize) errx(EXIT_FAILURE, _("%s: offset is greater than device size"), path); end = range[0] + range[1]; if (end < range[0] || end > blksize) end = blksize; range[1] = (step > 0) ? step : end - range[0]; /* check length alignment to the sector size */ if (range[1] % secsize) errx(EXIT_FAILURE, _("%s: length %" PRIu64 " is not aligned " "to sector size %i"), path, range[1], secsize); stats[0] = range[0], stats[1] = 0; gettime_monotonic(&last); for (range[0] = range[0]; range[0] < end; range[0] += range[1]) { if (range[0] + range[1] > end) range[1] = end - range[0]; if (secure) { if (ioctl(fd, BLKSECDISCARD, &range)) err(EXIT_FAILURE, _("%s: BLKSECDISCARD ioctl failed"), path); } else { if (ioctl(fd, BLKDISCARD, &range)) err(EXIT_FAILURE, _("%s: BLKDISCARD ioctl failed"), path); } /* reporting progress */ if (verbose && step) { gettime_monotonic(&now); if (last.tv_sec < now.tv_sec) { print_stats(path, stats); stats[0] = range[0], stats[1] = 0; last = now; } } stats[1] += range[1]; } if (verbose) print_stats(path, stats); close(fd); return EXIT_SUCCESS; }
int main(int argc, char **argv) { struct mcookie_control ctl = { .verbose = 0 }; size_t i; unsigned char digest[MD5LENGTH]; unsigned char buf[RAND_BYTES]; int c; static const struct option longopts[] = { {"file", required_argument, NULL, 'f'}, {"max-size", required_argument, NULL, 'm'}, {"verbose", no_argument, NULL, 'v'}, {"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 (2 < argc) ctl.files = xmalloc(sizeof(char *) * argc); while ((c = getopt_long(argc, argv, "f:m:vVh", longopts, NULL)) != -1) { switch (c) { case 'v': ctl.verbose = 1; break; case 'f': ctl.files[ctl.nfiles++] = optarg; break; case 'm': ctl.maxsz = strtosize_or_err(optarg, _("failed to parse length")); break; case 'V': printf(UTIL_LINUX_VERSION); return EXIT_SUCCESS; case 'h': usage(stdout); default: usage(stderr); } } if (ctl.maxsz && ctl.nfiles == 0) warnx(_("--max-size ignored when used without --file.")); randomness_from_files(&ctl); free(ctl.files); random_get_bytes(&buf, RAND_BYTES); MD5Update(&ctl.ctx, buf, RAND_BYTES); if (ctl.verbose) fprintf(stderr, _("Got %d bytes from %s\n"), RAND_BYTES, random_tell_source()); MD5Final(digest, &ctl.ctx); for (i = 0; i < MD5LENGTH; i++) printf("%02x", digest[i]); putchar('\n'); return EXIT_SUCCESS; }
int main(int argc, char **argv) { struct loopdev_cxt lc; int act = 0, flags = 0, c; char *file = NULL; uint64_t offset = 0, sizelimit = 0; int res = 0, showdev = 0, lo_flags = 0; enum { OPT_SIZELIMIT = CHAR_MAX + 1, OPT_SHOW }; static const struct option longopts[] = { { "all", 0, 0, 'a' }, { "set-capacity", 1, 0, 'c' }, { "detach", 1, 0, 'd' }, { "detach-all", 0, 0, 'D' }, { "encryption", 1, 0, 'e' }, { "find", 0, 0, 'f' }, { "help", 0, 0, 'h' }, { "associated", 1, 0, 'j' }, { "offset", 1, 0, 'o' }, { "sizelimit", 1, 0, OPT_SIZELIMIT }, { "pass-fd", 1, 0, 'p' }, { "partscan", 0, 0, 'P' }, { "read-only", 0, 0, 'r' }, { "show", 0, 0, OPT_SHOW }, { "verbose", 0, 0, 'v' }, { "version", 0, 0, 'V' }, { NULL, 0, 0, 0 } }; static const ul_excl_t excl[] = { /* rows and cols in ASCII order */ { 'D','a','c','d','f','j' }, { 0 } }; int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT; setlocale(LC_ALL, ""); bindtextdomain(PACKAGE, LOCALEDIR); textdomain(PACKAGE); atexit(close_stdout); if (loopcxt_init(&lc, 0)) err(EXIT_FAILURE, _("failed to initialize loopcxt")); while ((c = getopt_long(argc, argv, "ac:d:De:E:fhj:o:p:PrvV", longopts, NULL)) != -1) { err_exclusive_options(c, longopts, excl, excl_st); switch (c) { case 'a': act = A_SHOW; break; case 'c': act = A_SET_CAPACITY; if (loopcxt_set_device(&lc, optarg)) err(EXIT_FAILURE, _("%s: failed to use device"), optarg); break; case 'r': lo_flags |= LO_FLAGS_READ_ONLY; break; case 'd': act = A_DELETE; if (loopcxt_set_device(&lc, optarg)) err(EXIT_FAILURE, _("%s: failed to use device"), optarg); break; case 'D': act = A_DELETE_ALL; break; case 'E': case 'e': errx(EXIT_FAILURE, _("encryption not supported, use cryptsetup(8) instead")); break; case 'f': act = A_FIND_FREE; break; case 'h': usage(stdout); break; case 'j': act = A_SHOW; file = optarg; break; case 'o': offset = strtosize_or_err(optarg, _("failed to parse offset")); flags |= LOOPDEV_FL_OFFSET; break; case 'p': warn(_("--pass-fd is no longer supported")); break; case 'P': lo_flags |= LO_FLAGS_PARTSCAN; break; case OPT_SHOW: showdev = 1; break; case 'v': verbose = 1; break; case 'V': printf(UTIL_LINUX_VERSION); return EXIT_SUCCESS; case OPT_SIZELIMIT: /* --sizelimit */ sizelimit = strtosize_or_err(optarg, _("failed to parse size")); flags |= LOOPDEV_FL_SIZELIMIT; break; default: usage(stderr); } } if (argc == 1) usage(stderr); if (act == A_FIND_FREE && optind < argc) { /* * losetup -f <backing_file> */ act = A_CREATE; file = argv[optind++]; } if (!act && optind + 1 == argc) { /* * losetup <device> */ act = A_SHOW_ONE; if (loopcxt_set_device(&lc, argv[optind])) err(EXIT_FAILURE, _("%s: failed to use device"), argv[optind]); optind++; } if (!act) { /* * losetup <loopdev> <backing_file> */ act = A_CREATE; if (optind >= argc) errx(EXIT_FAILURE, _("no loop device specified")); if (loopcxt_set_device(&lc, argv[optind])) err(EXIT_FAILURE, _("%s: failed to use device"), argv[optind]); optind++; if (optind >= argc) errx(EXIT_FAILURE, _("no file specified")); file = argv[optind++]; } if (act != A_CREATE && (sizelimit || lo_flags || showdev)) errx(EXIT_FAILURE, _("the options %s are allowed to loop device setup only"), "--{sizelimit,read-only,show}"); if ((flags & LOOPDEV_FL_OFFSET) && act != A_CREATE && (act != A_SHOW || !file)) errx(EXIT_FAILURE, _("the option --offset is not allowed in this context.")); switch (act) { case A_CREATE: { int hasdev = loopcxt_has_device(&lc); do { /* Note that loopcxt_{find_unused,set_device}() resets * loopcxt struct. */ if (!hasdev && (res = loopcxt_find_unused(&lc))) { warnx(_("not found unused device")); break; } if (flags & LOOPDEV_FL_OFFSET) loopcxt_set_offset(&lc, offset); if (flags & LOOPDEV_FL_SIZELIMIT) loopcxt_set_sizelimit(&lc, sizelimit); if (lo_flags) loopcxt_set_flags(&lc, lo_flags); if ((res = loopcxt_set_backing_file(&lc, file))) { warn(_("%s: failed to use backing file"), file); break; } errno = 0; res = loopcxt_setup_device(&lc); if (res == 0) break; /* success */ if (errno != EBUSY) { warn(_("%s: failed to setup loop device"), hasdev && loopcxt_get_fd(&lc) < 0 ? loopcxt_get_device(&lc) : file); break; } } while (hasdev == 0); if (res == 0) { if (showdev) printf("%s\n", loopcxt_get_device(&lc)); warn_size(file, sizelimit); } break; } case A_DELETE: res = delete_loop(&lc); while (optind < argc) { if (loopcxt_set_device(&lc, argv[optind])) warn(_("%s: failed to use device"), argv[optind]); optind++; res += delete_loop(&lc); } break; case A_DELETE_ALL: res = delete_all_loops(&lc); break; case A_FIND_FREE: if (loopcxt_find_unused(&lc)) warn(_("find unused loop device failed")); else printf("%s\n", loopcxt_get_device(&lc)); break; case A_SHOW: res = show_all_loops(&lc, file, offset, flags); break; case A_SHOW_ONE: res = printf_loopdev(&lc); if (res) warn(_("%s"), loopcxt_get_device(&lc)); break; case A_SET_CAPACITY: res = set_capacity(&lc); break; default: usage(stderr); break; } loopcxt_deinit(&lc); return res ? EXIT_FAILURE : EXIT_SUCCESS; }