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"; } }
int main(int argc, char *argv[]) { librdf_world *world; world=librdf_new_world(); librdf_world_init_mutex(world); librdf_init_digest(world); librdf_init_hash(world); librdf_init_uri(world); librdf_init_node(world); librdf_init_concepts(world); librdf_finish_concepts(world); librdf_finish_node(world); librdf_finish_uri(world); librdf_finish_hash(world); librdf_finish_digest(world); LIBRDF_FREE(librdf_world, world); /* keep gcc -Wall happy */ return(0); }
int main(int argc, char *argv[]) { librdf_world* world; GMainLoop *loop; DBusServer *server; DBusError error; char *program=argv[0]; if (argc < 2) { fprintf (stderr, "%s: USAGE [server address]\n", program); return 1; } world=librdf_new_world(); librdf_world_open(world); g_thread_init (NULL); dbus_gthread_init (); dbus_error_init (&error); server = dbus_server_listen (argv[1], &error); if (server == NULL) { fprintf (stderr, "Failed to start server on %s: %s\n", argv[1], error.message); dbus_error_free (&error); return 1; } if (!dbus_connection_allocate_data_slot (&handler_slot)) g_error ("no memory for data slot"); disconnect_handler = dbus_message_handler_new (handle_disconnect, NULL, NULL); if (disconnect_handler == NULL) g_error ("no memory for handler"); dbus_server_set_new_connection_function (server, new_connection_callback, NULL, NULL); dbus_server_setup_with_g_main (server, NULL); loop = g_main_loop_new (NULL, FALSE); g_main_run (loop); 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; unsigned char* id; const char *program=librdf_basename((const char*)argv[0]); /* Minimal setup-cleanup test without opening the world */ fprintf(stdout, "%s: Creating new world\n", program); world = librdf_new_world(); if(!world) { fprintf(stderr, "%s: librdf_new_world failed\n", program); return 1; } fprintf(stdout, "%s: Deleting world\n", program); librdf_free_world(world); /* Test id generation */ fprintf(stdout, "%s: Creating new world\n", program); world = librdf_new_world(); if(!world) { fprintf(stderr, "%s: librdf_new_world failed\n", program); return 1; } fprintf(stdout, "%s: Generating an identifier\n", program); id = librdf_world_get_genid(world); if(id == NULL || strlen(id) < 6) { fprintf(stderr, "%s: librdf_world_get_genid failed\n", program); return 1; } fprintf(stdout, "%s: New identifier is: '%s'\n", program, id); LIBRDF_FREE(cstring, id); fprintf(stdout, "%s: Deleting world\n", program); librdf_free_world(world); /* keep gcc -Wall happy */ return(0); }
int main(int argc, char *argv[]) { librdf_storage* storage; char *program=argv[0]; librdf_world *world; world=librdf_new_world(); /* initialise hash, model and storage modules */ librdf_init_hash(world); librdf_init_storage(world); librdf_init_model(world); fprintf(stdout, "%s: Creating storage\n", program); storage=librdf_new_storage(world, NULL, "test", NULL); if(!storage) { fprintf(stderr, "%s: Failed to create new storage\n", program); return(1); } fprintf(stdout, "%s: Opening storage\n", program); if(librdf_storage_open(storage, NULL)) { fprintf(stderr, "%s: Failed to open storage\n", program); return(1); } /* Can do nothing here since need model and storage working */ fprintf(stdout, "%s: Closing storage\n", program); librdf_storage_close(storage); fprintf(stdout, "%s: Freeing storage\n", program); librdf_free_storage(storage); /* finish model and storage modules */ librdf_finish_model(world); librdf_finish_storage(world); librdf_finish_hash(world); LIBRDF_FREE(librdf_world, world); /* keep gcc -Wall happy */ return(0); }
/** * librdf_init_world: * @digest_factory_name: Name of digest factory to use * @not_used2: Not used * * Initialise the library * @deprecated: Do not use. * * Use librdf_new_world() and librdf_world_open() on #librdf_world object * * See librdf_world_set_digest() for documentation on arguments. **/ void librdf_init_world(char *digest_factory_name, void* not_used2) { #ifndef NO_STATIC_DATA RDF_World = librdf_new_world(); if(!RDF_World) return; if(digest_factory_name) librdf_world_set_digest(RDF_World, digest_factory_name); librdf_world_open(RDF_World); #else /* fail if NO_STATIC_DATA is defined */ abort(); #endif }
/** * @brief Initalizes the world, model and storage * * @return The success state of the initalizations */ bool RDF_InitRDF(void) { world = librdf_new_world(); librdf_world_open(world); #ifdef MEM_STORAGE storage = librdf_new_storage(world, NULL, NULL, "contexts='no'"); #else storage = librdf_new_storage(world, "hashes", "db", "hash-type='bdb',dir='.',new='yes', contexts='yes'"); #endif model = librdf_new_model(world, storage, NULL); printf("RDF Initalisation done!\n"); return true; }
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); }
static void test_all(const char *program) { librdf_hash *h; int num_test_hash_types, i, j; //const char *test_hash_types[]={"bdb", "tokyodb", "memory", NULL}; const char *test_hash_types[]={"tokyodb"}; librdf_world *world; world=librdf_new_world(); librdf_world_open(world); num_test_hash_types = sizeof(test_hash_types)/sizeof(const char*); for(i=0; i < num_test_hash_types; i++) { char db_name[100]; const char *type = test_hash_types[i]; fprintf(stdout, "Trying to create new %s hash\n", type); h=librdf_new_hash(world, type); if(!h) { fprintf(stderr, "Failed to create new hash type '%s' '%s'\n", program, type); continue; } sprintf(db_name, "test_%s_%s", type, DB_NAME_SUFFIX); if(librdf_hash_open(h, db_name, 0644, 1, 1, NULL)) { fprintf(stderr, "Failed to open new hash type '%s' '%s'\n", program, type); continue; } for (j=1; j<=STRESS_TEST_HASH_ITERATION; j++) { fprintf(stdout, "test_hash_funtionality iteration.. %d\n", j); test_hash_funtionality(world, h); } librdf_hash_close(h); fprintf(stdout, "Freeing hash: %s\n", program); librdf_free_hash(h); } librdf_free_world(world); }
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); }
int main(int argc, char *argv[]) { const char *program=librdf_basename((const char*)argv[0]); librdf_world *world; librdf_uri* uri; librdf_node* node; unsigned char* actual; world=librdf_new_world(); librdf_world_open(world); uri=LIBRDF_MS_Seq_URI(world); if(!uri) { fprintf(stderr, "%s: Got no concept URI for rdf:Seq\n", program); exit(1); } actual=librdf_uri_as_string(uri); if(strcmp(EXPECTED_STRING, (const char*)actual)) { fprintf(stderr, "%s: Expected URI: <%s> Got: <%s>\n", program, EXPECTED_STRING, actual); exit(1); } node=librdf_get_concept_resource_by_index(world, LIBRDF_CONCEPT_LAST); if(!node) { fprintf(stderr, "%s: Got no concept node for the last concept\n", program); exit(1); } librdf_free_world(world); /* keep gcc -Wall happy */ return(0); }
int main(int argc, char *argv[]) { librdf_statement *statement, *statement2; int size, size2; const char *program=librdf_basename((const char*)argv[0]); char *s, *buffer; librdf_world *world; raptor_iostream *iostr; world=librdf_new_world(); librdf_world_open(world); iostr = raptor_new_iostream_to_file_handle(world->raptor_world_ptr, stdout); fprintf(stdout, "%s: Creating statement\n", program); statement=librdf_new_statement(world); fprintf(stdout, "%s: Empty statement: ", program); librdf_statement_write(statement, iostr); fputs("\n", stdout); librdf_statement_set_subject(statement, librdf_new_node_from_uri_string(world, (const unsigned char*)"http://purl.org/net/dajobe/")); librdf_statement_set_predicate(statement, librdf_new_node_from_uri_string(world, (const unsigned char*)"http://purl.org/dc/elements/1.1/#Creator")); librdf_statement_set_object(statement, librdf_new_node_from_literal(world, (const unsigned char*)"Dave Beckett", NULL, 0)); fprintf(stdout, "%s: Resulting statement: ", program); librdf_statement_write(statement, iostr); fputs("\n", stdout); size = librdf_statement_encode2(world, statement, NULL, 0); fprintf(stdout, "%s: Encoding statement requires %d bytes\n", program, size); buffer=(char*)LIBRDF_MALLOC(cstring, size); fprintf(stdout, "%s: Encoding statement in buffer\n", program); size2 = librdf_statement_encode2(world, statement, (unsigned char*)buffer, size); if(size2 != size) { fprintf(stdout, "%s: Encoding statement used %d bytes, expected it to use %d\n", program, size2, size); return(1); } fprintf(stdout, "%s: Creating new statement\n", program); statement2=librdf_new_statement(world); fprintf(stdout, "%s: Decoding statement from buffer\n", program); if(!librdf_statement_decode2(world, statement2, NULL, (unsigned char*)buffer, size)) { fprintf(stdout, "%s: Decoding statement failed\n", program); return(1); } LIBRDF_FREE(cstring, buffer); fprintf(stdout, "%s: New statement is: ", program); librdf_statement_write(statement, iostr); fputs("\n", stdout); fprintf(stdout, "%s: Freeing statements\n", program); librdf_free_statement(statement2); librdf_free_statement(statement); librdf_free_world(world); /* keep gcc -Wall happy */ 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[]) { const unsigned char *hp_string=(const unsigned char*)"http://purl.org/net/dajobe/"; librdf_uri *uri1, *uri2, *uri3, *uri4, *uri5, *uri6, *uri7, *uri8, *uri9; librdf_digest *d; const char *program=librdf_basename((const char*)argv[0]); const char *file_string="/big/long/directory/file"; const unsigned char *file_uri_string=(const unsigned char*)"file:///big/long/directory/file"; const unsigned char *uri_string=(const unsigned char*)"http://example.com/big/long/directory/blah#frag"; const unsigned char *relative_uri_string1=(const unsigned char*)"#foo"; const unsigned char *relative_uri_string2=(const unsigned char*)"bar"; librdf_world *world; world=librdf_new_world(); librdf_world_open(world); fprintf(stderr, "%s: Creating new URI from string\n", program); uri1=librdf_new_uri(world, hp_string); if(!uri1) { fprintf(stderr, "%s: Failed to create URI from string '%s'\n", program, hp_string); return(1); } fprintf(stderr, "%s: Home page URI is ", program); librdf_uri_print(uri1, stderr); fputs("\n", stderr); fprintf(stderr, "%s: Creating URI from URI\n", program); uri2=librdf_new_uri_from_uri(uri1); if(!uri2) { fprintf(stderr, "%s: Failed to create new URI from old one\n", program); return(1); } fprintf(stderr, "%s: New URI is ", program); librdf_uri_print(uri2, stderr); fputs("\n", stderr); fprintf(stderr, "%s: Getting digest for URI\n", program); d = librdf_uri_get_digest(world, uri2); if(!d) { fprintf(stderr, "%s: Failed to get digest for URI %s\n", program, librdf_uri_as_string(uri2)); return(1); } fprintf(stderr, "%s: Digest is: ", program); librdf_digest_print(d, stderr); fputs("\n", stderr); librdf_free_digest(d); uri3=librdf_new_uri(world, (const unsigned char*)"file:/big/long/directory/"); uri4=librdf_new_uri(world, (const unsigned char*)"http://somewhere/dir/"); fprintf(stderr, "%s: Source URI is ", program); librdf_uri_print(uri3, stderr); fputs("\n", stderr); fprintf(stderr, "%s: Base URI is ", program); librdf_uri_print(uri4, stderr); fputs("\n", stderr); fprintf(stderr, "%s: URI string is '%s'\n", program, uri_string); uri5=librdf_new_uri_normalised_to_base(uri_string, uri3, uri4); fprintf(stderr, "%s: Normalised URI is ", program); librdf_uri_print(uri5, stderr); fputs("\n", stderr); uri6=librdf_new_uri_relative_to_base(uri5, relative_uri_string1); fprintf(stderr, "%s: URI + Relative URI %s gives ", program, relative_uri_string1); librdf_uri_print(uri6, stderr); fputs("\n", stderr); uri7=librdf_new_uri_relative_to_base(uri5, relative_uri_string2); fprintf(stderr, "%s: URI + Relative URI %s gives ", program, relative_uri_string2); librdf_uri_print(uri7, stderr); fputs("\n", stderr); uri8=librdf_new_uri_from_filename(world, file_string); uri9=librdf_new_uri(world, file_uri_string); if(!librdf_uri_equals(uri8, uri9)) { fprintf(stderr, "%s: URI string from filename %s returned %s, expected %s\n", program, file_string, librdf_uri_as_string(uri8), file_uri_string); return(1); } fprintf(stderr, "%s: Freeing URIs\n", program); librdf_free_uri(uri1); librdf_free_uri(uri2); librdf_free_uri(uri3); librdf_free_uri(uri4); librdf_free_uri(uri5); librdf_free_uri(uri6); librdf_free_uri(uri7); librdf_free_uri(uri8); librdf_free_uri(uri9); librdf_free_world(world); /* 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 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; }
int main(int argc, char *argv[]) { librdf_world *world; librdf_uri* prefix_uri; librdf_node* nodes[ITERATOR_NODES_COUNT]; int i; librdf_iterator* iterator; int count; char *program=argv[0]; world=librdf_new_world(); librdf_world_init_mutex(world); librdf_init_hash(world); librdf_init_uri(world); librdf_init_node(world); prefix_uri=librdf_new_uri(world, (const unsigned char*)NODE_URI_PREFIX); if(!prefix_uri) { fprintf(stderr, "%s: Failed to create prefix URI\n", program); return(1); } for(i=0; i < ITERATOR_NODES_COUNT; i++) { unsigned char buf[2]; buf[0]='a'+i; buf[1]='\0'; nodes[i]=librdf_new_node_from_uri_local_name(world, prefix_uri, buf); if(!nodes[i]) { fprintf(stderr, "%s: Failed to create node %i (%s)\n", program, i, buf); return(1); } } fprintf(stdout, "%s: Creating static node iterator\n", program); iterator=librdf_node_static_iterator_create(nodes, ITERATOR_NODES_COUNT); if(!iterator) { fprintf(stderr, "%s: Failed to createstatic node iterator\n", program); return(1); } fprintf(stdout, "%s: Listing static node iterator\n", program); count=0; while(!librdf_iterator_end(iterator)) { librdf_node* i_node=(librdf_node*)librdf_iterator_get_object(iterator); if(!i_node) { fprintf(stderr, "%s: librdf_iterator_current return NULL when not end o fiterator\n", program); return(1); } fprintf(stdout, "%s: node %d is: ", program, count); librdf_node_print(i_node, stdout); fputc('\n', stdout); if(!librdf_node_equals(i_node, nodes[count])) { fprintf(stderr, "%s: static node iterator node %i returned unexpected node\n", program, count); librdf_node_print(i_node, stderr); fputs(" rather than ", stdout); librdf_node_print(nodes[count], stderr); fputc('\n', stdout); return(1); } librdf_iterator_next(iterator); count++; } librdf_free_iterator(iterator); if(count != ITERATOR_NODES_COUNT) { fprintf(stderr, "%s: Iterator returned %d nodes, expected %d\n", program, count, ITERATOR_NODES_COUNT); return(1); } fprintf(stdout, "%s: Static node iterator worked ok\n", program); fprintf(stdout, "%s: Freeing nodes\n", program); for (i=0; i<ITERATOR_NODES_COUNT; i++) { librdf_free_node(nodes[i]); } librdf_free_uri(prefix_uri); librdf_finish_node(world); librdf_finish_uri(world); librdf_finish_hash(world); LIBRDF_FREE(librdf_world, world); /* keep gcc -Wall happy */ return(0); }
int main(int argc, char *argv[]) { librdf_statement *statement; librdf_stream* stream; const char *program=librdf_basename((const char*)argv[0]); librdf_world *world; librdf_uri* prefix_uri; librdf_node* nodes[STREAM_NODES_COUNT]; int i; librdf_iterator* iterator; int count; world=librdf_new_world(); librdf_world_open(world); prefix_uri=librdf_new_uri(world, (const unsigned char*)NODE_URI_PREFIX); if(!prefix_uri) { fprintf(stderr, "%s: Failed to create prefix URI\n", program); return(1); } for(i=0; i < STREAM_NODES_COUNT; i++) { unsigned char buf[2]; buf[0]='a'+i; buf[1]='\0'; nodes[i]=librdf_new_node_from_uri_local_name(world, prefix_uri, buf); if(!nodes[i]) { fprintf(stderr, "%s: Failed to create node %i (%s)\n", program, i, buf); return(1); } } fprintf(stdout, "%s: Creating static node iterator\n", program); iterator = librdf_node_new_static_node_iterator(world, nodes, STREAM_NODES_COUNT); if(!iterator) { fprintf(stderr, "%s: Failed to create static node iterator\n", program); return(1); } statement=librdf_new_statement_from_nodes(world, librdf_new_node_from_uri_string(world, (const unsigned char*)"http://example.org/resource"), librdf_new_node_from_uri_string(world, (const unsigned char*)"http://example.org/property"), NULL); if(!statement) { fprintf(stderr, "%s: Failed to create statement\n", program); return(1); } fprintf(stdout, "%s: Creating stream from node iterator\n", program); stream=librdf_new_stream_from_node_iterator(iterator, statement, LIBRDF_STATEMENT_OBJECT); if(!stream) { fprintf(stderr, "%s: Failed to createstatic node stream\n", program); return(1); } /* This is to check that the stream_from_node_iterator code * *really* takes a copy of what it needs from statement */ fprintf(stdout, "%s: Freeing statement\n", program); librdf_free_statement(statement); fprintf(stdout, "%s: Listing static node stream\n", program); count=0; while(!librdf_stream_end(stream)) { librdf_statement* s_statement=librdf_stream_get_object(stream); if(!s_statement) { fprintf(stderr, "%s: librdf_stream_current returned NULL when not end of stream\n", program); return(1); } fprintf(stdout, "%s: statement %d is: ", program, count); librdf_statement_print(s_statement, stdout); fputc('\n', stdout); librdf_stream_next(stream); count++; } if(count != STREAM_NODES_COUNT) { fprintf(stderr, "%s: Stream returned %d statements, expected %d\n", program, count, STREAM_NODES_COUNT); return(1); } fprintf(stdout, "%s: stream from node iterator worked ok\n", program); fprintf(stdout, "%s: Freeing stream\n", program); librdf_free_stream(stream); fprintf(stdout, "%s: Freeing nodes\n", program); for (i=0; i<STREAM_NODES_COUNT; i++) { librdf_free_node(nodes[i]); } librdf_free_uri(prefix_uri); librdf_free_world(world); /* keep gcc -Wall happy */ return(0); }
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); }
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(argv[0]); #define ITEM_COUNT 8 const char *items[ITEM_COUNT+1] = { "ron", "amy", "jen", "bij", "jib", "daj", "jim", "def", NULL }; #define DELETE_COUNT 2 const char *delete_items[DELETE_COUNT+1] = { "daj", "jim", NULL }; #define RESULT_COUNT (ITEM_COUNT-DELETE_COUNT) const char *results[RESULT_COUNT+1] = { "amy", "bij", /*"daj",*/ "def", "jen", "jib", /*"jim",*/"ron", NULL}; librdf_world* world; librdf_avltree* tree; librdf_iterator* iter; visit_state vs; int i; world = librdf_new_world(); tree = librdf_new_avltree(compare_strings, NULL); /* no free as they are static pointers above */ if(!tree) { fprintf(stderr, "%s: Failed to create tree\n", program); exit(1); } for(i = 0; items[i]; i++) { int rc; void* node; #if LIBRDF_DEBUG > 1 fprintf(stderr, "%s: Adding tree item '%s'\n", program, items[i]); #endif rc = librdf_avltree_add(tree, (void*)items[i]); if(rc) { fprintf(stderr, "%s: Adding tree item %d '%s' failed, returning error %d\n", program, i, items[i], rc); exit(1); } #ifdef LIBRDF_DEBUG librdf_avltree_check(tree); #endif node = librdf_avltree_search(tree, (void*)items[i]); if(!node) { fprintf(stderr, "%s: Tree did NOT contain item %d '%s' as expected\n", program, i, items[i]); exit(1); } } #if LIBRDF_DEBUG > 1 fprintf(stderr, "%s: Printing tree\n", program); vs.fh = stderr; vs.count = 0; librdf_avltree_visit(tree, print_string, &vs); //fprintf(stderr, "%s: Dumping tree\n", program); //librdf_avltree_dump(tree, stderr, print_string); #endif for(i = 0; delete_items[i]; i++) { int rc; #if LIBRDF_DEBUG > 1 fprintf(stderr, "%s: Deleting tree item '%s'\n", program, delete_items[i]); #endif rc = librdf_avltree_delete(tree, (void*)delete_items[i]); if(!rc) { fprintf(stderr, "%s: Deleting tree item %d '%s' failed, returning error %d\n", program, i, delete_items[i], rc); exit(1); } #ifdef LIBRDF_DEBUG librdf_avltree_check(tree); #endif } #if LIBRDF_DEBUG > 1 fprintf(stderr, "%s: Walking tree forwards via iterator\n", program); #endif iter = librdf_avltree_get_iterator_start(world, tree, NULL, NULL); for(i = 0; 1; i++) { const char* data = (const char*)librdf_iterator_get_object(iter); const char* result = results[i]; if((!data && data != result) || (data && strcmp(data, result))) { fprintf(stderr, "%3d: Forwards iterator expected '%s' but found '%s'\n", i, result, data); exit(1); } #if LIBRDF_DEBUG > 1 fprintf(stderr, "%3d: Got '%s'\n", i, data); #endif if(librdf_iterator_next(iter)) break; if(i > RESULT_COUNT) { fprintf(stderr, "Forward iterator did not end on result %i as expected\n", i); exit(1); } } #if LIBRDF_DEBUG > 1 fprintf(stderr, "%s: Checking tree\n", program); #endif vs.count = 0; vs.results=results; vs.failed = 0; librdf_avltree_visit(tree, check_string, &vs); if(vs.failed) { fprintf(stderr, "%s: Checking tree failed\n", program); exit(1); } for(i = 0; results[i]; i++) { const char* result = results[i]; char* data = (char*)librdf_avltree_remove(tree, (void*)result); if(!data) { fprintf(stderr, "%s: remove %i failed at item '%s'\n", program, i, result); exit(1); } if(strcmp(data, result)) { fprintf(stderr, "%s: remove %i returned %s not %s as expected\n", program, i, data, result); exit(1); } } #if LIBRDF_DEBUG > 1 fprintf(stderr, "%s: Freeing tree\n", program); #endif librdf_free_avltree(tree); librdf_free_world(world); /* keep gcc -Wall happy */ return(0); }
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; }