/*- * Copyright (C) 2009 Gabor Kovesdan * Copyright (C) 2012 Oleg Moskalenko * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "coll.h" #include "file.h" #include "sort.h" #ifndef WITHOUT_NLS #include nl_catd catalog; #endif #define OPTIONS "bcCdfghik:Mmno:RrsS:t:T:uVz" #define DEFAULT_RANDOM_SORT_SEED_FILE ("/dev/random") #define MAX_DEFAULT_RANDOM_SEED_DATA_SIZE (1024) static bool need_random; static const char *random_source = DEFAULT_RANDOM_SORT_SEED_FILE; static const void *random_seed; static size_t random_seed_size; MD5_CTX md5_ctx; /* * Default messages to use when NLS is disabled or no catalogue * is found. */ const char *nlsstr[] = { "", /* 1*/"mutually exclusive flags", /* 2*/"extra argument not allowed with -c", /* 3*/"Unknown feature", /* 4*/"Wrong memory buffer specification", /* 5*/"0 field in key specs", /* 6*/"0 column in key specs", /* 7*/"Wrong file mode", /* 8*/"Cannot open file for reading", /* 9*/"Radix sort cannot be used with these sort options", /*10*/"The chosen sort method cannot be used with stable and/or unique sort", /*11*/"Invalid key position", /*12*/"Usage: %s [-bcCdfigMmnrsuz] [-kPOS1[,POS2] ... ] " "[+POS1 [-POS2]] [-S memsize] [-T tmpdir] [-t separator] " "[-o outfile] [--batch-size size] [--files0-from file] " "[--heapsort] [--mergesort] [--radixsort] [--qsort] " "[--mmap] " #if defined(SORT_THREADS) "[--parallel thread_no] " #endif "[--human-numeric-sort] " "[--version-sort] [--random-sort [--random-source file]] " "[--compress-program program] [file ...]\n" }; struct sort_opts sort_opts_vals; bool debug_sort; bool need_hint; #if defined(SORT_THREADS) size_t ncpu = 1; size_t nthreads = 1; #endif static bool gnusort_numeric_compatibility; static struct sort_mods default_sort_mods_object; struct sort_mods * const default_sort_mods = &default_sort_mods_object; static bool print_symbols_on_debug; /* * Arguments from file (when file0-from option is used: */ static int argc_from_file0 = -1; static char **argv_from_file0; /* * Placeholder symbols for options which have no single-character equivalent */ enum { SORT_OPT = CHAR_MAX + 1, HELP_OPT, FF_OPT, BS_OPT, VERSION_OPT, DEBUG_OPT, #if defined(SORT_THREADS) PARALLEL_OPT, #endif RANDOMSOURCE_OPT, COMPRESSPROGRAM_OPT, QSORT_OPT, MERGESORT_OPT, HEAPSORT_OPT, RADIXSORT_OPT, MMAP_OPT }; #define NUMBER_OF_MUTUALLY_EXCLUSIVE_FLAGS 6 static const char mutually_exclusive_flags[NUMBER_OF_MUTUALLY_EXCLUSIVE_FLAGS] = { 'M', 'n', 'g', 'R', 'h', 'V' }; static struct option long_options[] = { { "batch-size", required_argument, NULL, BS_OPT }, { "buffer-size", required_argument, NULL, 'S' }, { "check", optional_argument, NULL, 'c' }, { "check=silent|quiet", optional_argument, NULL, 'C' }, { "compress-program", required_argument, NULL, COMPRESSPROGRAM_OPT }, { "debug", no_argument, NULL, DEBUG_OPT }, { "dictionary-order", no_argument, NULL, 'd' }, { "field-separator", required_argument, NULL, 't' }, { "files0-from", required_argument, NULL, FF_OPT }, { "general-numeric-sort", no_argument, NULL, 'g' }, { "heapsort", no_argument, NULL, HEAPSORT_OPT }, { "help",no_argument, NULL, HELP_OPT }, { "human-numeric-sort", no_argument, NULL, 'h' }, { "ignore-leading-blanks", no_argument, NULL, 'b' }, { "ignore-case", no_argument, NULL, 'f' }, { "ignore-nonprinting", no_argument, NULL, 'i' }, { "key", required_argument, NULL, 'k' }, { "merge", no_argument, NULL, 'm' }, { "mergesort", no_argument, NULL, MERGESORT_OPT }, { "mmap", no_argument, NULL, MMAP_OPT }, { "month-sort", no_argument, NULL, 'M' }, { "numeric-sort", no_argument, NULL, 'n' }, { "output", required_argument, NULL, 'o' }, #if defined(SORT_THREADS) { "parallel", required_argument, NULL, PARALLEL_OPT }, #endif { "qsort", no_argument, NULL, QSORT_OPT }, { "radixsort", no_argument, NULL, RADIXSORT_OPT }, { "random-sort", no_argument, NULL, 'R' }, { "random-source", required_argument, NULL, RANDOMSOURCE_OPT }, { "reverse", no_argument, NULL, 'r' }, { "sort", required_argument, NULL, SORT_OPT }, { "stable", no_argument, NULL, 's' }, { "temporary-directory",required_argument, NULL, 'T' }, { "unique", no_argument, NULL, 'u' }, { "version", no_argument, NULL, VERSION_OPT }, { "version-sort",no_argument, NULL, 'V' }, { "zero-terminated", no_argument, NULL, 'z' }, { NULL, no_argument, NULL, 0 } }; void fix_obsolete_keys(int *argc, char **argv); /* * Check where sort modifier is present */ static bool sort_modifier_empty(struct sort_mods *sm) { if (sm == NULL) return (true); return (!(sm->Mflag || sm->Vflag || sm->nflag || sm->gflag || sm->rflag || sm->Rflag || sm->hflag || sm->dflag || sm->fflag)); } /* * Print out usage text. */ static void usage(bool opt_err) { struct option *o; FILE *out; out = stdout; o = &(long_options[0]); if (opt_err) out = stderr; fprintf(out, getstr(12), getprogname()); if (opt_err) exit(2); exit(0); } /* * Read input file names from a file (file0-from option). */ static void read_fns_from_file0(const char *fn) { if (fn) { struct file0_reader f0r; FILE *f; f = fopen(fn, "r"); if (f == NULL) err(2, NULL); memset(&f0r, 0, sizeof(f0r)); f0r.f = f; while (!feof(f)) { char *line = read_file0_line(&f0r); if (line && *line) { ++argc_from_file0; if (argc_from_file0 < 1) argc_from_file0 = 1; argv_from_file0 = sort_realloc(argv_from_file0, argc_from_file0 * sizeof(char *)); if (argv_from_file0 == NULL) err(2, NULL); argv_from_file0[argc_from_file0 - 1] = sort_strdup(line); } } closefile(f, fn); } } /* * Check how much RAM is available for the sort. */ static void set_hw_params(void) { #if defined(SORT_THREADS) size_t ncpusz; #endif size_t pages, psize, psz, pszsz; pages = psize = 0; #if defined(SORT_THREADS) ncpu = 1; ncpusz = sizeof(size_t); #endif psz = pszsz = sizeof(size_t); if (sysctlbyname("vm.stats.vm.v_free_count", &pages, &psz, NULL, 0) < 0) { perror("vm.stats.vm.v_free_count"); return; } if (sysctlbyname("vm.stats.vm.v_page_size", &psize, &pszsz, NULL, 0) < 0) { perror("vm.stats.vm.v_page_size"); return; } #if defined(SORT_THREADS) if (sysctlbyname("hw.ncpu", &ncpu, &ncpusz, NULL, 0) < 0) ncpu = 1; else if(ncpu > 32) ncpu = 32; nthreads = ncpu; #endif free_memory = (unsigned long long) pages * (unsigned long long) psize; available_free_memory = (free_memory * 9) / 10; } /* * Convert "plain" symbol to wide symbol, with default value. */ static void conv_mbtowc(wchar_t *wc, const char *c, const wchar_t def) { if (wc && c) { int res; res = mbtowc(wc, c, MB_CUR_MAX); if (res < 1) *wc = def; } } /* * Set current locale symbols. */ static void set_locale(void) { struct lconv *lc; const char *locale; setlocale(LC_ALL, ""); lc = localeconv(); if (lc) { /* obtain LC_NUMERIC info */ /* Convert to wide char form */ conv_mbtowc(&symbol_decimal_point, lc->decimal_point, symbol_decimal_point); conv_mbtowc(&symbol_thousands_sep, lc->thousands_sep, symbol_thousands_sep); conv_mbtowc(&symbol_positive_sign, lc->positive_sign, symbol_positive_sign); conv_mbtowc(&symbol_negative_sign, lc->negative_sign, symbol_negative_sign); } if (getenv("GNUSORT_NUMERIC_COMPATIBILITY")) gnusort_numeric_compatibility = true; locale = setlocale(LC_COLLATE, NULL); if (locale) { char *tmpl; const char *cclocale; tmpl = sort_strdup(locale); cclocale = setlocale(LC_COLLATE, "C"); if (cclocale && !strcmp(cclocale, tmpl)) byte_sort = true; else { const char *pclocale; pclocale = setlocale(LC_COLLATE, "POSIX"); if (pclocale && !strcmp(pclocale, tmpl)) byte_sort = true; } setlocale(LC_COLLATE, tmpl); sort_free(tmpl); } } /* * Set directory temporary files. */ static void set_tmpdir(void) { char *td; td = getenv("TMPDIR"); if (td != NULL) tmpdir = sort_strdup(td); } /* * Parse -S option. */ static unsigned long long parse_memory_buffer_value(const char *value) { if (value == NULL) return (available_free_memory); else { char *endptr; unsigned long long membuf; endptr = NULL; errno = 0; membuf = strtoll(value, &endptr, 10); if (errno != 0) { warn("%s",getstr(4)); membuf = available_free_memory; } else { switch (*endptr){ case 'Y': membuf *= 1024; /* FALLTHROUGH */ case 'Z': membuf *= 1024; /* FALLTHROUGH */ case 'E': membuf *= 1024; /* FALLTHROUGH */ case 'P': membuf *= 1024; /* FALLTHROUGH */ case 'T': membuf *= 1024; /* FALLTHROUGH */ case 'G': membuf *= 1024; /* FALLTHROUGH */ case 'M': membuf *= 1024; /* FALLTHROUGH */ case '\0': case 'K': membuf *= 1024; /* FALLTHROUGH */ case 'b': break; case '%': membuf = (available_free_memory * membuf) / 100; break; default: fprintf(stderr, "%s: %s\n", strerror(EINVAL), optarg); membuf = available_free_memory; } } return (membuf); } } /* * Signal handler that clears the temporary files. */ static void sig_handler(int sig __unused, siginfo_t *siginfo __unused, void *context __unused) { clear_tmp_files(); exit(-1); } /* * Set signal handler on panic signals. */ static void set_signal_handler(void) { struct sigaction sa; memset(&sa, 0, sizeof(sa)); sa.sa_sigaction = &sig_handler; sa.sa_flags = SA_SIGINFO; if (sigaction(SIGTERM, &sa, NULL) < 0) { perror("sigaction"); return; } if (sigaction(SIGHUP, &sa, NULL) < 0) { perror("sigaction"); return; } if (sigaction(SIGINT, &sa, NULL) < 0) { perror("sigaction"); return; } if (sigaction(SIGQUIT, &sa, NULL) < 0) { perror("sigaction"); return; } if (sigaction(SIGABRT, &sa, NULL) < 0) { perror("sigaction"); return; } if (sigaction(SIGBUS, &sa, NULL) < 0) { perror("sigaction"); return; } if (sigaction(SIGSEGV, &sa, NULL) < 0) { perror("sigaction"); return; } if (sigaction(SIGUSR1, &sa, NULL) < 0) { perror("sigaction"); return; } if (sigaction(SIGUSR2, &sa, NULL) < 0) { perror("sigaction"); return; } } /* * Print "unknown" message and exit with status 2. */ static void unknown(const char *what) { errx(2, "%s: %s", getstr(3), what); } /* * Check whether contradictory input options are used. */ static void check_mutually_exclusive_flags(char c, bool *mef_flags) { int fo_index, mec; bool found_others, found_this; found_others = found_this =false; fo_index = 0; for (int i = 0; i < NUMBER_OF_MUTUALLY_EXCLUSIVE_FLAGS; i++) { mec = mutually_exclusive_flags[i]; if (mec != c) { if (mef_flags[i]) { if (found_this) errx(1, "%c:%c: %s", c, mec, getstr(1)); found_others = true; fo_index = i; } } else { if (found_others) errx(1, "%c:%c: %s", c, mutually_exclusive_flags[fo_index], getstr(1)); mef_flags[i] = true; found_this = true; } } } /* * Initialise sort opts data. */ static void set_sort_opts(void) { memset(&default_sort_mods_object, 0, sizeof(default_sort_mods_object)); memset(&sort_opts_vals, 0, sizeof(sort_opts_vals)); default_sort_mods_object.func = get_sort_func(&default_sort_mods_object); } /* * Set a sort modifier on a sort modifiers object. */ static bool set_sort_modifier(struct sort_mods *sm, int c) { if (sm) { switch (c){ case 'b': sm->bflag = true; break; case 'd': sm->dflag = true; break; case 'f': sm->fflag = true; break; case 'g': sm->gflag = true; need_hint = true; break; case 'i': sm->iflag = true; break; case 'R': sm->Rflag = true; need_random = true; break; case 'M': initialise_months(); sm->Mflag = true; need_hint = true; break; case 'n': sm->nflag = true; need_hint = true; print_symbols_on_debug = true; break; case 'r': sm->rflag = true; break; case 'V': sm->Vflag = true; break; case 'h': sm->hflag = true; need_hint = true; print_symbols_on_debug = true; break; default: return false; } sort_opts_vals.complex_sort = true; sm->func = get_sort_func(sm); } return (true); } /* * Parse POS in -k option. */ static int parse_pos(const char *s, struct key_specs *ks, bool *mef_flags, bool second) { regmatch_t pmatch[4]; regex_t re; char *c, *f; const char *sregexp = "^([0-9]+)(\\.[0-9]+)?([bdfirMngRhV]+)?$"; size_t len, nmatch; int ret; ret = -1; nmatch = 4; c = f = NULL; if (regcomp(&re, sregexp, REG_EXTENDED) != 0) return (-1); if (regexec(&re, s, nmatch, pmatch, 0) != 0) goto end; if (pmatch[0].rm_eo <= pmatch[0].rm_so) goto end; if (pmatch[1].rm_eo <= pmatch[1].rm_so) goto end; len = pmatch[1].rm_eo - pmatch[1].rm_so; f = sort_malloc((len + 1) * sizeof(char)); strncpy(f, s + pmatch[1].rm_so, len); f[len] = '\0'; if (second) { errno = 0; ks->f2 = (size_t) strtoul(f, NULL, 10); if (errno != 0) errx(2, "%s: -k", strerror(errno)); if (ks->f2 == 0) { warn("%s",getstr(5)); goto end; } } else { errno = 0; ks->f1 = (size_t) strtoul(f, NULL, 10); if (errno != 0) errx(2, "%s: -k", strerror(errno)); if (ks->f1 == 0) { warn("%s",getstr(5)); goto end; } } if (pmatch[2].rm_eo > pmatch[2].rm_so) { len = pmatch[2].rm_eo - pmatch[2].rm_so - 1; c = sort_malloc((len + 1) * sizeof(char)); strncpy(c, s + pmatch[2].rm_so + 1, len); c[len] = '\0'; if (second) { errno = 0; ks->c2 = (size_t) strtoul(c, NULL, 10); if (errno != 0) errx(2, "%s: -k", strerror(errno)); } else { errno = 0; ks->c1 = (size_t) strtoul(c, NULL, 10); if (errno != 0) errx(2, "%s: -k", strerror(errno)); if (ks->c1 == 0) { warn("%s",getstr(6)); goto end; } } } else { if (second) ks->c2 = 0; else ks->c1 = 1; } if (pmatch[3].rm_eo > pmatch[3].rm_so) { regoff_t i = 0; for (i = pmatch[3].rm_so; i < pmatch[3].rm_eo; i++) { check_mutually_exclusive_flags(s[i], mef_flags); if (s[i] == 'b') { if (second) ks->pos2b = true; else ks->pos1b = true; } else if (!set_sort_modifier(&(ks->sm), s[i])) goto end; } } ret = 0; end: if (c) sort_free(c); if (f) sort_free(f); regfree(&re); return (ret); } /* * Parse -k option value. */ static int parse_k(const char *s, struct key_specs *ks) { int ret = -1; bool mef_flags[NUMBER_OF_MUTUALLY_EXCLUSIVE_FLAGS] = { false, false, false, false, false, false }; if (s && *s) { char *sptr; sptr = strchr(s, ','); if (sptr) { size_t size1; char *pos1, *pos2; size1 = sptr - s; if (size1 < 1) return (-1); pos1 = sort_malloc((size1 + 1) * sizeof(char)); strncpy(pos1, s, size1); pos1[size1] = '\0'; ret = parse_pos(pos1, ks, mef_flags, false); sort_free(pos1); if (ret < 0) return (ret); pos2 = sort_strdup(sptr + 1); ret = parse_pos(pos2, ks, mef_flags, true); sort_free(pos2); } else ret = parse_pos(s, ks, mef_flags, false); } return (ret); } /* * Parse POS in +POS -POS option. */ static int parse_pos_obs(const char *s, int *nf, int *nc, char* sopts) { regex_t re; regmatch_t pmatch[4]; char *c, *f; const char *sregexp = "^([0-9]+)(\\.[0-9]+)?([A-Za-z]+)?$"; int ret; size_t len, nmatch; ret = -1; nmatch = 4; c = f = NULL; *nc = *nf = 0; if (regcomp(&re, sregexp, REG_EXTENDED) != 0) return (-1); if (regexec(&re, s, nmatch, pmatch, 0) != 0) goto end; if (pmatch[0].rm_eo <= pmatch[0].rm_so) goto end; if (pmatch[1].rm_eo <= pmatch[1].rm_so) goto end; len = pmatch[1].rm_eo - pmatch[1].rm_so; f = sort_malloc((len + 1) * sizeof(char)); strncpy(f, s + pmatch[1].rm_so, len); f[len] = '\0'; errno = 0; *nf = (size_t) strtoul(f, NULL, 10); if (errno != 0) errx(2, "%s", getstr(11)); if (pmatch[2].rm_eo > pmatch[2].rm_so) { len = pmatch[2].rm_eo - pmatch[2].rm_so - 1; c = sort_malloc((len + 1) * sizeof(char)); strncpy(c, s + pmatch[2].rm_so + 1, len); c[len] = '\0'; errno = 0; *nc = (size_t) strtoul(c, NULL, 10); if (errno != 0) errx(2, "%s", getstr(11)); } if (pmatch[3].rm_eo > pmatch[3].rm_so) { len = pmatch[3].rm_eo - pmatch[3].rm_so; strncpy(sopts, s + pmatch[3].rm_so, len); sopts[len] = '\0'; } ret = 0; end: if (c) sort_free(c); if (f) sort_free(f); regfree(&re); return (ret); } /* * "Translate" obsolete +POS1 -POS2 syntax into new -kPOS1,POS2 syntax */ void fix_obsolete_keys(int *argc, char **argv) { char sopt[129]; for (int i = 1; i < *argc; i++) { char *arg1; arg1 = argv[i]; if (strlen(arg1) > 1 && arg1[0] == '+') { int c1, f1; char sopts1[128]; sopts1[0] = 0; c1 = f1 = 0; if (parse_pos_obs(arg1 + 1, &f1, &c1, sopts1) < 0) continue; else { f1 += 1; c1 += 1; if (i + 1 < *argc) { char *arg2 = argv[i + 1]; if (strlen(arg2) > 1 && arg2[0] == '-') { int c2, f2; char sopts2[128]; sopts2[0] = 0; c2 = f2 = 0; if (parse_pos_obs(arg2 + 1, &f2, &c2, sopts2) >= 0) { if (c2 > 0) f2 += 1; sprintf(sopt, "-k%d.%d%s,%d.%d%s", f1, c1, sopts1, f2, c2, sopts2); argv[i] = sort_strdup(sopt); for (int j = i + 1; j + 1 < *argc; j++) argv[j] = argv[j + 1]; *argc -= 1; continue; } } } sprintf(sopt, "-k%d.%d", f1, c1); argv[i] = sort_strdup(sopt); } } } } /* * Set random seed */ static void set_random_seed(void) { if (need_random) { if (strcmp(random_source, DEFAULT_RANDOM_SORT_SEED_FILE) == 0) { FILE* fseed; MD5_CTX ctx; char rsd[MAX_DEFAULT_RANDOM_SEED_DATA_SIZE]; size_t sz = 0; fseed = openfile(random_source, "r"); while (!feof(fseed)) { int cr; cr = fgetc(fseed); if (cr == EOF) break; rsd[sz++] = (char) cr; if (sz >= MAX_DEFAULT_RANDOM_SEED_DATA_SIZE) break; } closefile(fseed, random_source); MD5Init(&ctx); MD5Update(&ctx, rsd, sz); random_seed = MD5End(&ctx, NULL); random_seed_size = strlen(random_seed); } else { MD5_CTX ctx; char *b; MD5Init(&ctx); b = MD5File(random_source, NULL); if (b == NULL) err(2, NULL); random_seed = b; random_seed_size = strlen(b); } MD5Init(&md5_ctx); if(random_seed_size>0) { MD5Update(&md5_ctx, random_seed, random_seed_size); } } } /* * Main function. */ int main(int argc, char **argv) { char *outfile, *real_outfile; int c, result; bool mef_flags[NUMBER_OF_MUTUALLY_EXCLUSIVE_FLAGS] = { false, false, false, false, false, false }; result = 0; outfile = sort_strdup("-"); real_outfile = NULL; struct sort_mods *sm = &default_sort_mods_object; init_tmp_files(); set_signal_handler(); set_hw_params(); set_locale(); set_tmpdir(); set_sort_opts(); #if 0 { static int counter = 0; char fn[128]; sprintf(fn, "/var/tmp/debug.sort.%d", counter++); FILE* f = fopen(fn, "w"); fprintf(f, ">>sort>>"); for (int i = 0; i < argc; i++) { fprintf(f, "<%s>", argv[i]); } fprintf(f, "< 1) { if (optarg[0] != '\\') { errx(2, "%s: %s\n", strerror(EINVAL), optarg); } optarg += 1; if (*optarg == '0') { *optarg = 0; break; } } sort_opts_vals.tflag = true; sort_opts_vals.field_sep = btowc(optarg[0]); if (sort_opts_vals.field_sep == WEOF) { errno = EINVAL; err(2, NULL); } if (!gnusort_numeric_compatibility) { if (symbol_decimal_point == sort_opts_vals.field_sep) symbol_decimal_point = WEOF; if (symbol_thousands_sep == sort_opts_vals.field_sep) symbol_thousands_sep = WEOF; if (symbol_negative_sign == sort_opts_vals.field_sep) symbol_negative_sign = WEOF; if (symbol_positive_sign == sort_opts_vals.field_sep) symbol_positive_sign = WEOF; } break; case 'u': sort_opts_vals.uflag = true; /* stable sort for the correct unique val */ sort_opts_vals.sflag = true; break; case 'z': sort_opts_vals.zflag = true; break; case SORT_OPT: if (optarg) { if (!strcmp(optarg, "general-numeric")) set_sort_modifier(sm, 'g'); else if (!strcmp(optarg, "human-numeric")) set_sort_modifier(sm, 'h'); else if (!strcmp(optarg, "numeric")) set_sort_modifier(sm, 'n'); else if (!strcmp(optarg, "month")) set_sort_modifier(sm, 'M'); else if (!strcmp(optarg, "random")) set_sort_modifier(sm, 'R'); else unknown(optarg); } break; #if defined(SORT_THREADS) case PARALLEL_OPT: nthreads = (size_t)(atoi(optarg)); if (nthreads < 1) nthreads = 1; if (nthreads > 1024) nthreads = 1024; break; #endif case QSORT_OPT: sort_opts_vals.sort_method = SORT_QSORT; break; case MERGESORT_OPT: sort_opts_vals.sort_method = SORT_MERGESORT; break; case MMAP_OPT: use_mmap = true; break; case HEAPSORT_OPT: sort_opts_vals.sort_method = SORT_HEAPSORT; break; case RADIXSORT_OPT: sort_opts_vals.sort_method = SORT_RADIXSORT; break; case RANDOMSOURCE_OPT: random_source = strdup(optarg); break; case COMPRESSPROGRAM_OPT: compress_program = strdup(optarg); break; case FF_OPT: read_fns_from_file0(optarg); break; case BS_OPT: { errno = 0; long mof = strtol(optarg, NULL, 10); if (errno != 0) errx(2, "--batch-size: %s", strerror(errno)); if (mof >= 2) max_open_files = (size_t) mof + 1; } break; case VERSION_OPT: printf("%s\n", VERSION); exit(EXIT_SUCCESS); /* NOTREACHED */ break; case DEBUG_OPT: debug_sort = true; break; case HELP_OPT: usage(false); /* NOTREACHED */ break; default: usage(true); /* NOTREACHED */ } } } argc -= optind; argv += optind; #ifndef WITHOUT_NLS catalog = catopen("sort", NL_CAT_LOCALE); #endif if (sort_opts_vals.cflag && sort_opts_vals.mflag) errx(1, "%c:%c: %s", 'm', 'c', getstr(1)); #ifndef WITHOUT_NLS catclose(catalog); #endif if (keys_num == 0) { keys_num = 1; keys = sort_realloc(keys, sizeof(struct key_specs)); memset(&(keys[0]), 0, sizeof(struct key_specs)); keys[0].c1 = 1; keys[0].pos1b = default_sort_mods->bflag; keys[0].pos2b = default_sort_mods->bflag; memcpy(&(keys[0].sm), default_sort_mods, sizeof(struct sort_mods)); } for (size_t i = 0; i < keys_num; i++) { struct key_specs *ks; ks = &(keys[i]); if (sort_modifier_empty(&(ks->sm)) && !(ks->pos1b) && !(ks->pos2b)) { ks->pos1b = sm->bflag; ks->pos2b = sm->bflag; memcpy(&(ks->sm), sm, sizeof(struct sort_mods)); } ks->sm.func = get_sort_func(&(ks->sm)); } if (argc_from_file0 >= 0) { argc = argc_from_file0; argv = argv_from_file0; } if (debug_sort) { #if defined(SORT_THREADS) nthreads = 1; #endif printf("Using collate rules of %s locale\n", setlocale(LC_COLLATE, NULL)); if (byte_sort) printf("Byte sort is used\n"); if (print_symbols_on_debug) { printf("Decimal Point: <%lc>\n", symbol_decimal_point); if (symbol_thousands_sep) printf("Thousands separator: <%lc>\n", symbol_thousands_sep); printf("Positive sign: <%lc>\n", symbol_positive_sign); printf("Negative sign: <%lc>\n", symbol_negative_sign); } } set_random_seed(); /* Case when the outfile equals one of the input files: */ if (strcmp(outfile, "-")) { for(int i = 0; i < argc; ++i) { if (strcmp(argv[i], outfile) == 0) { real_outfile = sort_strdup(outfile); for(;;) { char* tmp = sort_malloc(strlen(outfile) + strlen(".tmp") + 1); strcpy(tmp, outfile); strcpy(tmp + strlen(tmp), ".tmp"); sort_free(outfile); outfile = tmp; if (access(outfile, F_OK) < 0) break; } tmp_file_atexit(outfile); } } } #if defined(SORT_THREADS) if ((argc < 1) || (strcmp(outfile, "-") == 0) || (*outfile == 0)) nthreads = 1; #endif if (!sort_opts_vals.cflag && !sort_opts_vals.mflag) { struct file_list fl; struct sort_list list; sort_list_init(&list); file_list_init(&fl, true); if (argc < 1) procfile("-", &list, &fl); else { while (argc > 0) { procfile(*argv, &list, &fl); --argc; ++argv; } } if (fl.count < 1) sort_list_to_file(&list, outfile); else { if (list.count > 0) { char *flast = new_tmp_file_name(); sort_list_to_file(&list, flast); file_list_add(&fl, flast, false); } merge_files(&fl, outfile); } file_list_clean(&fl); /* * We are about to exit the program, so we can ignore * the clean-up for speed * * sort_list_clean(&list); */ } else if (sort_opts_vals.cflag) { result = (argc == 0) ? (check("-")) : (check(*argv)); } else if (sort_opts_vals.mflag) { struct file_list fl; file_list_init(&fl, false); file_list_populate(&fl, argc, argv, true); merge_files(&fl, outfile); file_list_clean(&fl); } if (real_outfile) { unlink(real_outfile); if (rename(outfile, real_outfile) < 0) err(2, NULL); sort_free(real_outfile); } sort_free(outfile); return (result); }