path: root/dbfp.c

/*
 * Copyright (C) 2016 Robin Krahl <robin.krahl@ireas.org>
 *
 * dbfp.c
 */

#include "dbfp.h"

#include <errno.h>
#include <expat.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define DBFP_BASE_URL "http://open-api.bahn.de/bin/rest.exe"
#define DBFP_URL_FORMAT "%s/%s?authKey=%s&%s"
#define DBFP_URL_LEN 8000

struct parse_data {
	int error;
	void *data;
};

struct location_data {
	size_t n;
	struct dbfp_location *locations;
};

struct object_data {
	const char *name;
	int (*read)(const char **, size_t, void *);
	void *value;
};

static int dbfp_parse(void *contents, size_t len, size_t n, void *data);
static int dbfp_request(struct dbfp *dbfp, char *service, char *query,
		XML_Parser parser, struct parse_data *pd);
static int dbfp_url(struct dbfp *dbfp, char *service, char *query, char **url);
static int dbfp_format_url(char **out, const char *format, ...);

static int check_ele_error(const char *name, const char **atts);
static int read_string(const char **atts, size_t idx, void *value);
static int read_float(const char **atts, size_t idx, void *value);
static int read_object_indizes(const char **atts, struct object_data *data,
		size_t *indizes);
static int read_object(const char **atts, struct object_data *data);

static void location_start(void *data, const char *name, const char **atts);
static void location_end(void *data, const char *name);

int dbfp_init(struct dbfp *dbfp, char *key)
{
	int err = 0;
	char *keydup = NULL;
	CURL *curl = NULL;

	if (!dbfp || !key)
		return EINVAL;

	keydup = strdup(key);
	if (!keydup) {
		err = ENOMEM;
		goto cleanup;
	}	

	curl_global_init(CURL_GLOBAL_ALL ^ CURL_GLOBAL_SSL);
	curl = curl_easy_init();
	if (!curl) {
		err = DBFP_ERROR_CURL;
		goto cleanup;
	}

	dbfp->key = keydup;
	dbfp->curl = curl;

cleanup:
	if (err) {
		free(keydup);
		if (curl)
			curl_easy_cleanup(curl);
	}

	return err;
}

void dbfp_close(struct dbfp *dbfp)
{
	if (!dbfp)
		return;

	if (dbfp->curl) {
		curl_easy_cleanup(dbfp->curl);
		dbfp->curl = NULL;
	}
	curl_global_cleanup();

	free(dbfp->key);
	dbfp->key = NULL;
}

void dbfp_location_close(struct dbfp_location *location)
{
	if (!location)
		return;

	free(location->name);
	free(location->id);
}

int dbfp_query_location_name(struct dbfp *dbfp, char *input,
		size_t *n, struct dbfp_location **locations)
{
	int err = 0;
	char *input_enc = NULL;
	char *query = NULL;
	XML_Parser parser = NULL;
	struct location_data ld = { .n = 0, .locations = NULL };
	struct parse_data pd = { .error = 0, .data = &ld };

	if (!dbfp || !input || !n || !locations)
		return EINVAL;

	*n = 0;
	*locations = NULL;

	input_enc = curl_easy_escape(dbfp->curl, input, 0);
	if (!input_enc) {
		err = DBFP_ERROR_CURL;
		goto cleanup;
	}
	err = dbfp_format_url(&query, "input=%s", input_enc);
	if (err)
		goto cleanup;

	parser = XML_ParserCreateNS(NULL, '\0');
	XML_SetElementHandler(parser, location_start, location_end);

	err = dbfp_request(dbfp, "location.name", query, parser, &pd);
	if (err)
		goto cleanup;

	*n = ld.n;
	*locations = ld.locations;

cleanup:
	// TODO check whether the elements of ld.locations should be closed
	if (err)
		free(ld.locations);
	if (input_enc)
		curl_free(input_enc);
	XML_ParserFree(parser);
	free(query);

	return err;
}

void dbfp_departure_close(struct dbfp_departure *departure)
{
	if (!departure)
		return;

	free(departure->name);
	free(departure->type);
	free(departure->stopid);
	free(departure->stop);
	free(departure->direction);
	free(departure->track);
}

static int dbfp_parse(void *contents, size_t len, size_t n, void *data)
{
	XML_Parser parser = (XML_Parser)data;
	struct parse_data *pd;
	size_t size = len * n;

	pd = (struct parse_data *)XML_GetUserData(parser);

	if (!pd->error && !XML_Parse(parser, contents, size, 0))
		pd->error = DBFP_ERROR_PARSE;

	return size;
}

