/*------------------------------------------------------------------------------------------------------------------------*/
FIXErrCode fix_groups_to_string(FIXMsg* msg, FIXField const* field, FIXFieldDescr const* fdescr, char delimiter,
char** buff, uint32_t* buffLen, int32_t* crc, FIXError** error)
{
FIXErrCode res = int32_to_str(field->descr->type->tag, field->size, delimiter, 0, 0, buff, buffLen, error);
(*crc) += (FIX_SOH - delimiter);
for(uint32_t i = 0; i < field->size && res != FIX_FAILED; ++i)
{
FIXGroup* group = ((FIXGroups*)field->data)->group[i];
for(uint32_t i = 0; i < fdescr->group_count && res == FIX_SUCCESS; ++i)
{
FIXFieldDescr* child_fdescr = &fdescr->group[i];
FIXField* child_field = fix_field_get(msg, group, child_fdescr->type->tag);
if ((msg->parser->flags & PARSER_FLAG_CHECK_REQUIRED) && !child_field && (child_fdescr->flags & FIELD_FLAG_REQUIRED))
{
*error = fix_error_create(FIX_ERROR_FIELD_NOT_FOUND, "Field '%d' is required", child_fdescr->type->tag);
return FIX_FAILED;
}
else if (!child_field && i == 0)
{
*error = fix_error_create(FIX_ERROR_FIELD_NOT_FOUND, "Field '%d' must be first field in group", child_fdescr->type->tag);
return FIX_FAILED;
}
else if (child_field && child_field->descr->category == FIXFieldCategory_Group)
{
res = fix_groups_to_string(msg, child_field, child_fdescr, delimiter, buff, buffLen, crc, error);
}
else if(child_field)
{
res = field_to_str(child_field, delimiter, buff, buffLen, error);
(*crc) += (FIX_SOH - delimiter);
}
}
}
return FIX_SUCCESS;
}
void print_rec(const uint8_t *data)
{
size_t off = 0;
static bool first_rec = true;
static size_t col_width[LNF_FLD_TERM_];
if (output_params.print_records != OUTPUT_ITEM_YES) {
return;
}
if (first_rec) {
first_item = first_item ? false : (putchar('\n'), false);
for (size_t i = 0; i < fields_cnt; ++i) {
const char *header_str = field_get_name(fields[i].id);
const size_t header_str_len = strlen(header_str);
const size_t field_str_len = strlen(field_to_str(
fields[i].id, data + off));
col_width[i] = header_str_len > field_str_len ?
header_str_len : field_str_len;
col_width[i] += COL_WIDTH_RESERVE;
off += fields[i].size;
print_field(header_str, col_width[i],
PRETTY_PRINT_COL_WIDTH -
COL_WIDTH_RESERVE,
i == (fields_cnt - 1));
}
off = 0;
first_rec = false;
}
/* Loop through the fields in one record. */
for (size_t i = 0; i < fields_cnt; ++i) {
print_field(field_to_str(fields[i].id, data + off),
col_width[i], PRETTY_PRINT_COL_WIDTH -
COL_WIDTH_RESERVE,
i == (fields_cnt - 1));
off += fields[i].size;
}
}
static char *arg_to_str(struct event_filter *filter, struct filter_arg *arg)
{
char *str;
switch (arg->type) {
case FILTER_ARG_BOOLEAN:
str = malloc_or_die(6);
if (arg->boolean.value)
strcpy(str, "TRUE");
else
strcpy(str, "FALSE");
return str;
case FILTER_ARG_OP:
return op_to_str(filter, arg);
case FILTER_ARG_NUM:
return num_to_str(filter, arg);
case FILTER_ARG_STR:
return str_to_str(filter, arg);
case FILTER_ARG_VALUE:
return val_to_str(filter, arg);
case FILTER_ARG_FIELD:
return field_to_str(filter, arg);
case FILTER_ARG_EXP:
return exp_to_str(filter, arg);
default:
/* ?? */
return NULL;
}
}
error_code_t print_mem(lnf_mem_t *mem, size_t limit)
{
lnf_rec_t *rec; //record = line
size_t rec_cntr = 0; //aka lines counter
lnf_mem_cursor_t *cursor; //current record (line) cursor
size_t fld_max_size = 0; //maximum data size length in bytes
size_t data_max_strlen[LNF_FLD_TERM_] = {0}; //maximum data string len
if (output_params.print_records != OUTPUT_ITEM_YES) {
return E_OK;
}
first_item = first_item ? false : (putchar('\n'), false);
secondary_errno = lnf_rec_init(&rec);
if (secondary_errno != LNF_OK) {
print_err(E_LNF, secondary_errno, "lnf_rec_init()");
return E_LNF;
}
/*
* Find out maximum data type size of present fields, length of headers
* and last present field ID.
*/
for (size_t i = 0; i < fields_cnt; ++i) {
size_t header_str_len = strlen(field_get_name(fields[i].id));
MAX_ASSIGN(fld_max_size, fields[i].size);
MAX_ASSIGN(data_max_strlen[fields[i].id], header_str_len);
}
/* Find out max data length, converted to string. */
lnf_mem_first_c(mem, &cursor);
while (cursor != NULL) { //row loop
char buff[fld_max_size];
lnf_mem_read_c(mem, cursor, rec);
for (size_t i = 0; i < fields_cnt; ++i) { //column loop
size_t data_str_len;
//XXX: lnf_rec_fget() may return LNF_ERR_UNKFLD even if
//field is present (e.g. if duration is zero).
lnf_rec_fget(rec, fields[i].id, buff);
data_str_len = strlen(field_to_str(fields[i].id, buff));
MAX_ASSIGN(data_max_strlen[fields[i].id], data_str_len);
}
if (++rec_cntr == limit) {
break;
}
lnf_mem_next_c(mem, &cursor);
}
rec_cntr = 0;
/* Actual printing: header. */
for (size_t i = 0; i < fields_cnt; ++i) { //column loop
print_field(field_get_name(fields[i].id),
data_max_strlen[fields[i].id],
PRETTY_PRINT_COL_WIDTH, i == (fields_cnt - 1));
}
/* Actual printing: field data converted to string. */
lnf_mem_first_c(mem, &cursor);
while (cursor != NULL) { //row loop
char buff[fld_max_size];
lnf_mem_read_c(mem, cursor, rec);
for (size_t i = 0; i < fields_cnt; ++i) { //column loop
//XXX: see above lnf_rec_fget()
lnf_rec_fget(rec, fields[i].id, buff);
print_field(field_to_str(fields[i].id, buff),
data_max_strlen[fields[i].id],
PRETTY_PRINT_COL_WIDTH,
i == (fields_cnt - 1));
}
if (++rec_cntr == limit) {
break;
}
lnf_mem_next_c(mem, &cursor);
}
lnf_rec_free(rec);
return E_OK;
}
/** \brief Convert lnf_brec1_t structure to string.
*
* \param[in] brec lnf basic record 1.
* \return String containing lnf_brec1_t representation. Static memory.
*/
static const char * mylnf_brec_to_str(const lnf_brec1_t *brec)
{
static char res[MAX_STR_LEN];
size_t off = 0;
switch (output_params.format) {
case OUTPUT_FORMAT_PRETTY:
off += snprintf(res + off, MAX_STR_LEN - off, "%-27s",
field_to_str(LNF_FLD_FIRST, &brec->first));
off += snprintf(res + off, MAX_STR_LEN - off, "%-27s",
field_to_str(LNF_FLD_LAST, &brec->last));
off += snprintf(res + off, MAX_STR_LEN - off, "%-6s",
field_to_str(LNF_FLD_PROT, &brec->prot));
off += snprintf(res + off, MAX_STR_LEN - off, "%17s:",
field_to_str(LNF_FLD_SRCADDR, &brec->srcaddr));
off += snprintf(res + off, MAX_STR_LEN - off, "%-7s",
field_to_str(LNF_FLD_SRCPORT, &brec->srcport));
off += snprintf(res + off, MAX_STR_LEN - off, "%17s:",
field_to_str(LNF_FLD_DSTADDR, &brec->dstaddr));
off += snprintf(res + off, MAX_STR_LEN - off, "%-7s",
field_to_str(LNF_FLD_DSTPORT, &brec->dstport));
off += snprintf(res + off, MAX_STR_LEN - off, "%13s",
field_to_str(LNF_FLD_DOCTETS, &brec->bytes));
off += snprintf(res + off, MAX_STR_LEN - off, "%13s",
field_to_str(LNF_FLD_DPKTS, &brec->pkts));
off += snprintf(res + off, MAX_STR_LEN - off, "%13s",
field_to_str(LNF_FLD_AGGR_FLOWS, &brec->flows));
break;
case OUTPUT_FORMAT_CSV:
off += snprintf(res + off, MAX_STR_LEN - off, "%s%c",
field_to_str(LNF_FLD_FIRST, &brec->first),
CSV_SEP);
off += snprintf(res + off, MAX_STR_LEN - off, "%s%c",
field_to_str(LNF_FLD_LAST, &brec->last),
CSV_SEP);
off += snprintf(res + off, MAX_STR_LEN - off, "%s%c",
field_to_str(LNF_FLD_PROT, &brec->prot),
CSV_SEP);
off += snprintf(res + off, MAX_STR_LEN - off, "%s%c",
field_to_str(LNF_FLD_SRCADDR, &brec->srcaddr),
CSV_SEP);
off += snprintf(res + off, MAX_STR_LEN - off, "%s%c",
field_to_str(LNF_FLD_SRCPORT, &brec->srcport),
CSV_SEP);
off += snprintf(res + off, MAX_STR_LEN - off, "%s%c",
field_to_str(LNF_FLD_DSTADDR, &brec->dstaddr),
CSV_SEP);
off += snprintf(res + off, MAX_STR_LEN - off, "%s%c",
field_to_str(LNF_FLD_DSTPORT, &brec->dstport),
CSV_SEP);
off += snprintf(res + off, MAX_STR_LEN - off, "%s%c",
field_to_str(LNF_FLD_DOCTETS, &brec->bytes),
CSV_SEP);
off += snprintf(res + off, MAX_STR_LEN - off, "%s%c",
field_to_str(LNF_FLD_DPKTS, &brec->pkts),
CSV_SEP);
off += snprintf(res + off, MAX_STR_LEN - off, "%s",
field_to_str(LNF_FLD_AGGR_FLOWS, &brec->flows));
break;
default:
assert(!"unknown output format");
}
return res;
}
