static int file_read_header(avro_reader_t reader,
avro_schema_t * writers_schema, char *sync,
int synclen)
{
int rval;
avro_schema_t meta_schema;
avro_schema_t meta_values_schema;
avro_datum_t meta;
char magic[4];
avro_datum_t schema_bytes;
char *p;
int64_t len;
avro_schema_error_t schema_error;
check(rval, avro_read(reader, magic, sizeof(magic)));
if (magic[0] != 'O' || magic[1] != 'b' || magic[2] != 'j'
|| magic[3] != 1) {
return EILSEQ;
}
meta_values_schema = avro_schema_bytes();
meta_schema = avro_schema_map(meta_values_schema);
rval = avro_read_data(reader, meta_schema, NULL, &meta);
if (rval) {
return EILSEQ;
}
check(rval, avro_map_get(meta, "avro.schema", &schema_bytes));
avro_bytes_get(schema_bytes, &p, &len);
check(rval,
avro_schema_from_json(p, len, writers_schema, &schema_error));
avro_schema_decref(meta);
return avro_read(reader, sync, synclen);
}
int avro_file_reader_read(avro_file_reader_t r, avro_schema_t readers_schema,
avro_datum_t * datum)
{
int rval;
char sync[16];
if (!r || !datum) {
return EINVAL;
}
check(rval,
avro_read_data(r->reader, r->writers_schema, readers_schema,
datum));
r->blocks_read++;
if (r->blocks_read == r->blocks_total) {
check(rval, avro_read(r->reader, sync, sizeof(sync)));
if (memcmp(r->sync, sync, sizeof(r->sync)) != 0) {
/* wrong sync bytes */
return EILSEQ;
}
/* For now, ignore errors (e.g. EOF) */
file_read_block_count(r);
}
return 0;
}
int
avro_consume_binary(avro_reader_t reader, avro_consumer_t *consumer, void *ud)
{
int rval;
const avro_encoding_t *enc = &avro_binary_encoding;
check_param(EINVAL, reader, "reader");
check_param(EINVAL, consumer, "consumer");
switch (avro_typeof(consumer->schema)) {
case AVRO_NULL:
check_prefix(rval, enc->read_null(reader),
"Cannot read null value: ");
check(rval, avro_consumer_call(consumer, null_value, ud));
break;
case AVRO_BOOLEAN:
{
int8_t b;
check_prefix(rval, enc->read_boolean(reader, &b),
"Cannot read boolean value: ");
check(rval, avro_consumer_call(consumer, boolean_value, b, ud));
}
break;
case AVRO_STRING:
{
int64_t len;
char *s;
check_prefix(rval, enc->read_string(reader, &s, &len),
"Cannot read string value: ");
check(rval, avro_consumer_call(consumer, string_value, s, len, ud));
}
break;
case AVRO_INT32:
{
int32_t i;
check_prefix(rval, enc->read_int(reader, &i),
"Cannot read int value: ");
check(rval, avro_consumer_call(consumer, int_value, i, ud));
}
break;
case AVRO_INT64:
{
int64_t l;
check_prefix(rval, enc->read_long(reader, &l),
"Cannot read long value: ");
check(rval, avro_consumer_call(consumer, long_value, l, ud));
}
break;
case AVRO_FLOAT:
{
float f;
check_prefix(rval, enc->read_float(reader, &f),
"Cannot read float value: ");
check(rval, avro_consumer_call(consumer, float_value, f, ud));
}
break;
case AVRO_DOUBLE:
{
double d;
check_prefix(rval, enc->read_double(reader, &d),
"Cannot read double value: ");
check(rval, avro_consumer_call(consumer, double_value, d, ud));
}
break;
case AVRO_BYTES:
{
char *bytes;
int64_t len;
check_prefix(rval, enc->read_bytes(reader, &bytes, &len),
"Cannot read bytes value: ");
check(rval, avro_consumer_call(consumer, bytes_value, bytes, len, ud));
}
break;
case AVRO_FIXED:
{
char *bytes;
int64_t size =
avro_schema_to_fixed(consumer->schema)->size;
bytes = avro_malloc(size);
if (!bytes) {
avro_prefix_error("Cannot allocate new fixed value");
return ENOMEM;
}
rval = avro_read(reader, bytes, size);
if (rval) {
avro_prefix_error("Cannot read fixed value: ");
avro_free(bytes, size);
return rval;
}
rval = avro_consumer_call(consumer, fixed_value, bytes, size, ud);
if (rval) {
avro_free(bytes, size);
return rval;
}
}
break;
case AVRO_ENUM:
check(rval, read_enum(reader, enc, consumer, ud));
break;
case AVRO_ARRAY:
check(rval, read_array(reader, enc, consumer, ud));
break;
case AVRO_MAP:
check(rval, read_map(reader, enc, consumer, ud));
break;
case AVRO_UNION:
check(rval, read_union(reader, enc, consumer, ud));
break;
case AVRO_RECORD:
check(rval, read_record(reader, enc, consumer, ud));
break;
case AVRO_LINK:
avro_set_error("Consumer can't consume a link schema directly");
return EINVAL;
}
return 0;
}
