void WIPLogger::debug( unsigned int flags,char* buffer,... )
{
parse_flags(flags);
printf(_current_line.data());
printf(" ");
va_list vl;
va_start(vl,buffer);
vprintf(buffer,vl);
va_end(vl);
printf("\n");
if(!m_initialized)
return;
parse_flags(flags);
va_list vl1;
char temp[MAX_SINGLE_LINE_CHAR_NUM];
va_start(vl1,buffer);
vsprintf(temp,buffer,vl1);
va_end(vl1);
_current_line += temp;
_current_line += '\n';
_buf += _current_line;
_current_lines++;
if(_current_lines>=MAX_DEBUG_LINE_LEN)
{
flush();
}
}
int
main(int argc, char **argv)
{
int i = 1;
int flags;
if(argc > 1 && argv[1][0] == '-') {
flags = parse_flags(argv[1]);
i = 2;
} else
flags = parse_flags(NULL);
list_files(stdout, (const char **)argv + i, argc - i, flags);
return 0;
}
/*
*
* vivi> part add <name> <offset> <size> <flag>
*
* add (argv[0]): command of mtd partition
* <name> (argv[1]): name of partition.
* <offset> (argv[2]): offset of partition.
* <size> (argv[3]): size of partition.
* <flag> (argv[4]): flag of partition.
*/
static void command_add(int argc, const char **argv)
{
mtd_partition_t part;
int ret;
if (argc != 5) {
invalid_cmd("part add", part_cmds);
return;
}
if (argv[1] == NULL) goto error_parse_arg;
if (strlen(argv[1]) >= MAX_PART_NAME) {
printk("too long partition name\n");
}
strncpy((char *)part.name, argv[1], strlen(argv[1]) + 1);
part.offset = strtoul(argv[2], NULL, 0, &ret);
if (ret) goto error_parse_arg;
part.size = strtoul(argv[3], NULL, 0, &ret);
if (ret) goto error_parse_arg;
part.flag = parse_flags((char *)argv[4]);
add_mtd_partition(&part);
printk("%s: offset = 0x%08lx, size = 0x%08lx, flag = %d\n",
part.name, part.offset, part.size, part.flag);
return;
error_parse_arg:
printk("Can't parsing arguments\n");
return;
}
int
nnpfsdebug_print_cmd (int argc, char **argv)
{
int ret;
int flags = 0;
char *textflags;
nnpfsdebug_units[0].mult = all;
nnpfsdebug_units[1].mult = all & ~almost_all_mask;
if (argc != 2 && argc != 3) {
fprintf (stderr, "usage: nnpfsprint <");
print_flags_table (nnpfsdebug_units, stderr);
fprintf (stderr, "> [filename]\n");
return 0;
}
textflags = argv[1];
ret = parse_flags (textflags, nnpfsdebug_units, flags);
if (ret < 0) {
fprintf (stderr, "nnpfsprint: unknown/bad flags `%s'\n",
textflags);
return 0;
}
flags = ret;
ret = nnpfs_debug_print(flags, argv[2]);
if (ret)
fprintf (stderr, "nnpfsprint: %s\n", strerror(ret));
return 0;
}
int
builtin_ls(FILE *out, const char *file)
{
int flags;
int ret;
if(*file == '-') {
flags = parse_flags(file);
file = ".";
} else
flags = parse_flags("");
ret = list_files(out, &file, 1, flags);
sec_fflush(out);
return ret;
}
void
Face::SetProperty( const std::string &name,
const std::string &value )
{
if (name == "size") {
sscanf( value.c_str(), "%u", &size );
return;
}
if (name == "height") {
sscanf( value.c_str(), "%u", &height );
return;
}
if (name == "ascender") {
sscanf( value.c_str(), "%d", &ascender );
return;
}
if (name == "descender") {
sscanf( value.c_str(), "%d", &descender );
return;
}
if (name == "maxadvance") {
sscanf( value.c_str(), "%d", &maxadvance );
return;
}
if (name == "blittingflags") {
parse_flags( value.c_str(), &blittingflags );
return;
}
}
/**
* Parse a protocol packet.
*
* @param buf Buffer containing the protocol packet. Must not be NULL.
* @param floatval Pointer to a float variable. That variable will be modified
* in-place depending on the protocol packet. Must not be NULL.
* @param analog Pointer to a struct sr_datafeed_analog. The struct will be
* filled with data according to the protocol packet.
* Must not be NULL.
* @param info Pointer to a struct metex14_info. The struct will be filled
* with data according to the protocol packet. Must not be NULL.
*
* @return SR_OK upon success, SR_ERR upon failure. Upon errors, the
* 'analog' variable contents are undefined and should not be used.
*/
SR_PRIV int sr_metex14_parse(const uint8_t *buf, float *floatval,
struct sr_datafeed_analog *analog, void *info)
{
int ret, exponent = 0;
struct metex14_info *info_local;
info_local = (struct metex14_info *)info;
/* Don't print byte 13. That one contains the carriage return. */
sr_dbg("DMM packet: \"%.13s\"", buf);
memset(info_local, 0x00, sizeof(struct metex14_info));
if ((ret = parse_value(buf, info_local, floatval, &exponent)) != SR_OK) {
sr_dbg("Error parsing value: %d.", ret);
return ret;
}
parse_flags((const char *)buf, info_local);
handle_flags(analog, floatval, &exponent, info_local);
analog->encoding->digits = -exponent;
analog->spec->spec_digits = -exponent;
return SR_OK;
}
static int parse_cb (void *arg, const char *section, const char *name,
const char *value)
{
struct cf_file *cf = arg;
struct cf_instrument *cfi = hash_find (cf->db, section);
if (!cfi)
cfi = cfi_create (cf, section);
if (!cfi)
goto error;
if (!strcmp (name, "address"))
snprintf (cfi->addr, MAX_GPIB_ADDR, "%s", value);
else if (!strcmp (name, "manufacturer"))
snprintf (cfi->make, MAX_GPIB_MAKE, "%s", value);
else if (!strcmp (name, "model"))
snprintf (cfi->model, MAX_GPIB_MODEL, "%s", value);
else if (!strcmp (name, "idn"))
snprintf (cfi->idncmd, MAX_GPIB_IDNCMD, "%s", value);
else if (!strcmp (name, "flags")) {
if (parse_flags (value, &cfi->flags) < 0)
goto error;
} else {
fprintf (stderr, "unknown config file attribute '%s'\n", name);
goto error;
}
return 1; /* ini success */
error:
return 0; /* ini error */
}
static void save_file_metadata(filedelete* f,
const drakvuf_trap_info_t* info,
int sequence_number,
addr_t control_area,
const char* filename,
size_t file_size,
uint64_t fo_flags,
uint32_t ntstatus = 0)
{
char* file = NULL;
if ( asprintf(&file, "%s/file.%06d.metadata", f->dump_folder, sequence_number) < 0 )
return;
FILE* fp = fopen(file, "w");
free(file);
if (!fp)
return;
fprintf(fp, "FileName: \"%s\"\n", filename ?: "<UNKNOWN>");
fprintf(fp, "FileSize: %zu\n", file_size);
fprintf(fp, "FileFlags: 0x%lx (%s)\n", fo_flags, parse_flags(fo_flags, fo_flags_map, OUTPUT_DEFAULT, "0").c_str());
fprintf(fp, "SequenceNumber: %d\n", sequence_number);
fprintf(fp, "ControlArea: 0x%lx\n", control_area);
fprintf(fp, "PID: %" PRIu64 "\n", static_cast<uint64_t>(info->proc_data.pid));
fprintf(fp, "PPID: %" PRIu64 "\n", static_cast<uint64_t>(info->proc_data.ppid));
fprintf(fp, "ProcessName: \"%s\"\n", info->proc_data.name);
if (ntstatus)
fprintf(fp, "WARNING: The file have been read partially with status 0x%x\n", ntstatus);
fclose(fp);
}
SR_PRIV int sr_vc870_parse(const uint8_t *buf, float *floatval,
struct sr_datafeed_analog_old *analog, void *info)
{
int ret;
struct vc870_info *info_local;
info_local = (struct vc870_info *)info;
memset(info_local, 0, sizeof(struct vc870_info));
if (!sr_vc870_packet_valid(buf))
return SR_ERR;
parse_flags(buf, info_local);
if ((ret = parse_value(buf, info_local, floatval)) != SR_OK) {
sr_dbg("Error parsing value: %d.", ret);
return ret;
}
if ((ret = parse_range(buf[2], floatval, info_local)) != SR_OK)
return ret;
handle_flags(analog, floatval, info_local);
return SR_OK;
}
apr_status_t lwt_template_parse (const char *filename, lua_State *L,
const char *flags, apr_pool_t *pool, apr_array_header_t **t,
const char **err) {
parser_rec *p;
apr_status_t status;
p = (parser_rec *) apr_pcalloc(pool, sizeof(parser_rec));
p->filename = filename;
p->L = L;
p->flags = parse_flags(flags != NULL ? flags : TEMPLATE_DEFAULT_FLAGS);
p->pool = pool;
p->t = apr_array_make(pool, 32, sizeof(template_node_t));
p->b = apr_array_make(pool, 8, sizeof(block_t));
status = parse_template(p);
if (status == APR_SUCCESS) {
if (!apr_is_empty_array(p->b)) {
status = parse_error(p, apr_psprintf(p->pool,
"%d open elements at end of template",
p->b->nelts));
}
}
if (status != APR_SUCCESS) {
if (err != NULL) {
*err = p->err;
}
return status;
}
if (t != NULL) {
*t = p->t;
}
return APR_SUCCESS;
}
static void
parse_ticket_flags(krb5_context context,
const char *string, krb5_ticket_flags *ret_flags)
{
TicketFlags ff;
int flags = parse_flags(string, asn1_TicketFlags_units(), 0);
if (flags == -1) /* XXX */
krb5_errx(context, 1, "bad flags specified: \"%s\"", string);
memset(&ff, 0, sizeof(ff));
ff.proxy = 1;
if (parse_flags("proxy", asn1_TicketFlags_units(), 0) == TicketFlags2int(ff))
ret_flags->i = flags;
else
ret_flags->i = bitswap32(flags);
}
int main(int argc, char *argv[])
{
parse_flags(argc, argv);
call_flags();
if (fflush(0) != 0) return 112;
return 0;
}
kadm5_ret_t
_kadm5_string_to_privs(const char *s, uint32_t* privs)
{
int flags;
flags = parse_flags(s, acl_units, 0);
if(flags < 0)
return KADM5_FAILURE;
*privs = flags;
return 0;
}
char *parse_options(char *params, t_options *options, t_list *output)
{
params = parse_argpos(params, options, output);
params = parse_flags(params, options);
params = parse_field_width(params, options, output);
check_field_width(options);
params = parse_precision(params, options, output);
params = parse_casters(params, options);
return (params);
}
static void load_flags(void)
{
unsigned int i, j;
/* Use "key" for temporary storage */
if (getconf_line(&key,"flags",0)) {
parse_flags(key.s,key.len);
}
else if (getconf(&key,"config",0)) {
for (i = 0; i < key.len; ++i) {
for (j = i; j < key.len && key.s[j] != 0; ++j)
;
if (key.s[i] == 'F' && key.s[i+1] == ':') {
parse_flags(key.s+i+2,j-i-2);
return;
}
i = j;
}
}
}
int handle_conversion(t_env *e, va_list ap)
{
if (check_percent_percent(e) || e->str[e->current] == '\0')
return (0);
parse_flags(e);
parse_width(e, ap);
parse_precision(e, ap);
parse_modificator(e);
parse_convertor(e);
return (1);
}
static void print_filedelete_information(filedelete* f, drakvuf_t drakvuf, drakvuf_trap_info_t* info, const char* filename, size_t bytes_read, uint64_t fo_flags)
{
std::string flags = parse_flags(fo_flags, fo_flags_map, f->format);
gchar* escaped_pname = NULL;
gchar* escaped_fname = NULL;
switch (f->format)
{
case OUTPUT_CSV:
printf("filedelete," FORMAT_TIMEVAL ",%" PRIu32 ",0x%" PRIx64 ",\"%s\",%" PRIi64 ",\"%s\",%" PRIu64 ",0x%" PRIx64 "(%s)\n",
UNPACK_TIMEVAL(info->timestamp), info->vcpu, info->regs->cr3, info->proc_data.name,
info->proc_data.userid, filename, bytes_read, fo_flags, flags.c_str());
break;
case OUTPUT_KV:
printf("filedelete Time=" FORMAT_TIMEVAL ",PID=%d,PPID=%d,ProcessName=\"%s\",Method=%s,FileName=\"%s\",Size=%ld,Flags=0x%" PRIx64 "%s%s\n",
UNPACK_TIMEVAL(info->timestamp), info->proc_data.pid, info->proc_data.ppid, info->proc_data.name,
info->trap->name, filename, bytes_read, fo_flags, (flags.empty() ? "" : ","), flags.c_str());
break;
case OUTPUT_JSON:
escaped_pname = drakvuf_escape_str(info->proc_data.name);
escaped_fname = drakvuf_escape_str(filename);
printf( "{"
"\"Plugin\" : \"filedelete\","
"\"TimeStamp\" :" "\"" FORMAT_TIMEVAL "\","
"\"ProcessName\": %s,"
"\"UserName\": \"%s\","
"\"UserId\": %" PRIu64 ","
"\"PID\" : %d,"
"\"PPID\": %d,"
"\"Method\" : \"%s\","
"\"FileName\" : %s,"
"\"Size\" : %ld,"
"\"Flags\" : %" PRIu64 ","
"\"FlagsExpanded\" : \"%s\""
"}\n",
UNPACK_TIMEVAL(info->timestamp),
escaped_pname,
USERIDSTR(drakvuf), info->proc_data.userid,
info->proc_data.pid, info->proc_data.ppid,
info->trap->name, escaped_fname,
bytes_read, fo_flags, flags.c_str());
g_free(escaped_fname);
g_free(escaped_pname);
break;
default:
case OUTPUT_DEFAULT:
printf("[FILEDELETE] TIME:" FORMAT_TIMEVAL " VCPU:%" PRIu32 " CR3:0x%" PRIx64 ",\"%s\" %s:%" PRIi64" \"%s\" SIZE:%" PRIu64 " FO_FLAGS:0x%" PRIx64 "(%s)\n",
UNPACK_TIMEVAL(info->timestamp), info->vcpu, info->regs->cr3, info->proc_data.name,
USERIDSTR(drakvuf), info->proc_data.userid, filename, bytes_read, fo_flags, flags.c_str());
break;
}
}
SR_PRIV gboolean sr_vc870_packet_valid(const uint8_t *buf)
{
struct vc870_info info;
/* Byte 21: Always '\r' (carriage return, 0x0d, 13) */
/* Byte 22: Always '\n' (newline, 0x0a, 10) */
if (buf[21] != '\r' || buf[22] != '\n')
return FALSE;
parse_flags(buf, &info);
return flags_valid(&info);
}
int
str2attributes(const char *str, krb5_flags *flags)
{
int res;
res = parse_flags (str, kdb_attrs, *flags);
if (res < 0)
return res;
else {
*flags = res;
return 0;
}
}
int
format_str_v(const StrFormatContext *ctxt, const char *format, va_list ap)
{
unsigned int written = 0;
const char *pos = format;
while(*pos != '\0') {
FormatFlags flags;
unsigned int minwidth = 0;
int precision = -1; /* Negative means no precision */
char ch;
const char *start = pos;
while( (ch = *pos) != '\0' && ch != '%') pos++;
if (pos != start) {
CHECKCB(ctxt->write_str(ctxt->user_data, start, pos - start));
written += pos - start;
}
if (*pos == '\0') {
va_end(ap);
return written;
}
pos++;
if (*pos == '\0') {
va_end(ap);
return written;
}
flags = parse_flags(&pos);
/* parse width */
if (*pos >= '1' && *pos <= '9') {
minwidth = parse_uint(&pos);
} else if (*pos == '*') {
int w = va_arg(ap,int);
if (w < 0) {
flags |= JUSTIFY_LEFT;
minwidth = w;
} else {
minwidth = w;
}
pos ++;
}
/* parse precision */
if (*pos == '.') {
pos++;
if (*pos >= '0' && *pos <= '9') {
precision = parse_uint(&pos);
} else if (*pos == '*') {
pos++;
precision = va_arg(ap,int);
}
void WIPLogger::debug_print(unsigned int flags,const char* buffer,...)
{
parse_flags(flags);
printf(_current_line.data());
printf(" ");
va_list vl;
va_start(vl,buffer);
vprintf(buffer,vl);
va_end(vl);
printf("\n");
fflush(stdout);
}
void
flags_parse(char *tline, FILE * fd, char *myname, int *pflags, SyntaxDef *syntax, ASFlagType (*parse_flags)( FreeStorageElem *) )
{
FreeStorageElem *Storage = NULL;
if( pflags == NULL )
return;
Storage = tline_subsyntax_parse(NULL, tline, fd, myname, syntax, NULL, NULL);
if( Storage )
{
*pflags = parse_flags(Storage);
DestroyFreeStorage (&Storage);
}
}
int main(int argc, char **argv) {
program_name = L"fish_key_reader";
bool continuous_mode = false;
if (!parse_flags(argc, argv, &continuous_mode)) return 1;
if (!isatty(STDIN_FILENO)) {
std::fwprintf(stderr, L"Stdin must be attached to a tty.\n");
return 1;
}
setup_and_process_keys(continuous_mode);
return 0;
}
SR_PRIV gboolean sr_metex14_packet_valid(const uint8_t *buf)
{
struct metex14_info info;
memset(&info, 0x00, sizeof(struct metex14_info));
parse_flags((const char *)buf, &info);
if (!flags_valid(&info))
return FALSE;
if (buf[13] != '\r')
return FALSE;
return TRUE;
}
/**
* Check whether a received frame is valid.
*
* @param[in] buf The text buffer with received data.
*
* @return TRUE upon success, FALSE otherwise.
*/
SR_PRIV gboolean sr_asycii_packet_valid(const uint8_t *buf)
{
struct asycii_info info;
/* First check whether we are in sync with the packet stream. */
if (buf[15] != '\r')
return FALSE;
/* Have the received packet content parsed. */
memset(&info, 0x00, sizeof(info));
parse_flags((const char *)buf, &info);
if (!flags_valid(&info))
return FALSE;
return TRUE;
}
void gazetteer_style_t::load_style(std::string const &filename)
{
fprintf(stderr, "Parsing gazetteer style file '%s'.\n", filename.c_str());
pt::ptree root;
pt::read_json(filename, root);
for (auto &entry : root) {
for (auto &tag : entry.second.get_child("keys")) {
for (auto &value : entry.second.get_child("values")) {
add_style_entry(tag.second.data(), value.first,
parse_flags(value.second.data()));
}
}
}
}
int
nnpfsdebug_cmd (int argc, char **argv)
{
int ret;
int flags;
nnpfsdebug_units[0].mult = all;
nnpfsdebug_units[1].mult = all & ~almost_all_mask;
if ((argc > 1 && strncmp(argv[1], "-h", 2) == 0) || argc > 2) {
fprintf (stderr, "usage: nnpfsdebug [-h] [");
print_flags_table (nnpfsdebug_units, stderr);
fprintf (stderr, "]\n");
return 0;
}
ret = nnpfs_debug (-1, &flags);
if (ret) {
fprintf (stderr, "nnpfs_debug: %s\n", strerror(ret));
return 0;
}
if (argc == 1) {
char buf[1024];
unparse_flags (flags, nnpfsdebug_units, buf, sizeof(buf));
printf("nnpfsdebug is: %s\n", buf);
} else if (argc == 2) {
char *textflags;
textflags = argv[1];
ret = parse_flags (textflags, nnpfsdebug_units, flags);
if (ret < 0) {
fprintf (stderr, "nnpfsdebug: unknown/bad flags `%s'\n",
textflags);
return 0;
}
flags = ret;
ret = nnpfs_debug(flags, NULL);
if (ret)
fprintf (stderr, "nnpfs_debug: %s\n", strerror(ret));
}
return 0;
}
SR_PRIV gboolean sr_fs9922_packet_valid(const uint8_t *buf)
{
struct fs9922_info info;
/* Byte 0: Sign (must be '+' or '-') */
if (buf[0] != '+' && buf[0] != '-')
return FALSE;
/* Byte 12: Always '\r' (carriage return, 0x0d, 13) */
/* Byte 13: Always '\n' (newline, 0x0a, 10) */
if (buf[12] != '\r' || buf[13] != '\n')
return FALSE;
parse_flags(buf, &info);
return flags_valid(&info);
}
int main(int argc, char** argv) {
char* arg_flags[] = {"o", "t"};
set_flags_with_args(arg_flags, 2);
parse_flags(argv+1, argc-1);
char* flag = get_flag("o");
if (flag == 0) {
puts("not passed");
} else if (flag == (char*)1) {
puts("flag triggered");
} else {
printf("flag value: %s\n", flag);
}
return 0;
}
