install: install-prep transport-install stack-install gateway-install \
router-install srfsh-install jserver-install perl-install \
- libjson-install objson-install utils-install bin-install info
+ objson-install utils-install bin-install info
prep:
mkdir -p $(TMPDIR)
@echo -e "\n + objson"
make -C objson
-json: prep
- @echo -e "\n + libjson"
- make -C libjson
-
-stack: json objson transport
+stack: objson transport
@echo -e "\n + stack"
make -C libstack
transport-install: install-prep utils-install
make -C libtransport install
-libjson-install: install-prep
- make -C libjson install
-
utils-install: install-prep
make -C utils install
objson-install: install-prep utils-install
make -C objson install
-stack-install: install-prep transport-install libjson-install objson-install
+stack-install: install-prep transport-install objson-install
make -C libstack install
gateway-install: install-prep stack-install
clean:
@echo "Cleaning..."
make -C libtransport clean
- make -C libjson clean
make -C libstack clean
make -C router clean
make -C gateway clean
make -C jserver clean
make -C utils clean
make -C objson clean
- make -C libjson clean
make -C srfsh clean
/bin/rm -rf $(TMPDIR)
CC_OPTS += -DASSUME_STATELESS
-LD_OPTS += -lc_utils -lobjson -lxml2 -lopensrf_transport -lopensrf_stack -ljson
+LD_OPTS += -lc_utils -lobjson -lxml2 -lopensrf_transport -lopensrf_stack
all: libmod_ils_gateway.so
#include "opensrf/osrf_app_session.h"
#include "opensrf/string_array.h"
#include "md5.h"
+#include "objson/object.h"
+#include "objson/json_parser.h"
/*
* This function is registered as a handler for HTTP methods and will
char* service = NULL; /* service to connect to */
char* method = NULL; /* method to perform */
- json* exception = NULL; /* returned in error conditions */
+ //json* exception = NULL; /* returned in error conditions */
+ object* exception = NULL; /* returned in error conditions */
string_array* sarray = init_string_array(12); /* method parameters */
growing_buffer* buffer = NULL; /* POST data */
}
*/
- int req_id = osrf_app_session_make_request( session, NULL, method, 1, sarray );
+ int req_id = osrf_app_session_make_req( session, NULL, method, 1, sarray );
string_array_destroy(sarray);
osrf_message* omsg = NULL;
buffer_add( exc_buffer, code );
/* build the exception object */
+ /*
exception = json_object_new_object();
json_object_object_add( exception, "is_err", json_object_new_int(1));
json_object_object_add( exception,
"err_msg", json_object_new_string(exc_buffer->buf));
+ */
+ exception = json_parse_string("{}");
+ exception->add_key(exception, "is_err", json_parse_string("1"));
+ exception->add_key(exception, "err_msg", json_parse_string(exc_buffer->buf));
warning_handler("*** Looks like we got a "
"server exception\n%s", exc_buffer->buf );
/* round up our data */
if(exception) {
- content = strdup(json_object_to_json_string(exception));
- json_object_put(exception);
+ //content = strdup(json_object_to_json_string(exception));
+ //json_object_put(exception);
+ content = strdup(exception->to_json(exception));
+ free_object(exception);
} else
content = buffer_data(result_data);
CC_OPTS += -DASSUME_STATELESS
-EXE_LD_OPTS += -lxml2 -lopensrf_transport -lopensrf_stack -lobjson -ljson -lc_utils
+EXE_LD_OPTS += -lxml2 -lopensrf_transport -lopensrf_stack -lobjson -lc_utils
SOURCES = osrf_message.c osrf_app_session.c osrf_stack.c osrf_system.c osrf_config.c
TARGETS = osrf_message.o osrf_app_session.o osrf_stack.o osrf_system.o osrf_config.o
}
+/*
int osrf_app_session_make_request(
osrf_app_session* session, json* params,
char* method_name, int protocol, string_array* param_strings ) {
osrf_message* req_msg = osrf_message_init( REQUEST, ++(session->thread_trace), protocol );
osrf_message_set_request_info( req_msg, method_name, params );
+ if(!req_msg->parse_json_params && param_strings) {
+ int i;
+ for(i = 0; i!= param_strings->size ; i++ ) {
+ osrf_message_add_param(req_msg,
+ string_array_get_string(param_strings,i));
+ }
+ }
+
+ osrf_app_request* req = _osrf_app_request_init( session, req_msg );
+ if(!_osrf_app_session_send( session, req_msg ) ) {
+ warning_handler( "Error sending request message [%d]", session->thread_trace );
+ return -1;
+ }
+
+ _osrf_app_session_push_request( session, req );
+ return req->request_id;
+}
+*/
+
+
+
+
+int osrf_app_session_make_req(
+ osrf_app_session* session, object* params,
+ char* method_name, int protocol, string_array* param_strings ) {
+ if(session == NULL) return -1;
+
+ osrf_message* req_msg = osrf_message_init( REQUEST, ++(session->thread_trace), protocol );
+ //osrf_message_set_request_info( req_msg, method_name, params );
+ osrf_message_set_method(req_msg, method_name);
+ if(params) osrf_message_set_params(req_msg, params);
+
/* if we're not parsing the json, shove the strings in manually */
if(!req_msg->parse_json_params && param_strings) {
int i;
return req->request_id;
}
+
+
/** Adds an app_request to the request set */
void _osrf_app_session_push_request( osrf_app_session* session, osrf_app_request* req ){
if(session == NULL || req == NULL)
-#include "libjson/json.h"
#include "opensrf/transport_client.h"
#include "osrf_message.h"
#include "osrf_system.h"
#include "string_array.h"
#include "osrf_config.h"
+#include "objson/object.h"
+#include "objson/json_parser.h"
+
#ifndef OSRF_APP_SESSION
#define OSRF_APP_SESSION
* the id of the request. This id is then used to perform work on the
* requeset.
*/
+
+
+int osrf_app_session_make_req(
+ osrf_app_session* session, object* params,
+ char* method_name, int protocol, string_array* param_strings);
+
+/*
int osrf_app_session_make_request(
osrf_app_session* session, json* params,
char* method_name, int protocol, string_array* arr );
+ */
/** Sets the given request to complete state */
void osrf_app_session_set_complete( osrf_app_session* session, int request_id );
msg->parse_json_result = parse_json_result;
msg->parse_json_params = parse_json_params;
msg->parray = init_string_array(16); /* start out with a slot for 16 params. can grow */
- msg->params = NULL;
+ msg->_params = NULL;
+ msg->_result_content = NULL;
return msg;
}
parse_json_params = ibool;
}
+/*
void osrf_message_set_request_info(
osrf_message* msg, char* method_name, json* json_params ) {
msg->method_name = strdup( method_name );
}
+*/
+
+void osrf_message_set_method( osrf_message* msg, char* method_name ) {
+ if( msg == NULL || method_name == NULL ) return;
+ msg->method_name = strdup( method_name );
+}
+
+
+/* uses the object passed in directly, do not FREE! */
+void osrf_message_add_object_param( osrf_message* msg, object* o ) {
+ if(!msg|| !o) return;
+ if(msg->parse_json_params) {
+ if(!msg->_params)
+ msg->_params = json_parse_string("[]");
+ msg->_params->push(msg->_params, json_parse_string(o->to_json(o)));
+ }
+}
+
+void osrf_message_set_params( osrf_message* msg, object* o ) {
+ if(!msg || !o) return;
+
+ char* j = object_to_json(o);
+ debug_handler("Setting params to\n%s", j);
+ free(j);
+
+ if(msg->parse_json_params) {
+ if(!o->is_array) {
+ warning_handler("passing non-array to osrf_message_set_params()");
+ return;
+ }
+ if(msg->_params) free_object(msg->_params);
+ char* j = o->to_json(o);
+ msg->_params = json_parse_string(j);
+ free(j);
+ }
+}
/* only works of parse_json_params is false */
msg->result_string = strdup(json_string);
/* ----------------------------------------------------- */
+ /*
object* o = json_parse_string(json_string);
char* string = o->to_json(o);
debug_handler("---------------------------------------------------");
debug_handler("---------------------------------------------------");
free_object(o);
free(string);
+ */
/* ----------------------------------------------------- */
- debug_handler( "Message Parse JSON is set to: %d", msg->parse_json_result );
+ debug_handler( "Message Parse JSON result is set to: %d", msg->parse_json_result );
if(msg->parse_json_result) {
- msg->result_content = json_tokener_parse(msg->result_string);
+ //msg->result_content = json_tokener_parse(msg->result_string);
msg->_result_content = json_parse_string(msg->result_string);
-
- char* j = object_to_json(msg->_result_content);
- debug_handler("PARSE json result content %s", j);
- free(j);
}
}
if( msg->status_text != NULL )
free(msg->status_text);
+ /*
if( msg->result_content != NULL )
json_object_put( msg->result_content );
+ */
if( msg->_result_content != NULL )
free_object( msg->_result_content );
if( msg->method_name != NULL )
free(msg->method_name);
+ /*
if( msg->params != NULL )
json_object_put( msg->params );
+ */
if( msg->_params != NULL )
free_object(msg->_params);
xmlSetProp( method_name_node, BAD_CAST "value", BAD_CAST msg->method_name );
if( msg->parse_json_params ) {
- if( msg->params != NULL ) {
+ if( msg->_params != NULL ) {
//char* jj = json_object_to_json_string( msg->params );
char* jj = msg->_params->to_json(msg->_params);
if( !strcmp((char*)meth_node->name,"params" ) && meth_node->children->content ) {
//new_msg->params = json_object_new_string( meth_node->children->content );
if( new_msg->parse_json_params) {
- new_msg->params = json_tokener_parse(meth_node->children->content);
+ //new_msg->params = json_tokener_parse(meth_node->children->content);
new_msg->_params = json_parse_string(meth_node->children->content);
} else {
/* XXX this will have to parse the JSON to
grab the strings for full support! This should only be
necessary for server support of
non-json-param-parsing, though. Ugh. */
- new_msg->params = json_tokener_parse(meth_node->children->content);
+ //new_msg->params = json_tokener_parse(meth_node->children->content);
new_msg->_params = json_parse_string(meth_node->children->content);
}
}
-#include "libjson/json.h"
#include "string_array.h"
#include "utils.h"
#include "logging.h"
int is_exception;
/* if we're a RESULT */
- json* result_content;
+ //json* result_content;
object* _result_content;
/* unparsed json string */
/* if we're a REQUEST */
char* method_name;
- json* params;
+ //json* params;
object* _params;
/* in case anyone wants to make a list of us.
osrf_message* osrf_message_init( enum M_TYPE type, int thread_trace, int protocol );
-void osrf_message_set_request_info( osrf_message*, char* param_name, json* params );
+//void osrf_message_set_request_info( osrf_message*, char* param_name, json* params );
void osrf_message_set_status_info( osrf_message*, char* status_name, char* status_text, int status_code );
void osrf_message_set_result_content( osrf_message*, char* json_string );
void osrf_message_free( osrf_message* );
void osrf_message_set_json_parse_params( int ibool );
+void osrf_message_set_params( osrf_message* msg, object* o );
+void osrf_message_set_method( osrf_message* msg, char* method_name );
+void osrf_message_add_object_param( osrf_message* msg, object* o );
void osrf_message_add_param( osrf_message*, char* param_string );
@echo "Installing libopensrf_transport..."
cp $(TMPDIR)/libopensrf_transport.so $(LIBDIR)/
cp $(HEADERS) $(INCLUDEDIR)/$(OPENSRF)
-# for h in $(TMPDIR)/$(HEADERS); do
-# mv $$h $(INCLUDEDIR)/$(OPENSRF);
-# done
-
clean:
/bin/rm -f *.o basic_client component
object* obj = new_object(NULL);
unsigned long index = 0;
+ json_eat_ws(string, &index, 1); /* remove leading whitespace */
+ if(index == current_strlen) return NULL;
+
int status = _json_parse_string(string, &index, obj);
- if(!status)
- return obj;
+ if(!status) return obj;
if(status == -2)
return NULL;
return _init_object(string_value);
}
+
+object* new_int_object(long num) {
+ object* o = new_object(NULL);
+ o->is_null = 0;
+ o->is_number = 1;
+ o->num_value = num;
+ return o;
+}
+
+object* new_double_object(double num) {
+ object* o = new_object(NULL);
+ o->is_null = 0;
+ o->is_double = 1;
+ o->double_value = num;
+ return o;
+}
+
object* _init_object(char* string_value) {
object* obj = (object*) safe_malloc(sizeof(object));
is to be a string. if not, string should be NULL */
object* new_object(char* string);
+object* new_int_object(long num);
+
+object* new_double_object(double num);
+
/* utility method for initing an object */
object* _init_object();
# set this shell variable prior to calling make to run with malloc_check enabled
#MALLOC_CHECK_=1 # XXX debug only
-LD_OPTS += -lc_utils -lxml2 -lopensrf_stack -ljson -lobjson
+LD_OPTS += -lc_utils -lxml2 -lopensrf_stack -lobjson
LP = ../libtransport
LIB_SOURCES = $(LP)/transport_socket.c $(LP)/transport_session.c $(LP)/transport_message.c $(LP)/transport_client.c
+
osrf_message** router_registrar_process_app_request(
transport_router_registrar* router, osrf_message* omsg, int* num_responses ) {
if(!strcmp(omsg->method_name,"opensrf.router.info.class.list")) {
- json* result_content = NULL;
+ object* result_content = json_parse_string("[]");
debug_handler("Processing opensrf.router.info.class.list request");
- result_content = json_object_new_array();
server_class_node* cur_class = router->server_class_list;
while( cur_class != NULL ) {
debug_handler("Adding %s to request list", cur_class->server_class);
- json_object_array_add(
- result_content, json_object_new_string(cur_class->server_class));
+ result_content->push(result_content, new_object(cur_class->server_class));
cur_class = cur_class->next;
}
result_array = safe_malloc(sizeof(osrf_message*));
result_array[0] = osrf_message_init(
RESULT, omsg->thread_trace, omsg->protocol );
- osrf_message_set_result_content( result_array[0],
- json_object_to_json_string(result_content) );
- json_object_put(result_content);
+
+ osrf_message_set_result_content( result_array[0], object_to_json(result_content));
+ free_object(result_content);
} else if(!strcmp(omsg->method_name,"opensrf.router.info.stats")) {
debug_handler("Processing opensrf.router.info.stats request");
- json* result_content = NULL;
- result_content = json_object_new_object();
+ object* result_content = json_parse_string("{}");
+
server_class_node* cur_class = router->server_class_list;
while( cur_class != NULL ) {
server_node* cur_node = start_node;
if( cur_node == NULL ) continue;
- json* server_object = json_object_new_object();
+ object* server_object = json_parse_string("{}");
do {
- json* node_stats_array = json_object_new_array();
+ object* node_stats_array = json_parse_string("[]");
+
+ object* json_reg_time = json_parse_string("{}");
+
+ object_add_key( json_reg_time, "reg_time",
+ new_int_object((int) cur_node->reg_time));
+
+ object_push( node_stats_array, json_reg_time );
+
+ object* json_upd_time = json_parse_string("{}");
+
+
+ object_add_key( json_upd_time, "upd_time",
+ new_int_object((int)cur_node->upd_time));
+
+
+
+ object_push( node_stats_array, json_upd_time );
+
- json* json_reg_time = json_object_new_object();
- json_object_object_add( json_reg_time, "reg_time",
- json_object_new_int((int)cur_node->reg_time));
- json_object_array_add( node_stats_array, json_reg_time );
- json* json_upd_time = json_object_new_object();
- json_object_object_add( json_upd_time, "upd_time",
- json_object_new_int((int)cur_node->upd_time));
- json_object_array_add( node_stats_array, json_upd_time );
+ object* json_la_time = json_parse_string("{}");
- json* json_la_time = json_object_new_object();
- json_object_object_add( json_la_time, "la_time",
- json_object_new_int((int)cur_node->la_time));
- json_object_array_add( node_stats_array, json_la_time );
- json* json_serve_count = json_object_new_object();
- json_object_object_add( json_serve_count, "serve_count",
- json_object_new_int((int)cur_node->serve_count));
- json_object_array_add( node_stats_array, json_serve_count );
- json_object_object_add( server_object, cur_node->remote_id, node_stats_array );
+ object_add_key( json_la_time, "la_time",
+ new_int_object((int)cur_node->la_time));
+
+
+ object_push( node_stats_array, json_la_time );
+
+ object* json_serve_count = json_parse_string("{}");
+
+
+ object_add_key( json_serve_count, "serve_count",
+ new_int_object((int)cur_node->serve_count));
+
+
+ object_push( node_stats_array, json_serve_count );
+
+
+ object_add_key( server_object, cur_node->remote_id, node_stats_array );
cur_node = cur_node->next;
} while( cur_node != start_node );
- json_object_object_add(
- result_content, cur_class->server_class, server_object );
+ object_add_key( result_content, cur_class->server_class, server_object );
cur_class = cur_class->next;
result_array[0] = osrf_message_init(
RESULT, omsg->thread_trace, omsg->protocol );
- osrf_message_set_result_content( result_array[0],
- json_object_to_json_string(result_content) );
- json_object_put(result_content);
+
+ osrf_message_set_result_content(result_array[0], object_to_json(result_content));
+
+ free_object(result_content);
} else if(!strcmp(omsg->method_name,"opensrf.system.method.all")) {
- json* content = json_object_new_object();
- json_object_object_add(content, "api_level", json_object_new_string("1"));
- json_object_object_add(content, "api_name", json_object_new_string("opensrf.router.info.class.list"));
- json_object_object_add(content, "server_class", json_object_new_string("router"));
- json_object_object_add(content, "stream", json_object_new_string("0"));
+ object* content = json_parse_string("{}");
+ object_add_key(content, "api_level", new_object("1"));
+ object_add_key(content, "api_name", new_object("opensrf.router.info.class.list"));
+ object_add_key(content, "server_class", new_object("router"));
+ object_add_key(content, "stream", new_object("0"));
- json* content2 = json_object_new_object();
- json_object_object_add(content2, "api_level", json_object_new_string("1"));
- json_object_object_add(content2, "api_name", json_object_new_string("opensrf.router.info.stats"));
- json_object_object_add(content2, "server_class", json_object_new_string("router"));
- json_object_object_add(content2, "stream", json_object_new_string("0"));
+ object* content2 = json_parse_string("{}");
+ object_add_key(content2, "api_level", new_object("1"));
+ object_add_key(content2, "api_name", new_object("opensrf.router.info.stats"));
+ object_add_key(content2, "server_class", new_object("router"));
+ object_add_key(content2, "stream", new_object("0"));
- json* content3 = json_object_new_object();
- json_object_object_add(content3, "api_level", json_object_new_string("1"));
- json_object_object_add(content3, "api_name", json_object_new_string("opensrf.system.method.all"));
- json_object_object_add(content3, "server_class", json_object_new_string("router"));
- json_object_object_add(content3, "stream", json_object_new_string("1"));
+ object* content3 = json_parse_string("{}");
+ object_add_key(content3, "api_level", new_object("1"));
+ object_add_key(content3, "api_name", new_object("opensrf.system.method.all"));
+ object_add_key(content3, "server_class", new_object("router"));
+ object_add_key(content3, "stream", new_object("1"));
result_array = safe_malloc(3*sizeof(osrf_message*));
*num_responses = 3;
result_array[0] = osrf_message_init(
RESULT, omsg->thread_trace, omsg->protocol );
- osrf_message_set_result_content( result_array[0], json_object_to_json_string(content) );
- json_object_put(content);
+
+ osrf_message_set_result_content( result_array[0], object_to_json(content));
+ free_object(content);
result_array[1] = osrf_message_init(
RESULT, omsg->thread_trace, omsg->protocol );
- osrf_message_set_result_content( result_array[1], json_object_to_json_string(content2) );
- json_object_put(content2);
+ osrf_message_set_result_content( result_array[1], object_to_json(content2) );
+ free_object(content2);
result_array[2] = osrf_message_init(
RESULT, omsg->thread_trace, omsg->protocol );
- osrf_message_set_result_content( result_array[1], json_object_to_json_string(content3) );
- json_object_put(content3);
+ osrf_message_set_result_content( result_array[1], object_to_json(content3) );
+ free_object(content3);
}
-LD_OPTS += -lobjson -lreadline -lxml2 -lopensrf_transport -lopensrf_stack -ljson -lncurses -lc_utils
+LD_OPTS += -lobjson -lreadline -lxml2 -lopensrf_transport -lopensrf_stack -lncurses -lc_utils
all: srfsh
client = osrf_system_get_transport_client();
- //osrf_message_set_json_parse_result(1);
- //osrf_message_set_json_parse_result(1);
-
/* main process loop */
char* request;
int handle_introspect(char* words[]) {
- if(words[1]) {
+ if(words[1] && words[2]) {
fprintf(stderr, "--> %s\n", words[1]);
char buf[256];
memset(buf,0,256);
- sprintf( buf, "request %s opensrf.system.method.all", words[1] );
+ sprintf( buf, "request %s opensrf.system.method %s", words[1], words[2] );
return parse_request( buf );
+
+ } else {
+
+ if(words[1]) {
+ fprintf(stderr, "--> %s\n", words[1]);
+ char buf[256];
+ memset(buf,0,256);
+ sprintf( buf, "request %s opensrf.system.method.all", words[1] );
+ return parse_request( buf );
+ }
}
return 0;
"request open-ils.auth open-ils.auth.authenticate.init \"%s\"", username );
parse_request(buf);
- //char* hash = json_object_get_string( last_result->result_content );
-
char* hash;
if(last_result && last_result->_result_content) {
object* r = last_result->_result_content;
hash = r->string_data;
} else return 0;
- /*
- fprintf(stderr, "HASHES %s : %s\n", hash, hash2);
- object* r = last_result->_result_content;
- fprintf(stderr, "%s\n", r->to_json(r));
- */
-
char* pass_buf = md5sum(password);
parse_request( buf2 );
- //login_session = strdup(json_object_get_string( last_result->result_content ));
login_session = strdup(last_result->_result_content->string_data);
printf("Login Session: %s\n", login_session );
if( server == NULL || method == NULL )
return 0;
- json* params = NULL;
+ object* params = NULL;
if( !relay ) {
if( buffer != NULL && buffer->n_used > 0 )
- params = json_tokener_parse(buffer->buf);
+ params = json_parse_string(buffer->buf);
} else {
- if(!last_result || ! last_result->result_content) {
+ if(!last_result || ! last_result->_result_content) {
printf("We're not going to call 'relay' with no result params\n");
return 1;
}
else {
- json* arr = json_object_new_array();
- json_object_array_add( arr, last_result->result_content );
- params = arr;
+ object* o = new_object(NULL);
+ o->push(o, last_result->_result_content );
+ params = o;
}
}
+
+ if(buffer->n_used > 0 && params == NULL) {
+ fprintf(stderr, "JSON error detected, not executing\n");
+ return 1;
+ }
+
osrf_app_session* session = osrf_app_client_session_init(server);
if(!osrf_app_session_connect(session)) {
}
double start = get_timestamp_millis();
- int req_id = osrf_app_session_make_request( session, params, method, 1, NULL );
+ //int req_id = osrf_app_session_make_request( session, params, method, 1, NULL );
+ int req_id = osrf_app_session_make_req( session, params, method, 1, NULL );
osrf_message* omsg = osrf_app_session_request_recv( session, req_id, 60 );
while(omsg) {
- if(omsg->result_content) {
+ if(omsg->_result_content) {
debug_handler("srfsh1");
osrf_message_free(last_result);
char* content;
- if( pretty_print )
- content = json_printer( omsg->result_content );
- else
- //content = json_object_get_string(omsg->result_content);
+ if( pretty_print && omsg->_result_content ) {
+ char* j = object_to_json(omsg->_result_content);
+ content = json_printer(j);
+ free(j);
+ } else
content = object_get_string(omsg->_result_content);
debug_handler("srfsh2");
return final;
}
-char* json_printer( json* object ) {
-
- if(object == NULL)
- return NULL;
- char* string = json_object_get_string(object);
+char* json_printer( char* string ) {
growing_buffer* buf = buffer_init(64);
int i;
osrf_app_session* session = osrf_app_client_session_init( "opensrf.math" );
- json* params = json_object_new_array();
- json_object_array_add(params, json_object_new_string("1"));
- json_object_array_add(params, json_object_new_string("2"));
+ object* params = json_parse_string("[]");
+ params->push(params,new_object("1"));
+ params->push(params,new_object("2"));
char* methods[] = { "add", "sub", "mult", "div" };
- char* answers[] = { "3", "-1", "2", "0.5" };
+ char* answers[] = { "\"3\"", "\"-1\"", "\"2\"", "\"0.5\"" };
float times[ count * 4 ];
memset(times,0,count*4);
struct timeb t2;
ftime(&t1);
- int req_id = osrf_app_session_make_request( session, params, methods[j], 1, NULL );
-
+ //int req_id = osrf_app_session_make_request( session, params, methods[j], 1, NULL );
+ int req_id = osrf_app_session_make_req( session, params, methods[j], 1, NULL );
osrf_message* omsg = osrf_app_session_request_recv( session, req_id, 5 );
if(omsg) {
- if(omsg->result_content) {
- char* jsn = json_object_get_string( omsg->result_content );
+ if(omsg->_result_content) {
+ char* jsn = object_to_json(omsg->_result_content);
if(!strcmp(jsn, answers[j]))
fprintf(stderr, "+");
else
fprintf(stderr, "\n![%s] - should be %s\n", jsn, answers[j] );
+ free(jsn);
}
+
osrf_message_free(omsg);
} else { fprintf( stderr, "\nempty message for tt: %d\n", req_id ); }
}
osrf_app_session_destroy( session );
- json_object_put( params );
+ free_object(params);
int c;
float total = 0;
int router_query_servers( char* server );
int srfsh_client_connect();
int print_help();
-char* json_printer( json* object );
+char* json_printer( char* string );
char* tabs(int count);
void sig_child_handler( int s );
void sig_int_handler( int s );
projects / opensrf / bjwebb.git / commitdiff