/*!
* @brief Free the existing content
*
* @return true
*/
bool RDF_ShutdownRDF(void )
{
librdf_free_model(model);
librdf_free_storage(storage);
librdf_free_world(world);
}
void RdfStorePrivate::CleanUp()
{
// CleanUp old Store if there is one
if(m_Model)
librdf_free_model(m_Model);
if(m_Storage)
librdf_free_storage(m_Storage);
if(m_World)
librdf_free_world(m_World);
// SetUp new Store
m_World = librdf_new_world();
librdf_world_open(m_World);
m_Storage = librdf_new_storage(m_World, "memory", nullptr, nullptr);
if(!m_Storage)
{
mitkThrow() << "RDF Library Error";
}
m_Model = librdf_new_model(m_World, m_Storage, nullptr);
if(!m_Model)
{
mitkThrow() << "RDF Library Error";
}
}
static librdf_query_results*
librdf_query_rasqal_execute(librdf_query* query, librdf_model* model)
{
librdf_query_rasqal_context *context=(librdf_query_rasqal_context*)query->context;
librdf_query_results* results;
if (context->model)
librdf_free_model(context->model);
/* model is always non-NULL */
context->model = model;
librdf_model_add_reference(model);
/* This assumes raptor's URI implementation is librdf_uri */
if(rasqal_query_prepare(context->rq, context->query_string,
(raptor_uri*)context->uri))
return NULL;
if(context->results)
rasqal_free_query_results(context->results);
context->results=rasqal_query_execute(context->rq);
if(!context->results)
return NULL;
results = LIBRDF_MALLOC(librdf_query_results*, sizeof(*results));
if(!results) {
rasqal_free_query_results(context->results);
context->results=NULL;
} else {
results->query=query;
}
return results;
}
/*
* call-seq:
* graph.dup -> graph
*
* Duplicate the receiver and return the copy.
*
*/
static VALUE
rleaf_redleaf_graph_dup( VALUE self ) {
rleaf_GRAPH *ptr = rleaf_get_graph( self );
VALUE dup = rleaf_redleaf_graph_s_allocate( CLASS_OF(self) );
rleaf_GRAPH *dup_ptr = ALLOC( rleaf_GRAPH );
librdf_stream *statements = librdf_model_as_stream( ptr->model );
rleaf_log_with_context( self, "debug", "Duping %s 0x%x", rb_obj_classname(self), self );
dup_ptr->store = ptr->store;
dup_ptr->model = librdf_new_model_from_model( ptr->model );
if ( ! dup_ptr->model ) {
librdf_free_stream( statements );
xfree( dup_ptr );
rb_raise( rleaf_eRedleafError, "couldn't create new model from model <%p>", ptr->model );
}
if ( (librdf_model_add_statements(dup_ptr->model, statements)) != 0 ) {
librdf_free_stream( statements );
librdf_free_model( dup_ptr->model );
xfree( dup_ptr );
rb_raise( rleaf_eRedleafError, "couldn't add statements from the original model" );
}
DATA_PTR( dup ) = dup_ptr;
OBJ_INFECT( dup, self );
return dup;
}
static void
librdf_storage_file_terminate(librdf_storage* storage)
{
librdf_storage_file_instance* context=(librdf_storage_file_instance*)storage->instance;
if (context == NULL)
return;
librdf_storage_file_sync(storage);
if(context->format_name)
LIBRDF_FREE(cstring, context->format_name);
if(context->name)
LIBRDF_FREE(cstring, context->name);
if(context->uri)
librdf_free_uri(context->uri);
if(context->model)
librdf_free_model(context->model);
if(context->storage)
librdf_free_storage(context->storage);
LIBRDF_FREE(librdf_storage_file_instance, context);
}
RdfStorePrivate::~RdfStorePrivate()
{
if(m_Model)
librdf_free_model(m_Model);
if(m_Storage)
librdf_free_storage(m_Storage);
if(m_World)
librdf_free_world(m_World);
}
/*
* GC Free function
*/
static void
rleaf_graph_gc_free( rleaf_GRAPH *ptr ) {
if ( ptr->model && rleaf_rdf_world ) {
/* Not sure if I need to break the graph<->storage link here, and if I do, how. [MG] */
librdf_free_model( ptr->model );
ptr->model = NULL;
ptr->store = Qnil;
xfree( ptr );
ptr = NULL;
}
}
redhttp_response_t *handle_description_get(redhttp_request_t * request, void *user_data)
{
const raptor_syntax_description* desc = NULL;
redhttp_response_t *response = NULL;
librdf_storage *sd_storage = NULL;
librdf_model *sd_model = NULL;
librdf_stream *sd_stream = NULL;
desc = redstore_negotiate_format(request, librdf_serializer_get_description, "text/html", NULL);
if (desc == NULL || strcmp("html", desc->names[0])==0) {
response = handle_html_description(request, user_data);
} else {
const char *request_url = redhttp_request_get_url(request);
sd_storage = librdf_new_storage(world, NULL, NULL, NULL);
if (!sd_storage) {
redstore_error("Failed to create temporary storage for service description.");
goto CLEANUP;
}
sd_model = create_service_description(sd_storage, request_url);
if (!sd_model) {
redstore_error("Failed to create model for service description.");
goto CLEANUP;
}
sd_stream = librdf_model_as_stream(sd_model);
if (!sd_stream) {
redstore_error("Failed to create stream for service description.");
goto CLEANUP;
}
response = format_graph_stream(request, sd_stream);
if (!response) {
redstore_error("Failed to create temporary storage for service description.");
goto CLEANUP;
}
}
CLEANUP:
if (sd_stream)
librdf_free_stream(sd_stream);
if (sd_model)
librdf_free_model(sd_model);
if (sd_storage)
librdf_free_storage(sd_storage);
return response;
}
static void
librdf_query_rasqal_terminate(librdf_query* query)
{
librdf_query_rasqal_context *context=(librdf_query_rasqal_context*)query->context;
if(context->rq)
rasqal_free_query(context->rq);
if(context->query_string)
LIBRDF_FREE(char*, context->query_string);
if(context->uri)
librdf_free_uri(context->uri);
if(context->model)
librdf_free_model(context->model);
}
void reset_storage_model(sib_data_structure* sd)
{
// Cleaning ////////////////////////
librdf_free_model(sd->RDF_model);
librdf_free_storage(sd->RDF_storage);
////////////////////////////////////
//MAIN TRIPLESTORE
if (sd->mem_volatile)
{
sd->RDF_storage=librdf_new_storage(sd->RDF_world, "hashes", NULL, "hash-type='memory'");
}
else
{
if (sd->sqlite)
{
sd->RDF_storage=librdf_new_storage(sd->RDF_world, "sqlite", sd->ss_name, "new='yes'");
}
else
{
//BDB default
gchar* sp2o;
gchar* po2s;
gchar* so2p;
sp2o= g_strdup_printf("%s%s",sd->ss_name,"-sp2o.db");
so2p= g_strdup_printf("%s%s",sd->ss_name,"-so2p.db");
po2s= g_strdup_printf("%s%s",sd->ss_name,"-po2s.db");
sd->RDF_storage=librdf_new_storage(sd->RDF_world, "hashes", sd->ss_name, "new='yes',hash-type='bdb',dir='.'");
g_free(sp2o);
g_free(po2s);
g_free(so2p);
}
}
sd->RDF_model=librdf_new_model(sd->RDF_world, sd->RDF_storage , NULL);
}
int
main(int argc, char *argv[])
{
librdf_world* world;
librdf_storage *storage;
librdf_model* model;
librdf_statement* statement;
raptor_world *raptor_world_ptr;
raptor_iostream* iostr;
world=librdf_new_world();
librdf_world_open(world);
raptor_world_ptr = librdf_world_get_raptor(world);
model=librdf_new_model(world, storage=librdf_new_storage(world, "hashes", "test", "hash-type='bdb',dir='.'"), NULL);
librdf_model_add_statement(model,
statement=librdf_new_statement_from_nodes(world, librdf_new_node_from_uri_string(world, (const unsigned char*)"http://www.dajobe.org/"),
librdf_new_node_from_uri_string(world, (const unsigned char*)"http://purl.org/dc/elements/1.1/creator"),
librdf_new_node_from_literal(world, (const unsigned char*)"Dave Beckett", NULL, 0)
)
);
librdf_free_statement(statement);
iostr = raptor_new_iostream_to_file_handle(raptor_world_ptr, stdout);
librdf_model_write(model, iostr);
raptor_free_iostream(iostr);
librdf_free_model(model);
librdf_free_storage(storage);
librdf_free_world(world);
#ifdef LIBRDF_MEMORY_DEBUG
librdf_memory_report(stderr);
#endif
/* keep gcc -Wall happy */
return(0);
}
bool RdfNode::dummy()
{
librdf_world* world;
librdf_storage *storage;
librdf_model* model;
librdf_statement* statement;
raptor_world *raptor_world_ptr;
raptor_iostream* iostr;
world=librdf_new_world();
librdf_world_open(world);
raptor_world_ptr = librdf_world_get_raptor(world);
model=librdf_new_model(world, storage=librdf_new_storage(world, "hashes", nullptr, "hash-type='memory'"), nullptr);
librdf_model_add_statement(model,
statement=librdf_new_statement_from_nodes(world, librdf_new_node_from_uri_string(world, (const unsigned char*)"http://www.dajobe.org/"),
librdf_new_node_from_uri_string(world, (const unsigned char*)"http://purl.org/dc/elements/1.1/creator"),
librdf_new_node_from_literal(world, (const unsigned char*)"Dave Beckett", nullptr, 0)
)
);
librdf_free_statement(statement);
iostr = raptor_new_iostream_to_file_handle(raptor_world_ptr, stdout);
librdf_model_write(model, iostr);
raptor_free_iostream(iostr);
librdf_free_model(model);
librdf_free_storage(storage);
librdf_free_world(world);
#ifdef LIBRDF_MEMORY_DEBUG
librdf_memory_report(stderr);
#endif
return true;
}
int
main(int argc, char *argv[])
{
librdf_world* world;
librdf_storage *storage;
librdf_model* model;
librdf_uri* uri;
unsigned char *string;
librdf_world_open(world=librdf_new_world());
model=librdf_new_model(world, storage=librdf_new_storage(world, "memory", NULL, NULL), NULL);
uri=librdf_new_uri(world, (const unsigned char*)"http://planetrdf.com/index.rdf");
librdf_model_load(model, uri, NULL, NULL, NULL);
string=librdf_model_to_string(model, uri, "ntriples", NULL, NULL);
if(!string)
printf("Failed to serialize model\n");
else {
printf("Made a %d byte string\n", (int)strlen((char*)string));
free(string);
}
librdf_free_uri(uri);
librdf_free_model(model);
librdf_free_storage(storage);
librdf_free_world(world);
#ifdef LIBRDF_MEMORY_DEBUG
librdf_memory_report(stderr);
#endif
/* keep gcc -Wall happy */
return(0);
}
ModelPrivate::~ModelPrivate() {
librdf_free_model(_model);
_model = 0;
}
int
print_query_results(librdf_world* world, librdf_model* model, librdf_query_results *results)
{
int i;
char *name;
librdf_stream* stream;
librdf_serializer* serializer;
const char *query_graph_serializer_syntax_name="rdfxml";
if(librdf_query_results_is_bindings(results)) {
fprintf(stdout, ": Query returned bindings results:\n");
while(!librdf_query_results_finished(results)) {
fputs("result: [", stdout);
for(i=0; i<librdf_query_results_get_bindings_count(results); i++) {
librdf_node *value=librdf_query_results_get_binding_value(results, i);
name=(char*)librdf_query_results_get_binding_name(results, i);
if(i>0)
fputs(", ", stdout);
fprintf(stdout, "%s=", name);
if(value) {
librdf_node_print(value, stdout);
librdf_free_node(value);
} else
fputs("NULL", stdout);
}
fputs("]\n", stdout);
librdf_query_results_next(results);
}
fprintf(stdout, ": Query returned %d results\n", librdf_query_results_get_count(results));
} else if(librdf_query_results_is_boolean(results)) {
fprintf(stdout, ": Query returned boolean result: %s\n", librdf_query_results_get_boolean(results) ? "true" : "false");
} else if(librdf_query_results_is_graph(results)) {
librdf_storage* tmp_storage;
librdf_model* tmp_model;
tmp_storage=librdf_new_storage(world, NULL, NULL, NULL);
tmp_model=librdf_new_model(world, tmp_storage, NULL);
fprintf(stdout, ": Query returned graph result:\n");
stream=librdf_query_results_as_stream(results);
if(!stream) {
fprintf(stderr, ": Failed to get query results graph\n");
return -1;
}
librdf_model_add_statements(tmp_model, stream);
librdf_free_stream(stream);
fprintf(stdout, ": Total %d triples\n", librdf_model_size(model));
serializer=librdf_new_serializer(world, query_graph_serializer_syntax_name, NULL, NULL);
if(!serializer) {
fprintf(stderr, ": Failed to create serializer type %s\n", query_graph_serializer_syntax_name);
return -1;
}
librdf_serializer_serialize_model_to_file_handle(serializer, stdout, NULL, tmp_model);
librdf_free_serializer(serializer);
librdf_free_model(tmp_model);
librdf_free_storage(tmp_storage);
} else {
fprintf(stdout, ": Query returned unknown result format\n");
return -1;
}
return 0;
}
int
main(int argc, char *argv[])
{
librdf_world* world;
librdf_parser* parser;
librdf_serializer* serializer;
librdf_storage *storage;
librdf_model* model;
librdf_node *source, *arc, *target, *node;
librdf_node *subject, *predicate, *object;
librdf_node* context_node=NULL;
librdf_stream* stream;
librdf_iterator* iterator;
librdf_uri *uri;
librdf_uri *base_uri=NULL;
librdf_query *query;
librdf_query_results *results;
librdf_hash *options;
int count;
int rc;
int transactions=0;
const char* storage_name;
const char* storage_options;
const char* context;
const char* identifier;
const char* results_format;
librdf_statement* statement=NULL;
char* query_cmd=NULL;
char* s;
/*
* Initialize
*/
storage_name="virtuoso";
results_format="xml";
context=DEFAULT_CONTEXT;
identifier=DEFAULT_IDENTIFIER;
/*
* Get connection options
*/
if(argc == 2 && argv[1][0] != '\0')
storage_options=argv[1];
else if((s=getenv ("VIRTUOSO_STORAGE_OPTIONS")) != NULL)
storage_options=s;
else
storage_options=DEFAULT_STORAGE_OPTIONS;
world=librdf_new_world();
librdf_world_set_logger(world, world, log_handler);
librdf_world_open(world);
options=librdf_new_hash(world, NULL);
librdf_hash_open(options, NULL, 0, 1, 1, NULL);
librdf_hash_put_strings(options, "contexts", "yes");
transactions=1;
librdf_hash_from_string(options, storage_options);
storage=librdf_new_storage_with_options(world, storage_name, identifier, options);
if(!storage) {
fprintf(stderr, ": Failed to open %s storage '%s'\n", storage_name, identifier);
return(1);
}
model=librdf_new_model(world, storage, NULL);
if(!model) {
fprintf(stderr, ": Failed to create model\n");
return(1);
}
if(transactions)
librdf_model_transaction_start(model);
/* Do this or gcc moans */
stream=NULL;
iterator=NULL;
parser=NULL;
serializer=NULL;
source=NULL;
arc=NULL;
target=NULL;
subject=NULL;
predicate=NULL;
object=NULL;
uri=NULL;
node=NULL;
query=NULL;
results=NULL;
context_node=librdf_new_node_from_uri_string(world, (const unsigned char *)context);
/**** Test 1 *******/
startTest(1, " Remove all triples in <%s> context\n", context);
{
rc=librdf_model_context_remove_statements(model, context_node);
if(rc)
endTest(0, " failed to remove context triples from the graph\n");
else
endTest(1, " removed context triples from the graph\n");
}
/**** Test 2 *******/
startTest(2, " Add triples to <%s> context\n", context);
{
rc=0;
rc |= add_triple(world, context_node, model, "aa", "bb", "cc");
rc |= add_triple(world, context_node, model, "aa", "bb1", "cc");
rc |= add_triple(world, context_node, model, "aa", "a2", "_:cc");
rc |= add_triple_typed(world, context_node, model, "aa", "a2", "cc");
rc |= add_triple_typed(world, context_node, model, "mm", "nn", "Some long literal with language@en");
rc |= add_triple_typed(world, context_node, model, "oo", "pp", "12345^^<http://www.w3.org/2001/XMLSchema#int>");
if(rc)
endTest(0, " failed add triple\n");
else
endTest(1, " add triple to context\n");
}
/**** Test 3 *******/
startTest(3, " Print all triples in <%s> context\n", context);
{
raptor_iostream* iostr = raptor_new_iostream_to_file_handle(librdf_world_get_raptor(world), stdout);
librdf_model_write(model, iostr);
raptor_free_iostream(iostr);
endTest(1, "\n");
}
/***** Test 4 *****/
startTest(4, " Count of triples in <%s> context\n", context);
{
count=librdf_model_size(model);
if(count >= 0)
endTest(1, " graph has %d triples\n", count);
else
endTest(0, " graph has unknown number of triples\n");
}
/***** Test 5 *****/
startTest(5, " Exec: ARC aa bb \n");
{
subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa");
predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb");
node=librdf_model_get_target(model, subject, predicate);
librdf_free_node(subject);
librdf_free_node(predicate);
if(!node) {
endTest(0, " Failed to get arc\n");
} else {
print_node(stdout, node);
librdf_free_node(node);
endTest(1, "\n");
}
}
/***** Test 6 *****/
startTest(6, " Exec: ARCS aa cc \n");
{
subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa");
object=librdf_new_node_from_uri_string(world, (const unsigned char*)"cc");
iterator=librdf_model_get_arcs(model, subject, object);
librdf_free_node(subject);
librdf_free_node(object);
if(!iterator) {
endTest(0, " Failed to get arcs\n");
} else {
print_nodes(stdout, iterator);
endTest(1, "\n");
}
}
/***** Test 7 *****/
startTest(7, " Exec: ARCS-IN cc \n");
{
object=librdf_new_node_from_uri_string(world, (const unsigned char*)"cc");
iterator=librdf_model_get_arcs_in(model, object);
librdf_free_node(object);
if(!iterator) {
endTest(0, " Failed to get arcs in\n");
} else {
int ok=1;
count=0;
while(!librdf_iterator_end(iterator)) {
context_node=(librdf_node*)librdf_iterator_get_context(iterator);
node=(librdf_node*)librdf_iterator_get_object(iterator); /*returns SHARED pointer */
if(!node) {
ok=0;
endTest(ok, " librdf_iterator_get_next returned NULL\n");
break;
}
fputs("Matched arc: ", stdout);
librdf_node_print(node, stdout);
if(context_node) {
fputs(" with context ", stdout);
librdf_node_print(context_node, stdout);
}
fputc('\n', stdout);
count++;
librdf_iterator_next(iterator);
}
librdf_free_iterator(iterator);
endTest(ok, " matching arcs: %d\n", count);
}
}
/***** Test 8 *****/
startTest(8, " Exec: ARCS-OUT aa \n");
{
subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa");
iterator=librdf_model_get_arcs_out(model, subject);
librdf_free_node(subject);
if(!iterator)
endTest(0, " Failed to get arcs out\n");
else {
int ok=1;
count=0;
while(!librdf_iterator_end(iterator)) {
context_node=(librdf_node*)librdf_iterator_get_context(iterator);
node=(librdf_node*)librdf_iterator_get_object(iterator);
if(!node) {
ok=0;
endTest(ok, " librdf_iterator_get_next returned NULL\n");
break;
}
fputs("Matched arc: ", stdout);
librdf_node_print(node, stdout);
if(context_node) {
fputs(" with context ", stdout);
librdf_node_print(context_node, stdout);
}
fputc('\n', stdout);
count++;
librdf_iterator_next(iterator);
}
librdf_free_iterator(iterator);
endTest(ok, " matching arcs: %d\n", count);
}
}
/***** Test 9 *****/
startTest(9, " Exec: CONTAINS aa bb1 cc \n");
{
subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa");
predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb1");
object=librdf_new_node_from_uri_string(world, (const unsigned char*)"cc");
statement=librdf_new_statement(world);
librdf_statement_set_subject(statement, subject);
librdf_statement_set_predicate(statement, predicate);
librdf_statement_set_object(statement, object);
if(librdf_model_contains_statement(model, statement))
endTest(1, " the graph contains the triple\n");
else
endTest(0, " the graph does not contain the triple\n");
librdf_free_statement(statement);
}
/***** Test 10 *****/
startTest(10, " Exec: FIND aa - - \n");
{
subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa");
statement=librdf_new_statement(world);
librdf_statement_set_subject(statement, subject);
stream=librdf_model_find_statements_in_context(model, statement, context_node);
if(!stream) {
endTest(0, " FIND returned no results (NULL stream)\n");
} else {
librdf_node* ctxt_node=NULL;
int ok=1;
count=0;
while(!librdf_stream_end(stream)) {
librdf_statement *stmt=librdf_stream_get_object(stream);
ctxt_node=(librdf_node*)librdf_stream_get_context(stream);
if(!stmt) {
ok=0;
endTest(ok, " librdf_stream_next returned NULL\n");
break;
}
fputs("Matched triple: ", stdout);
librdf_statement_print(stmt, stdout);
if(context) {
fputs(" with context ", stdout);
librdf_node_print(ctxt_node, stdout);
}
fputc('\n', stdout);
count++;
librdf_stream_next(stream);
}
librdf_free_stream(stream);
endTest(ok, " matching triples: %d\n", count);
}
librdf_free_statement(statement);
}
/***** Test 11 *****/
startTest(11, " Exec: HAS-ARC-IN cc bb \n");
{
predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb");
object=librdf_new_node_from_uri_string(world, (const unsigned char*)"cc");
if(librdf_model_has_arc_in(model, object, predicate))
endTest(1, " the graph contains the arc\n");
else
endTest(0, " the graph does not contain the arc\n");
librdf_free_node(predicate);
librdf_free_node(object);
}
/***** Test 12 *****/
startTest(12, " Exec: HAS-ARC-OUT aa bb \n");
{
subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa");
predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb");
if(librdf_model_has_arc_out(model, subject, predicate))
endTest(1, " the graph contains the arc\n");
else
endTest(0, " the graph does not contain the arc\n");
librdf_free_node(predicate);
librdf_free_node(subject);
}
/***** Test 13 *****/
startTest(13, " Exec: SOURCE aa cc \n");
{
predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb");
object=librdf_new_node_from_uri_string(world, (const unsigned char*)"cc");
node=librdf_model_get_source(model, predicate, object);
librdf_free_node(predicate);
librdf_free_node(object);
if(!node) {
endTest(0, " Failed to get source\n");
} else {
print_node(stdout, node);
librdf_free_node(node);
endTest(1, "\n");
}
}
/***** Test 14 *****/
startTest(14, " Exec: SOURCES bb cc \n");
{
predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb");
object=librdf_new_node_from_uri_string(world, (const unsigned char*)"cc");
iterator=librdf_model_get_sources(model, predicate, object);
librdf_free_node(predicate);
librdf_free_node(object);
if(!iterator) {
endTest(0, " Failed to get sources\n");
} else {
print_nodes(stdout, iterator);
endTest(1, "\n");
}
}
/***** Test 15 *****/
startTest(15, " Exec: TARGET aa bb \n");
{
subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa");
predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb");
node=librdf_model_get_target(model, subject, predicate);
librdf_free_node(subject);
librdf_free_node(predicate);
if(!node) {
endTest(0, " Failed to get target\n");
} else {
print_node(stdout, node);
librdf_free_node(node);
endTest(1, "\n");
}
}
/***** Test 16 *****/
startTest(16, " Exec: TARGETS aa bb \n");
{
subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa");
predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb");
iterator=librdf_model_get_targets(model, subject, predicate);
librdf_free_node(subject);
librdf_free_node(predicate);
if(!iterator) {
endTest(0, " Failed to get targets\n");
} else {
print_nodes(stdout, iterator);
endTest(1, "\n");
}
}
/***** Test 17 *****/
startTest(17, " Exec: REMOVE aa bb1 cc \n");
{
subject=librdf_new_node_from_uri_string(world, (const unsigned char*)"aa");
predicate=librdf_new_node_from_uri_string(world, (const unsigned char*)"bb1");
object=librdf_new_node_from_uri_string(world, (const unsigned char*)"cc");
statement=librdf_new_statement(world);
librdf_statement_set_subject(statement, subject);
librdf_statement_set_predicate(statement, predicate);
librdf_statement_set_object(statement, object);
if(librdf_model_context_remove_statement(model, context_node, statement))
endTest(0, " failed to remove triple from the graph\n");
else
endTest(1, " removed triple from the graph\n");
librdf_free_statement(statement);
}
/***** Test 18 *****/
query_cmd=(char *)"CONSTRUCT {?s ?p ?o} FROM <http://red> WHERE {?s ?p ?o}";
startTest(18, " Exec: QUERY \"%s\" \n", query_cmd);
{
query=librdf_new_query(world, (char *)"vsparql", NULL, (const unsigned char *)query_cmd, NULL);
if(!(results=librdf_model_query_execute(model, query))) {
endTest(0, " Query of model with '%s' failed\n", query_cmd);
librdf_free_query(query);
query=NULL;
} else {
stream=librdf_query_results_as_stream(results);
if(!stream) {
endTest(0, " QUERY returned no results (NULL stream)\n");
} else {
librdf_node* ctxt=NULL;
count=0;
while(!librdf_stream_end(stream)) {
librdf_statement *stmt=librdf_stream_get_object(stream); /*returns SHARED pointer */
ctxt=(librdf_node*)librdf_stream_get_context(stream);
if(!stmt) {
endTest(0, " librdf_stream_next returned NULL\n");
break;
}
fputs("Matched triple: ", stdout);
librdf_statement_print(stmt, stdout);
if(ctxt) {
fputs(" with context ", stdout);
librdf_node_print(ctxt, stdout);
}
fputc('\n', stdout);
count++;
librdf_stream_next(stream);
}
librdf_free_stream(stream);
endTest(1, " matching triples: %d\n", count);
librdf_free_query_results(results);
}
}
librdf_free_query(query);
}
/***** Test 19 *****/
query_cmd=(char *)"SELECT * WHERE {graph <http://red> { ?s ?p ?o }}";
startTest(19, " Exec1: QUERY_AS_BINDINGS \"%s\" \n", query_cmd);
{
query=librdf_new_query(world, (char *)"vsparql", NULL, (const unsigned char *)query_cmd, NULL);
if(!(results=librdf_model_query_execute(model, query))) {
endTest(0, " Query of model with '%s' failed\n", query_cmd);
librdf_free_query(query);
query=NULL;
} else {
raptor_iostream *iostr;
librdf_query_results_formatter *formatter;
fprintf(stderr, "**: Formatting query result as '%s':\n", results_format);
iostr = raptor_new_iostream_to_file_handle(librdf_world_get_raptor(world), stdout);
formatter = librdf_new_query_results_formatter2(results, results_format,
NULL /* mime type */,
NULL /* format_uri */);
base_uri = librdf_new_uri(world, (const unsigned char*)"http://example.org/");
librdf_query_results_formatter_write(iostr, formatter, results, base_uri);
librdf_free_query_results_formatter(formatter);
raptor_free_iostream(iostr);
librdf_free_uri(base_uri);
endTest(1, "\n");
librdf_free_query_results(results);
}
librdf_free_query(query);
}
/***** Test 20 *****/
query_cmd=(char *)"SELECT * WHERE {graph <http://red> { ?s ?p ?o }}";
startTest(20, " Exec2: QUERY_AS_BINDINGS \"%s\" \n", query_cmd);
{
query=librdf_new_query(world, (char *)"vsparql", NULL, (const unsigned char *)query_cmd, NULL);
if(!(results=librdf_model_query_execute(model, query))) {
endTest(0, " Query of model with '%s' failed\n", query_cmd);
librdf_free_query(query);
query=NULL;
} else {
if(print_query_results(world, model, results))
endTest(0, "\n");
else
endTest(1, "\n");
librdf_free_query_results(results);
}
librdf_free_query(query);
}
getTotal();
if(transactions)
librdf_model_transaction_commit(model);
librdf_free_node(context_node);
librdf_free_node(context_node);
librdf_free_hash(options);
librdf_free_model(model);
librdf_free_storage(storage);
librdf_free_world(world);
#ifdef LIBRDF_MEMORY_DEBUG
librdf_memory_report(stderr);
#endif
/* keep gcc -Wall happy */
return(0);
}
int
main(int argc, char *argv[])
{
librdf_world* world;
librdf_storage *storage, *new_storage;
librdf_model *model, *new_model;
librdf_stream *stream;
char *program=argv[0];
char *name;
char *new_name;
int count;
if(argc < 2 || argc >3) {
fprintf(stderr, "USAGE: %s: <Redland BDB name> [new DB name]\n", program);
return(1);
}
name=argv[1];
if(argc < 3) {
new_name=librdf_heuristic_gen_name(name);
if(!new_name) {
fprintf(stderr, "%s: Failed to create new name from '%s'\n", program,
name);
return(1);
}
} else {
new_name=argv[2];
}
fprintf(stderr, "%s: Upgrading DB '%s' to '%s'\n", program, name, new_name);
world=librdf_new_world();
librdf_world_open(world);
storage=librdf_new_storage(world, "hashes", name,
"hash-type='bdb',dir='.',write='no',new='no'");
if(!storage) {
fprintf(stderr, "%s: Failed to open old storage '%s'\n", program, name);
return(1);
}
new_storage=librdf_new_storage(world, "hashes", new_name,
"hash-type='bdb',dir='.',write='yes',new='yes'");
if(!storage) {
fprintf(stderr, "%s: Failed to create new storage '%s'\n", program, new_name);
return(1);
}
model=librdf_new_model(world, storage, NULL);
if(!model) {
fprintf(stderr, "%s: Failed to create model for '%s'\n", program, name);
return(1);
}
new_model=librdf_new_model(world, new_storage, NULL);
if(!new_model) {
fprintf(stderr, "%s: Failed to create new model for '%s'\n", program, new_name);
return(1);
}
stream=librdf_model_as_stream(model);
if(!stream) {
fprintf(stderr, "%s: librdf_model_as_stream returned NULL stream\n",
program);
return(1);
} else {
count=0;
while(!librdf_stream_end(stream)) {
librdf_statement *statement=librdf_stream_get_object(stream);
if(!statement) {
fprintf(stderr, "%s: librdf_stream_next returned NULL\n", program);
break;
}
librdf_model_add_statement(new_model, statement);
librdf_stream_next(stream);
count++;
}
librdf_free_stream(stream);
}
librdf_free_model(model);
librdf_free_model(new_model);
librdf_free_storage(storage);
librdf_free_storage(new_storage);
librdf_free_world(world);
if(argc < 3)
free(new_name);
#ifdef LIBRDF_MEMORY_DEBUG
librdf_memory_report(stderr);
#endif
/* keep gcc -Wall happy */
return(0);
}
static librdf_model * create_service_description(librdf_storage *sd_storage, const char * request_url)
{
librdf_model *sd_model = NULL;
librdf_node *service_node = NULL;
char *comment = NULL;
sd_model = librdf_new_model(world, sd_storage, NULL);
if (!sd_model) {
redstore_error("Failed to create model for service description.");
return NULL;
}
service_node = librdf_new_node(world);
if (!service_node) {
redstore_error("Failed to create service description bnode - librdf_new_node returned NULL");
librdf_free_model(sd_model);
return NULL;
}
librdf_model_add(sd_model,
librdf_new_node_from_node(service_node),
librdf_new_node_from_node(LIBRDF_MS_type(world)),
librdf_new_node_from_uri_local_name(world, sd_ns_uri, (unsigned char *) "Service")
);
sd_add_format_descriptions(sd_model, service_node, librdf_parser_get_description, "inputFormat");
sd_add_format_descriptions(sd_model, service_node, librdf_serializer_get_description, "resultFormat");
sd_add_format_descriptions(sd_model, service_node, librdf_query_results_formats_get_description, "resultFormat");
sd_add_query_languages(sd_model, service_node);
sd_add_dataset_description(sd_model, service_node);
librdf_model_add(sd_model,
librdf_new_node_from_node(service_node),
librdf_new_node_from_node(LIBRDF_S_label(world)),
librdf_new_node_from_literal(world, (unsigned char *) storage_name, NULL, 0)
);
#define COMMENT_MAX_LEN (128)
comment = malloc(COMMENT_MAX_LEN);
snprintf(comment, COMMENT_MAX_LEN, "RedStore %s endpoint using the '%s' storage module.",
PACKAGE_VERSION, storage_type);
librdf_model_add(sd_model,
librdf_new_node_from_node(service_node),
librdf_new_node_from_node(LIBRDF_S_comment(world)),
librdf_new_node_from_literal(world, (unsigned char *) comment, NULL, 0)
);
free(comment);
librdf_model_add(sd_model,
librdf_new_node_from_node(service_node),
librdf_new_node_from_uri_local_name(world, sd_ns_uri, (unsigned char *) "endpoint"),
sd_get_endpoint_node(request_url)
);
// Redland's default graph is the union of all other graphs
librdf_model_add(sd_model,
librdf_new_node_from_node(service_node),
librdf_new_node_from_uri_local_name(world, sd_ns_uri, (unsigned char *) "feature"),
librdf_new_node_from_uri_local_name(world, sd_ns_uri, (unsigned char *) "UnionDefaultGraph")
);
librdf_free_node(service_node);
return sd_model;
}
~RdfStorage()
{
librdf_free_model(m_model);
librdf_free_storage(m_storage);
}
int main(int argc, char** argv)
{
try {
/*********************************************************************/
/* Initialise */
/*********************************************************************/
std::cout << "** Initialise" << std::endl;
librdf_world* world = librdf_new_world();
if (world == 0)
throw std::runtime_error("Didn't get world");
librdf_storage* storage =
librdf_new_storage(world, STORE, STORE_NAME, "new='yes'");
if (storage == 0)
throw std::runtime_error("Didn't get storage");
librdf_model* model =
librdf_new_model(world, storage, 0);
if (model == 0)
throw std::runtime_error("Couldn't construct model");
/*********************************************************************/
/* Create in-memory model */
/*********************************************************************/
std::cout << "** Create in-memory model" << std::endl;
librdf_storage* mstorage =
librdf_new_storage(world, "memory", 0, 0);
if (storage == 0)
throw std::runtime_error("Didn't get storage");
librdf_model* mmodel =
librdf_new_model(world, mstorage, 0);
if (model == 0)
throw std::runtime_error("Couldn't construct model");
for(int i = 0; i < 10; i++) {
char sbuf[256];
char obuf[256];
sprintf(sbuf, "http://gaffer.test/number#%d", i);
sprintf(obuf, "http://gaffer.test/number#%d", i+1);
librdf_node *s =
librdf_new_node_from_uri_string(world,
(const unsigned char *) sbuf);
librdf_node *p =
librdf_new_node_from_uri_string(world,
(const unsigned char *)
"http://gaffer.test/number#is_before");
librdf_node *o =
librdf_new_node_from_uri_string(world,
(const unsigned char*) obuf);
librdf_statement* st = librdf_new_statement_from_nodes(world,
s, p, o);
librdf_model_add_statement(mmodel, st);
librdf_free_statement(st);
}
/*********************************************************************/
/* Size */
/*********************************************************************/
std::cout << "** Model size is " << librdf_model_size(model)
<< std::endl;
/*********************************************************************/
/* Add statement */
/*********************************************************************/
std::cout << "** Add statement" << std::endl;
const char* fred = "http://gaffer.test/#fred";
const char* is_a = "http://gaffer.test/#is_a";
const char* cat = "http://gaffer.test/#cat";
librdf_node *s =
librdf_new_node_from_uri_string(world,
(const unsigned char *) fred);
librdf_node *p =
librdf_new_node_from_uri_string(world,
(const unsigned char *) is_a);
librdf_node *o =
librdf_new_node_from_uri_string(world,
(const unsigned char *) cat);
librdf_statement* st = librdf_new_statement_from_nodes(world, s, p, o);
librdf_model_add_statement(model, st);
/*********************************************************************/
/* Add memory model statements */
/*********************************************************************/
std::cout << "** Add statements" << std::endl;
librdf_stream* strm = librdf_model_as_stream(mmodel);
if (strm == 0)
throw std::runtime_error("Couldn't get memory stream");
int ret = librdf_model_add_statements(model, strm);
if (ret != 0)
throw std::runtime_error("Couldn't add_statements");
librdf_free_stream(strm);
librdf_free_model(mmodel);
librdf_free_storage(mstorage);
/*********************************************************************/
/* Run queries */
/*********************************************************************/
run_query(world, model, query_string8);
run_query(world, model, query_string1);
run_query(world, model, query_string2);
run_query(world, model, query_string3);
run_query(world, model, query_string4);
run_query(world, model, query_string5);
run_query(world, model, query_string6);
run_query2(world, model, query_string7);
/*********************************************************************/
/* Remove statement */
/*********************************************************************/
std::cout << "** Remove statements" << std::endl;
librdf_model_remove_statement(model, st);
/*********************************************************************/
/* Serialise */
/*********************************************************************/
std::cout << "** Serialise" << std::endl;
strm = librdf_model_as_stream(model);
if (strm == 0)
throw std::runtime_error("Couldn't get model as stream");
librdf_serializer* srl = librdf_new_serializer(world, "ntriples",
0, 0);
if (srl == 0)
throw std::runtime_error("Couldn't create serialiser");
size_t len;
unsigned char* out =
librdf_serializer_serialize_stream_to_counted_string(srl, 0,
strm, &len);
std::cout << "--------------------------------------------------------"
<< std::endl;
write(1, out, len);
std::cout << "--------------------------------------------------------"
<< std::endl;
free(out);
librdf_free_stream(strm);
librdf_free_serializer(srl);
/*********************************************************************/
/* Cleanup */
/*********************************************************************/
librdf_free_statement(st);
librdf_free_model(model);
librdf_free_storage(storage);
librdf_free_world(world);
} catch (std::exception& e) {
std::cerr << e.what() << std::endl;
}
}
int
main(int argc, char *argv[])
{
const char *program=librdf_basename((const char*)argv[0]);
const char *test_serializer_types[]={"rdfxml", "ntriples", NULL};
int i;
const char *type;
unsigned char *string;
size_t string_length;
librdf_world *world;
librdf_storage *storage;
librdf_model* model;
librdf_uri* base_uri;
librdf_statement* statement;
librdf_serializer* serializer;
librdf_parser* parser;
librdf_stream* stream;
FILE *fh;
struct stat st_buf;
world=librdf_new_world();
librdf_world_open(world);
librdf_world_set_logger(world, &LogData, log_handler);
for(i=0; (type=test_serializer_types[i]); i++) {
fprintf(stderr, "%s: Trying to create new %s serializer\n", program, type);
serializer=librdf_new_serializer(world, type, NULL, NULL);
if(!serializer) {
fprintf(stderr, "%s: Failed to create new serializer type %s\n", program, type);
continue;
}
fprintf(stderr, "%s: Freeing serializer\n", program);
librdf_free_serializer(serializer);
}
storage=librdf_new_storage(world, NULL, NULL, NULL);
model=librdf_new_model(world, storage, NULL);
/* ERROR: Subject URI is bad UTF-8 */
statement=librdf_new_statement_from_nodes(world,
librdf_new_node_from_uri_string(world, (const unsigned char*)"http://example.org/foo\xfc"),
librdf_new_node_from_uri_string(world, (const unsigned char*)"http://example.org/bar"),
librdf_new_node_from_literal(world, (const unsigned char*)"blah", NULL, 0));
librdf_model_add_statement(model, statement);
librdf_free_statement(statement);
/* ERROR: Predicate URI is not serializable */
statement=librdf_new_statement_from_nodes(world,
librdf_new_node_from_uri_string(world, (const unsigned char*)"http://example.org/foo"),
librdf_new_node_from_uri_string(world, (const unsigned char*)"http://bad.example.org/"),
librdf_new_node_from_literal(world, (const unsigned char*)"blah", NULL, 0));
librdf_model_add_statement(model, statement);
librdf_free_statement(statement);
/* ERROR: Object literal is bad UTF-8 */
statement=librdf_new_statement_from_nodes(world,
librdf_new_node_from_uri_string(world, (const unsigned char*)"http://example.org/foo"),
librdf_new_node_from_uri_string(world, (const unsigned char*)"http://example.org/abc"),
librdf_new_node_from_literal(world, (const unsigned char*)"\xfc", NULL, 0));
librdf_model_add_statement(model, statement);
librdf_free_statement(statement);
serializer=librdf_new_serializer(world, "rdfxml", NULL, NULL);
base_uri=librdf_new_uri(world, (const unsigned char*)"http://example.org/base#");
string=librdf_serializer_serialize_model_to_counted_string(serializer,
base_uri, model,
&string_length);
#define EXPECTED_BAD_STRING_LENGTH 382
if(string_length != EXPECTED_BAD_STRING_LENGTH) {
fprintf(stderr, "%s: Serialising model to RDF/XML returned string '%s' size %d, expected %d\n", program, string,
(int)string_length, EXPECTED_BAD_STRING_LENGTH);
return 1;
}
if(string)
free(string);
librdf_free_uri(base_uri); base_uri=NULL;
librdf_free_model(model); model=NULL;
librdf_free_storage(storage); storage=NULL;
if(LogData.errors != EXPECTED_ERRORS) {
fprintf(stderr, "%s: Serialising to RDF/XML returned %d errors, expected %d\n", program,
LogData.errors, EXPECTED_ERRORS);
return 1;
}
if(LogData.warnings != EXPECTED_WARNINGS) {
fprintf(stderr, "%s: Serialising to RDF/XML returned %d warnings, expected %d\n", program,
LogData.warnings, EXPECTED_WARNINGS);
return 1;
}
/* Good model to serialize */
storage=librdf_new_storage(world, NULL, NULL, NULL);
model=librdf_new_model(world, storage, NULL);
parser=librdf_new_parser(world, SYNTAX_TYPE, NULL, NULL);
if(!parser) {
fprintf(stderr, "%s: Failed to create new parser type %s\n", program,
SYNTAX_TYPE);
return 1;
}
fprintf(stderr, "%s: Adding %s string content\n", program, SYNTAX_TYPE);
if(librdf_parser_parse_string_into_model(parser,
(const unsigned char*)SYNTAX_CONTENT,
NULL /* no base URI*/,
model)) {
fprintf(stderr, "%s: Failed to parse RDF from %s string into model\n",
SYNTAX_TYPE, program);
return 1;
}
librdf_free_parser(parser);
fprintf(stderr, "%s: Serializing stream to a string\n", program);
stream=librdf_model_as_stream(model);
string_length=0;
string=librdf_serializer_serialize_stream_to_counted_string(serializer,
NULL, stream,
&string_length);
#define EXPECTED_GOOD_STRING_LENGTH 668
if(string_length != EXPECTED_GOOD_STRING_LENGTH) {
fprintf(stderr, "%s: Serialising stream to RDF/XML returned string '%s' size %d, expected %d\n", program, string,
(int)string_length, EXPECTED_GOOD_STRING_LENGTH);
return 1;
}
librdf_free_stream(stream);
if(string)
free(string);
fprintf(stderr, "%s: Serializing stream to a file handle\n", program);
stream=librdf_model_as_stream(model);
#define FILENAME "test.rdf"
fh=fopen(FILENAME, "w");
if(!fh) {
fprintf(stderr, "%s: Failed to fopen for writing '%s' - %s\n",
program, FILENAME, strerror(errno));
return 1;
}
librdf_serializer_serialize_stream_to_file_handle(serializer, fh, NULL,
stream);
fclose(fh);
stat(FILENAME, &st_buf);
if((int)st_buf.st_size != EXPECTED_GOOD_STRING_LENGTH) {
fprintf(stderr, "%s: Serialising stream to file handle returned file '%s' of size %d bytes, expected %d\n", program, FILENAME, (int)st_buf.st_size,
EXPECTED_GOOD_STRING_LENGTH);
return 1;
}
unlink(FILENAME);
librdf_free_stream(stream);
librdf_free_serializer(serializer); serializer=NULL;
librdf_free_model(model); model=NULL;
librdf_free_storage(storage); storage=NULL;
librdf_free_world(world);
/* keep gcc -Wall happy */
return(0);
}
static int
validate_webid(request_rec *request, const char *subjAltName, char *pkey_n, unsigned int pkey_e_i) {
int r = HTTP_UNAUTHORIZED;
librdf_world *rdf_world = NULL;
librdf_storage *rdf_storage = NULL;
librdf_model *rdf_model = NULL;
librdf_query *rdf_query = NULL;
librdf_query_results *rdf_query_results = NULL;
rdf_world = librdf_new_world();
if (rdf_world != NULL) {
librdf_world_open(rdf_world);
librdf_world_set_logger(rdf_world, (void *)request, ap_rdf_log_proxy);
rdf_storage = librdf_new_storage(rdf_world, "uri", subjAltName, NULL);
if (rdf_storage != NULL) {
rdf_model = librdf_new_model(rdf_world, rdf_storage, NULL);
} else
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, request, "WebID: librdf_new_storage returned NULL");
}
if (rdf_model != NULL) {
char *c_query = apr_psprintf(request->pool, SPARQL_WEBID, subjAltName);
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, request, "WebID: SPARQL query = %s", c_query);
rdf_query = librdf_new_query(rdf_world, "sparql", NULL, (unsigned char*)c_query, NULL);
} else {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, request, "WebID: librdf_new_query returned NULL");
}
if (rdf_query != NULL) {
rdf_query_results = librdf_query_execute(rdf_query, rdf_model);
if (rdf_query_results != NULL) {
for (; r != OK && librdf_query_results_finished(rdf_query_results)==0; librdf_query_results_next(rdf_query_results)) {
librdf_node *m_node, *e_node;
unsigned char *rdf_mod;
unsigned char *rdf_exp;
if (r != OK
&& NULL != (m_node = librdf_query_results_get_binding_value_by_name(rdf_query_results, "m"))
&& NULL != (e_node = librdf_query_results_get_binding_value_by_name(rdf_query_results, "e"))) {
if (librdf_node_get_type(m_node) == LIBRDF_NODE_TYPE_LITERAL
&& librdf_node_get_type(e_node) == LIBRDF_NODE_TYPE_LITERAL) {
rdf_mod = librdf_node_get_literal_value(m_node);
rdf_exp = librdf_node_get_literal_value(e_node);
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, request, "WebID: modulus = %s", rdf_mod);
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, request, "WebID: exponent = %s", rdf_exp);
if (rdf_exp != NULL
&& apr_strtoi64((char*)rdf_exp, NULL, 10) == pkey_e_i
&& matches_pkey(rdf_mod, pkey_n))
r = OK;
librdf_free_node(m_node);
librdf_free_node(e_node);
}
}
}
librdf_free_query_results(rdf_query_results);
} else
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, request, "WebID: librdf_query_execute returned NULL");
librdf_free_query(rdf_query);
} else
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, request, "WebID: librdf_new_query returned NULL");
if (rdf_model) librdf_free_model(rdf_model);
if (rdf_storage) librdf_free_storage(rdf_storage);
if (rdf_world) librdf_free_world(rdf_world);
return r;
}
static int
check_request_acl(request_rec *r, int req_access) {
char *dir_path, *acl_path;
apr_finfo_t acl_finfo;
const char *req_uri, *dir_uri, *acl_uri, *access;
const char *port, *par_uri, *req_file;
librdf_world *rdf_world = NULL;
librdf_storage *rdf_storage = NULL;
librdf_model *rdf_model = NULL;
librdf_parser *rdf_parser = NULL;
librdf_uri *rdf_uri_acl = NULL,
*rdf_uri_base = NULL;
int ret = HTTP_FORBIDDEN;
// dir_path: parent directory of request filename
// acl_path: absolute path to request ACL
dir_path = ap_make_dirstr_parent(r->pool, r->filename);
acl_path = ap_make_full_path(r->pool, dir_path, WEBID_ACL_FNAME);
if (apr_filepath_merge(&acl_path, NULL, acl_path, APR_FILEPATH_NOTRELATIVE, r->pool) != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r,
"Module bug? Request filename path %s is invalid or "
"or not absolute for uri %s",
r->filename, r->uri);
return HTTP_FORBIDDEN;
}
// acl_path: 403 if missing
if ((apr_stat(&acl_finfo, acl_path, APR_FINFO_TYPE, r->pool) != APR_SUCCESS) ||
(acl_finfo.filetype != APR_REG)) {
return HTTP_FORBIDDEN;
}
// req_uri: fully qualified URI of request filename
// dir_uri: fully qualified URI of request filename parent
// acl_uri: fully qualified URI of request filename ACL
// access: ACL URI of requested access
port = ap_is_default_port(ap_get_server_port(r), r)
? "" : apr_psprintf(r->pool, ":%u", ap_get_server_port(r));
req_uri = apr_psprintf(r->pool, "%s://%s%s%s%s",
ap_http_scheme(r), ap_get_server_name(r), port,
(*r->uri == '/') ? "" : "/",
r->uri);
par_uri = ap_make_dirstr_parent(r->pool, r->uri);
dir_uri = apr_psprintf(r->pool, "%s://%s%s%s%s",
ap_http_scheme(r), ap_get_server_name(r), port,
(*par_uri == '/') ? "" : "/",
par_uri);
acl_uri = ap_make_full_path(r->pool, dir_uri, WEBID_ACL_FNAME);
if (req_access == WEBID_ACCESS_READ) {
access = "Read";
} else if (req_access == WEBID_ACCESS_WRITE) {
if ((req_file = strrchr(r->filename, '/')) != NULL &&
strcmp(++req_file, WEBID_ACL_FNAME) == 0)
access = "Control";
else
access = "Write";
} else {
access = "Control";
}
ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r,
"[ACL] %s (%s) %s | URI: %s | DIR: %s (%s) | ACL: %s (%s) | status: %d",
r->method, access, r->uri, req_uri, dir_uri, dir_path, acl_uri, acl_path, r->status);
if ((rdf_world = librdf_new_world()) != NULL) {
librdf_world_open(rdf_world);
if ((rdf_storage = librdf_new_storage(rdf_world, "memory", NULL, NULL)) != NULL) {
if ((rdf_model = librdf_new_model(rdf_world, rdf_storage, NULL)) != NULL) {
if ((rdf_parser = librdf_new_parser(rdf_world, "turtle", NULL, NULL)) != NULL) {
if ((rdf_uri_base = librdf_new_uri(rdf_world, (unsigned char*)acl_uri)) != NULL) {
if ((rdf_uri_acl = librdf_new_uri_from_filename(rdf_world, acl_path)) != NULL) {
if (!librdf_parser_parse_into_model(rdf_parser, rdf_uri_acl, rdf_uri_base, rdf_model)) {
//log_stream_prefix(r, librdf_model_as_stream(rdf_model), "[ACL] [model]");
if (query_results(r, rdf_world, rdf_model,
apr_psprintf(r->pool, SPARQL_URI_MODE_AGENT, "accessTo", req_uri, access, r->user)) > 0 || \
query_results(r, rdf_world, rdf_model,
apr_psprintf(r->pool, SPARQL_URI_MODE_AGENTCLASS, "accessTo", req_uri, access, r->user)) > 0 || \
query_results(r, rdf_world, rdf_model,
apr_psprintf(r->pool, SPARQL_URI_MODE_WORLD, "accessTo", req_uri, access)) > 0 || \
( ( query_results(r, rdf_world, rdf_model,
apr_psprintf(r->pool, SPARQL_URI_ACL_EXISTS, "accessTo", req_uri )) == 0 ) &&
( query_results(r, rdf_world, rdf_model,
apr_psprintf(r->pool, SPARQL_URI_MODE_AGENT, "defaultForNew", dir_uri, access, r->user)) > 0 || \
query_results(r, rdf_world, rdf_model,
apr_psprintf(r->pool, SPARQL_URI_MODE_AGENTCLASS, "defaultForNew", dir_uri, access, r->user)) > 0 || \
query_results(r, rdf_world, rdf_model,
apr_psprintf(r->pool, SPARQL_URI_MODE_WORLD, "defaultForNew", dir_uri, access)) > 0 ) ) ) {
apr_table_set(r->headers_out, "Link", apr_psprintf(r->pool, "%s; rel=meta", acl_uri));
ret = OK;
}
} else
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "librdf_parser_parse_into_model failed");
librdf_free_uri(rdf_uri_acl);
} else
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "librdf_new_uri_from_filename returned NULL");
librdf_free_uri(rdf_uri_base);
} else
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "librdf_new_uri returned NULL");
librdf_free_parser(rdf_parser);
} else
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "librdf_new_parser returned NULL");
librdf_free_model(rdf_model);
} else
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "librdf_new_model returned NULL");
librdf_free_storage(rdf_storage);
} else
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "librdf_new_storage returned NULL");
librdf_free_world(rdf_world);
} else
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "librdf_new_world returned NULL");
return ret;
}
