navit/maptool/osm_protobuf.c

/**
 * Navit, a modular navigation system.
 * Copyright (C) 2005-2011 Navit Team
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <unistd.h>
#include <time.h>
#include <zlib.h>
#include "maptool.h"
#include "debug.h"
#include "linguistics.h"
#include "file.h"
#include "generated-code/fileformat.pb-c.h"
#include "generated-code/osmformat.pb-c.h"


static double latlon_scale=10000000.0;

static OSMPBF__BlobHeader *
read_header(FILE *f)
{
        unsigned char *buffer,lenb[4];
        int len;

        len=sizeof(lenb);
        if (fread(lenb, 4, 1, f) != 1)
                return NULL;
        len=(lenb[0] << 24) | (lenb[1] << 16) | (lenb[2] << 8) | lenb[3];
        buffer=alloca(len);
        if (fread(buffer, len, 1, f) != 1)
                return NULL;
        return osmpbf__blob_header__unpack(&protobuf_c_system_allocator, len, buffer);
}


static OSMPBF__Blob *
read_blob(OSMPBF__BlobHeader *header, FILE *f)
{
        unsigned char *buffer;
        int len=header->datasize;

        buffer=alloca(len);
        if (fread(buffer, len, 1, f) != 1)
                return NULL;
        return osmpbf__blob__unpack(&protobuf_c_system_allocator, len, buffer);
}

static unsigned char *
uncompress_blob(OSMPBF__Blob *blob)
{
        unsigned char *ret=malloc(blob->raw_size);
        int zerr;
        z_stream strm;

        if (!ret)
                return NULL;
        strm.zalloc = Z_NULL;
        strm.zfree = Z_NULL;
        strm.opaque = Z_NULL;
        strm.avail_in=blob->zlib_data.len;
        strm.next_in=blob->zlib_data.data;
        strm.avail_out=blob->raw_size;
        strm.next_out=ret;
        zerr = inflateInit(&strm);
        if (zerr != Z_OK) {
                free(ret);
                return NULL;
        }
        zerr = inflate(&strm, Z_NO_FLUSH);
        if (zerr != Z_STREAM_END) {
                free(ret);
                return NULL;
        }
        inflateEnd(&strm);
        return ret;
}

static int
get_string(char *buffer, int buffer_size, OSMPBF__PrimitiveBlock *primitive_block, int id, int escape)
{
        int len=primitive_block->stringtable->s[id].len;
        char *data=(char *)primitive_block->stringtable->s[id].data;
        if (primitive_block->stringtable->s[id].len >= buffer_size) {
                buffer[0]='\0';
                return 0;
        }
        if (escape) {
                int i;
                char *p=buffer;
                for (i = 0 ; i < len ; i++) {
                        switch(data[i]) {
                        case '\t':
                        case '\r':
                        case '\n':
                        case '>':
                        case '<':
                        case '\'':
                        case '"':
                        case '&':
                                sprintf(p,"&#%d;",data[i]);
                                p+=strlen(p);
                                break;
                        default:
                                *p++=data[i];
                        }
                }
                *p++='\0';
                return 1;
        } else {
                strncpy(buffer, data, len);
                buffer[len]='\0';
                return 1;
        }
}


static void
process_osmheader(OSMPBF__Blob *blob, unsigned char *data)
{
        OSMPBF__HeaderBlock *header_block;
        header_block=osmpbf__header_block__unpack(&protobuf_c_system_allocator, blob->raw_size, data);
        osmpbf__header_block__free_unpacked(header_block, &protobuf_c_system_allocator);
}

#if 0

static void
process_user(OSMPBF__PrimitiveBlock *primitive_block, int user_sid, int uid, int swap)
{
        char userbuff[1024];
        get_string(userbuff, sizeof(userbuff), primitive_block, user_sid, 1);
        if (userbuff[0] && uid != -1) {
                if (swap)
                        printf(" uid=\"%d\" user=\"%s\"",uid,userbuff);
                else
                        printf(" user=\"%s\" uid=\"%d\"",userbuff,uid);
        }
}

static void
process_timestamp(long long timestamp)
{
        time_t ts;
        struct tm *tm;
        char tsbuff[1024];
        ts=timestamp;
        tm=gmtime(&ts);
        strftime(tsbuff, sizeof(tsbuff), "%Y-%m-%dT%H:%M:%SZ", tm);
        printf(" timestamp=\"%s\"",tsbuff);
}

#endif

static void
process_tag(OSMPBF__PrimitiveBlock *primitive_block, int key, int val)
{
        char keybuff[1024];
        char valbuff[1024];
#if 0
        get_string(keybuff, sizeof(keybuff), primitive_block, key, 1);
        get_string(valbuff, sizeof(valbuff), primitive_block, val, 1);
        printf("\t\t<tag k=\"%s\" v=\"%s\" />\n",keybuff,valbuff);
#else
        get_string(keybuff, sizeof(keybuff), primitive_block, key, 0);
        get_string(valbuff, sizeof(valbuff), primitive_block, val, 0);
        osm_add_tag(keybuff, valbuff);
#endif
}


static void
process_dense(OSMPBF__PrimitiveBlock *primitive_block, OSMPBF__DenseNodes *dense, FILE *out_nodes)
{
        int i,j=0,has_tags;
        long long id=0,lat=0,lon=0,changeset=0,timestamp=0;
        int version,user_sid=0,uid=0;

        if (!dense)
                return;

        for (i = 0 ; i < dense->n_id ; i++) {
                id+=dense->id[i];
                lat+=dense->lat[i];
                lon+=dense->lon[i];
                version=dense->denseinfo->version[i];
                changeset+=dense->denseinfo->changeset[i];
                user_sid+=dense->denseinfo->user_sid[i];
                uid+=dense->denseinfo->uid[i];
                timestamp+=dense->denseinfo->timestamp[i];
                has_tags=dense->keys_vals && dense->keys_vals[j];
                osm_add_node(id, lat/latlon_scale,lon/latlon_scale);
#if 0
                printf("\t<node id=\"%Ld\" lat=\"%.7f\" lon=\"%.7f\" version=\"%d\" changeset=\"%Ld\"",id,lat/latlon_scale,lon/latlon_scale,version,changeset);
                process_user(primitive_block, user_sid, uid, 0);
                process_timestamp(timestamp);
#endif
                if (has_tags) {
#if 0
                        printf(">\n");
#endif
                        while (dense->keys_vals[j]) {
                                process_tag(primitive_block, dense->keys_vals[j], dense->keys_vals[j+1]);
                                j+=2;
                        }
#if 0
                        printf("\t</node>\n");
                } else
                        printf("/>\n");
#else
                }
#endif
                osm_end_node(out_nodes);
                j++;
        }
}

#if 0
static void
process_info(OSMPBF__PrimitiveBlock *primitive_block, OSMPBF__Info *info)
{
        printf(" version=\"%d\" changeset=\"%Ld\"",info->version,info->changeset);
        process_user(primitive_block, info->user_sid, info->uid, 1);
        process_timestamp(info->timestamp);
}
#endif

static void
process_way(OSMPBF__PrimitiveBlock *primitive_block, OSMPBF__Way *way, FILE *out_ways)
{
        int i;
        long long ref=0;

        osm_add_way(way->id);
#if 0
        printf("\t<way id=\"%Ld\"",way->id);
        process_info(primitive_block, way->info);
        printf(">\n");
#else
#endif
        for (i = 0 ; i < way->n_refs ; i++) {
                ref+=way->refs[i];
                osm_add_nd(ref);
#if 0
                printf("\t\t<nd ref=\"%Ld\"/>\n",ref);
#else
#endif
        }
        for (i = 0 ; i < way->n_keys ; i++) 
                process_tag(primitive_block, way->keys[i], way->vals[i]);
#if 0
        printf("\t</way>\n");
#endif
        osm_end_way(out_ways);
}

static void
process_relation(OSMPBF__PrimitiveBlock *primitive_block, OSMPBF__Relation *relation, FILE *out_turn_restrictions, FILE *out_boundaries)
{
        int i;
        long long ref=0;
        char rolebuff[1024];

#if 0
        printf("\t<relation id=\"%Ld\"",relation->id);
        process_info(primitive_block, relation->info);
        printf(">\n");
#endif
        osm_add_relation(relation->id);
        for (i = 0 ; i < relation->n_roles_sid ; i++) {
#if 0
                printf("\t\t<member type=\"");
                switch (relation->types[i]) {
                case 0:
                        printf("node");
                        break;
                case 1:
                        printf("way");
                        break;
                case 2:
                        printf("relation");
                        break;
                default:
                        printf("unknown");
                        break;
                }
#endif
                ref+=relation->memids[i];
                get_string(rolebuff, sizeof(rolebuff), primitive_block, relation->roles_sid[i], 1);
#if 0
                printf("\" ref=\"%Ld\" role=\"%s\"/>\n",ref,rolebuff);
#else
                osm_add_member(relation->types[i]+1,ref,rolebuff);
#endif
        }
        for (i = 0 ; i < relation->n_keys ; i++) 
                process_tag(primitive_block, relation->keys[i], relation->vals[i]);
#if 0
        printf("\t</relation>\n");
#else
        osm_end_relation(out_turn_restrictions, out_boundaries);
#endif
}

static void
process_osmdata(OSMPBF__Blob *blob, unsigned char *data, FILE *out_nodes, FILE *out_ways, FILE *out_turn_restrictions, FILE *out_boundaries)
{
        int i,j;
        OSMPBF__PrimitiveBlock *primitive_block;
        primitive_block=osmpbf__primitive_block__unpack(&protobuf_c_system_allocator, blob->raw_size, data);
        for (i = 0 ; i < primitive_block->n_primitivegroup ; i++) {
                OSMPBF__PrimitiveGroup *primitive_group=primitive_block->primitivegroup[i];
                process_dense(primitive_block, primitive_group->dense, out_nodes);
                for (j = 0 ; j < primitive_group->n_ways ; j++)
                        process_way(primitive_block, primitive_group->ways[j], out_ways);
                for (j = 0 ; j < primitive_group->n_relations ; j++)
                        process_relation(primitive_block, primitive_group->relations[j], out_turn_restrictions, out_boundaries);
#if 0
                printf("Group %p %d %d %d %d\n",primitive_group->dense,primitive_group->n_nodes,primitive_group->n_ways,primitive_group->n_relations,primitive_group->n_changesets);
#endif
        }
        osmpbf__primitive_block__free_unpacked(primitive_block, &protobuf_c_system_allocator);
}


int
map_collect_data_osm_protobuf(FILE *in, FILE *out_ways, FILE *out_nodes, FILE *out_turn_restrictions, FILE *out_boundaries)
{
        OSMPBF__BlobHeader *header;
        OSMPBF__Blob *blob;
        unsigned char *data;
#if 0
        printf("<?xml version='1.0' encoding='UTF-8'?>\n");
        printf("<osm version=\"0.6\" generator=\"pbf2osm\">\n");
#endif
        while ((header=read_header(in))) {
                blob=read_blob(header, in);
                data=uncompress_blob(blob);
                if (!strcmp(header->type,"OSMHeader")) {
                        process_osmheader(blob, data);
                } else if (!strcmp(header->type,"OSMData")) {
                        process_osmdata(blob, data, out_nodes, out_ways, out_turn_restrictions, out_boundaries);
                } else {
                        printf("unknown\n");
                        return 0;
                }
                free(data);
                osmpbf__blob__free_unpacked(blob, &protobuf_c_system_allocator);
                osmpbf__blob_header__free_unpacked(header, &protobuf_c_system_allocator);
        }
#if 0
        printf("</osm>\n");
#endif
        return 1;
}
1	zoff99	8	/**
2			* Navit, a modular navigation system.
3			* Copyright (C) 2005-2011 Navit Team
4			*
5			* This program is free software; you can redistribute it and/or
6			* modify it under the terms of the GNU General Public License
7			* version 2 as published by the Free Software Foundation.
8			*
9			* This program is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12			* GNU General Public License for more details.
13			*
14			* You should have received a copy of the GNU General Public License
15			* along with this program; if not, write to the
16			* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17			* Boston, MA 02110-1301, USA.
18			*/
19			#include <string.h>
20			#include <stdlib.h>
21			#include <math.h>
22			#include <unistd.h>
23			#include <time.h>
24			#include <zlib.h>
25			#include "maptool.h"
26			#include "debug.h"
27			#include "linguistics.h"
28			#include "file.h"
29			#include "generated-code/fileformat.pb-c.h"
30			#include "generated-code/osmformat.pb-c.h"
31
32
33			static double latlon_scale=10000000.0;
34
35			static OSMPBF__BlobHeader *
36			read_header(FILE *f)
37			{
38			unsigned char *buffer,lenb[4];
39			int len;
40
41			len=sizeof(lenb);
42			if (fread(lenb, 4, 1, f) != 1)
43			return NULL;
44			len=(lenb[0] << 24) \| (lenb[1] << 16) \| (lenb[2] << 8) \| lenb[3];
45			buffer=alloca(len);
46			if (fread(buffer, len, 1, f) != 1)
47			return NULL;
48			return osmpbf__blob_header__unpack(&protobuf_c_system_allocator, len, buffer);
49			}
50
51
52			static OSMPBF__Blob *
53			read_blob(OSMPBF__BlobHeader header, FILE f)
54			{
55			unsigned char *buffer;
56			int len=header->datasize;
57
58			buffer=alloca(len);
59			if (fread(buffer, len, 1, f) != 1)
60			return NULL;
61			return osmpbf__blob__unpack(&protobuf_c_system_allocator, len, buffer);
62			}
63
64			static unsigned char *
65			uncompress_blob(OSMPBF__Blob *blob)
66			{
67			unsigned char *ret=malloc(blob->raw_size);
68			int zerr;
69			z_stream strm;
70
71			if (!ret)
72			return NULL;
73			strm.zalloc = Z_NULL;
74			strm.zfree = Z_NULL;
75			strm.opaque = Z_NULL;
76			strm.avail_in=blob->zlib_data.len;
77			strm.next_in=blob->zlib_data.data;
78			strm.avail_out=blob->raw_size;
79			strm.next_out=ret;
80			zerr = inflateInit(&strm);
81			if (zerr != Z_OK) {
82			free(ret);
83			return NULL;
84			}
85			zerr = inflate(&strm, Z_NO_FLUSH);
86			if (zerr != Z_STREAM_END) {
87			free(ret);
88			return NULL;
89			}
90			inflateEnd(&strm);
91			return ret;
92			}
93
94			static int
95			get_string(char buffer, int buffer_size, OSMPBF__PrimitiveBlock primitive_block, int id, int escape)
96			{
97			int len=primitive_block->stringtable->s[id].len;
98			char data=(char )primitive_block->stringtable->s[id].data;
99			if (primitive_block->stringtable->s[id].len >= buffer_size) {
100			buffer[0]='\0';
101			return 0;
102			}
103			if (escape) {
104			int i;
105			char *p=buffer;
106			for (i = 0 ; i < len ; i++) {
107			switch(data[i]) {
108			case '\t':
109			case '\r':
110			case '\n':
111			case '>':
112			case '<':
113			case '\'':
114			case '"':
115			case '&':
116			sprintf(p,"&#%d;",data[i]);
117			p+=strlen(p);
118			break;
119			default:
120			*p++=data[i];
121			}
122			}
123			*p++='\0';
124			return 1;
125			} else {
126			strncpy(buffer, data, len);
127			buffer[len]='\0';
128			return 1;
129			}
130			}
131
132
133			static void
134			process_osmheader(OSMPBF__Blob blob, unsigned char data)
135			{
136			OSMPBF__HeaderBlock *header_block;
137			header_block=osmpbf__header_block__unpack(&protobuf_c_system_allocator, blob->raw_size, data);
138			osmpbf__header_block__free_unpacked(header_block, &protobuf_c_system_allocator);
139			}
140
141			#if 0
142
143			static void
144			process_user(OSMPBF__PrimitiveBlock *primitive_block, int user_sid, int uid, int swap)
145			{
146			char userbuff[1024];
147			get_string(userbuff, sizeof(userbuff), primitive_block, user_sid, 1);
148			if (userbuff[0] && uid != -1) {
149			if (swap)
150			printf(" uid=\"%d\" user=\"%s\"",uid,userbuff);
151			else
152			printf(" user=\"%s\" uid=\"%d\"",userbuff,uid);
153			}
154			}
155
156			static void
157			process_timestamp(long long timestamp)
158			{
159			time_t ts;
160			struct tm *tm;
161			char tsbuff[1024];
162			ts=timestamp;
163			tm=gmtime(&ts);
164			strftime(tsbuff, sizeof(tsbuff), "%Y-%m-%dT%H:%M:%SZ", tm);
165			printf(" timestamp=\"%s\"",tsbuff);
166			}
167
168			#endif
169
170			static void
171			process_tag(OSMPBF__PrimitiveBlock *primitive_block, int key, int val)
172			{
173			char keybuff[1024];
174			char valbuff[1024];
175			#if 0
176			get_string(keybuff, sizeof(keybuff), primitive_block, key, 1);
177			get_string(valbuff, sizeof(valbuff), primitive_block, val, 1);
178			printf("\t\t<tag k=\"%s\" v=\"%s\" />\n",keybuff,valbuff);
179			#else
180			get_string(keybuff, sizeof(keybuff), primitive_block, key, 0);
181			get_string(valbuff, sizeof(valbuff), primitive_block, val, 0);
182			osm_add_tag(keybuff, valbuff);
183			#endif
184			}
185
186
187			static void
188			process_dense(OSMPBF__PrimitiveBlock primitive_block, OSMPBF__DenseNodes dense, FILE *out_nodes)
189			{
190			int i,j=0,has_tags;
191			long long id=0,lat=0,lon=0,changeset=0,timestamp=0;
192			int version,user_sid=0,uid=0;
193
194			if (!dense)
195			return;
196
197			for (i = 0 ; i < dense->n_id ; i++) {
198			id+=dense->id[i];
199			lat+=dense->lat[i];
200			lon+=dense->lon[i];
201			version=dense->denseinfo->version[i];
202			changeset+=dense->denseinfo->changeset[i];
203			user_sid+=dense->denseinfo->user_sid[i];
204			uid+=dense->denseinfo->uid[i];
205			timestamp+=dense->denseinfo->timestamp[i];
206			has_tags=dense->keys_vals && dense->keys_vals[j];
207			osm_add_node(id, lat/latlon_scale,lon/latlon_scale);
208			#if 0
209			printf("\t<node id=\"%Ld\" lat=\"%.7f\" lon=\"%.7f\" version=\"%d\" changeset=\"%Ld\"",id,lat/latlon_scale,lon/latlon_scale,version,changeset);
210			process_user(primitive_block, user_sid, uid, 0);
211			process_timestamp(timestamp);
212			#endif
213			if (has_tags) {
214			#if 0
215			printf(">\n");
216			#endif
217			while (dense->keys_vals[j]) {
218			process_tag(primitive_block, dense->keys_vals[j], dense->keys_vals[j+1]);
219			j+=2;
220			}
221			#if 0
222			printf("\t</node>\n");
223			} else
224			printf("/>\n");
225			#else
226			}
227			#endif
228			osm_end_node(out_nodes);
229			j++;
230			}
231			}
232
233			#if 0
234			static void
235			process_info(OSMPBF__PrimitiveBlock primitive_block, OSMPBF__Info info)
236			{
237			printf(" version=\"%d\" changeset=\"%Ld\"",info->version,info->changeset);
238			process_user(primitive_block, info->user_sid, info->uid, 1);
239			process_timestamp(info->timestamp);
240			}
241			#endif
242
243			static void
244			process_way(OSMPBF__PrimitiveBlock primitive_block, OSMPBF__Way way, FILE *out_ways)
245			{
246			int i;
247			long long ref=0;
248
249			osm_add_way(way->id);
250			#if 0
251			printf("\t<way id=\"%Ld\"",way->id);
252			process_info(primitive_block, way->info);
253			printf(">\n");
254			#else
255			#endif
256			for (i = 0 ; i < way->n_refs ; i++) {
257			ref+=way->refs[i];
258			osm_add_nd(ref);
259			#if 0
260			printf("\t\t<nd ref=\"%Ld\"/>\n",ref);
261			#else
262			#endif
263			}
264			for (i = 0 ; i < way->n_keys ; i++)
265			process_tag(primitive_block, way->keys[i], way->vals[i]);
266			#if 0
267			printf("\t</way>\n");
268			#endif
269			osm_end_way(out_ways);
270			}
271
272			static void
273			process_relation(OSMPBF__PrimitiveBlock primitive_block, OSMPBF__Relation relation, FILE out_turn_restrictions, FILE out_boundaries)
274			{
275			int i;
276			long long ref=0;
277			char rolebuff[1024];
278
279			#if 0
280			printf("\t<relation id=\"%Ld\"",relation->id);
281			process_info(primitive_block, relation->info);
282			printf(">\n");
283			#endif
284			osm_add_relation(relation->id);
285			for (i = 0 ; i < relation->n_roles_sid ; i++) {
286			#if 0
287			printf("\t\t<member type=\"");
288			switch (relation->types[i]) {
289			case 0:
290			printf("node");
291			break;
292			case 1:
293			printf("way");
294			break;
295			case 2:
296			printf("relation");
297			break;
298			default:
299			printf("unknown");
300			break;
301			}
302			#endif
303			ref+=relation->memids[i];
304			get_string(rolebuff, sizeof(rolebuff), primitive_block, relation->roles_sid[i], 1);
305			#if 0
306			printf("\" ref=\"%Ld\" role=\"%s\"/>\n",ref,rolebuff);
307			#else
308			osm_add_member(relation->types[i]+1,ref,rolebuff);
309			#endif
310			}
311			for (i = 0 ; i < relation->n_keys ; i++)
312			process_tag(primitive_block, relation->keys[i], relation->vals[i]);
313			#if 0
314			printf("\t</relation>\n");
315			#else
316			osm_end_relation(out_turn_restrictions, out_boundaries);
317			#endif
318			}
319
320			static void
321			process_osmdata(OSMPBF__Blob blob, unsigned char data, FILE out_nodes, FILE out_ways, FILE out_turn_restrictions, FILE out_boundaries)
322			{
323			int i,j;
324			OSMPBF__PrimitiveBlock *primitive_block;
325			primitive_block=osmpbf__primitive_block__unpack(&protobuf_c_system_allocator, blob->raw_size, data);
326			for (i = 0 ; i < primitive_block->n_primitivegroup ; i++) {
327			OSMPBF__PrimitiveGroup *primitive_group=primitive_block->primitivegroup[i];
328			process_dense(primitive_block, primitive_group->dense, out_nodes);
329			for (j = 0 ; j < primitive_group->n_ways ; j++)
330			process_way(primitive_block, primitive_group->ways[j], out_ways);
331			for (j = 0 ; j < primitive_group->n_relations ; j++)
332			process_relation(primitive_block, primitive_group->relations[j], out_turn_restrictions, out_boundaries);
333			#if 0
334			printf("Group %p %d %d %d %d\n",primitive_group->dense,primitive_group->n_nodes,primitive_group->n_ways,primitive_group->n_relations,primitive_group->n_changesets);
335			#endif
336			}
337			osmpbf__primitive_block__free_unpacked(primitive_block, &protobuf_c_system_allocator);
338			}
339
340
341			int
342			map_collect_data_osm_protobuf(FILE in, FILE out_ways, FILE out_nodes, FILE out_turn_restrictions, FILE *out_boundaries)
343			{
344			OSMPBF__BlobHeader *header;
345			OSMPBF__Blob *blob;
346			unsigned char *data;
347			#if 0
348			printf("<?xml version='1.0' encoding='UTF-8'?>\n");
349			printf("<osm version=\"0.6\" generator=\"pbf2osm\">\n");
350			#endif
351			while ((header=read_header(in))) {
352			blob=read_blob(header, in);
353			data=uncompress_blob(blob);
354			if (!strcmp(header->type,"OSMHeader")) {
355			process_osmheader(blob, data);
356			} else if (!strcmp(header->type,"OSMData")) {
357			process_osmdata(blob, data, out_nodes, out_ways, out_turn_restrictions, out_boundaries);
358			} else {
359			printf("unknown\n");
360			return 0;
361			}
362			free(data);
363			osmpbf__blob__free_unpacked(blob, &protobuf_c_system_allocator);
364			osmpbf__blob_header__free_unpacked(header, &protobuf_c_system_allocator);
365			}
366			#if 0
367			printf("</osm>\n");
368			#endif
369			return 1;
370			}