#include <sys/stat.h>
#include <sys/sysctl.h>
#include <sys/types.h>
#include <err.h>
#include <errno.h>
#include <getopt.h>
#include <limits.h>
#include <locale.h>
#include <regex.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <wchar.h>
#include <wctype.h>
#if defined(SORT_RANDOM)
#include <openssl/md5.h>
#endif
#include "coll.h"
#include "file.h"
#include "sort.h"
#ifndef WITHOUT_NLS
#include <nl_types.h>
nl_catd catalog;
#endif
#if defined(SORT_RANDOM)
#define OPTIONS "bcCdfghik:Mmno:RrsS:t:T:uVz"
#else
#define OPTIONS "bcCdfghik:Mmno:rsS:t:T:uVz"
#endif
#if defined(SORT_RANDOM)
#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;
#endif
const char *nlsstr[] = { "",
"mutually exclusive flags",
"extra argument not allowed with -c",
"Unknown feature",
"Wrong memory buffer specification",
"0 field in key specs",
"0 column in key specs",
"Wrong file mode",
"Cannot open file for reading",
"Radix sort cannot be used with these sort options",
"The chosen sort method cannot be used with stable and/or unique sort",
"Invalid key position",
"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] "
#if defined(SORT_RANDOM)
"[--version-sort] [--random-sort [--random-source file]] "
#else
"[--version-sort] "
#endif
"[--compress-program program] [file ...]\n" };
struct sort_opts sort_opts_vals;
bool debug_sort;
bool need_hint;
#if defined(SORT_THREADS)
unsigned int 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;
static size_t argc_from_file0 = (size_t)-1;
static char **argv_from_file0;
enum
{
SORT_OPT = CHAR_MAX + 1,
HELP_OPT,
FF_OPT,
BS_OPT,
VERSION_OPT,
DEBUG_OPT,
#if defined(SORT_THREADS)
PARALLEL_OPT,
#endif
#if defined(SORT_RANDOM)
RANDOMSOURCE_OPT,
#endif
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 },
#if defined(SORT_RANDOM)
{ "random-sort", no_argument, NULL, 'R' },
{ "random-source", required_argument, NULL, RANDOMSOURCE_OPT },
#endif
{ "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 }
};
static void fix_obsolete_keys(int *argc, char **argv);
static bool
sort_modifier_empty(struct sort_mods *sm)
{
if (sm == NULL)
return (true);
return (!(sm->Mflag || sm->Vflag || sm->nflag || sm->gflag ||
#ifdef SORT_RANDOM
sm->Rflag ||
#endif
sm->rflag || sm->hflag || sm->dflag || sm->fflag));
}
static void
usage(bool opt_err)
{
FILE *out;
out = opt_err ? stderr : stdout;
fprintf(out, getstr(12), getprogname());
if (opt_err)
exit(2);
exit(0);
}
static void
read_fns_from_file0(const char *fn)
{
FILE *f;
char *line = NULL;
size_t linesize = 0;
ssize_t linelen;
if (fn == NULL)
return;
f = fopen(fn, "r");
if (f == NULL)
err(2, "%s", fn);
while ((linelen = getdelim(&line, &linesize, '\0', f)) != -1) {
if (*line != '\0') {
if (argc_from_file0 == (size_t) - 1)
argc_from_file0 = 0;
++argc_from_file0;
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] = line;
} else {
free(line);
}
line = NULL;
linesize = 0;
}
if (ferror(f))
err(2, "%s: getdelim", fn);
closefile(f, fn);
}
static void
set_hw_params(void)
{
long pages, psize;
pages = psize = 0;
#if defined(SORT_THREADS)
ncpu = 1;
#endif
pages = sysconf(_SC_PHYS_PAGES);
if (pages < 1) {
perror("sysconf pages");
pages = 1;
}
psize = sysconf(_SC_PAGESIZE);
if (psize < 1) {
perror("sysconf psize");
psize = 4096;
}
#if defined(SORT_THREADS)
ncpu = (unsigned int)sysconf(_SC_NPROCESSORS_ONLN);
if (ncpu < 1)
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 / 2;
if (available_free_memory < 1024)
available_free_memory = 1024;
}
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;
}
}
static void
set_locale(void)
{
struct lconv *lc;
const char *locale;
setlocale(LC_ALL, "");
lc = localeconv();
if (lc) {
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);
}
}
static void
set_tmpdir(void)
{
char *td;
td = getenv("TMPDIR");
if (td != NULL)
tmpdir = sort_strdup(td);
}
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;
case 'Z':
membuf *= 1024;
case 'E':
membuf *= 1024;
case 'P':
membuf *= 1024;
case 'T':
membuf *= 1024;
case 'G':
membuf *= 1024;
case 'M':
membuf *= 1024;
case '\0':
case 'K':
membuf *= 1024;
case 'b':
break;
case '%':
membuf = (available_free_memory * membuf) /
100;
break;
default:
warnc(EINVAL, "%s", optarg);
membuf = available_free_memory;
}
}
return (membuf);
}
}
static void
sig_handler(int sig __unused, siginfo_t *siginfo __unused,
void *context __unused)
{
clear_tmp_files();
exit(-1);
}
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;
}
}
static void
unknown(const char *what)
{
errx(2, "%s: %s", getstr(3), what);
}
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;
}
}
}
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);
}
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;
#ifdef SORT_RANDOM
case 'R':
sm->Rflag = true;
need_random = true;
break;
#endif
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);
}
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)
err(2, "-k");
if (ks->f2 == 0) {
warn("%s",getstr(5));
goto end;
}
} else {
errno = 0;
ks->f1 = (size_t) strtoul(f, NULL, 10);
if (errno != 0)
err(2, "-k");
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)
err(2, "-k");
} else {
errno = 0;
ks->c1 = (size_t) strtoul(c, NULL, 10);
if (errno != 0)
err(2, "-k");
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);
}
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);
}
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);
}
static void
fix_obsolete_keys(int *argc, char **argv)
{
char *snew = NULL;
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;
if (asprintf(&snew,
"-k%d.%d%s,%d.%d%s",
f1, c1, sopts1,
f2, c2, sopts2)== -1)
return;
argv[i] = snew;
for (int j = i + 1; j + 1 < *argc; j++)
argv[j] = argv[j + 1];
*argc -= 1;
continue;
}
}
}
asprintf(&snew, "-k%d.%d%s", f1, c1, sopts1);
argv[i] = snew;
}
}
}
}
#if defined(SORT_RANDOM)
static char *
random_md5end(MD5_CTX *ctx)
{
unsigned char digest[MD5_DIGEST_LENGTH];
static const char hex[]="0123456789abcdef";
char *buf;
int i;
buf = malloc(MD5_DIGEST_LENGTH * 2 + 1);
if (!buf)
return NULL;
MD5_Final(digest, ctx);
for (i = 0; i < MD5_DIGEST_LENGTH; i++) {
buf[2*i] = hex[digest[i] >> 4];
buf[2*i+1] = hex[digest[i] & 0x0f];
}
buf[MD5_DIGEST_LENGTH * 2] = '\0';
return buf;
}
static char *
random_fromfile(const char *filename)
{
MD5_CTX ctx;
FILE* fp;
unsigned char buffer[4096];
struct stat st;
off_t size;
int bytes;
fp = openfile(filename, "r");
if (fp == NULL)
return NULL;
if (fstat(fileno(fp), &st) < 0) {
bytes = -1;
goto err;
}
MD5_Init(&ctx);
size = st.st_size;
bytes = 0;
while (size > 0 && (bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) {
MD5_Update(&ctx, buffer, bytes);
size -= bytes;
}
err:
closefile(fp, NULL);
if (bytes < 0)
return NULL;
return (random_md5end(&ctx));
}
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);
MD5_Init(&ctx);
MD5_Update(&ctx, rsd, sz);
random_seed = random_md5end(&ctx);
random_seed_size = strlen(random_seed);
} else {
MD5_CTX ctx;
char *b;
MD5_Init(&ctx);
b = random_fromfile(random_source);
if (b == NULL)
err(2, NULL);
random_seed = b;
random_seed_size = strlen(b);
}
MD5_Init(&md5_ctx);
if(random_seed_size>0) {
MD5_Update(&md5_ctx, random_seed, random_seed_size);
}
}
}
#endif
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();
fix_obsolete_keys(&argc, argv);
while (((c = getopt_long(argc, argv, OPTIONS, long_options, NULL))
!= -1)) {
check_mutually_exclusive_flags(c, mef_flags);
if (!set_sort_modifier(sm, c)) {
switch (c) {
case 'c':
sort_opts_vals.cflag = true;
if (optarg) {
if (!strcmp(optarg, "diagnose-first"))
;
else if (!strcmp(optarg, "silent") ||
!strcmp(optarg, "quiet"))
sort_opts_vals.csilentflag = true;
else if (*optarg)
unknown(optarg);
}
break;
case 'C':
sort_opts_vals.cflag = true;
sort_opts_vals.csilentflag = true;
break;
case 'k':
{
sort_opts_vals.complex_sort = true;
sort_opts_vals.kflag = true;
keys_num++;
keys = sort_realloc(keys, keys_num *
sizeof(struct key_specs));
memset(&(keys[keys_num - 1]), 0,
sizeof(struct key_specs));
if (parse_k(optarg, &(keys[keys_num - 1]))
< 0) {
errc(2, EINVAL, "-k %s", optarg);
}
break;
}
case 'm':
sort_opts_vals.mflag = true;
break;
case 'o':
outfile = sort_realloc(outfile, (strlen(optarg) + 1));
strcpy(outfile, optarg);
break;
case 's':
sort_opts_vals.sflag = true;
break;
case 'S':
available_free_memory =
parse_memory_buffer_value(optarg);
break;
case 'T':
tmpdir = sort_strdup(optarg);
break;
case 't':
while (strlen(optarg) > 1) {
if (optarg[0] != '\\') {
errc(2, EINVAL, "%s", 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;
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');
#if defined(SORT_RANDOM)
else if (!strcmp(optarg, "random"))
set_sort_modifier(sm, 'R');
#endif
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;
#if defined(SORT_RANDOM)
case RANDOMSOURCE_OPT:
random_source = strdup(optarg);
break;
#endif
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)
err(2, "--batch-size");
if (mof >= 2)
max_open_files = (size_t) mof + 1;
}
break;
case VERSION_OPT:
printf("%s\n", VERSION);
exit(EXIT_SUCCESS);
break;
case DEBUG_OPT:
debug_sort = true;
break;
case HELP_OPT:
usage(false);
break;
default:
usage(true);
}
}
}
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 (argv_from_file0) {
argc = argc_from_file0;
argv = argv_from_file0;
}
if (debug_sort) {
printf("Memory to be used for sorting: %llu\n",available_free_memory);
#if defined(SORT_THREADS)
printf("Number of CPUs: %d\n",(int)ncpu);
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);
}
}
#if defined(SORT_RANDOM)
set_random_seed();
#endif
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);
} 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);
}
