static void
printdata(size_t level, const void *v, size_t x, size_t l)
{
const uint8_t *p = v, *ep = p + l;
size_t ox;
char buf[128];
while (p + x < ep) {
const uint8_t *q;
uint8_t c = getclass(p[x]);
uint8_t t = gettype(p[x]);
ox = x;
if (x != 0)
printf("%.2x %.2x %.2x\n", p[x - 1], p[x], p[x + 1]);
uint32_t tag = gettag(p, &x, ep - p + x);
if (p + x >= ep)
break;
uint32_t len = getlength(p, &x, ep - p + x);
printf("%zu %zu-%zu %c,%c,%s,%u:", level, ox, x,
der_class[c], der_type[t],
der_tag(buf, sizeof(buf), tag), len);
q = p + x;
if (p + len > ep)
errx(EXIT_FAILURE, "corrupt der");
printtag(tag, q, len);
if (t != DER_TYPE_PRIMITIVE)
printdata(level + 1, p, x, len + x);
x += len;
}
}
int mm_init(void)
{
t_block prolog_header, prolog_footer, epilog;
//printf("sizeof struct:%d\n",sizeof(struct s_block));
//try to allocated 3* Struct(8bytes) = 24 bytes
if ((heap_listp = mem_sbrk(3*sizeof(struct s_block))) == NULL)
return -1;
prolog_header = heap_listp;
prolog_header->size = PACK(0,USED);
prolog_footer = heap_listp + 1;
epilog = heap_listp + 2;
prolog_header->size = PACK(0,USED);
prolog_footer->size = PACK(0,USED);
epilog->size = PACK(0,USED);
printtag(epilog);
heap_listp += 1;
//printblock(heap_listp);
return 0;
}
int main(int argc, char **argv) {
uint32_t length; // length of the BlockHeader message
BlockHeader *bhmsg = NULL; // serialized BlockHeader message
Blob *bmsg = NULL; // serialized Blob message (size is given in the header)
FILE * fd;
char lenbuf[4];
unsigned char *buf = NULL;
enum {
osmheader,
osmdata
} state = osmheader;
if (argc == 2) {
fd = fopen(argv[1], "r");
if (fd == NULL) {
fprintf(stderr, "Can't open %s", argv[1]);
return -1;
}
} else {
fd = stdin;
}
fputs_unlocked("<?xml version='1.0' encoding='UTF-8'?>\n<osm version=\"0.6\" generator=\"" PACKAGE_STRING "\">""\n", stdout);
do {
if (!fread(lenbuf, 4, 1, fd)) break;
length = ntohl(*((uint32_t *) lenbuf)); // convert the buffer to a value
if (verbose) fprintf(stderr, "Length BlockHeader: %d\n", length);
if (length == 0 || length > MAX_BLOCK_HEADER_SIZE) {
if (feof(fd)) {
break;
}
fprintf(stderr, "Block Header isn't present or exceeds minimum/maximum size\n");
return 1;
}
/* Since we know the length of the BlockHeader now, we can allocate it */
buf = (unsigned char *) malloc(length * sizeof(unsigned char));
if (buf == NULL) {
fprintf (stderr, "Error allocating BlockHeader buffer\n");
return 1;
}
/* We are reading the BlockHeader */
if(! fread(buf, length, 1, fd)) break;
bhmsg = block_header__unpack (NULL, length, buf);
free(buf);
if (bhmsg == NULL) {
fprintf(stderr, "Error unpacking BlockHeader message\n");
return 1;
}
length = bhmsg->datasize;
if (verbose) fprintf(stderr, "Type: %s\nLength: %u\n", bhmsg->type, length);
if (length <= 0 || length > MAX_BLOB_SIZE) {
fprintf(stderr, "Blob isn't present or exceeds minimum/maximum size\n");
return 1;
}
if (strcmp(bhmsg->type, "OSMHeader") == 0) {
state = osmheader;
} else if (strcmp(bhmsg->type, "OSMData") == 0) {
state = osmdata;
}
block_header__free_unpacked (bhmsg, &protobuf_c_system_allocator);
/* We are now reading the 'Blob' */
buf = (unsigned char *) malloc(length * sizeof(unsigned char *));
if(! fread(buf, length, 1, fd)) break;
bmsg = blob__unpack (NULL, length, buf);
if (bmsg == NULL) {
fprintf(stderr, "Error unpacking Blob message\n");
return 1;
}
free(buf);
unsigned char *uncompressed;
if (bmsg->has_raw) {
uncompressed = bmsg->raw.data;
bmsg->raw_size = bmsg->raw.len; // I wonder if we should do this.
} else {
uncompressed = handleCompressedBlob(bmsg);
if (uncompressed == NULL) {
fprintf(stderr, "Uncompression failed\n");
return 1;
}
}
if (state == osmheader) {
HeaderBlock *hmsg = header_block__unpack (NULL, bmsg->raw_size, uncompressed);
if (hmsg == NULL) {
fprintf(stderr, "Error unpacking HeaderBlock message\n");
return 1;
}
if (verbose) fprintf(stderr, "%s\n", hmsg->required_features[0]);
header_block__free_unpacked (hmsg, &protobuf_c_system_allocator);
} else if (state == osmdata) {
/*
* Unpack Block and check if all went well
*/
PrimitiveBlock *pmsg = primitive_block__unpack (NULL, bmsg->raw_size, uncompressed);
if (pmsg == NULL) {
fprintf(stderr, "Error unpacking PrimitiveBlock message\n");
return 1;
}
double lat_offset = NANO_DEGREE * pmsg->lat_offset;
double lon_offset = NANO_DEGREE * pmsg->lon_offset;
double granularity = NANO_DEGREE * pmsg->granularity;
if (verbose) fprintf(stderr, "\t""Granularity: %d""\n", pmsg->granularity);
if (verbose) fprintf(stderr, "\t""Primitive groups: %li""\n", pmsg->n_primitivegroup);
for (unsigned int j = 0; j < pmsg->n_primitivegroup; j++) {
if (verbose) fprintf(stderr,"\t\t""Nodes: %li""\n"\
"\t\t""Ways: %li""\n"\
"\t\t""Relations: %li""\n",
(pmsg->primitivegroup[j]->dense ?
pmsg->primitivegroup[j]->dense->n_id :
pmsg->primitivegroup[j]->n_nodes),
pmsg->primitivegroup[j]->n_ways,
pmsg->primitivegroup[j]->n_relations);
/* TODO: Nodes is *untested* */
if (pmsg->primitivegroup[j]->n_nodes > 0) {
for (unsigned k = 0; k < pmsg->primitivegroup[j]->n_nodes; k++) {
Node *node = pmsg->primitivegroup[j]->nodes[k];
printf("\t""<node id=\"%li\" lat=\"%.07f\" lon=\"%.07f\"",
node->id,
lat_offset + (node->lat * granularity),
lon_offset + (node->lon * granularity));
if (node->info) {
Info *info = node->info;
if (info->has_version) {
printnumericattribute("version", info->version);
}
if (info->has_changeset) {
printnumericattribute("changeset", info->changeset);
}
if (info->has_user_sid) {
ProtobufCBinaryData user = pmsg->stringtable->s[info->user_sid];
printuser(user);
}
if (info->has_uid) {
printnumericattribute("uid", info->uid);
}
if (info->has_timestamp) {
printtimestamp("timestamp", info->timestamp);
}
}
if (node->n_keys == 0 || node->n_vals == 0) {
fputs_unlocked("/>""\n", stdout);
} else {
fputs_unlocked(">""\n", stdout);
for (unsigned l = 0; l < node->n_keys; l++) {
ProtobufCBinaryData key = pmsg->stringtable->s[node->keys[l]];
ProtobufCBinaryData val = pmsg->stringtable->s[node->vals[l]];
printtag(key, val);
}
fputs_unlocked("\t""</node>""\n", stdout);
}
}
}
else
if (pmsg->primitivegroup[j]->n_ways > 0) {
for (unsigned k = 0; k < pmsg->primitivegroup[j]->n_ways; k++) {
Way *way = pmsg->primitivegroup[j]->ways[k];
printsotid("way", way->id);
if (way->info) {
Info *info = way->info;
if (info->has_version) {
printnumericattribute("version", info->version);
}
if (info->has_changeset) {
printnumericattribute("changeset", info->changeset);
}
if (info->has_user_sid) {
ProtobufCBinaryData user = pmsg->stringtable->s[info->user_sid];
printuser(user);
}
if (info->has_uid) {
printnumericattribute("uid", info->uid);
}
if (info->has_timestamp) {
printtimestamp("timestamp", info->timestamp);
}
}
if ((way->n_keys == 0 || way->n_vals == 0) && way->n_refs == 0) {
fputs_unlocked("/>""\n", stdout);
} else {
long int deltaref = 0;
fputs_unlocked(">""\n", stdout);
for (unsigned l = 0; l < way->n_refs; l++) {
deltaref += way->refs[l];
printnd(deltaref);
}
for (unsigned l = 0; l < way->n_keys; l++) {
ProtobufCBinaryData key = pmsg->stringtable->s[way->keys[l]];
ProtobufCBinaryData val = pmsg->stringtable->s[way->vals[l]];
printtag(key, val);
}
fputs_unlocked("\t""</way>""\n", stdout);
}
}
}
else
if (pmsg->primitivegroup[j]->n_relations > 0) {
for (unsigned k = 0; k < pmsg->primitivegroup[j]->n_relations; k++) {
Relation *relation = pmsg->primitivegroup[j]->relations[k];
printsotid("relation", relation->id);
if (relation->info) {
Info *info = relation->info;
if (info->has_version) {
printnumericattribute("version", info->version);
}
if (info->has_changeset) {
printnumericattribute("changeset", info->changeset);
}
if (info->has_user_sid) {
ProtobufCBinaryData user = pmsg->stringtable->s[info->user_sid];
printuser(user);
}
if (info->has_uid) {
printnumericattribute("uid", info->uid);
}
if (info->has_timestamp) {
printtimestamp("timestamp", info->timestamp);
}
}
if ((relation->n_keys == 0 || relation->n_vals == 0) && relation->n_memids == 0) {
fputs_unlocked("/>""\n", stdout);
} else {
long int deltamemids = 0;
fputs_unlocked(">""\n", stdout);
for (unsigned l = 0; l < relation->n_memids; l++) {
char *type;
ProtobufCBinaryData role = pmsg->stringtable->s[relation->roles_sid[l]];
deltamemids += relation->memids[l];
switch (relation->types[l]) {
case RELATION__MEMBER_TYPE__NODE:
type = "node";
break;
case RELATION__MEMBER_TYPE__WAY:
type = "way";
break;
case RELATION__MEMBER_TYPE__RELATION:
type = "relation";
break;
default:
fprintf(stderr, "Unsupported type: %u""\n", relation->types[l]);
return 1;
}
printmember(type, deltamemids, role);
}
for (unsigned l = 0; l < relation->n_keys; l++) {
ProtobufCBinaryData key = pmsg->stringtable->s[relation->keys[l]];
ProtobufCBinaryData val = pmsg->stringtable->s[relation->vals[l]];
printtag(key, val);
}
fputs_unlocked("\t""</relation>""\n", stdout);
}
}
}
else
if (pmsg->primitivegroup[j]->n_changesets > 0) {
for (unsigned k = 0; k < pmsg->primitivegroup[j]->n_changesets; k++) {
ChangeSet *changeset = pmsg->primitivegroup[j]->changesets[k];
printsotid("changeset", changeset->id);
if (changeset->info) {
Info *info = changeset->info;
/* Not in Changeset
if (info->has_version) {
printnumericattribute("version", info->version);
}
if (info->has_changeset) {
printnumericattribute("changeset", info->changeset);
}*/
if (info->has_user_sid) {
ProtobufCBinaryData user = pmsg->stringtable->s[info->user_sid];
printuser(user);
}
if (info->has_uid) {
printnumericattribute("uid", info->uid);
}
if (info->has_timestamp) {
printtimestamp("created_at", info->timestamp);
if (changeset->has_closetime_delta) {
printtimestamp("closed_at", (info->timestamp + changeset->closetime_delta));
}
}
}
printf(" open=\"%s\" min_lon=\"%.07f\" min_lat=\"%.07f\" max_lon=\"%.07f\" max_lat=\"%.07f\"",
(changeset->open ? "true" : "false"),
lat_offset + (changeset->bbox->left * granularity),
lon_offset + (changeset->bbox->bottom * granularity),
lat_offset + (changeset->bbox->right * granularity),
lon_offset + (changeset->bbox->top * granularity));
if (changeset->n_keys == 0 || changeset->n_vals == 0) {
fputs_unlocked("/>""\n", stdout);
} else {
fputs_unlocked(">""\n", stdout);
for (unsigned l = 0; l < changeset->n_keys; l++) {
ProtobufCBinaryData key = pmsg->stringtable->s[changeset->keys[l]];
ProtobufCBinaryData val = pmsg->stringtable->s[changeset->vals[l]];
printtag(key, val);
}
fputs_unlocked("\t""</changeset>""\n", stdout);
}
}
}
else
if (pmsg->primitivegroup[j]->dense) {
unsigned l = 0;
unsigned long int deltaid = 0;
long int deltalat = 0;
long int deltalon = 0;
unsigned long int deltatimestamp = 0;
unsigned long int deltachangeset = 0;
long int deltauid = 0;
unsigned long int deltauser_sid = 0;
DenseNodes *dense = pmsg->primitivegroup[j]->dense;
for (unsigned k = 0; k < dense->n_id; k++) {
unsigned char has_tags = 0;
deltaid += dense->id[k];
deltalat += dense->lat[k];
deltalon += dense->lon[k];
printf("\t""<node id=\"%li\" lat=\"%.07f\" lon=\"%.07f\"", deltaid,
lat_offset + (deltalat * granularity),
lon_offset + (deltalon * granularity));
if (dense->denseinfo) {
DenseInfo *denseinfo = dense->denseinfo;
deltatimestamp += denseinfo->timestamp[k];
deltachangeset += denseinfo->changeset[k];
deltauid += denseinfo->uid[k];
deltauser_sid += denseinfo->user_sid[k];
printnumericattribute("version", denseinfo->version[k]);
printnumericattribute("changeset", deltachangeset);
if (deltauid != -1) { // osmosis devs failed to read the specs
printuser(pmsg->stringtable->s[deltauser_sid]);
printnumericattribute("uid", deltauid);
}
printtimestamp("timestamp", deltatimestamp);
}
if (l < dense->n_keys_vals) {
while (dense->keys_vals[l] != 0 && l < dense->n_keys_vals) {
if (has_tags < 1) {
has_tags++;
fputs_unlocked(">\n", stdout);
}
ProtobufCBinaryData key = pmsg->stringtable->s[dense->keys_vals[l]];
ProtobufCBinaryData val = pmsg->stringtable->s[dense->keys_vals[l+1]];
printtag(key, val);
l += 2;
}
l += 1;
}
if (has_tags < 1) {
fputs_unlocked("/>""\n", stdout);
} else {
fputs_unlocked("\t""</node>""\n", stdout);
}
}
}
}
primitive_block__free_unpacked (pmsg, &protobuf_c_system_allocator);
}
if (!bmsg->has_raw) free(uncompressed);
blob__free_unpacked (bmsg, &protobuf_c_system_allocator);
} while (!feof(fd));
fputs_unlocked("</osm>""\n", stdout);
if (!feof(fd)) {
fprintf(stderr, "Input processing terminated early\n");
return 1;
}
return 0;
}
