static void
test_f_owner_ex_umove_or_printaddr(const int type, const char *const type_name,
pid_t pid)
{
long rc = test_f_owner_ex_type_pid(ARG_STR(F_SETOWN_EX),
type, type_name, pid);
if (!rc)
test_f_owner_ex_type_pid(ARG_STR(F_GETOWN_EX),
type, type_name, pid);
}
bool_t
Json_spew_json(Obj *dump, Folder *folder, const CharBuf *filename)
{
return (bool_t)Host_callback_i(&JSON, "spew_json", 3,
ARG_OBJ("dump", dump), ARG_OBJ("folder", folder),
ARG_STR("filename", filename));
}
int
main(void)
{
static struct {
kernel_ulong_t cmd;
const char * cmd_str;
} cmd_args[] = {
{ 0, "???" },
{ 4, "???" },
{ (kernel_ulong_t) 0xdeafbeefdeadc0deULL, "???" },
{ 2, "STOP", },
};
static struct {
kernel_ulong_t sig;
const char * sig_str;
} start_sig_args[] = {
{ 0, "SIG_0" },
{ (kernel_ulong_t) 0xfacefeedac0ffeedULL, NULL },
{ ARG_STR(SIGALRM) },
{ 33, "SIGRT_1" },
{ 63, "SIGRT_31" },
};
unsigned int i;
long rc;
for (i = 0; i < ARRAY_SIZE(cmd_args); i++) {
rc = syscall(__NR_s390_runtime_instr, cmd_args[i].cmd, 0xdead);
printf("s390_runtime_instr(%d /* S390_RUNTIME_INSTR_%s */) = "
"%s\n",
(int) cmd_args[i].cmd, cmd_args[i].cmd_str,
sprintrc(rc));
}
for (i = 0; i < ARRAY_SIZE(start_sig_args); i++) {
long saved_errno;
rc = syscall(__NR_s390_runtime_instr, 1, start_sig_args[i].sig);
saved_errno = errno;
printf("s390_runtime_instr(1 /* S390_RUNTIME_INSTR_START */, ");
if (start_sig_args[i].sig_str)
printf("%s", start_sig_args[i].sig_str);
else
printf("%d", (int) start_sig_args[i].sig);
errno = saved_errno;
printf(") = %s\n", sprintrc(rc));
}
puts("+++ exited with 0 +++");
return 0;
}
static void
test_f_owner_ex(void)
{
static const struct {
int type;
const char *type_name;
pid_t pid[2];
} a[] = {
{ ARG_STR(F_OWNER_TID), { 1234567890, 20 } },
{ ARG_STR(F_OWNER_PID), { 1298126790, 30 } },
{ ARG_STR(F_OWNER_PGRP), { 1294567890, 40 } }
};
for (unsigned int i = 0; i < ARRAY_SIZE(a); i++) {
for (unsigned int j = 0; j < ARRAY_SIZE(a[0].pid); j++) {
test_f_owner_ex_umove_or_printaddr(a[i].type,
a[i].type_name,
a[i].pid[j]);
}
}
}
int
main(void)
{
static const kernel_ulong_t flags[] = {
0,
(kernel_ulong_t) 0xbadc0ded00000000ULL,
(kernel_ulong_t) 0xffff0000eeee1111ULL,
(kernel_ulong_t) 0x123456789abcdef0ULL,
};
static const struct {
kernel_ulong_t val;
const char *str;
} rights[] = {
{ (kernel_ulong_t) 0xbadc0ded00000002ULL,
sizeof(kernel_ulong_t) > sizeof(int) ?
"PKEY_DISABLE_WRITE|0xbadc0ded00000000" :
"PKEY_DISABLE_WRITE" },
{ 0xdec0ded, "PKEY_DISABLE_ACCESS|0xdec0dec" },
{ 0x3, "PKEY_DISABLE_ACCESS|PKEY_DISABLE_WRITE" },
{ ARG_STR(0) },
{ 0xbadc0dec, "0xbadc0dec /* PKEY_??? */" },
};
long rc;
unsigned int i;
unsigned int j;
for (i = 0; i < ARRAY_SIZE(flags); i++) {
for (j = 0; j < ARRAY_SIZE(rights); j++) {
rc = syscall(__NR_pkey_alloc, flags[i], rights[j].val);
printf("pkey_alloc(%#llx, %s) = %s\n",
(unsigned long long) flags[i], rights[j].str,
sprintrc(rc));
}
}
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
static const char unterminated1[] = { '\1', '\2', '\3', '\4', '\5' };
static const char unterminated2[] = { '\6', '\7', '\10', '\11', '\12' };
static const char unterminated3[] = { '\16', '\17', '\20', '\21', '\22' };
char *bogus_type = tail_memdup(unterminated1, sizeof(unterminated1));
char *bogus_desc = tail_memdup(unterminated2, sizeof(unterminated2));
char *bogus_payload = tail_memdup(unterminated3, sizeof(unterminated3));
unsigned i;
unsigned j;
unsigned k;
unsigned l;
struct {
const char *type;
const char *str;
} types[] = {
{ ARG_STR(NULL) },
{ bogus_type + sizeof(unterminated1), NULL },
{ bogus_type, NULL },
{ ARG_STR("\20\21\22\23\24") },
{ ARG_STR("user") },
};
struct {
const char *desc;
const char *str;
} descs[] = {
{ ARG_STR(NULL) },
{ bogus_desc + sizeof(unterminated2), NULL },
{ bogus_desc, NULL },
{ ARG_STR("\25\26\27\30\31") },
{ ARG_STR("desc") },
{ "overly long description", STRINGIFY("overly long ") "..." },
};
struct {
const char *pload;
const char *str;
size_t plen;
} payloads[] = {
{ ARG_STR(NULL), 0 },
{ bogus_payload + sizeof(unterminated3), NULL,
(size_t) 0xdeadbeefbadc0dedULL },
{ bogus_payload, STRINGIFY(""), 0 },
{ bogus_payload, STRINGIFY("\16\17\20\21\22"), 5 },
{ bogus_payload, NULL, 10 },
{ "overly long payload", STRINGIFY("overly long ") "...", 15 },
};
struct {
uint32_t keyring;
const char *str;
} keyrings[] = {
{ ARG_STR(0) },
{ ARG_STR(1234567890) },
{ ARG_STR(-1234567890) },
{ -1, "KEY_SPEC_THREAD_KEYRING" },
};
for (i = 0; i < ARRAY_SIZE(types); i++)
for (j = 0; j < ARRAY_SIZE(descs); j++)
for (k = 0; k < ARRAY_SIZE(payloads); k++)
for (l = 0; l < ARRAY_SIZE(keyrings); l++)
do_add_key(types[i].type, types[i].str,
descs[j].desc, descs[j].str,
payloads[k].pload,
payloads[k].str,
payloads[k].plen,
keyrings[l].keyring,
keyrings[l].str);
puts("+++ exited with 0 +++");
return 0;
}
static vmResult
alsa_init(void)
{
command_symbol_table *alsacommands =
command_symbol_table_new(_("ALSA Sound Mixer Options"),
_("These commands control the ALSA 99/4A sound module"),
command_symbol_new("ALSADevice",
_("Specify ALSA PCM drivere"),
c_STATIC,
alsa_change_device,
NULL /* ret */ ,
command_arg_new_string
(_("device"),
_("device to use for PCM sound; e.g. 'plughw:0,0' "),
NULL /* action */ ,
ARG_STR(pcm_name),
NULL /* next */ )
,
command_symbol_new("RecordSoundToFile",
_("Record soundtrack to a file"),
c_DONT_SAVE,
alsa_record_sound,
NULL /* ret */ ,
command_arg_new_string
(_("file"),
_("file to receive sound; "
"if file exists, new data will be appended to it; "
"if no extension is given, one will be added that details "
"the RAW sound format used"),
alsa_add_file_extension
/* action */ ,
NEW_ARG_STR(OS_PATHSIZE),
NULL /* next */ )
,
command_symbol_new
("PausingSoundRecording",
_("Pause or resume soundtrack recording (does not close sound file)"),
c_DONT_SAVE,
alsa_pause_sound
/* action */ ,
RET_FIRST_ARG,
command_arg_new_num
(_("state"),
_("whether recording is paused"),
NULL /* action */ ,
ARG_NUM(alsa_paused),
NULL /* next */ )
,
command_symbol_new
("StopSoundRecording",
_("Stop soundtrack recording and close sound file"),
c_DONT_SAVE,
alsa_stop_recording,
NULL /* ret */ ,
NULL /* args */
,
NULL /* next */ )))),
NULL /* sub */ ,
NULL /* next */
);
command_symbol_table_add_subtable(universe, alsacommands);
strcpy(pcm_name, "default");
alsa_sndf = 0;
alsa_paused = 0;
return vmOk;
}
int
main(void)
{
static const kernel_ulong_t unknown_perf_cmd =
(kernel_ulong_t) 0xbadc0dedfeed24edULL;
static const kernel_ulong_t magic =
(kernel_ulong_t) 0xdeadbeefbadc0dedULL;
static const uint64_t magic64 = 0xfacefeeddeadc0deULL;
static const char str[] = STR16 STR16 STR16 STR16;
static struct {
unsigned int cmd;
const char *str;
} flag_iocs[] = {
{ ARG_STR(PERF_EVENT_IOC_ENABLE) },
{ ARG_STR(PERF_EVENT_IOC_DISABLE) },
{ ARG_STR(PERF_EVENT_IOC_RESET) },
};
TAIL_ALLOC_OBJECT_CONST_PTR(uint64_t, u64_ptr);
uint64_t *const u64_efault = u64_ptr + 1;
uint32_t *const u32_arr = tail_alloc(sizeof(uint32_t) * 4);
uint32_t *const u32_efault = u32_arr + 4;
char *const str_ptr = tail_memdup(str, sizeof(str));
char *const str_efault = str_ptr + sizeof(str);
TAIL_ALLOC_OBJECT_CONST_PTR(struct perf_event_attr, pea_ptr);
*u64_ptr = magic64;
fill_memory_ex(pea_ptr, sizeof(*pea_ptr), 0xaa, 0x55);
/* Unknown perf commands */
sys_ioctl(-1, unknown_perf_cmd, magic);
printf("ioctl(-1, _IOC(_IOC_READ|_IOC_WRITE%s, 0x24, %#x, %#x), "
"%#lx) = -1 EBADF (%m)\n",
_IOC_DIR((unsigned int) unknown_perf_cmd) & _IOC_NONE ?
"|_IOC_NONE" : "",
_IOC_NR((unsigned int) unknown_perf_cmd),
_IOC_SIZE((unsigned int) unknown_perf_cmd),
(unsigned long) magic);
sys_ioctl(-1, PERF_EVENT_IOC_MODIFY_ATTRIBUTES + 1, magic);
printf("ioctl(-1, _IOC(_IOC_WRITE, 0x24, %#x, %#x), %#lx)"
" = -1 EBADF (%m)\n",
(unsigned int) _IOC_NR(PERF_EVENT_IOC_MODIFY_ATTRIBUTES + 1),
(unsigned int) _IOC_SIZE(PERF_EVENT_IOC_MODIFY_ATTRIBUTES + 1),
(unsigned long) magic);
/* PERF_EVENT_IOC_{ENABLE,DISABLE,RESET} */
for (unsigned i = 0; i < ARRAY_SIZE(flag_iocs); i++) {
ioctl(-1, flag_iocs[i].cmd, 0);
printf("ioctl(-1, %s, 0) = -1 EBADF (%m)\n", flag_iocs[i].str);
ioctl(-1, flag_iocs[i].cmd, 1);
printf("ioctl(-1, %s, PERF_IOC_FLAG_GROUP) = -1 EBADF (%m)\n",
flag_iocs[i].str);
ioctl(-1, flag_iocs[i].cmd, 2);
printf("ioctl(-1, %s, 0x2 /* PERF_IOC_FLAG_??? */) "
"= -1 EBADF (%m)\n",
flag_iocs[i].str);
sys_ioctl(-1, flag_iocs[i].cmd, magic);
printf("ioctl(-1, %s, PERF_IOC_FLAG_GROUP|%#x) "
"= -1 EBADF (%m)\n",
flag_iocs[i].str, (unsigned int) magic & ~1U);
}
/* PERF_EVENT_IOC_REFRESH */
sys_ioctl(-1, PERF_EVENT_IOC_REFRESH, magic);
printf("ioctl(-1, PERF_EVENT_IOC_REFRESH, %d) = -1 EBADF (%m)\n",
(int) magic);
/* PERF_EVENT_IOC_PERIOD */
ioctl(-1, PERF_EVENT_IOC_PERIOD, NULL);
printf("ioctl(-1, PERF_EVENT_IOC_PERIOD, NULL) = -1 EBADF (%m)\n");
ioctl(-1, PERF_EVENT_IOC_PERIOD, u64_efault);
printf("ioctl(-1, PERF_EVENT_IOC_PERIOD, %p) = -1 EBADF (%m)\n",
u64_efault);
ioctl(-1, PERF_EVENT_IOC_PERIOD, u64_ptr);
printf("ioctl(-1, PERF_EVENT_IOC_PERIOD, [%" PRIu64 "])"
" = -1 EBADF (%m)\n",
magic64);
/* PERF_EVENT_IOC_SET_OUTPUT */
sys_ioctl(-1, PERF_EVENT_IOC_SET_OUTPUT, magic);
printf("ioctl(-1, PERF_EVENT_IOC_SET_OUTPUT, %d) = -1 EBADF (%m)\n",
(int) magic);
/* PERF_EVENT_IOC_SET_FILTER */
ioctl(-1, PERF_EVENT_IOC_SET_FILTER, NULL);
printf("ioctl(-1, PERF_EVENT_IOC_SET_FILTER, NULL) = -1 EBADF (%m)\n");
ioctl(-1, PERF_EVENT_IOC_SET_FILTER, str_efault);
printf("ioctl(-1, PERF_EVENT_IOC_SET_FILTER, %p) = -1 EBADF (%m)\n",
str_efault);
ioctl(-1, PERF_EVENT_IOC_SET_FILTER, str_ptr);
printf("ioctl(-1, PERF_EVENT_IOC_SET_FILTER, \"%.32s\"...)"
" = -1 EBADF (%m)\n",
str_ptr);
ioctl(-1, PERF_EVENT_IOC_SET_FILTER, str_ptr + 40);
printf("ioctl(-1, PERF_EVENT_IOC_SET_FILTER, \"%.32s\")"
" = -1 EBADF (%m)\n",
str_ptr + 40);
str_ptr[sizeof(str) - 1] = '0';
ioctl(-1, PERF_EVENT_IOC_SET_FILTER, str_ptr + 40);
printf("ioctl(-1, PERF_EVENT_IOC_SET_FILTER, %p)"
" = -1 EBADF (%m)\n",
str_ptr + 40);
/* PERF_EVENT_IOC_ID */
ioctl(-1, PERF_EVENT_IOC_ID, NULL);
printf("ioctl(-1, PERF_EVENT_IOC_ID, NULL) = -1 EBADF (%m)\n");
ioctl(-1, PERF_EVENT_IOC_ID, u64_efault);
printf("ioctl(-1, PERF_EVENT_IOC_ID, %p) = -1 EBADF (%m)\n",
u64_efault);
ioctl(-1, PERF_EVENT_IOC_ID, u64_ptr);
printf("ioctl(-1, PERF_EVENT_IOC_ID, %p) = -1 EBADF (%m)\n",
u64_ptr);
/* PERF_EVENT_IOC_SET_BPF */
sys_ioctl(-1, PERF_EVENT_IOC_SET_BPF, magic);
printf("ioctl(-1, PERF_EVENT_IOC_SET_BPF, %d) = -1 EBADF (%m)\n",
(int) magic);
/* PERF_EVENT_IOC_PAUSE_OUTPUT */
sys_ioctl(-1, PERF_EVENT_IOC_PAUSE_OUTPUT, magic);
printf("ioctl(-1, PERF_EVENT_IOC_PAUSE_OUTPUT, %lu) = -1 EBADF (%m)\n",
(unsigned long) magic);
/* PERF_EVENT_IOC_QUERY_BPF */
ioctl(-1, PERF_EVENT_IOC_QUERY_BPF, NULL);
printf("ioctl(-1, PERF_EVENT_IOC_QUERY_BPF, NULL) = -1 EBADF (%m)\n");
ioctl(-1, PERF_EVENT_IOC_QUERY_BPF, u32_efault);
printf("ioctl(-1, PERF_EVENT_IOC_QUERY_BPF, %p) = -1 EBADF (%m)\n",
u32_efault);
u32_arr[0] = 0xbadc0ded;
ioctl(-1, PERF_EVENT_IOC_QUERY_BPF, u32_arr);
printf("ioctl(-1, PERF_EVENT_IOC_QUERY_BPF, {ids_len=3134983661, ...})"
" = -1 EBADF (%m)\n");
/* PERF_EVENT_IOC_MODIFY_ATTRIBUTES */
ioctl(-1, PERF_EVENT_IOC_MODIFY_ATTRIBUTES, NULL);
printf("ioctl(-1, PERF_EVENT_IOC_MODIFY_ATTRIBUTES, NULL)"
" = -1 EBADF (%m)\n");
ioctl(-1, PERF_EVENT_IOC_MODIFY_ATTRIBUTES, pea_ptr + 1);
printf("ioctl(-1, PERF_EVENT_IOC_MODIFY_ATTRIBUTES, %p)"
" = -1 EBADF (%m)\n",
pea_ptr + 1);
printf("ioctl(-1, PERF_EVENT_IOC_MODIFY_ATTRIBUTES"
", {type=%#x /* PERF_TYPE_??? */"
", size=%#x /* PERF_ATTR_SIZE_??? */"
", config=%#llx, ...}) = -1 EBADF (%m)\n",
(unsigned int) pea_ptr->type,
(unsigned int) pea_ptr->size,
(unsigned long long) pea_ptr->config);
ioctl(-1, PERF_EVENT_IOC_MODIFY_ATTRIBUTES, pea_ptr);
puts("+++ exited with 0 +++");
return 0;
}
void
format (struct obstack *obs, int argc, token_data **argv)
{
#ifdef HAVE_EFGCVT
const char *fmt; /* format control string */
int c; /* a simple character */
char fc; /* format code */
/* Flags. */
char flags; /* 1 iff treating flags */
char ljust; /* left justification */
char mandsign; /* mandatory sign */
char noplus; /* use space if no sign */
char alternate; /* use alternate form */
char zeropad; /* do zero padding */
char plus; /* plus-sign, according to mandatory and noplus */
/* Precision specifiers. */
int width; /* minimum field width */
int prec; /* precision */
int maxch; /* maximum no. of chars to print */
char lflag; /* long flag */
char hflag; /* short flag */
/* Different parts of each specification. */
char sign; /* wanted sign, iff any */
int ppad; /* pre-prefix zero padding */
const char *prefix; /* value prefix */
int lpad; /* zero padding on the left */
register char *s; /* ptr to formatted text */
int rpad; /* zero padding on the rigth*/
const char *suffix; /* value suffix */
/* Buffer and stuff. */
char str[MAXFIELD]; /* buffer for formatted text */
int length; /* length of str */
int padding; /* padding at the left or rigth */
register int i; /* an index */
/* Length of trailing string in str. */
#define LENGTH(s) (&str[MAXFIELD-1] - (s))
#define HAS_SIGN (sign != '\0')
fmt = ARG_STR (argc, argv);
for (;;)
{
while ((c = *fmt++) != '%')
{
if (c == 0)
return;
obstack_1grow (obs, c);
}
if (*fmt == '%')
{
obstack_1grow (obs, '%');
fmt++;
continue;
}
/* Parse flags. */
flags = 1;
ljust = mandsign = noplus = alternate = zeropad = 0;
do
{
switch (*fmt)
{
case '-': /* left justification */
ljust = 1;
break;
case '+': /* mandatory sign */
mandsign = 1;
break;
case ' ': /* space instead of positive sign */
noplus = 1;
break;
case '0': /* zero padding */
zeropad = 1;
break;
case '#': /* alternate output */
alternate = 1;
break;
default:
flags = 0;
break;
}
}
while (flags && fmt++);
plus = '\0'; /* what to use as a plus ??? */
if (mandsign)
plus = '+';
else if (noplus)
plus = ' ';
if (ljust)
zeropad = 0;
/* Minimum field width. */
width = -1;
if (*fmt == '*')
{
width = ARG_INT (argc, argv);
fmt++;
}
else if (isdigit (*fmt))
{
width = 0;
do
{
width = width * 10 + *fmt++ - '0';
}
while (isdigit (*fmt));
}
/* Maximum precision. */
prec = -1;
if (*fmt == '.')
{
if (*(++fmt) == '*')
{
prec = ARG_INT (argc, argv);
++fmt;
}
else if (isdigit (*fmt))
{
prec = 0;
do
{
prec = prec * 10 + *fmt++ - '0';
}
while (isdigit (*fmt))
;
}
}
/* Length modifiers. */
lflag = (*fmt == 'l');
hflag = (*fmt == 'h');
if (lflag || hflag)
fmt++;
sign = '\0';
ppad = lpad = rpad = 0;
maxch = -1;
prefix = suffix = "";
switch (fc = *fmt++)
{
case '\0':
return;
case 'c':
c = ARG_INT (argc, argv);
str[0] = (unsigned char) c;
str[1] = '\0';
s = str;
break;
case 's':
s = ARG_STR (argc, argv);
maxch = prec;
break;
case 'd':
case 'i':
if (lflag)
{
long val = ARG_LONG (argc, argv);
if (val < 0)
{
val = -val; /* does not work for MINLONG */
sign = '-';
}
else
sign = plus;
s = ulong_to_str ((unsigned long) val, str, 10, digits);
}
else
{
int val = ARG_INT (argc, argv);
if (hflag)
val = (short) val;
if (val < 0)
{
val = -val; /* does not work for MININT */
sign = '-';
}
else
sign = plus;
s = ulong_to_str ((unsigned long) val, str, 10, digits);
}
if (zeropad)
lpad = width - LENGTH (s) - HAS_SIGN;
break;
case 'o':
if (lflag)
{
unsigned long val = ARG_ULONG (argc, argv);
s = ulong_to_str ((unsigned long) val, str, 8, digits);
}
else
{
unsigned int val = ARG_UINT (argc, argv);
if (hflag)
val = (unsigned short) val;
s = ulong_to_str ((unsigned long) val, str, 8, digits);
}
if (alternate)
prefix = "0";
if (zeropad)
lpad = width - LENGTH (s) - alternate;
break;
case 'x':
case 'X':
if (lflag)
{
unsigned long val = ARG_ULONG (argc, argv);
s = ulong_to_str ((unsigned long) val, str, 16,
(fc == 'x') ? digits : Digits);
}
else
{
unsigned int val = ARG_UINT (argc, argv);
if (hflag)
val = (unsigned short) val;
s = ulong_to_str ((unsigned long) val, str, 16,
(fc == 'x') ? digits : Digits);
}
if (alternate)
prefix = (fc == 'X') ? "0X" : "0x";
if (zeropad)
lpad = width - LENGTH (s) - 2*alternate;
break;
case 'u':
if (lflag)
{
unsigned long val = ARG_ULONG (argc, argv);
s = ulong_to_str ((unsigned long) val, str, 10, digits);
}
else
{
unsigned int val = ARG_UINT (argc, argv);
if (hflag)
val = (unsigned short) val;
s = ulong_to_str ((unsigned long) val, str, 10, digits);
}
if (zeropad)
lpad = width - LENGTH (s);
break;
case 'e':
case 'E':
{
char *t;
int sgn, decpt, exp, n;
double val = ARG_DOUBLE (argc, argv);
if (prec < 0)
prec = 6;
t = clr0 (ecvt (val, min (prec + 1, ECVTMAX), &decpt, &sgn));
sign = sgn ? '-' : plus;
n = prec;
s = str;
exp = (t[0] == '0' && t[1] == '\0') ? 0 : decpt - 1;
*s++ = *t++;
if (n > 0 || alternate)
*s++ = '.';
while (*t != '\0' && --n >= 0)
*s++ = *t++;
*s = '\0';
rpad = n;
sgn = 0;
if (exp < 0)
{
exp = -exp;
sgn = 1;
}
t = ulong_to_str ((unsigned long) exp, str, 10, digits);
if (exp < 10)
*--t = '0'; /* always at least two digits */
*--t = sgn ? '-' : '+';
*--t = fc;
if (zeropad)
{
lpad = width - HAS_SIGN - (s - str) - LENGTH (t);
if (rpad > 0)
lpad -= rpad;
}
suffix = t;
s = str;
}
break;
case 'f':
{
const char *t;
int sgn, decpt, n;
double val = ARG_DOUBLE (argc, argv);
if (prec < 0)
prec = 6;
/* FIXME: For the following line, Dave Anglin reports
``warning: passing arg 1 of `clr0' discards `const' from
pointer target type''. I suspect fcvt might be declared
as returning const on some systems. Pouah! I should
revise this whole module, one of these days... */
t = clr0 (fcvt (val, min (prec, FCVTMAX), &decpt, &sgn));
sign = sgn ? '-' : plus;
n = prec;
s = str;
if (decpt <= 0)
{
prefix = (n > 0 || alternate) ? "0." : "0";
lpad = min (-decpt, prec);
n -= lpad;
}
else
{
while (--decpt >= 0)
*s++ = *t++;
if (n > 0 || alternate)
*s++ = '.';
}
while (*t && --n >= 0)
*s++ = *t++;
*s = '\0';
rpad = n;
if (zeropad)
ppad = width - HAS_SIGN - (prefix[1] ? 2 : 1) - lpad -
(s - str) - rpad;
s = str;
}
break;
default:
continue;
}
if (lpad < 0)
lpad = 0;
if (rpad < 0)
rpad = 0;
if (width < 0)
width = 0;
i = strlen (s);
if (maxch <= 0 || maxch > i)
maxch = i;
length = (HAS_SIGN + ppad + strlen (prefix) + lpad + maxch
+ rpad + strlen (suffix));
padding = 0;
if (width != 0)
{
padding = width - length;
}
if (ljust == 0) /* left padding */
for (i = padding; --i >= 0;)
obstack_1grow (obs, ' ');
if (HAS_SIGN) /* sign */
obstack_1grow (obs, sign);
for (i = ppad; --i >= 0;) /* pre-prefix zero padding */
obstack_1grow (obs, '0');
for (; *prefix; ++prefix) /* prefix */
obstack_1grow (obs, *prefix);
for (i = lpad; --i >= 0;) /* left zero padding */
obstack_1grow (obs, '0');
for (i = maxch; --i >= 0; ++s) /* actual text */
obstack_1grow (obs, *s);
for (i = rpad; --i >= 0;) /* right zero padding */
obstack_1grow (obs, '0');
for (; *suffix; ++suffix) /* suffix */
obstack_1grow (obs, *suffix);
if (ljust != 0) /* right padding */
for (i = padding; --i >= 0;)
obstack_1grow (obs, ' ');
}
#else /* not HAVE_EFGCVT */
char *fmt; /* format control string */
const char *fstart; /* beginning of current format spec */
int c; /* a simple character */
/* Flags. */
char flags; /* 1 iff treating flags */
/* Precision specifiers. */
int width; /* minimum field width */
int prec; /* precision */
char lflag; /* long flag */
char hflag; /* short flag */
/* Buffer and stuff. */
char str[256]; /* buffer for formatted text */
enum {INT, UINT, LONG, ULONG, DOUBLE, STR} datatype;
fmt = ARG_STR (argc, argv);
for (;;)
{
while ((c = *fmt++) != '%')
{
if (c == 0)
return;
obstack_1grow (obs, c);
}
fstart = fmt - 1;
if (*fmt == '%')
{
obstack_1grow (obs, '%');
fmt++;
continue;
}
/* Parse flags. */
flags = 1;
do
{
switch (*fmt)
{
case '-': /* left justification */
case '+': /* mandatory sign */
case ' ': /* space instead of positive sign */
case '0': /* zero padding */
case '#': /* alternate output */
break;
default:
flags = 0;
break;
}
}
while (flags && fmt++);
/* Minimum field width. */
width = -1;
if (*fmt == '*')
{
width = ARG_INT (argc, argv);
fmt++;
}
else if (isdigit (*fmt))
{
do
{
fmt++;
}
while (isdigit (*fmt));
}
/* Maximum precision. */
prec = -1;
if (*fmt == '.')
{
if (*(++fmt) == '*')
{
prec = ARG_INT (argc, argv);
++fmt;
}
else if (isdigit (*fmt))
{
do
{
fmt++;
}
while (isdigit (*fmt));
}
}
/* Length modifiers. */
lflag = (*fmt == 'l');
hflag = (*fmt == 'h');
if (lflag || hflag)
fmt++;
switch (*fmt++)
{
case '\0':
return;
case 'c':
datatype = INT;
break;
case 's':
datatype = STR;
break;
case 'd':
case 'i':
if (lflag)
{
datatype = LONG;
}
else
{
datatype = INT;
}
break;
case 'o':
case 'x':
case 'X':
case 'u':
if (lflag)
{
datatype = ULONG;
}
else
{
datatype = UINT;
}
break;
case 'e':
case 'E':
case 'f':
datatype = DOUBLE;
break;
default:
continue;
}
c = *fmt;
*fmt = '\0';
switch(datatype)
{
case INT:
if (width != -1 && prec != -1)
sprintf (str, fstart, width, prec, ARG_INT(argc, argv));
else if (width != -1)
sprintf (str, fstart, width, ARG_INT(argc, argv));
else if (prec != -1)
sprintf (str, fstart, prec, ARG_INT(argc, argv));
else
sprintf (str, fstart, ARG_INT(argc, argv));
break;
case UINT:
if (width != -1 && prec != -1)
sprintf (str, fstart, width, prec, ARG_UINT(argc, argv));
else if (width != -1)
sprintf (str, fstart, width, ARG_UINT(argc, argv));
else if (prec != -1)
sprintf (str, fstart, prec, ARG_UINT(argc, argv));
else
sprintf (str, fstart, ARG_UINT(argc, argv));
break;
case LONG:
if (width != -1 && prec != -1)
sprintf (str, fstart, width, prec, ARG_LONG(argc, argv));
else if (width != -1)
sprintf (str, fstart, width, ARG_LONG(argc, argv));
else if (prec != -1)
sprintf (str, fstart, prec, ARG_LONG(argc, argv));
else
sprintf (str, fstart, ARG_LONG(argc, argv));
break;
case ULONG:
if (width != -1 && prec != -1)
sprintf (str, fstart, width, prec, ARG_ULONG(argc, argv));
else if (width != -1)
sprintf (str, fstart, width, ARG_ULONG(argc, argv));
else if (prec != -1)
sprintf (str, fstart, prec, ARG_ULONG(argc, argv));
else
sprintf (str, fstart, ARG_ULONG(argc, argv));
break;
case DOUBLE:
if (width != -1 && prec != -1)
sprintf (str, fstart, width, prec, ARG_DOUBLE(argc, argv));
else if (width != -1)
sprintf (str, fstart, width, ARG_DOUBLE(argc, argv));
else if (prec != -1)
sprintf (str, fstart, prec, ARG_DOUBLE(argc, argv));
else
sprintf (str, fstart, ARG_DOUBLE(argc, argv));
break;
case STR:
if (width != -1 && prec != -1)
sprintf (str, fstart, width, prec, ARG_STR(argc, argv));
else if (width != -1)
sprintf (str, fstart, width, ARG_STR(argc, argv));
else if (prec != -1)
sprintf (str, fstart, prec, ARG_STR(argc, argv));
else
sprintf (str, fstart, ARG_STR(argc, argv));
break;
}
*fmt = c;
obstack_grow (obs, str, strlen (str));
}
#endif /* not HAVE_EFGCVT */
}
int
main(void)
{
char bogus_special_str[sizeof(void *) * 2 + sizeof("0x")];
char bogus_addr_str[sizeof(void *) * 2 + sizeof("0x")];
char unterminated_str[sizeof(void *) * 2 + sizeof("0x")];
long rc;
struct fs_disk_quota *xdq = tail_alloc(sizeof(*xdq));
struct fs_quota_stat *xqstat = tail_alloc(sizeof(*xqstat));
struct fs_quota_statv *xqstatv = tail_alloc(sizeof(*xqstatv));
uint32_t *flags = tail_alloc(sizeof(*flags));
char *unterminated = tail_memdup(unterminated_data,
sizeof(unterminated_data));
snprintf(bogus_special_str, sizeof(bogus_special_str), "%p",
bogus_special);
snprintf(bogus_addr_str, sizeof(bogus_addr_str), "%p",
bogus_addr);
snprintf(unterminated_str, sizeof(unterminated_str), "%p",
unterminated);
/* Q_XQUOTAON */
*flags = 0xdeadbeef;
check_quota(CQF_ID_SKIP | CQF_ADDR_STR,
ARG_STR(QCMD(Q_XQUOTAON, USRQUOTA)),
ARG_STR("/dev/bogus/"), flags,
"[XFS_QUOTA_UDQ_ACCT|XFS_QUOTA_UDQ_ENFD"
"|XFS_QUOTA_GDQ_ACCT|XFS_QUOTA_GDQ_ENFD"
"|XFS_QUOTA_PDQ_ENFD|0xdeadbec0]");
rc = syscall(__NR_quotactl, QCMD(Q_XQUOTAON, 0xfacefeed), bogus_dev,
bogus_id, bogus_addr);
printf("quotactl(QCMD(Q_XQUOTAON, %#x /* ???QUOTA */)"
", %s, %p) = %s\n",
QCMD_TYPE(QCMD(Q_XQUOTAON, 0xfacefeed)),
bogus_dev_str, bogus_addr, sprintrc(rc));
/* Q_XQUOTAOFF */
check_quota(CQF_ID_SKIP | CQF_ADDR_STR,
ARG_STR(QCMD(Q_XQUOTAOFF, USRQUOTA)),
bogus_special, bogus_special_str,
bogus_addr, bogus_addr_str);
check_quota(CQF_ID_SKIP | CQF_ADDR_STR,
ARG_STR(QCMD(Q_XQUOTAOFF, GRPQUOTA)),
ARG_STR("/dev/bogus/"),
ARG_STR(NULL));
check_quota(CQF_ID_SKIP | CQF_ADDR_STR,
QCMD(Q_XQUOTAOFF, 3),
"QCMD(Q_XQUOTAOFF, 0x3 /* ???QUOTA */)",
ARG_STR("/dev/bogus/"), flags,
"[XFS_QUOTA_UDQ_ACCT|XFS_QUOTA_UDQ_ENFD"
"|XFS_QUOTA_GDQ_ACCT|XFS_QUOTA_GDQ_ENFD"
"|XFS_QUOTA_PDQ_ENFD|0xdeadbec0]");
/* Q_XGETQUOTA */
/* Trying our best to get successful result */
check_quota(CQF_ADDR_CB, ARG_STR(QCMD(Q_GETQUOTA, USRQUOTA)),
ARG_STR("/dev/sda1"), getuid(), xdq, print_xdisk_quota,
(intptr_t) 1);
check_quota(CQF_ADDR_CB, ARG_STR(QCMD(Q_GETQUOTA, GRPQUOTA)),
ARG_STR(NULL), -1, xdq, print_xdisk_quota, (intptr_t) 2);
/* Q_XGETNEXTQUOTA */
check_quota(CQF_ADDR_CB, ARG_STR(QCMD(Q_XGETNEXTQUOTA, USRQUOTA)),
ARG_STR("/dev/sda1"), 0, xdq, print_xdisk_quota,
(intptr_t) 1);
/* Q_XSETQLIM */
check_quota(CQF_NONE, ARG_STR(QCMD(Q_XSETQLIM, PRJQUOTA)),
bogus_special, bogus_special_str, 0, bogus_addr);
fill_memory_ex((char *) xdq, sizeof(*xdq), 0x8e);
check_quota(CQF_ADDR_CB, ARG_STR(QCMD(Q_XSETQLIM, PRJQUOTA)),
bogus_dev, bogus_dev_str, 3141592653U,
xdq, print_xdisk_quota, (intptr_t) 0);
/* Q_XGETQSTAT */
check_quota(CQF_ID_SKIP | CQF_ADDR_CB,
ARG_STR(QCMD(Q_XGETQSTAT, USRQUOTA)),
ARG_STR("/dev/sda1"), xqstat, print_xquota_stat, (intptr_t) 1);
check_quota(CQF_ID_SKIP | CQF_ADDR_CB,
ARG_STR(QCMD(Q_XGETQSTATV, PRJQUOTA)),
unterminated, unterminated_str,
xqstat + 1, print_xquota_stat, (intptr_t) 2);
/* Q_XGETQSTATV */
check_quota(CQF_ID_SKIP | CQF_ADDR_CB,
ARG_STR(QCMD(Q_XGETQSTAT, USRQUOTA)),
ARG_STR("/dev/sda1"), xqstatv, print_xquota_statv, 1);
check_quota(CQF_ID_SKIP | CQF_ADDR_CB,
ARG_STR(QCMD(Q_XGETQSTATV, GRPQUOTA)),
ARG_STR(NULL), xqstatv, print_xquota_statv, (intptr_t) 2);
/* Q_XQUOTARM */
check_quota(CQF_ID_SKIP | CQF_ADDR_STR,
ARG_STR(QCMD(Q_XQUOTARM, PRJQUOTA)),
bogus_special, bogus_special_str, ARG_STR(NULL));
check_quota(CQF_ID_SKIP,
ARG_STR(QCMD(Q_XQUOTARM, USRQUOTA)),
unterminated, unterminated_str, flags + 1);
*flags = 0xdeadbeef;
check_quota(CQF_ID_SKIP | CQF_ADDR_STR,
ARG_STR(QCMD(Q_XQUOTARM, GRPQUOTA)),
ARG_STR(NULL), flags,
"[XFS_USER_QUOTA|XFS_PROJ_QUOTA"
"|XFS_GROUP_QUOTA|0xdeadbee8]");
/* Q_XQUOTASYNC */
check_quota(CQF_ID_SKIP | CQF_ADDR_SKIP,
ARG_STR(QCMD(Q_XQUOTASYNC, USRQUOTA)),
bogus_special, bogus_special_str);
check_quota(CQF_ID_SKIP | CQF_ADDR_SKIP,
QCMD(Q_XQUOTASYNC, 0xfff),
"QCMD(Q_XQUOTASYNC, 0xff /* ???QUOTA */)",
ARG_STR(NULL));
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
static const char unterminated1[] = { '\1', '\2', '\3', '\4', '\5' };
static const char unterminated2[] = { '\6', '\7', '\10', '\11', '\12' };
static const char unterminated3[] = { '\16', '\17', '\20', '\21', '\22' };
char *bogus_type = tail_memdup(unterminated1, sizeof(unterminated1));
char *bogus_desc = tail_memdup(unterminated2, sizeof(unterminated2));
char *bogus_info = tail_memdup(unterminated3, sizeof(unterminated3));
unsigned i;
unsigned j;
unsigned k;
unsigned l;
struct {
const char *type;
const char *str;
} types[] = {
{ ARG_STR(NULL) },
{ bogus_type + sizeof(unterminated1), NULL },
{ bogus_type, NULL },
{ ARG_STR("\20\21\22\23\24") },
{ ARG_STR("user") },
};
struct {
const char *desc;
const char *str;
} descs[] = {
{ ARG_STR(NULL) },
{ bogus_desc + sizeof(unterminated2), NULL },
{ bogus_desc, NULL },
{ ARG_STR("\25\26\27\30\31") },
{ ARG_STR("desc") },
{ "overly long description", STRINGIFY("overly long ") "..." },
};
struct {
const char *info;
const char *str;
} infos[] = {
{ ARG_STR(NULL) },
{ bogus_info + sizeof(unterminated3), NULL },
{ bogus_info, NULL },
{ ARG_STR("\32\33\34\35\36") },
{ ARG_STR("info") },
{ "overly long info", STRINGIFY("overly long ") "..." },
};
struct {
uint32_t keyring;
const char *str;
} keyrings[] = {
{ ARG_STR(0) },
{ ARG_STR(1234567890) },
{ ARG_STR(-1234567890) },
{ -1, "KEY_SPEC_THREAD_KEYRING" },
};
for (i = 0; i < ARRAY_SIZE(types); i++)
for (j = 0; j < ARRAY_SIZE(descs); j++)
for (k = 0; k < ARRAY_SIZE(infos); k++)
for (l = 0; l < ARRAY_SIZE(keyrings); l++)
do_request_key(
types[i].type, types[i].str,
descs[j].desc, descs[j].str,
infos[k].info, infos[k].str,
keyrings[l].keyring,
keyrings[l].str);
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
TAIL_ALLOC_OBJECT_CONST_PTR(struct ip_mreq, m4);
TAIL_ALLOC_OBJECT_CONST_PTR(struct ipv6_mreq, m6);
unsigned int i;
int rc;
inet_pton(AF_INET, multi4addr, &m4->imr_multiaddr);
inet_pton(AF_INET, interface, &m4->imr_interface);
inet_pton(AF_INET6, multi6addr, &m6->ipv6mr_multiaddr);
m6->ipv6mr_interface = ifindex_lo();
if (!m6->ipv6mr_interface)
perror_msg_and_skip("lo");
(void) close(0);
if (socket(AF_INET, SOCK_DGRAM, 0))
perror_msg_and_skip("socket");
struct {
const int level;
const char *const str_level;
const int name;
const char *str_name;
const void *const val;
unsigned int size;
const char *const addr;
} opts[] = {
{
ARG_STR(SOL_IP), ARG_STR(IP_ADD_MEMBERSHIP),
m4, sizeof(*m4),
"{imr_multiaddr=inet_addr(\"" multi4addr
"\"), imr_interface=inet_addr(\"" interface "\")}"
},
{
ARG_STR(SOL_IP), ARG_STR(IP_DROP_MEMBERSHIP),
m4, sizeof(*m4),
"{imr_multiaddr=inet_addr(\"" multi4addr
"\"), imr_interface=inet_addr(\"" interface "\")}"
},
{
ARG_STR(SOL_IPV6), ARG_STR(IPV6_ADD_MEMBERSHIP),
m6, sizeof(*m6),
"{inet_pton(AF_INET6, \"" multi6addr
"\", &ipv6mr_multiaddr)"
", ipv6mr_interface=" IFINDEX_LO_STR "}"
},
{
ARG_STR(SOL_IPV6), ARG_STR(IPV6_DROP_MEMBERSHIP),
m6, sizeof(*m6),
"{inet_pton(AF_INET6, \"" multi6addr
"\", &ipv6mr_multiaddr)"
", ipv6mr_interface=" IFINDEX_LO_STR "}"
},
{
ARG_STR(SOL_IPV6), ARG_STR(IPV6_JOIN_ANYCAST),
m6, sizeof(*m6),
"{inet_pton(AF_INET6, \"" multi6addr
"\", &ipv6mr_multiaddr)"
", ipv6mr_interface=" IFINDEX_LO_STR "}"
},
{
ARG_STR(SOL_IPV6), ARG_STR(IPV6_LEAVE_ANYCAST),
m6, sizeof(*m6),
"{inet_pton(AF_INET6, \"" multi6addr
"\", &ipv6mr_multiaddr)"
", ipv6mr_interface=" IFINDEX_LO_STR "}"
}
};
for (i = 0; i < ARRAY_SIZE(opts); ++i) {
/* optlen < 0, EINVAL */
rc = setsockopt(0, opts[i].level, opts[i].name,
opts[i].val, -1);
printf("setsockopt(0, %s, %s, %p, -1) = %s\n",
opts[i].str_level, opts[i].str_name,
opts[i].val, sprintrc(rc));
/* optlen < sizeof(struct), EINVAL */
rc = setsockopt(0, opts[i].level, opts[i].name,
opts[i].val, opts[i].size - 1);
printf("setsockopt(0, %s, %s, %p, %u) = %s\n",
opts[i].str_level, opts[i].str_name,
opts[i].val, opts[i].size - 1, sprintrc(rc));
/* optval EFAULT */
rc = setsockopt(0, opts[i].level, opts[i].name,
opts[i].val + 1, opts[i].size);
printf("setsockopt(0, %s, %s, %p, %u) = %s\n",
opts[i].str_level, opts[i].str_name,
opts[i].val + 1, opts[i].size, sprintrc(rc));
/* classic */
rc = setsockopt(0, opts[i].level, opts[i].name,
opts[i].val, opts[i].size);
printf("setsockopt(0, %s, %s, %s, %u) = %s\n",
opts[i].str_level, opts[i].str_name,
opts[i].addr, opts[i].size, sprintrc(rc));
/* optlen > sizeof(struct), shortened */
rc = setsockopt(0, opts[i].level, opts[i].name,
opts[i].val, INT_MAX);
printf("setsockopt(0, %s, %s, %s, %u) = %s\n",
opts[i].str_level, opts[i].str_name,
opts[i].addr, INT_MAX, sprintrc(rc));
}
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
skip_if_unavailable("/proc/self/fd/");
static const struct rtnl_link_stats st = {
.rx_packets = 0xabcdefac,
.tx_packets = 0xbcdacdab,
.rx_bytes = 0xcdbafaab,
.tx_bytes = 0xdafabadb,
.rx_errors = 0xeabcdaeb,
.tx_errors = 0xfefabeab,
.rx_dropped = 0xadbafafb,
.tx_dropped = 0xbdffabda,
.multicast = 0xcdabdfea,
.collisions = 0xefadbaeb,
.rx_length_errors = 0xfabffabd,
.rx_over_errors = 0xafbafabc,
.rx_crc_errors = 0xbfdabdad,
.rx_frame_errors = 0xcfdabfad,
.rx_fifo_errors = 0xddfdebad,
.rx_missed_errors = 0xefabdcba,
.tx_aborted_errors = 0xefdadbfa,
.tx_carrier_errors = 0xfaefbada,
.tx_fifo_errors = 0xaebdffab,
.tx_heartbeat_errors = 0xbadebaaf,
.tx_window_errors = 0xcdafbada,
.rx_compressed = 0xdeffadbd,
.tx_compressed = 0xefdadfab
};
const int fd = create_nl_socket(NETLINK_ROUTE);
const unsigned int hdrlen = sizeof(struct ifinfomsg);
void *nlh0 = midtail_alloc(NLMSG_SPACE(hdrlen),
NLA_HDRLEN + sizeof(st));
static char pattern[4096];
fill_memory_ex(pattern, sizeof(pattern), 'a', 'z' - 'a' + 1);
const unsigned int nla_type = 0xffff & NLA_TYPE_MASK;
char nla_type_str[256];
sprintf(nla_type_str, "%#x /* IFLA_??? */", nla_type);
TEST_NLATTR_(fd, nlh0, hdrlen,
init_ifinfomsg, print_ifinfomsg,
nla_type, nla_type_str,
4, pattern, 4,
print_quoted_hex(pattern, 4));
const int32_t netnsid = 0xacbdabda;
TEST_NLATTR_OBJECT(fd, nlh0, hdrlen,
init_ifinfomsg, print_ifinfomsg,
IFLA_LINK_NETNSID, pattern, netnsid,
printf("%d", netnsid));
TEST_NLATTR_OBJECT(fd, nlh0, hdrlen,
init_ifinfomsg, print_ifinfomsg,
IFLA_STATS, pattern, st,
PRINT_FIELD_U("{", st, rx_packets);
PRINT_FIELD_U(", ", st, tx_packets);
PRINT_FIELD_U(", ", st, rx_bytes);
PRINT_FIELD_U(", ", st, tx_bytes);
PRINT_FIELD_U(", ", st, rx_errors);
PRINT_FIELD_U(", ", st, tx_errors);
PRINT_FIELD_U(", ", st, rx_dropped);
PRINT_FIELD_U(", ", st, tx_dropped);
PRINT_FIELD_U(", ", st, multicast);
PRINT_FIELD_U(", ", st, collisions);
PRINT_FIELD_U(", ", st, rx_length_errors);
PRINT_FIELD_U(", ", st, rx_over_errors);
PRINT_FIELD_U(", ", st, rx_crc_errors);
PRINT_FIELD_U(", ", st, rx_frame_errors);
PRINT_FIELD_U(", ", st, rx_fifo_errors);
PRINT_FIELD_U(", ", st, rx_missed_errors);
PRINT_FIELD_U(", ", st, tx_aborted_errors);
PRINT_FIELD_U(", ", st, tx_carrier_errors);
PRINT_FIELD_U(", ", st, tx_fifo_errors);
PRINT_FIELD_U(", ", st, tx_heartbeat_errors);
PRINT_FIELD_U(", ", st, tx_window_errors);
PRINT_FIELD_U(", ", st, rx_compressed);
PRINT_FIELD_U(", ", st, tx_compressed);
#ifdef HAVE_STRUCT_RTNL_LINK_STATS_RX_NOHANDLER
PRINT_FIELD_U(", ", st, rx_nohandler);
#endif
printf("}"));
#ifdef HAVE_STRUCT_RTNL_LINK_STATS_RX_NOHANDLER
const unsigned int sizeof_stats =
offsetofend(struct rtnl_link_stats, tx_compressed);
TEST_NLATTR(fd, nlh0, hdrlen,
init_ifinfomsg, print_ifinfomsg,
IFLA_STATS, sizeof_stats, &st, sizeof_stats,
PRINT_FIELD_U("{", st, rx_packets);
PRINT_FIELD_U(", ", st, tx_packets);
PRINT_FIELD_U(", ", st, rx_bytes);
PRINT_FIELD_U(", ", st, tx_bytes);
PRINT_FIELD_U(", ", st, rx_errors);
PRINT_FIELD_U(", ", st, tx_errors);
PRINT_FIELD_U(", ", st, rx_dropped);
PRINT_FIELD_U(", ", st, tx_dropped);
PRINT_FIELD_U(", ", st, multicast);
PRINT_FIELD_U(", ", st, collisions);
PRINT_FIELD_U(", ", st, rx_length_errors);
PRINT_FIELD_U(", ", st, rx_over_errors);
PRINT_FIELD_U(", ", st, rx_crc_errors);
PRINT_FIELD_U(", ", st, rx_frame_errors);
PRINT_FIELD_U(", ", st, rx_fifo_errors);
PRINT_FIELD_U(", ", st, rx_missed_errors);
PRINT_FIELD_U(", ", st, tx_aborted_errors);
PRINT_FIELD_U(", ", st, tx_carrier_errors);
PRINT_FIELD_U(", ", st, tx_fifo_errors);
PRINT_FIELD_U(", ", st, tx_heartbeat_errors);
PRINT_FIELD_U(", ", st, tx_window_errors);
PRINT_FIELD_U(", ", st, rx_compressed);
PRINT_FIELD_U(", ", st, tx_compressed);
printf("}"));
#endif /* HAVE_STRUCT_RTNL_LINK_STATS_RX_NOHANDLER */
static const struct rtnl_link_ifmap map = {
.mem_start = 0xadcbefedefbcdedb,
.mem_end = 0xefcbeabdecdcdefa,
.base_addr = 0xaddbeabdfaacdbae,
.irq = 0xefaf,
.dma = 0xab,
.port = 0xcd
};
const unsigned int sizeof_ifmap =
offsetofend(struct rtnl_link_ifmap, port);
const unsigned int plen = sizeof_ifmap - 1 > DEFAULT_STRLEN
? DEFAULT_STRLEN
: (int) sizeof_ifmap - 1;
/* len < sizeof_ifmap */
TEST_NLATTR(fd, nlh0, hdrlen,
init_ifinfomsg, print_ifinfomsg,
IFLA_MAP, plen, pattern, plen,
print_quoted_hex(pattern, plen));
/* short read of sizeof_ifmap */
TEST_NLATTR(fd, nlh0, hdrlen,
init_ifinfomsg, print_ifinfomsg,
IFLA_MAP, sizeof_ifmap, &map, sizeof_ifmap - 1,
printf("%p", RTA_DATA(TEST_NLATTR_nla)));
/* sizeof_ifmap */
TEST_NLATTR(fd, nlh0, hdrlen,
init_ifinfomsg, print_ifinfomsg,
IFLA_MAP, sizeof_ifmap, &map, sizeof_ifmap,
PRINT_FIELD_X("{", map, mem_start);
PRINT_FIELD_X(", ", map, mem_end);
PRINT_FIELD_X(", ", map, base_addr);
PRINT_FIELD_U(", ", map, irq);
PRINT_FIELD_U(", ", map, dma);
PRINT_FIELD_U(", ", map, port);
printf("}"));
#ifdef HAVE_STRUCT_RTNL_LINK_STATS64
static const struct rtnl_link_stats64 st64 = {
.rx_packets = 0xadcbefedefbcdedb,
.tx_packets = 0xbdabdedabdcdeabd,
.rx_bytes = 0xcdbaefbaeadfabec,
.tx_bytes = 0xdbaedbafabbeacdb,
.rx_errors = 0xefabfdaefabaefab,
.tx_errors = 0xfaebfabfabbaeabf,
.rx_dropped = 0xacdbaedbadbabeba,
.tx_dropped = 0xbcdeffebdabeadbe,
.multicast = 0xeeffbaeabaeffabe,
.collisions = 0xffbaefcefbafacef,
.rx_length_errors = 0xaabbdeabceffdecb,
.rx_over_errors = 0xbbdcdadebadeaeed,
.rx_crc_errors= 0xccdeabecefaedbef,
.rx_frame_errors = 0xddbedaedebcedaef,
.rx_fifo_errors = 0xeffbadefafdaeaab,
.rx_missed_errors = 0xfefaebccceadeecd,
.tx_aborted_errors = 0xabcdadefcdadef,
.tx_carrier_errors = 0xbccdafaeeaaefe,
.tx_fifo_errors = 0xcddefdbedeadce,
.tx_heartbeat_errors = 0xedaededdadcdea,
.tx_window_errors = 0xfdacdeaccedcda,
.rx_compressed = 0xacdbbcacdbccef,
.tx_compressed = 0xbcdadefcdedfea
};
TEST_NLATTR_OBJECT(fd, nlh0, hdrlen,
init_ifinfomsg, print_ifinfomsg,
IFLA_STATS64, pattern, st64,
PRINT_FIELD_U("{", st64, rx_packets);
PRINT_FIELD_U(", ", st64, tx_packets);
PRINT_FIELD_U(", ", st64, rx_bytes);
PRINT_FIELD_U(", ", st64, tx_bytes);
PRINT_FIELD_U(", ", st64, rx_errors);
PRINT_FIELD_U(", ", st64, tx_errors);
PRINT_FIELD_U(", ", st64, rx_dropped);
PRINT_FIELD_U(", ", st64, tx_dropped);
PRINT_FIELD_U(", ", st64, multicast);
PRINT_FIELD_U(", ", st64, collisions);
PRINT_FIELD_U(", ", st64, rx_length_errors);
PRINT_FIELD_U(", ", st64, rx_over_errors);
PRINT_FIELD_U(", ", st64, rx_crc_errors);
PRINT_FIELD_U(", ", st64, rx_frame_errors);
PRINT_FIELD_U(", ", st64, rx_fifo_errors);
PRINT_FIELD_U(", ", st64, rx_missed_errors);
PRINT_FIELD_U(", ", st64, tx_aborted_errors);
PRINT_FIELD_U(", ", st64, tx_carrier_errors);
PRINT_FIELD_U(", ", st64, tx_fifo_errors);
PRINT_FIELD_U(", ", st64, tx_heartbeat_errors);
PRINT_FIELD_U(", ", st64, tx_window_errors);
PRINT_FIELD_U(", ", st64, rx_compressed);
PRINT_FIELD_U(", ", st64, tx_compressed);
#ifdef HAVE_STRUCT_RTNL_LINK_STATS64_RX_NOHANDLER
PRINT_FIELD_U(", ", st64, rx_nohandler);
#endif
printf("}"));
#ifdef HAVE_STRUCT_RTNL_LINK_STATS64_RX_NOHANDLER
const unsigned int sizeof_stats64 =
offsetofend(struct rtnl_link_stats64, tx_compressed);
TEST_NLATTR(fd, nlh0, hdrlen,
init_ifinfomsg, print_ifinfomsg,
IFLA_STATS64, sizeof_stats64, &st64, sizeof_stats64,
PRINT_FIELD_U("{", st64, rx_packets);
PRINT_FIELD_U(", ", st64, tx_packets);
PRINT_FIELD_U(", ", st64, rx_bytes);
PRINT_FIELD_U(", ", st64, tx_bytes);
PRINT_FIELD_U(", ", st64, rx_errors);
PRINT_FIELD_U(", ", st64, tx_errors);
PRINT_FIELD_U(", ", st64, rx_dropped);
PRINT_FIELD_U(", ", st64, tx_dropped);
PRINT_FIELD_U(", ", st64, multicast);
PRINT_FIELD_U(", ", st64, collisions);
PRINT_FIELD_U(", ", st64, rx_length_errors);
PRINT_FIELD_U(", ", st64, rx_over_errors);
PRINT_FIELD_U(", ", st64, rx_crc_errors);
PRINT_FIELD_U(", ", st64, rx_frame_errors);
PRINT_FIELD_U(", ", st64, rx_fifo_errors);
PRINT_FIELD_U(", ", st64, rx_missed_errors);
PRINT_FIELD_U(", ", st64, tx_aborted_errors);
PRINT_FIELD_U(", ", st64, tx_carrier_errors);
PRINT_FIELD_U(", ", st64, tx_fifo_errors);
PRINT_FIELD_U(", ", st64, tx_heartbeat_errors);
PRINT_FIELD_U(", ", st64, tx_window_errors);
PRINT_FIELD_U(", ", st64, rx_compressed);
PRINT_FIELD_U(", ", st64, tx_compressed);
printf("}"));
#endif /* HAVE_STRUCT_RTNL_LINK_STATS64_RX_NOHANDLER */
#endif /* HAVE_STRUCT_RTNL_LINK_STATS64 */
struct nlattr nla = {
.nla_len = sizeof(nla),
.nla_type = IFLA_INFO_KIND,
};
TEST_NLATTR(fd, nlh0, hdrlen,
init_ifinfomsg, print_ifinfomsg,
IFLA_LINKINFO, sizeof(nla), &nla, sizeof(nla),
printf("{nla_len=%u, nla_type=IFLA_INFO_KIND}",
nla.nla_len));
nla.nla_type = IFLA_VF_PORT;
TEST_NLATTR(fd, nlh0, hdrlen,
init_ifinfomsg, print_ifinfomsg,
IFLA_VF_PORTS, sizeof(nla), &nla, sizeof(nla),
printf("{nla_len=%u, nla_type=IFLA_VF_PORT}",
nla.nla_len));
static const struct {
uint32_t val;
const char *str;
} ifla_events[] = {
{ 0, "IFLA_EVENT_NONE" },
{ 6, "IFLA_EVENT_BONDING_OPTIONS" },
{ ARG_STR(0x7) " /* IFLA_EVENT_??? */" },
{ ARG_STR(0xdeadfeed) " /* IFLA_EVENT_??? */" },
};
for (size_t i = 0; i < ARRAY_SIZE(ifla_events); i++) {
TEST_NLATTR_OBJECT(fd, nlh0, hdrlen,
init_ifinfomsg, print_ifinfomsg,
IFLA_EVENT, pattern, ifla_events[i].val,
printf("%s", ifla_events[i].str));
}
puts("+++ exited with 0 +++");
return 0;
}
Obj*
Json_slurp_json(Folder *folder, const CharBuf *filename)
{
return Host_callback_obj(&JSON, "slurp_json", 2,
ARG_OBJ("folder", folder), ARG_STR("filename", filename));
}
void
format (struct obstack *obs, int argc, token_data **argv)
{
char *fmt; /* format control string */
const char *fstart; /* beginning of current format spec */
int c; /* a simple character */
/* Flags. */
char flags; /* 1 iff treating flags */
/* Precision specifiers. */
int width; /* minimum field width */
int prec; /* precision */
char lflag; /* long flag */
char hflag; /* short flag */
/* Buffer and stuff. */
char *str; /* malloc'd buffer of formatted text */
enum {INT, UINT, LONG, ULONG, DOUBLE, STR} datatype;
fmt = (char *) ARG_STR (argc, argv);
for (;;)
{
while ((c = *fmt++) != '%')
{
if (c == 0)
return;
obstack_1grow (obs, c);
}
fstart = fmt - 1;
if (*fmt == '%')
{
obstack_1grow (obs, '%');
fmt++;
continue;
}
/* Parse flags. */
flags = 1;
do
{
switch (*fmt)
{
case '-': /* left justification */
case '+': /* mandatory sign */
case ' ': /* space instead of positive sign */
case '0': /* zero padding */
case '#': /* alternate output */
break;
default:
flags = 0;
break;
}
}
while (flags && fmt++);
/* Minimum field width. */
width = -1;
if (*fmt == '*')
{
width = ARG_INT (argc, argv);
fmt++;
}
else if (isdigit (to_uchar (*fmt)))
{
do
{
fmt++;
}
while (isdigit (to_uchar (*fmt)));
}
/* Maximum precision. */
prec = -1;
if (*fmt == '.')
{
if (*(++fmt) == '*')
{
prec = ARG_INT (argc, argv);
++fmt;
}
else if (isdigit (to_uchar (*fmt)))
{
do
{
fmt++;
}
while (isdigit (to_uchar (*fmt)));
}
}
/* Length modifiers. */
lflag = (*fmt == 'l');
hflag = (*fmt == 'h');
if (lflag || hflag)
fmt++;
switch (*fmt++)
{
case '\0':
return;
case 'c':
datatype = INT;
break;
case 's':
datatype = STR;
break;
case 'd':
case 'i':
if (lflag)
{
datatype = LONG;
}
else
{
datatype = INT;
}
break;
case 'o':
case 'x':
case 'X':
case 'u':
if (lflag)
{
datatype = ULONG;
}
else
{
datatype = UINT;
}
break;
case 'e':
case 'E':
case 'f':
case 'F':
case 'g':
case 'G':
datatype = DOUBLE;
break;
default:
continue;
}
c = *fmt;
*fmt = '\0';
switch(datatype)
{
case INT:
if (width != -1 && prec != -1)
str = xasprintf (fstart, width, prec, ARG_INT(argc, argv));
else if (width != -1)
str = xasprintf (fstart, width, ARG_INT(argc, argv));
else if (prec != -1)
str = xasprintf (fstart, prec, ARG_INT(argc, argv));
else
str = xasprintf (fstart, ARG_INT(argc, argv));
break;
case UINT:
if (width != -1 && prec != -1)
str = xasprintf (fstart, width, prec, ARG_UINT(argc, argv));
else if (width != -1)
str = xasprintf (fstart, width, ARG_UINT(argc, argv));
else if (prec != -1)
str = xasprintf (fstart, prec, ARG_UINT(argc, argv));
else
str = xasprintf (fstart, ARG_UINT(argc, argv));
break;
case LONG:
if (width != -1 && prec != -1)
str = xasprintf (fstart, width, prec, ARG_LONG(argc, argv));
else if (width != -1)
str = xasprintf (fstart, width, ARG_LONG(argc, argv));
else if (prec != -1)
str = xasprintf (fstart, prec, ARG_LONG(argc, argv));
else
str = xasprintf (fstart, ARG_LONG(argc, argv));
break;
case ULONG:
if (width != -1 && prec != -1)
str = xasprintf (fstart, width, prec, ARG_ULONG(argc, argv));
else if (width != -1)
str = xasprintf (fstart, width, ARG_ULONG(argc, argv));
else if (prec != -1)
str = xasprintf (fstart, prec, ARG_ULONG(argc, argv));
else
str = xasprintf (fstart, ARG_ULONG(argc, argv));
break;
case DOUBLE:
if (width != -1 && prec != -1)
str = xasprintf (fstart, width, prec, ARG_DOUBLE(argc, argv));
else if (width != -1)
str = xasprintf (fstart, width, ARG_DOUBLE(argc, argv));
else if (prec != -1)
str = xasprintf (fstart, prec, ARG_DOUBLE(argc, argv));
else
str = xasprintf (fstart, ARG_DOUBLE(argc, argv));
break;
case STR:
if (width != -1 && prec != -1)
str = xasprintf (fstart, width, prec, ARG_STR(argc, argv));
else if (width != -1)
str = xasprintf (fstart, width, ARG_STR(argc, argv));
else if (prec != -1)
str = xasprintf (fstart, prec, ARG_STR(argc, argv));
else
str = xasprintf (fstart, ARG_STR(argc, argv));
break;
default:
abort();
}
*fmt = c;
/* NULL was returned on failure, such as invalid format string. For
now, just silently ignore that bad specifier. */
if (str == NULL)
continue;
obstack_grow (obs, str, strlen (str));
free (str);
}
}
Hash*
Stopalizer_gen_stoplist(const CharBuf *language)
{
return (Hash*)Host_callback_obj(&STOPALIZER, "gen_stoplist", 1,
ARG_STR("language", language));
}
Obj*
Json_from_json(CharBuf *json)
{
return Host_callback_obj(&JSON, "from_json", 1,
ARG_STR("json", json));
}
