merged the modularization branch (credentials) back to trunk
This commit is contained in:
Martin Willi
@@ -0,0 +1,105 @@
|
||||
/*
|
||||
* Copyright (C) 2008 Martin Willi
|
||||
* Hochschule fuer Technik Rapperswil
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License as published by the
|
||||
* Free Software Foundation; either version 2 of the License, or (at your
|
||||
* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @defgroup fetcher fetcher
|
||||
* @{ @ingroup fetcher
|
||||
*/
|
||||
|
||||
#ifndef FETCHER_H_
|
||||
#define FETCHER_H_
|
||||
|
||||
typedef struct fetcher_t fetcher_t;
|
||||
typedef enum fetcher_option_t fetcher_option_t;
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#include <library.h>
|
||||
|
||||
/**
|
||||
* Fetching options to use for fetcher_t.fetch() call.
|
||||
*/
|
||||
enum fetcher_option_t {
|
||||
|
||||
/**
|
||||
* Data to include in fetch request, e.g. on a HTTP post.
|
||||
* Additional argument is a chunk_t
|
||||
*/
|
||||
FETCH_REQUEST_DATA,
|
||||
|
||||
/**
|
||||
* Mime-Type of data included in FETCH_REQUEST_DATA.
|
||||
* Additional argument is a char*.
|
||||
*/
|
||||
FETCH_REQUEST_TYPE,
|
||||
|
||||
/**
|
||||
* Timeout to use for fetch, in seconds.
|
||||
* Additional argument is u_int
|
||||
*/
|
||||
FETCH_TIMEOUT,
|
||||
|
||||
/**
|
||||
* end of fetching options
|
||||
*/
|
||||
FETCH_END,
|
||||
};
|
||||
|
||||
/**
|
||||
* Constructor function which creates fetcher instances.
|
||||
*
|
||||
* @return fetcher instance
|
||||
*/
|
||||
typedef fetcher_t* (*fetcher_constructor_t)();
|
||||
|
||||
/**
|
||||
* Fetcher interface, an implementation fetches data from an URL.
|
||||
*/
|
||||
struct fetcher_t {
|
||||
|
||||
/**
|
||||
* Fetch data from URI into chunk.
|
||||
*
|
||||
* The fetcher returns NOT_SUPPORTED to indicate that it is uncappable
|
||||
* to handle such URLs. Other return values indicate a failure, and
|
||||
* fetching of that URL gets cancelled.
|
||||
*
|
||||
* @param uri URI to fetch from
|
||||
* @param result chunk which receives allocated data
|
||||
* @return
|
||||
* - SUCCESS if fetch was successful
|
||||
* - NOT_SUPPORTED if fetcher does not support such URLs
|
||||
* - FAILED, NOT_FOUND, PARSE_ERROR on failure
|
||||
*/
|
||||
status_t (*fetch)(fetcher_t *this, char *uri, chunk_t *result);
|
||||
|
||||
/**
|
||||
* Set a fetcher option, as defined in fetcher_option_t.
|
||||
*
|
||||
* Arguments passed to options must stay in memory until fetch() returns.
|
||||
*
|
||||
* @param option option to set
|
||||
* @param ... variable argument(s) to option
|
||||
* @return TRUE if option supported, FALSE otherwise
|
||||
*/
|
||||
bool (*set_option)(fetcher_t *this, fetcher_option_t option, ...);
|
||||
|
||||
/**
|
||||
* Destroy the fetcher instance.
|
||||
*/
|
||||
void (*destroy)(fetcher_t *this);
|
||||
};
|
||||
|
||||
#endif /* FETCHER_H_ @}*/
|
||||
@@ -0,0 +1,206 @@
|
||||
/*
|
||||
* Copyright (C) 2008 Martin Willi
|
||||
* Hochschule fuer Technik Rapperswil
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License as published by the
|
||||
* Free Software Foundation; either version 2 of the License, or (at your
|
||||
* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
#include "fetcher_manager.h"
|
||||
|
||||
#include <debug.h>
|
||||
#include <utils/linked_list.h>
|
||||
#include <utils/mutex.h>
|
||||
|
||||
typedef struct private_fetcher_manager_t private_fetcher_manager_t;
|
||||
|
||||
/**
|
||||
* private data of fetcher_manager
|
||||
*/
|
||||
struct private_fetcher_manager_t {
|
||||
|
||||
/**
|
||||
* public functions
|
||||
*/
|
||||
fetcher_manager_t public;
|
||||
|
||||
/**
|
||||
* list of registered fetchers, as entry_t
|
||||
*/
|
||||
linked_list_t *fetchers;
|
||||
|
||||
/**
|
||||
* read write lock to list
|
||||
*/
|
||||
pthread_rwlock_t lock;
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
/** assocaited fetcher construction function */
|
||||
fetcher_constructor_t create;
|
||||
/** URL this fetcher support */
|
||||
char *url;
|
||||
} entry_t;
|
||||
|
||||
/**
|
||||
* destroy an entry_t
|
||||
*/
|
||||
static void entry_destroy(entry_t *entry)
|
||||
{
|
||||
free(entry->url);
|
||||
free(entry);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of fetcher_manager_t.fetch.
|
||||
*/
|
||||
static status_t fetch(private_fetcher_manager_t *this,
|
||||
char *url, chunk_t *response, ...)
|
||||
{
|
||||
enumerator_t *enumerator;
|
||||
status_t status = NOT_SUPPORTED;
|
||||
entry_t *entry;
|
||||
bool capable = FALSE;
|
||||
|
||||
pthread_rwlock_rdlock(&this->lock);
|
||||
enumerator = this->fetchers->create_enumerator(this->fetchers);
|
||||
while (enumerator->enumerate(enumerator, &entry))
|
||||
{
|
||||
fetcher_option_t opt;
|
||||
fetcher_t *fetcher;
|
||||
bool good = TRUE;
|
||||
va_list args;
|
||||
|
||||
/* check URL support of fetcher */
|
||||
if (strncasecmp(entry->url, url, strlen(entry->url)))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
/* create fetcher instance and set options */
|
||||
fetcher = entry->create();
|
||||
if (!fetcher)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
va_start(args, response);
|
||||
while (good)
|
||||
{
|
||||
opt = va_arg(args, fetcher_option_t);
|
||||
switch (opt)
|
||||
{
|
||||
case FETCH_REQUEST_DATA:
|
||||
good = fetcher->set_option(fetcher, opt, va_arg(args, chunk_t));
|
||||
continue;
|
||||
case FETCH_REQUEST_TYPE:
|
||||
good = fetcher->set_option(fetcher, opt, va_arg(args, char*));
|
||||
continue;
|
||||
case FETCH_TIMEOUT:
|
||||
good = fetcher->set_option(fetcher, opt, va_arg(args, u_int));
|
||||
continue;
|
||||
case FETCH_END:
|
||||
break;;
|
||||
}
|
||||
break;
|
||||
}
|
||||
va_end(args);
|
||||
if (!good)
|
||||
{ /* fetcher does not support supplied options, try another */
|
||||
fetcher->destroy(fetcher);
|
||||
continue;
|
||||
}
|
||||
|
||||
status = fetcher->fetch(fetcher, url, response);
|
||||
fetcher->destroy(fetcher);
|
||||
/* try another fetcher only if this one does not support that URL */
|
||||
if (status == NOT_SUPPORTED)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
capable = TRUE;
|
||||
break;
|
||||
}
|
||||
enumerator->destroy(enumerator);
|
||||
pthread_rwlock_unlock(&this->lock);
|
||||
if (!capable)
|
||||
{
|
||||
DBG1("unable to fetch from %s, no capable fetcher found", url);
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of fetcher_manager_t.add_fetcher.
|
||||
*/
|
||||
static void add_fetcher(private_fetcher_manager_t *this,
|
||||
fetcher_constructor_t create, char *url)
|
||||
{
|
||||
entry_t *entry = malloc_thing(entry_t);
|
||||
|
||||
entry->url = strdup(url);
|
||||
entry->create = create;
|
||||
|
||||
pthread_rwlock_wrlock(&this->lock);
|
||||
this->fetchers->insert_last(this->fetchers, entry);
|
||||
pthread_rwlock_unlock(&this->lock);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of fetcher_manager_t.remove_fetcher.
|
||||
*/
|
||||
static void remove_fetcher(private_fetcher_manager_t *this,
|
||||
fetcher_constructor_t create)
|
||||
{
|
||||
enumerator_t *enumerator;
|
||||
entry_t *entry;
|
||||
|
||||
pthread_rwlock_wrlock(&this->lock);
|
||||
enumerator = this->fetchers->create_enumerator(this->fetchers);
|
||||
while (enumerator->enumerate(enumerator, &entry))
|
||||
{
|
||||
if (entry->create == create)
|
||||
{
|
||||
this->fetchers->remove_at(this->fetchers, enumerator);
|
||||
entry_destroy(entry);
|
||||
}
|
||||
}
|
||||
enumerator->destroy(enumerator);
|
||||
pthread_rwlock_unlock(&this->lock);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of fetcher_manager_t.destroy
|
||||
*/
|
||||
static void destroy(private_fetcher_manager_t *this)
|
||||
{
|
||||
this->fetchers->destroy_function(this->fetchers, (void*)entry_destroy);
|
||||
pthread_rwlock_destroy(&this->lock);
|
||||
free(this);
|
||||
}
|
||||
|
||||
/*
|
||||
* see header file
|
||||
*/
|
||||
fetcher_manager_t *fetcher_manager_create()
|
||||
{
|
||||
private_fetcher_manager_t *this = malloc_thing(private_fetcher_manager_t);
|
||||
|
||||
this->public.fetch = (status_t(*)(fetcher_manager_t*, char *url, chunk_t *response, ...))fetch;
|
||||
this->public.add_fetcher = (void(*)(fetcher_manager_t*, fetcher_constructor_t,char*))add_fetcher;
|
||||
this->public.remove_fetcher = (void(*)(fetcher_manager_t*, fetcher_constructor_t))remove_fetcher;
|
||||
this->public.destroy = (void(*)(fetcher_manager_t*))destroy;
|
||||
|
||||
this->fetchers = linked_list_create();
|
||||
pthread_rwlock_init(&this->lock, NULL);
|
||||
|
||||
return &this->public;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
/*
|
||||
* Copyright (C) 2008 Martin Willi
|
||||
* Hochschule fuer Technik Rapperswil
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License as published by the
|
||||
* Free Software Foundation; either version 2 of the License, or (at your
|
||||
* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @defgroup fetcher_manager fetcher_manager
|
||||
* @{ @ingroup fetcher
|
||||
*/
|
||||
|
||||
#ifndef FETCHER_MANAGER_H_
|
||||
#define FETCHER_MANAGER_H_
|
||||
|
||||
typedef struct fetcher_manager_t fetcher_manager_t;
|
||||
|
||||
#include <fetcher/fetcher.h>
|
||||
|
||||
/**
|
||||
* Fetches from URIs using registerd fetcher_t instances.
|
||||
*/
|
||||
struct fetcher_manager_t {
|
||||
|
||||
/**
|
||||
* Fetch data from URI into chunk.
|
||||
*
|
||||
* The variable argument list contains fetcher_option_t's, followed
|
||||
* by a option specific data argument.
|
||||
*
|
||||
* @param uri URI to fetch from
|
||||
* @param result chunk which receives allocated data
|
||||
* @param options FETCH_END terminated fetcher_option_t arguments
|
||||
* @return status indicating result of fetch
|
||||
*/
|
||||
status_t (*fetch)(fetcher_manager_t *this, char *url, chunk_t *response, ...);
|
||||
|
||||
/**
|
||||
* Register a fetcher implementation.
|
||||
*
|
||||
* @param constructor fetcher constructor function
|
||||
* @param url URL type this fetcher fetches, e.g. "http://"
|
||||
*/
|
||||
void (*add_fetcher)(fetcher_manager_t *this,
|
||||
fetcher_constructor_t constructor, char *url);
|
||||
|
||||
/**
|
||||
* Unregister a previously registered fetcher implementation.
|
||||
*
|
||||
* @param constructor fetcher constructor function to unregister
|
||||
*/
|
||||
void (*remove_fetcher)(fetcher_manager_t *this,
|
||||
fetcher_constructor_t constructor);
|
||||
|
||||
/**
|
||||
* Destroy a fetcher_manager instance.
|
||||
*/
|
||||
void (*destroy)(fetcher_manager_t *this);
|
||||
};
|
||||
|
||||
/**
|
||||
* Create a fetcher_manager instance.
|
||||
*/
|
||||
fetcher_manager_t *fetcher_manager_create();
|
||||
|
||||
#endif /* FETCHER_MANAGER_H_ @}*/
|
||||
Reference in New Issue
Block a user