static int parse_begin_string(struct fix_message *self)
{
// if first field is not BeginString -> garbled
// if BeginString is invalid or empty -> garbled
return match_field(self->head_buf, BeginString, &self->begin_string);
}
/**
* rb_ext_db_key_matches:
* @a: first #RBExtDBKey
* @b: second #RBExtDBKey
*
* Checks whether the fields specified in @a match @b.
* For keys to match, they must have the same set of required fields,
* and the values for all must match. Optional fields must have the
* same values if present in both. Informational fields are ignored.
*
* Return value: %TRUE if the keys match
*/
gboolean
rb_ext_db_key_matches (RBExtDBKey *a, RBExtDBKey *b)
{
GList *l;
for (l = a->fields; l != NULL; l = l->next) {
RBExtDBField *f = l->data;
if (match_field (b, f) == FALSE) {
return FALSE;
}
}
for (l = b->fields; l != NULL; l = l->next) {
RBExtDBField *f = l->data;
if (match_field (a, f) == FALSE) {
return FALSE;
}
}
return TRUE;
}
static int parse_body_length(struct fix_message *self)
{
int len, ret;
const char *ptr;
ret = match_field(self->head_buf, BodyLength, &ptr);
if (ret)
goto exit;
len = fix_uatoi(ptr, NULL);
self->body_length = len;
if (len <= 0 || len > FIX_MAX_MESSAGE_SIZE)
ret = FIX_MSG_STATE_GARBLED;
exit:
return ret;
}
/*
* The function assumes that the following patterns have fixed sizes:
* - "BeginString=" ("8=") is 2 bytes long
* - "CheckSum=" ("10=") is 3 bytes long
* - "MsgType=" ("35=") is 3 bytes long
*/
static int checksum(struct fix_message *self, struct buffer *buffer, unsigned long flags)
{
const char *start;
int offset;
int ret;
start = buffer_start(buffer);
/* The number of bytes between tag MsgType and buffer's start */
offset = start - (self->msg_type - 3);
/*
* Checksum tag and its trailing delimiter increase
* the message's length by seven bytes - "10=***\x01"
*/
if (buffer_size(buffer) + offset < self->body_length + 7) {
ret = FIX_MSG_STATE_PARTIAL;
goto exit;
}
if (flags & FIX_PARSE_FLAG_NO_CSUM) {
ret = 0;
goto exit;
}
/* Buffer's start will point to the CheckSum tag */
buffer_advance(buffer, self->body_length - offset);
ret = match_field(buffer, CheckSum, &self->check_sum);
if (ret)
goto exit;
if (!verify_checksum(self, buffer)) {
ret = FIX_MSG_STATE_GARBLED;
goto exit;
}
/* Go back to analyze other fields */
buffer_advance(buffer, start - buffer_start(buffer));
exit:
return ret;
}
static int parse_msg_type(struct fix_message *self, unsigned long flags)
{
int ret;
ret = match_field(self->head_buf, MsgType, &self->msg_type);
if (ret)
goto exit;
if (!(flags & FIX_PARSE_FLAG_NO_TYPE)) {
self->type = fix_msg_type_parse(self->msg_type, 0x01);
/* If third field is not MsgType -> garbled */
if (fix_message_type_is(self, FIX_MSG_TYPE_UNKNOWN))
ret = FIX_MSG_STATE_GARBLED;
} else
self->type = FIX_MSG_TYPE_UNKNOWN;
exit:
return ret;
}
/**
* json_events - Read JSON event file from disk and call event callback.
* @fn: File name to read or NULL for default.
* @func: Callback to call for each event
* @data: Abstract pointer to pass to func.
*
* The callback gets the data pointer, the event name, the event
* in perf format and a description passed.
*
* Call func with each event in the json file
* Return: -1 on failure, otherwise 0.
*/
int json_events(const char *fn,
int (*func)(void *data, char *name, char *event, char *desc, char *pmu),
void *data)
{
int err = -EIO;
size_t size;
jsmntok_t *tokens, *tok;
int i, j, len;
char *map;
char buf[128];
const char *orig_fn = fn;
if (!fn)
fn = json_default_name("-core");
tokens = parse_json(fn, &map, &size, &len);
if (!tokens)
return -EIO;
EXPECT(tokens->type == JSMN_ARRAY, tokens, "expected top level array");
tok = tokens + 1;
for (i = 0; i < tokens->size; i++) {
char *event = NULL, *desc = NULL, *name = NULL;
char *pmu = NULL;
char *filter = NULL;
unsigned long long eventcode = 0;
struct msrmap *msr = NULL;
jsmntok_t *msrval = NULL;
jsmntok_t *precise = NULL;
jsmntok_t *obj = tok++;
EXPECT(obj->type == JSMN_OBJECT, obj, "expected object");
for (j = 0; j < obj->size; j += 2) {
jsmntok_t *field, *val;
int nz;
field = tok + j;
EXPECT(field->type == JSMN_STRING, tok + j,
"Expected field name");
val = tok + j + 1;
EXPECT(val->type == JSMN_STRING, tok + j + 1,
"Expected string value");
nz = !json_streq(map, val, "0");
if (match_field(map, field, nz, &event, val)) {
/* ok */
} else if (json_streq(map, field, "EventCode")) {
char *code = NULL;
addfield(map, &code, "", "", val);
eventcode |= strtoul(code, NULL, 0);
free(code);
} else if (json_streq(map, field, "ExtSel")) {
char *code = NULL;
addfield(map, &code, "", "", val);
eventcode |= strtoul(code, NULL, 0) << 21;
free(code);
} else if (json_streq(map, field, "EventName")) {
addfield(map, &name, "", "", val);
} else if (json_streq(map, field, "BriefDescription")) {
addfield(map, &desc, "", "", val);
fixdesc(desc);
} else if (json_streq(map, field, "PEBS") && nz && desc &&
!strstr(desc, "(Precise Event)")) {
precise = val;
} else if (json_streq(map, field, "MSRIndex") && nz) {
msr = lookup_msr(map, val);
} else if (json_streq(map, field, "MSRValue")) {
msrval = val;
} else if (json_streq(map, field, "Errata") &&
!json_streq(map, val, "null")) {
addfield(map, &desc, ". ",
" Spec update: ", val);
} else if (json_streq(map, field, "Data_LA") && nz) {
addfield(map, &desc, ". ",
" Supports address when precise",
NULL);
} else if (json_streq(map, field, "Unit")) {
const char *ppmu;
char *s;
ppmu = field_to_perf(unit_to_pmu, map, val);
if (ppmu) {
pmu = strdup(ppmu);
} else {
addfield(map, &pmu, "", "", val);
for (s = pmu; *s; s++)
*s = tolower(*s);
}
addfield(map, &desc, ". ", "Unit: ", NULL);
addfield(map, &desc, "", pmu, NULL);
} else if (json_streq(map, field, "Filter")) {
addfield(map, &filter, "", "", val);
}
/* ignore unknown fields */
}
if (precise) {
if (json_streq(map, precise, "2"))
addfield(map, &desc, " ", "(Must be precise)",
NULL);
else
addfield(map, &desc, " ",
"(Precise event)", NULL);
}
snprintf(buf, sizeof buf, "event=%#llx", eventcode);
addfield(map, &event, ",", buf, NULL);
if (filter)
addfield(map, &event, ",", filter, NULL);
if (msr != NULL)
addfield(map, &event, ",", msr->pname, msrval);
if (!pmu)
pmu = strdup("cpu");
err = -EIO;
if (name && event) {
fixname(name);
err = func(data, name, event, desc, pmu);
}
free(event);
free(desc);
free(name);
free(pmu);
free(filter);
if (err)
break;
tok += j;
}
EXPECT(tok - tokens == len, tok, "unexpected objects at end");
err = 0;
out_free:
free_json(map, size, tokens);
if (!orig_fn && !err) {
fn = json_default_name("-uncore");
err = json_events(fn, func, data);
/* Ignore open error */
if (err == -EIO)
return 0;
}
if (!orig_fn)
free((char *)fn);
return err;
}
/**
* json_events - Read JSON event file from disk and call event callback.
* @fn: File name to read or NULL for default.
* @func: Callback to call for each event
* @data: Abstract pointer to pass to func.
*
* The callback gets the data pointer, the event name, the event
* in perf format and a description passed.
*
* Call func with each event in the json file
* Return: -1 on failure, otherwise 0.
*/
int json_events(const char *fn,
int (*func)(void *data, char *name, char *event, char *desc),
void *data)
{
int err = -EIO;
size_t size;
jsmntok_t *tokens, *tok;
int i, j, len;
char *map;
if (!fn)
fn = json_default_name();
tokens = parse_json(fn, &map, &size, &len);
if (!tokens)
return -EIO;
EXPECT(tokens->type == JSMN_ARRAY, tokens, "expected top level array");
tok = tokens + 1;
for (i = 0; i < tokens->size; i++) {
char *event = NULL, *desc = NULL, *name = NULL;
struct msrmap *msr = NULL;
jsmntok_t *msrval = NULL;
jsmntok_t *precise = NULL;
jsmntok_t *obj = tok++;
EXPECT(obj->type == JSMN_OBJECT, obj, "expected object");
for (j = 0; j < obj->size; j += 2) {
jsmntok_t *field, *val;
int nz;
field = tok + j;
EXPECT(field->type == JSMN_STRING, tok + j,
"Expected field name");
val = tok + j + 1;
EXPECT(val->type == JSMN_STRING, tok + j + 1,
"Expected string value");
nz = !json_streq(map, val, "0");
if (match_field(map, field, nz, &event, val)) {
/* ok */
} else if (json_streq(map, field, "EventName")) {
addfield(map, &name, "", "", val);
} else if (json_streq(map, field, "BriefDescription")) {
addfield(map, &desc, "", "", val);
fixdesc(desc);
} else if (json_streq(map, field, "PEBS") && nz && desc &&
!strstr(desc, "(Precise Event)")) {
precise = val;
} else if (json_streq(map, field, "MSRIndex") && nz) {
msr = lookup_msr(map, val);
} else if (json_streq(map, field, "MSRValue")) {
msrval = val;
} else if (json_streq(map, field, "Errata") &&
!json_streq(map, val, "null")) {
addfield(map, &desc, ". ",
" Spec update: ", val);
} else if (json_streq(map, field, "Data_LA") && nz) {
addfield(map, &desc, ". ",
" Supports address when precise",
NULL);
}
/* ignore unknown fields */
}
if (precise) {
if (json_streq(map, precise, "2"))
addfield(map, &desc, " ", "(Must be precise)",
NULL);
else
addfield(map, &desc, " ",
"(Precise event)", NULL);
}
if (msr != NULL)
addfield(map, &event, ",", msr->pname, msrval);
err = -EIO;
if (name && event) {
fixname(name);
err = func(data, name, event, desc);
}
free(event);
free(desc);
free(name);
if (err)
break;
tok += j;
}
EXPECT(tok - tokens == len, tok, "unexpected objects at end");
err = 0;
out_free:
free_json(map, size, tokens);
return err;
}
