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)); }