static osrfStringArray* apacheGetParamKeys(osrfStringArray* params) {
if(params == NULL) return NULL;
osrfStringArray* sarray = osrfNewStringArray(12);
int i;
//osrfLogDebug(OSRF_LOG_MARK, "Fetching URL param keys");
for( i = 0; i < params->size; i++ )
osrfStringArrayAdd(sarray, osrfStringArrayGetString(params, i++));
return sarray;
}
static osrfStringArray* apacheGetParamValues(osrfStringArray* params, char* key) {
if(params == NULL || key == NULL) return NULL;
osrfStringArray* sarray = osrfNewStringArray(12);
//osrfLogDebug(OSRF_LOG_MARK, "Fetching URL values for key %s", key);
int i;
for( i = 0; i < params->size; i++ ) {
const char* nkey = osrfStringArrayGetString(params, i++);
if(nkey && !strcmp(nkey, key))
osrfStringArrayAdd(sarray, osrfStringArrayGetString(params, i));
}
return sarray;
}
/**
@brief Search for one or more values in a configuration, specified by a path.
@param cfg (Optional) The configuration to search, or NULL for the default configuration.
@param arr Pointer to an osrfStringArray to be populated with values.
@param path A printf-style format string representing the search path. Subsequent
parameters, if any, are inserted into the format string to form the search path.
@return The number of values loaded into the osrfStringArray.
Search the configuration for values specified by the search path. Load any values
found (either strings or numbers) into an existing osrfStringArray supplied by the
calling code.
Make no effort to delete any strings that may already be in the osrfStringArray.
Ordinarily the calling code should ensure that the osrfStringArray is empty when passed.
If the configuration includes a configContext, then prepend it to the path, like so:
"//<configContext><path>". Hence the path should begin with a slash to separate it from
the context. Search for the resulting effective path at any level within the
configuration.
If the configuration does @em not include a configContext, then start the search at the
root of the configuration. In this case the path should @em not begin with a slash.
*/
int osrfConfigGetValueList(const osrfConfig* cfg, osrfStringArray* arr,
const char* path, ...) {
if(!arr || !path) return 0;
if(!cfg)
cfg = osrfConfigDefault;
if(!cfg) {
osrfLogWarning( OSRF_LOG_MARK, "No Config object!");
return -1;
}
VA_LIST_TO_STRING(path);
jsonObject* obj;
if(cfg->configContext) {
obj = jsonObjectFindPath( cfg->config, "//%s%s", cfg->configContext, VA_BUF);
} else {
obj = jsonObjectFindPath( cfg->config, VA_BUF);
}
int count = 0;
if(obj && obj->type == JSON_ARRAY ) {
int i;
for( i = 0; i < obj->size; i++ ) {
const char* val = jsonObjectGetString( jsonObjectGetIndex(obj, i) );
if(val) {
count++;
osrfStringArrayAdd(arr, val);
}
}
}
jsonObjectFree(obj);
return count;
}
osrfHash* oilsIDLInit( const char* idl_filename ) {
if (idlHash) return idlHash;
char* prop_str = NULL;
idlHash = osrfNewHash();
osrfHash* class_def_hash = NULL;
osrfLogInfo(OSRF_LOG_MARK, "Parsing the IDL XML...");
idlDoc = xmlReadFile( idl_filename, NULL, XML_PARSE_XINCLUDE );
if (!idlDoc) {
osrfLogError(OSRF_LOG_MARK, "Could not load or parse the IDL XML file!");
return NULL;
}
osrfLogDebug(OSRF_LOG_MARK, "Initializing the Fieldmapper IDL...");
xmlNodePtr docRoot = xmlDocGetRootElement(idlDoc);
xmlNodePtr kid = docRoot->children;
while (kid) {
if (!strcmp( (char*)kid->name, "class" )) {
class_def_hash = osrfNewHash();
char* current_class_name = (char*) xmlGetProp(kid, BAD_CAST "id");
osrfHashSet( class_def_hash, current_class_name, "classname" );
osrfHashSet( class_def_hash, xmlGetNsProp(kid, BAD_CAST "fieldmapper", BAD_CAST OBJECT_NS), "fieldmapper" );
osrfHashSet( class_def_hash, xmlGetNsProp(kid, BAD_CAST "readonly", BAD_CAST PERSIST_NS), "readonly" );
osrfHashSet( idlHash, class_def_hash, current_class_name );
if ((prop_str = (char*)xmlGetNsProp(kid, BAD_CAST "tablename", BAD_CAST PERSIST_NS))) {
osrfLogDebug(OSRF_LOG_MARK, "Using table '%s' for class %s", prop_str, current_class_name );
osrfHashSet(
class_def_hash,
prop_str,
"tablename"
);
}
if ((prop_str = (char*)xmlGetNsProp(kid, BAD_CAST "restrict_primary", BAD_CAST PERSIST_NS))) {
osrfLogDebug(OSRF_LOG_MARK, "Delete restriction policy set at '%s' for pkey of class %s", prop_str, current_class_name );
osrfHashSet(
class_def_hash,
prop_str,
"restrict_primary"
);
}
if ((prop_str = (char*)xmlGetNsProp(kid, BAD_CAST "virtual", BAD_CAST PERSIST_NS))) {
osrfHashSet(
class_def_hash,
prop_str,
"virtual"
);
}
// Tokenize controller attribute into an osrfStringArray
prop_str = (char*) xmlGetProp(kid, BAD_CAST "controller");
if( prop_str )
osrfLogDebug(OSRF_LOG_MARK, "Controller list is %s", prop_str );
osrfStringArray* controller = osrfStringArrayTokenize( prop_str, ' ' );
xmlFree( prop_str );
osrfHashSet( class_def_hash, controller, "controller");
osrfHash* current_links_hash = osrfNewHash();
osrfHash* current_fields_hash = osrfNewHash();
osrfHashSet( class_def_hash, current_fields_hash, "fields" );
osrfHashSet( class_def_hash, current_links_hash, "links" );
xmlNodePtr _cur = kid->children;
while (_cur) {
if (!strcmp( (char*)_cur->name, "fields" )) {
if( (prop_str = (char*)xmlGetNsProp(_cur, BAD_CAST "primary", BAD_CAST PERSIST_NS)) ) {
osrfHashSet(
class_def_hash,
prop_str,
"primarykey"
);
}
if( (prop_str = (char*)xmlGetNsProp(_cur, BAD_CAST "sequence", BAD_CAST PERSIST_NS)) ) {
osrfHashSet(
class_def_hash,
prop_str,
"sequence"
);
}
unsigned int array_pos = 0;
char array_pos_buf[ 7 ]; // For up to 1,000,000 fields per class
xmlNodePtr _f = _cur->children;
while(_f) {
if (strcmp( (char*)_f->name, "field" )) {
_f = _f->next;
continue;
}
// Get the field name. If it's one of the three standard
// fields that we always generate, ignore it.
char* field_name = (char*)xmlGetProp(_f, BAD_CAST "name");
if( field_name ) {
osrfLogDebug(OSRF_LOG_MARK,
"Found field %s for class %s", field_name, current_class_name );
if( !strcmp( field_name, "isnew" )
|| !strcmp( field_name, "ischanged" )
|| !strcmp( field_name, "isdeleted" ) ) {
free( field_name );
_f = _f->next;
continue;
}
} else {
osrfLogDebug(OSRF_LOG_MARK,
"Found field with no name for class %s", current_class_name );
_f = _f->next;
continue;
}
osrfHash* field_def_hash = osrfNewHash();
// Insert array_position
snprintf( array_pos_buf, sizeof( array_pos_buf ), "%u", array_pos++ );
osrfHashSet( field_def_hash, strdup( array_pos_buf ), "array_position" );
if( (prop_str = (char*)xmlGetNsProp(_f, BAD_CAST "i18n", BAD_CAST PERSIST_NS)) ) {
osrfHashSet(
field_def_hash,
prop_str,
"i18n"
);
}
if( (prop_str = (char*)xmlGetNsProp(_f, BAD_CAST "virtual", BAD_CAST PERSIST_NS)) ) {
osrfHashSet(
field_def_hash,
prop_str,
"virtual"
);
} else { // default to virtual
osrfHashSet(
field_def_hash,
"false",
"virtual"
);
}
if( (prop_str = (char*)xmlGetNsProp(_f, BAD_CAST "primitive", BAD_CAST PERSIST_NS)) ) {
osrfHashSet(
field_def_hash,
prop_str,
"primitive"
);
}
osrfHashSet( field_def_hash, field_name, "name" );
osrfHashSet(
current_fields_hash,
field_def_hash,
field_name
);
_f = _f->next;
}
// Create three standard, stereotyped virtual fields for every class
add_std_fld( current_fields_hash, "isnew", array_pos++ );
add_std_fld( current_fields_hash, "ischanged", array_pos++ );
add_std_fld( current_fields_hash, "isdeleted", array_pos );
}
if (!strcmp( (char*)_cur->name, "links" )) {
xmlNodePtr _l = _cur->children;
while(_l) {
if (strcmp( (char*)_l->name, "link" )) {
_l = _l->next;
continue;
}
osrfHash* link_def_hash = osrfNewHash();
if( (prop_str = (char*)xmlGetProp(_l, BAD_CAST "reltype")) ) {
osrfHashSet(
link_def_hash,
prop_str,
"reltype"
);
osrfLogDebug(OSRF_LOG_MARK, "Adding link with reltype %s", prop_str );
} else
osrfLogDebug(OSRF_LOG_MARK, "Adding link with no reltype" );
if( (prop_str = (char*)xmlGetProp(_l, BAD_CAST "key")) ) {
osrfHashSet(
link_def_hash,
prop_str,
"key"
);
osrfLogDebug(OSRF_LOG_MARK, "Link fkey is %s", prop_str );
} else
osrfLogDebug(OSRF_LOG_MARK, "Link with no fkey" );
if( (prop_str = (char*)xmlGetProp(_l, BAD_CAST "class")) ) {
osrfHashSet(
link_def_hash,
prop_str,
"class"
);
osrfLogDebug(OSRF_LOG_MARK, "Link fclass is %s", prop_str );
} else
osrfLogDebug(OSRF_LOG_MARK, "Link with no fclass" );
// Tokenize map attribute into an osrfStringArray
prop_str = (char*) xmlGetProp(_l, BAD_CAST "map");
if( prop_str )
osrfLogDebug(OSRF_LOG_MARK, "Link mapping list is %s", prop_str );
osrfStringArray* map = osrfStringArrayTokenize( prop_str, ' ' );
osrfHashSet( link_def_hash, map, "map");
xmlFree( prop_str );
if( (prop_str = (char*)xmlGetProp(_l, BAD_CAST "field")) ) {
osrfHashSet(
link_def_hash,
prop_str,
"field"
);
osrfLogDebug(OSRF_LOG_MARK, "Link fclass is %s", prop_str );
} else
osrfLogDebug(OSRF_LOG_MARK, "Link with no fclass" );
osrfHashSet(
current_links_hash,
link_def_hash,
prop_str
);
_l = _l->next;
}
}
/**** Structure of permacrud in memory ****
{ create :
{ permission : [ x, y, z ],
global_required : "true", -- anything else, or missing, is false
local_context : [ f1, f2 ],
foreign_context : { class1 : { fkey : local_class_key, field : class1_field, context : [ a, b, c ] }, ...}
},
retrieve : null, -- no perm check, or structure similar to the others
update : -- like create
...
delete : -- like create
...
}
**** Structure of permacrud in memory ****/
if (!strcmp( (char*)_cur->name, "permacrud" )) {
osrfHash* pcrud = osrfNewHash();
osrfHashSet( class_def_hash, pcrud, "permacrud" );
xmlNodePtr _l = _cur->children;
while(_l) {
if (strcmp( (char*)_l->name, "actions" )) {
_l = _l->next;
continue;
}
xmlNodePtr _a = _l->children;
while(_a) {
const char* action_name = (const char*) _a->name;
if (
strcmp( action_name, "create" ) &&
strcmp( action_name, "retrieve" ) &&
strcmp( action_name, "update" ) &&
strcmp( action_name, "delete" )
) {
_a = _a->next;
continue;
}
osrfLogDebug(OSRF_LOG_MARK, "Found Permacrud action %s for class %s",
action_name, current_class_name );
osrfHash* action_def_hash = osrfNewHash();
osrfHashSet( pcrud, action_def_hash, action_name );
// Tokenize permission attribute into an osrfStringArray
prop_str = (char*) xmlGetProp(_a, BAD_CAST "permission");
if( prop_str )
osrfLogDebug(OSRF_LOG_MARK,
"Permacrud permission list is %s", prop_str );
osrfStringArray* map = osrfStringArrayTokenize( prop_str, ' ' );
osrfHashSet( action_def_hash, map, "permission");
xmlFree( prop_str );
osrfHashSet( action_def_hash,
(char*)xmlGetNoNsProp(_a, BAD_CAST "global_required"), "global_required");
// Tokenize context_field attribute into an osrfStringArray
prop_str = (char*) xmlGetProp(_a, BAD_CAST "context_field");
if( prop_str )
osrfLogDebug(OSRF_LOG_MARK,
"Permacrud context_field list is %s", prop_str );
map = osrfStringArrayTokenize( prop_str, ' ' );
osrfHashSet( action_def_hash, map, "local_context");
xmlFree( prop_str );
osrfHash* foreign_context = osrfNewHash();
osrfHashSet( action_def_hash, foreign_context, "foreign_context");
xmlNodePtr _f = _a->children;
while(_f) {
if ( strcmp( (char*)_f->name, "context" ) ) {
_f = _f->next;
continue;
}
if( (prop_str = (char*)xmlGetNoNsProp(_f, BAD_CAST "link")) ) {
osrfLogDebug(OSRF_LOG_MARK,
"Permacrud context link definition is %s", prop_str );
osrfHash* _tmp_fcontext = osrfNewHash();
// Store pointers to elements already stored
// from the <link> aggregate
osrfHash* _flink = osrfHashGet( current_links_hash, prop_str );
osrfHashSet( _tmp_fcontext, osrfHashGet(_flink, "field"), "fkey" );
osrfHashSet( _tmp_fcontext, osrfHashGet(_flink, "key"), "field" );
xmlFree( prop_str );
if( (prop_str = (char*)xmlGetNoNsProp(_f, BAD_CAST "jump")) )
osrfHashSet( _tmp_fcontext, osrfStringArrayTokenize( prop_str, '.' ), "jump" );
xmlFree( prop_str );
// Tokenize field attribute into an osrfStringArray
char * field_list = (char*) xmlGetProp(_f, BAD_CAST "field");
if( field_list )
osrfLogDebug(OSRF_LOG_MARK,
"Permacrud foreign context field list is %s", field_list );
map = osrfStringArrayTokenize( field_list, ' ' );
osrfHashSet( _tmp_fcontext, map, "context");
xmlFree( field_list );
// Insert the new hash into a hash attached to the parent node
osrfHashSet( foreign_context, _tmp_fcontext, osrfHashGet( _flink, "class" ) );
} else {
if( (prop_str = (char*)xmlGetNoNsProp(_f, BAD_CAST "field") )) {
char* map_list = prop_str;
osrfLogDebug(OSRF_LOG_MARK,
"Permacrud local context field list is %s", prop_str );
if (strlen( map_list ) > 0) {
char* st_tmp = NULL;
char* _map_class = strtok_r(map_list, " ", &st_tmp);
osrfStringArrayAdd(
osrfHashGet( action_def_hash, "local_context"), _map_class);
while ((_map_class = strtok_r(NULL, " ", &st_tmp))) {
osrfStringArrayAdd(
osrfHashGet( action_def_hash, "local_context"), _map_class);
}
}
xmlFree(map_list);
}
}
_f = _f->next;
}
_a = _a->next;
}
_l = _l->next;
}
}
if (!strcmp( (char*)_cur->name, "source_definition" )) {
char* content_str;
if( (content_str = (char*)xmlNodeGetContent(_cur)) ) {
osrfLogDebug(OSRF_LOG_MARK, "Using source definition '%s' for class %s",
content_str, current_class_name );
osrfHashSet(
class_def_hash,
content_str,
"source_definition"
);
}
}
_cur = _cur->next;
} // end while
}
kid = kid->next;
} // end while
osrfLogInfo(OSRF_LOG_MARK, "...IDL XML parsed");
return idlHash;
}
static osrfStringArray* apacheParseParms(request_rec* r) {
if( r == NULL ) return NULL;
//ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "got a valid request_rec");
char* arg = NULL;
apr_pool_t *p = r->pool; /* memory pool */
growing_buffer* buffer = buffer_init(1025);
/* gather the post args and append them to the url query string */
if( !strcmp(r->method,"POST") ) {
ap_setup_client_block(r, REQUEST_CHUNKED_DECHUNK);
//osrfLogDebug(OSRF_LOG_MARK, "gateway reading post data..");
//ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "idlchunk reading post data..");
if(ap_should_client_block(r)) {
/* Start with url query string, if any */
if(r->args && r->args[0])
buffer_add(buffer, r->args);
char body[1025];
//osrfLogDebug(OSRF_LOG_MARK, "gateway client has post data, reading...");
/* Append POST data */
long bread;
while( (bread = ap_get_client_block(r, body, sizeof(body) - 1)) ) {
if(bread < 0) {
//osrfLogInfo(OSRF_LOG_MARK,
// "ap_get_client_block(): returned error, exiting POST reader");
break;
}
body[bread] = '\0';
buffer_add( buffer, body );
//osrfLogDebug(OSRF_LOG_MARK,
// "gateway read %ld bytes: %d bytes of data so far", bread, buffer->n_used);
if(buffer->n_used > APACHE_TOOLS_MAX_POST_SIZE) {
//osrfLogError(OSRF_LOG_MARK, "gateway received POST larger "
// "than %d bytes. dropping request", APACHE_TOOLS_MAX_POST_SIZE);
buffer_free(buffer);
return NULL;
}
}
//osrfLogDebug(OSRF_LOG_MARK, "gateway done reading post data");
}
} else { /* GET */
if(r->args && r->args[0])
buffer_add(buffer, r->args);
//ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "idlchunk read GET data..");
}
if(buffer->n_used > 0)
arg = apr_pstrdup(p, buffer->buf);
else
arg = NULL;
buffer_free(buffer);
if( !arg || !arg[0] ) { /* we received no request */
return NULL;
}
//osrfLogDebug(OSRF_LOG_MARK, "parsing URL params from post/get request data: %s", arg);
//ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "parsing URL params from post/get request data: %s", arg);
osrfStringArray* sarray = osrfNewStringArray(12); /* method parameters */
int sanity = 0;
char* key = NULL; /* query item name */
char* val = NULL; /* query item value */
/* Parse the post/get request data into a series of name/value pairs. */
/* Load each name into an even-numbered slot of an osrfStringArray, and */
/* the corresponding value into the following odd-numbered slot. */
while( arg && (val = ap_getword(p, (const char**) &arg, '&'))) {
key = ap_getword(r->pool, (const char**) &val, '=');
if(!key || !key[0])
break;
ap_unescape_url(key);
ap_unescape_url(val);
//osrfLogDebug(OSRF_LOG_MARK, "parsed URL params %s=%s", key, val);
osrfStringArrayAdd(sarray, key);
osrfStringArrayAdd(sarray, val);
if( sanity++ > 1000 ) {
//osrfLogError(OSRF_LOG_MARK,
// "Parsing URL params failed sanity check: 1000 iterations");
osrfStringArrayFree(sarray);
return NULL;
}
}
//osrfLogDebug(OSRF_LOG_MARK,
// "Apache tools parsed %d params key/values", sarray->size / 2 );
return sarray;
}