static int dbfp_request(struct dbfp *dbfp, char *service, char *query,
		XML_Parser parser, struct parse_data *pd)
{
	int err = 0;
	char *url = NULL;

	err = dbfp_url(dbfp, service, query, &url);
	if (err)
		goto cleanup;

	XML_SetUserData(parser, pd);

	curl_easy_setopt(dbfp->curl, CURLOPT_URL, url);
	curl_easy_setopt(dbfp->curl, CURLOPT_WRITEFUNCTION, dbfp_parse);
	curl_easy_setopt(dbfp->curl, CURLOPT_WRITEDATA, (void *)parser);

	if (curl_easy_perform(dbfp->curl) != CURLE_OK)
		err = DBFP_ERROR_CURL;

	if (pd->error)
		err = pd->error;

cleanup:
	free(url);

	return err;
}

static int dbfp_url(struct dbfp *dbfp, char *service, char *query, char **url)
{
	int len;

	*url = malloc(DBFP_URL_LEN);
	if (!*url)
		return ENOMEM;

	len = snprintf(*url, DBFP_URL_LEN, DBFP_URL_FORMAT, DBFP_BASE_URL,
			service, dbfp->key, query);
	if (len < 0 || len >= DBFP_URL_LEN) {
		free(*url);
		*url = NULL;
		return DBFP_ERROR_FORMAT;
	}

	return 0;
}

static int dbfp_format_url(char **out, const char *format, ...)
{
	va_list args;
	int len;

	*out = malloc(DBFP_URL_LEN);
	if (!*out)
		return ENOMEM;

	va_start(args, format);
	len = vsnprintf(*out, DBFP_URL_LEN, format, args);
	va_end(args);

	if (len < 0 || len >= DBFP_URL_LEN) {
		free(*out);
		*out = NULL;
		return DBFP_ERROR_FORMAT;
	}

	return 0;
}

static int check_ele_error(const char *name, const char **atts)
{
	if (strcmp(name, "Error") == 0) {
		return DBFP_ERROR_API;
	}

	return 0;
}

static int read_string(const char **atts, size_t idx, void *value)
{
	char **str = (char **)value;

	*str = strdup(atts[idx]);
	if (!*str)
		return ENOMEM;

	return 0;
}

static int read_float(const char **atts, size_t idx, void *value)
{
	float *f = (float *)value;
	char *endptr = NULL;

	errno = 0;
	*f = strtof(atts[idx], &endptr);
	if (atts[idx] == endptr || errno != 0)
		return DBFP_ERROR_STRUCTURE;

	return 0;
}

static int read_object_indizes(const char **atts, struct object_data *data,
		size_t *indizes)
{
	size_t i;
	size_t j;

	for (i = 0; data[i].name; i++)
		indizes[i] = 0;

	for (i = 0; atts[i]; i += 2) {
		for (j = 0; data[j].name; j++) {
			if (strcmp(atts[i], data[j].name) == 0) {
				indizes[j] = i + 1;
				break;
			}
		}
	}

	for (i = 0; data[i].name; i++) {
		if (!indizes[i])
			return DBFP_ERROR_STRUCTURE;
	}

	return 0;
}

static int read_object(const char **atts, struct object_data *data)
{
	int err = 0;
	size_t i = 0;
	size_t n = 0;
	size_t *indizes;

	for (i = 0; data[i].name; i++)
		n++;

	indizes = malloc(n * sizeof(*indizes));
	if (!indizes)
		return ENOMEM;

	err = read_object_indizes(atts, data, indizes);
	if (err)
		goto cleanup;

	for (i = 0; data[i].name; i++) {
		err = data[i].read(atts, indizes[i], data[i].value);
		if (err)
			goto cleanup;
	}

cleanup:
	free(indizes);

	return err;
}

static void location_start(void *data, const char *name, const char **atts)
{
	int err = 0;
	struct parse_data *pd = (struct parse_data *)data;
	struct location_data *ld = (struct location_data *)pd->data;
	struct dbfp_location location = { NULL, NULL, 0, 0 };
	struct object_data od[] = {
		{ "name", &read_string, &location.name },
		{ "id", &read_string, &location.id },
		{ "lon", &read_float, &location.lon },
		{ "lat", &read_float, &location.lat },
		{ NULL, NULL, NULL }
	};

	err = check_ele_error(name, atts);
	if (err)
		goto cleanup;

	if (strcmp(name, "StopLocation") != 0)
		goto cleanup;

	err = read_object(atts, od);
	if (err)
		goto cleanup;

	ld->locations = realloc(ld->locations,
			(ld->n + 1) * sizeof(*ld->locations));
	if (!ld->locations) {
		err = ENOMEM;
		goto cleanup;
	}

	ld->locations[ld->n] = location;
	ld->n++;

cleanup:
	if (err) {
		dbfp_location_close(&location);
		pd->error = err;
	}
}

static void location_end(void *data, const char *name)
{
}