/*
* Do file globbing:
* - appends * to (copy of) str if no globbing chars found
* - does expansion, checks for no match, etc.
* - sets *wordsp to array of matching strings
* - returns number of matching strings
*/
static int
x_file_glob(int flags, const char *str, int slen, char ***wordsp)
{
char *toglob;
char **words;
int nwords;
XPtrV w;
struct source *s, *sold;
if (slen < 0)
return 0;
toglob = add_glob(str, slen);
/*
* Convert "foo*" (toglob) to an array of strings (words)
*/
sold = source;
s = pushs(SWSTR, ATEMP);
s->start = s->str = toglob;
source = s;
if (yylex(ONEWORD|UNESCAPE) != LWORD) {
source = sold;
internal_warningf("%s: substitute error", __func__);
return 0;
}
source = sold;
XPinit(w, 32);
expand(yylval.cp, &w, DOGLOB|DOTILDE|DOMARKDIRS);
XPput(w, NULL);
words = (char **) XPclose(w);
for (nwords = 0; words[nwords]; nwords++)
;
if (nwords == 1) {
struct stat statb;
/* Check if file exists, also, check for empty
* result - happens if we tried to glob something
* which evaluated to an empty string (e.g.,
* "$FOO" when there is no FOO, etc).
*/
if ((lstat(words[0], &statb) < 0) ||
words[0][0] == '\0') {
x_free_words(nwords, words);
words = NULL;
nwords = 0;
}
}
afree(toglob, ATEMP);
if (nwords) {
*wordsp = words;
} else if (words) {
x_free_words(nwords, words);
*wordsp = NULL;
}
return nwords;
}
static void
dbteste_error(Test_env *te, int offset, const char *msg)
{
te->flags |= TEF_ERROR;
internal_warningf("dbteste_error: %s (offset %d)", msg, offset);
}
/*
* Print things in columns and rows - func() is called to format
* the i-th element
*/
void
print_columns(struct shf *shf, int n,
char *(*func)(char *, int, int, const void *),
const void *arg, int max_oct, int max_col, bool prefcol)
{
int i, r, c, rows, cols, nspace;
char *str;
if (n <= 0) {
#ifndef MKSH_SMALL
internal_warningf("print_columns called with n=%d <= 0", n);
#endif
return;
}
++max_oct;
str = alloc(max_oct, ATEMP);
/* ensure x_cols is valid first */
if (x_cols < MIN_COLS)
change_winsz();
/*
* We use (max_col + 1) to consider the space separator.
* Note that no space is printed after the last column
* to avoid problems with terminals that have auto-wrap.
*/
cols = x_cols / (max_col + 1);
/* if we can only print one column anyway, skip the goo */
if (cols < 2) {
for (i = 0; i < n; ++i)
shf_fprintf(shf, "%s \n",
(*func)(str, max_oct, i, arg));
goto out;
}
rows = (n + cols - 1) / cols;
if (prefcol && cols > rows) {
i = rows;
rows = cols > n ? n : cols;
cols = i;
}
max_col = -max_col;
nspace = (x_cols + max_col * cols) / cols;
if (nspace <= 0)
nspace = 1;
for (r = 0; r < rows; r++) {
for (c = 0; c < cols; c++) {
i = c * rows + r;
if (i < n) {
shf_fprintf(shf, "%*s", max_col,
(*func)(str, max_oct, i, arg));
if (c + 1 < cols)
shf_fprintf(shf, "%*s", nspace, null);
}
}
shf_putchar('\n', shf);
}
out:
afree(str, ATEMP);
}
/*
* Print things in columns and rows - func() is called to format
* the i-th element
*/
void
print_columns(struct shf *shf, unsigned int n,
void (*func)(char *, size_t, unsigned int, const void *),
const void *arg, size_t max_oct, size_t max_colz, bool prefcol)
{
unsigned int i, r, c, rows, cols, nspace, max_col;
char *str;
if (!n)
return;
if (max_colz > 2147483646) {
#ifndef MKSH_SMALL
internal_warningf("print_columns called with %s=%zu >= INT_MAX",
"max_col", max_colz);
#endif
return;
}
max_col = (unsigned int)max_colz;
if (max_oct > 2147483646) {
#ifndef MKSH_SMALL
internal_warningf("print_columns called with %s=%zu >= INT_MAX",
"max_oct", max_oct);
#endif
return;
}
++max_oct;
str = alloc(max_oct, ATEMP);
/*
* We use (max_col + 2) to consider the separator space.
* Note that no spaces are printed after the last column
* to avoid problems with terminals that have auto-wrap,
* but we need to also take this into account in x_cols.
*/
cols = (x_cols + 1) / (max_col + 2);
/* if we can only print one column anyway, skip the goo */
if (cols < 2) {
for (i = 0; i < n; ++i) {
(*func)(str, max_oct, i, arg);
shf_puts(str, shf);
shf_putc('\n', shf);
}
goto out;
}
rows = (n + cols - 1) / cols;
if (prefcol && cols > rows) {
cols = rows;
rows = (n + cols - 1) / cols;
}
nspace = (x_cols - max_col * cols) / cols;
if (nspace < 2)
nspace = 2;
max_col = -max_col;
for (r = 0; r < rows; r++) {
for (c = 0; c < cols; c++) {
if ((i = c * rows + r) >= n)
break;
(*func)(str, max_oct, i, arg);
if (i + rows >= n)
shf_puts(str, shf);
else
shf_fprintf(shf, "%*s%*s",
max_col, str, nspace, null);
}
shf_putchar('\n', shf);
}
out:
afree(str, ATEMP);
}
int
c_ulimit(char **wp)
{
static const struct limits limits[] = {
/* Do not use options -H, -S or -a or change the order. */
{ "time(cpu-seconds)", RLIMIT_CPU, 1, 't' },
{ "file(blocks)", RLIMIT_FSIZE, 512, 'f' },
{ "coredump(blocks)", RLIMIT_CORE, 512, 'c' },
{ "data(kbytes)", RLIMIT_DATA, 1024, 'd' },
{ "stack(kbytes)", RLIMIT_STACK, 1024, 's' },
{ "lockedmem(kbytes)", RLIMIT_MEMLOCK, 1024, 'l' },
{ "memory(kbytes)", RLIMIT_RSS, 1024, 'm' },
{ "nofiles(descriptors)", RLIMIT_NOFILE, 1, 'n' },
{ "processes", RLIMIT_NPROC, 1, 'p' },
{ NULL }
};
const char *options = "HSat#f#c#d#s#l#m#n#p#";
int how = SOFT | HARD;
const struct limits *l;
int optc, all = 0;
/* First check for -a, -H and -S. */
while ((optc = ksh_getopt(wp, &builtin_opt, options)) != -1)
switch (optc) {
case 'H':
how = HARD;
break;
case 'S':
how = SOFT;
break;
case 'a':
all = 1;
break;
case '?':
return 1;
default:
break;
}
if (wp[builtin_opt.optind] != NULL) {
bi_errorf("usage: ulimit [-acdfHlmnpSst] [value]");
return 1;
}
/* Then parse and act on the actual limits, one at a time */
ksh_getopt_reset(&builtin_opt, GF_ERROR);
while ((optc = ksh_getopt(wp, &builtin_opt, options)) != -1)
switch (optc) {
case 'a':
case 'H':
case 'S':
break;
case '?':
return 1;
default:
for (l = limits; l->name && l->option != optc; l++)
;
if (!l->name) {
internal_warningf("%s: %c", __func__, optc);
return 1;
}
if (builtin_opt.optarg) {
if (set_ulimit(l, builtin_opt.optarg, how))
return 1;
} else
print_ulimit(l, how);
break;
}
wp += builtin_opt.optind;
if (all) {
for (l = limits; l->name; l++) {
shprintf("%-20s ", l->name);
print_ulimit(l, how);
}
} else if (builtin_opt.optind == 1) {
/* No limit specified, use file size */
l = &limits[1];
if (wp[0] != NULL) {
if (set_ulimit(l, wp[0], how))
return 1;
wp++;
} else {
print_ulimit(l, how);
}
}
return 0;
}
