OpenSRF/src/srfsh/srfsh.c

   1 #include "srfsh.h"
   2
   3 int main( int argc, char* argv[] ) {
   4
   5
   6
   7         /* --------------------------------------------- */
   8         if( argc < 2 ) {
   9
  10                 /* see if they have a .srfsh.xml in their home directory */
  11                 char* home = getenv("HOME");
  12                 int l = strlen(home) + 36;
  13                 char fbuf[l];
  14                 memset(fbuf, 0, l);
  15                 sprintf(fbuf,"%s/.srfsh.xml",home);
  16
  17                 if(!access(fbuf, R_OK)) {
  18                         if( ! osrf_system_bootstrap_client(fbuf) )
  19                                 fatal_handler( "Unable to bootstrap client for requests");
  20
  21                 } else {
  22                         fatal_handler( "No Config file found at %s and none specified. "
  23                                         "\nusage: %s <config_file>", fbuf, argv[0] );
  24                 }
  25
  26         } else {
  27                 if( ! osrf_system_bootstrap_client(argv[1]) )
  28                         fatal_handler( "Unable to bootstrap client for requests");
  29         }
  30         /* --------------------------------------------- */
  31         load_history();
  32
  33
  34         client = osrf_system_get_transport_client();
  35         //osrf_message_set_json_parse_result(1);
  36         //osrf_message_set_json_parse_result(1);
  37
  38
  39         /* main process loop */
  40         char* request;
  41         while((request=readline(prompt))) {
  42
  43                 if( !strcmp(request, "exit") || !strcmp(request,"quit"))
  44                         break;
  45
  46                 char* req_copy = strdup(request);
  47
  48                 parse_request( req_copy );
  49                 if( request && strlen(request) > 1 ) {
  50                         add_history(request);
  51                 }
  52
  53                 free(request);
  54                 free(req_copy);
  55         }
  56
  57         if(history_file != NULL )
  58                 write_history(history_file);
  59         free(request);
  60         client_disconnect( client );
  61         client_free( client );
  62         config_reader_free();
  63         log_free();
  64
  65         return 0;
  66 }
  67
  68 void sig_child_handler( int s ) {
  69         child_dead = 1;
  70 }
  71
  72 /*
  73 void sig_int_handler( int s ) {
  74         printf("\n");
  75         caught_sigint = 1;
  76         signal(SIGINT,sig_int_handler);
  77 }
  78 */
  79
  80 int load_history() {
  81
  82         char* home = getenv("HOME");
  83         int l = strlen(home) + 24;
  84         char fbuf[l];
  85
  86         memset(fbuf, 0, l);
  87         sprintf(fbuf,"%s/.srfsh_history",home);
  88         history_file = strdup(fbuf);
  89
  90         if(!access(history_file, W_OK | R_OK )) {
  91                 //set_history_length(999);
  92                 history_length = 999;
  93                 read_history(history_file);
  94         }
  95         return 1;
  96 }
  97
  98
  99 int parse_error( char* words[] ) {
 100
 101         if( ! words )
 102                 return 0;
 103
 104         int i = 0;
 105         char* current;
 106         char buffer[256];
 107         memset(buffer, 0, 256);
 108         while( (current=words[i++]) ) {
 109                 strcat(buffer, current);
 110                 strcat(buffer, " ");
 111         }
 112         if( ! buffer || strlen(buffer) < 1 )
 113                 printf("\n");
 114
 115         fprintf( stderr, "???: %s\n", buffer );
 116         return 0;
 117
 118 }
 119
 120
 121 int parse_request( char* request ) {
 122
 123         if( request == NULL )
 124                 return 0;
 125
 126         int ret_val = 0;
 127         int i = 0;
 128         char* words[COMMAND_BUFSIZE];
 129         memset(words,0,COMMAND_BUFSIZE);
 130         char* req = request;
 131
 132         char* cur_tok = strtok( req, " " );
 133
 134         if( cur_tok == NULL )
 135                 return 0;
 136
 137         while(cur_tok != NULL) {
 138                 words[i++] = cur_tok;
 139                 cur_tok = strtok( NULL, " " );
 140         }
 141
 142
 143         // not sure why (strtok?), but this is necessary
 144         memset( words + i, 0, COMMAND_BUFSIZE - i );
 145
 146         /* pass off to the top level command */
 147         if( !strcmp(words[0],"router") )
 148                 ret_val = handle_router( words );
 149
 150         else if( !strcmp(words[0],"time") )
 151                 ret_val = handle_time( words );
 152
 153         else if (!strcmp(words[0],"request"))
 154                 ret_val = handle_request( words, 0 );
 155
 156         else if (!strcmp(words[0],"relay"))
 157                 ret_val = handle_request( words, 1 );
 158
 159         else if (!strcmp(words[0],"help"))
 160                 ret_val = print_help();
 161
 162         else if (!strcmp(words[0],"set"))
 163                 ret_val = handle_set(words);
 164
 165         else if (!strcmp(words[0],"print"))
 166                 ret_val = handle_print(words);
 167
 168         else if (!strcmp(words[0],"math_bench"))
 169                 ret_val = handle_math(words);
 170
 171         else if (!strcmp(words[0],"introspect"))
 172                 ret_val = handle_introspect(words);
 173
 174         else if (!strcmp(words[0],"login"))
 175                 ret_val = handle_login(words);
 176
 177         else if (words[0][0] == '!')
 178                 ret_val = handle_exec( words );
 179
 180         if(!ret_val)
 181                 return parse_error( words );
 182
 183         return 1;
 184
 185 }
 186
 187
 188 int handle_introspect(char* words[]) {
 189
 190         if(words[1]) {
 191                 fprintf(stderr, "--> %s\n", words[1]);
 192                 char buf[256];
 193                 memset(buf,0,256);
 194                 sprintf( buf, "request %s opensrf.system.method.all", words[1] );
 195                 return parse_request( buf );
 196         }
 197
 198         return 0;
 199 }
 200
 201
 202 int handle_login( char* words[]) {
 203
 204         if( words[1] && words[2]) {
 205
 206                 char* username = words[1];
 207                 char* password = words[2];
 208
 209                 char buf[256];
 210                 memset(buf,0,256);
 211
 212                 char buf2[256];
 213                 memset(buf2,0,256);
 214
 215                 sprintf( buf,
 216                                 "request open-ils.auth open-ils.auth.authenticate.init \"%s\"", username );
 217                 parse_request(buf);
 218
 219                 //char* hash = json_object_get_string( last_result->result_content );
 220
 221                 char* hash;
 222                 if(last_result && last_result->_result_content) {
 223                         object* r = last_result->_result_content;
 224                         hash = r->string_data;
 225                 } else return 0;
 226
 227                 /*
 228                 fprintf(stderr, "HASHES %s : %s\n", hash, hash2);
 229                 object* r = last_result->_result_content;
 230                 fprintf(stderr, "%s\n", r->to_json(r));
 231                 */
 232
 233
 234                 char* pass_buf = md5sum(password);
 235
 236                 char both_buf[256];
 237                 memset(both_buf,0,256);
 238                 sprintf(both_buf,"%s%s",hash, pass_buf);
 239
 240                 char* mess_buf = md5sum(both_buf);
 241
 242                 sprintf( buf2,
 243                                 "request open-ils.auth open-ils.auth.authenticate.complete \"%s\", \"%s\", \"opac\"",
 244                                 username, mess_buf );
 245
 246                 free(pass_buf);
 247                 free(mess_buf);
 248
 249                 parse_request( buf2 );
 250
 251                 //login_session = strdup(json_object_get_string( last_result->result_content ));
 252                 login_session = strdup(last_result->_result_content->string_data);
 253
 254                 printf("Login Session: %s\n", login_session );
 255
 256                 return 1;
 257
 258         }
 259
 260         return 0;
 261 }
 262
 263 char* md5sum( char* text ) {
 264
 265         struct md5_ctx ctx;
 266         unsigned char digest[16];
 267
 268         MD5_start (&ctx);
 269
 270         int i;
 271         for ( i=0 ; i != strlen(text) ; i++ )
 272                 MD5_feed (&ctx, text[i]);
 273
 274         MD5_stop (&ctx, digest);
 275
 276         char buf[16];
 277         memset(buf,0,16);
 278
 279         char final[256];
 280         memset(final,0,256);
 281
 282         for ( i=0 ; i<16 ; i++ ) {
 283                 sprintf(buf, "%02x", digest[i]);
 284                 strcat( final, buf );
 285         }
 286
 287         return strdup(final);
 288
 289 }
 290
 291
 292 int handle_set( char* words[]) {
 293
 294         char* variable;
 295         if( (variable=words[1]) ) {
 296
 297                 char* val;
 298                 if( (val=words[2]) ) {
 299
 300                         if(!strcmp(variable,"pretty_print")) {
 301                                 if(!strcmp(val,"true")) {
 302                                         pretty_print = 1;
 303                                         printf("pretty_print = true\n");
 304                                         return 1;
 305                                 }
 306                                 if(!strcmp(val,"false")) {
 307                                         pretty_print = 0;
 308                                         printf("pretty_print = false\n");
 309                                         return 1;
 310                                 }
 311                         }
 312                 }
 313         }
 314
 315         return 0;
 316 }
 317
 318
 319 int handle_print( char* words[]) {
 320
 321         char* variable;
 322         if( (variable=words[1]) ) {
 323                 if(!strcmp(variable,"pretty_print")) {
 324                         if(pretty_print) {
 325                                 printf("pretty_print = true\n");
 326                                 return 1;
 327                         } else {
 328                                 printf("pretty_print = false\n");
 329                                 return 1;
 330                         }
 331                 }
 332
 333                 if(!strcmp(variable,"login")) {
 334                         printf("login session = %s\n", login_session );
 335                         return 1;
 336                 }
 337
 338         }
 339         return 0;
 340 }
 341
 342 int handle_router( char* words[] ) {
 343
 344         if(!client)
 345                 return 1;
 346
 347         int i;
 348
 349         if( words[1] ) {
 350                 if( !strcmp(words[1],"query") ) {
 351
 352                         if( words[2] && !strcmp(words[2],"servers") ) {
 353                                 for(i=3; i < COMMAND_BUFSIZE - 3 && words[i]; i++ ) {
 354                                         router_query_servers( words[i] );
 355                                 }
 356                                 return 1;
 357                         }
 358                         return 0;
 359                 }
 360                 return 0;
 361         }
 362         return 0;
 363 }
 364
 365
 366 int handle_exec(char* words[]) {
 367
 368         int len = strlen(words[0]);
 369         char command[len];
 370         memset(command,0,len);
 371
 372         int i; /* chop out the ! */
 373         for( i=1; i!= len; i++) {
 374                 command[i-1] = words[0][i];
 375         }
 376
 377         free(words[0]);
 378         words[0] = strdup(command);
 379         signal(SIGCHLD,sig_child_handler);
 380         if(fork()) {
 381                 while(1) {
 382                         sleep(100);
 383                         if(child_dead) {
 384                                 signal(SIGCHLD,sig_child_handler);
 385                                 child_dead = 0;
 386                                 break;
 387                         }
 388                 }
 389         } else {
 390                 execvp( words[0], words );
 391                 exit(0);
 392         }
 393         return 1;
 394 }
 395
 396
 397 int handle_request( char* words[], int relay ) {
 398
 399         if(!client)
 400                 return 1;
 401
 402         if(words[1]) {
 403                 char* server = words[1];
 404                 char* method = words[2];
 405                 int i;
 406                 growing_buffer* buffer = NULL;
 407                 if(!relay) {
 408                         buffer = buffer_init(128);
 409                         buffer_add(buffer, "[");
 410                         for(i = 3; words[i] != NULL; i++ ) {
 411                                 /* removes trailing semicolon if user accidentally enters it */
 412                                 if( words[i][strlen(words[i])-1] == ';' )
 413                                         words[i][strlen(words[i])-1] = '\0';
 414                                 buffer_add( buffer, words[i] );
 415                                 buffer_add(buffer, " ");
 416                         }
 417                         buffer_add(buffer, "]");
 418                 }
 419
 420                 return send_request( server, method, buffer, relay );
 421         }
 422
 423         return 0;
 424 }
 425
 426 int send_request( char* server,
 427                 char* method, growing_buffer* buffer, int relay ) {
 428         if( server == NULL || method == NULL )
 429                 return 0;
 430
 431         json* params = NULL;
 432         if( !relay ) {
 433                 if( buffer != NULL && buffer->n_used > 0 )
 434                         params = json_tokener_parse(buffer->buf);
 435         } else {
 436                 if(!last_result || ! last_result->result_content) {
 437                         printf("We're not going to call 'relay' with no result params\n");
 438                         return 1;
 439                 }
 440                 else {
 441                         json* arr = json_object_new_array();
 442                         json_object_array_add( arr, last_result->result_content );
 443                         params = arr;
 444                 }
 445         }
 446
 447         osrf_app_session* session = osrf_app_client_session_init(server);
 448
 449         if(!osrf_app_session_connect(session)) {
 450                 warning_handler( "Unable to connect to remote service %s\n", server );
 451                 return 1;
 452         }
 453
 454         double start = get_timestamp_millis();
 455         int req_id = osrf_app_session_make_request( session, params, method, 1, NULL );
 456
 457
 458         osrf_message* omsg = osrf_app_session_request_recv( session, req_id, 60 );
 459         debug_handler("srfsh0");
 460
 461
 462         if(!omsg)
 463                 printf("\nReceived no data from server\n");
 464
 465
 466         signal(SIGPIPE, SIG_IGN);
 467
 468         FILE* less = popen( "less -EX", "w");
 469         if( less == NULL ) { less = stdout; }
 470
 471         growing_buffer* resp_buffer = buffer_init(4096);
 472
 473         while(omsg) {
 474
 475                 if(omsg->result_content) {
 476
 477                         debug_handler("srfsh1");
 478                         osrf_message_free(last_result);
 479                         last_result = omsg;
 480
 481                         char* content;
 482
 483                         if( pretty_print )
 484                                 content = json_printer( omsg->result_content );
 485                         else
 486                                 //content = json_object_get_string(omsg->result_content);
 487                                 content = object_get_string(omsg->_result_content);
 488
 489                         debug_handler("srfsh2");
 490
 491                         buffer_add( resp_buffer, "\nReceived Data: " );
 492                         buffer_add( resp_buffer, content );
 493                         buffer_add( resp_buffer, "\n" );
 494                         free(content);
 495
 496                 } else {
 497
 498                         buffer_add( resp_buffer, "\nReceived Exception:\nName: " );
 499                         buffer_add( resp_buffer, omsg->status_name );
 500                         buffer_add( resp_buffer, "\nStatus: " );
 501                         buffer_add( resp_buffer, omsg->status_text );
 502                         buffer_add( resp_buffer, "\nStatus: " );
 503                         char code[16];
 504                         memset(code, 0, 16);
 505                         sprintf( code, "%d", omsg->status_code );
 506                         buffer_add( resp_buffer, code );
 507                 }
 508
 509
 510                 omsg = osrf_app_session_request_recv( session, req_id, 5 );
 511
 512         }
 513
 514         double end = get_timestamp_millis();
 515
 516         fprintf( less, resp_buffer->buf );
 517         buffer_free( resp_buffer );
 518         fprintf( less, "\n------------------------------------\n");
 519         if( osrf_app_session_request_complete( session, req_id ))
 520                 fprintf(less, "Request Completed Successfully\n");
 521
 522
 523         fprintf(less, "Request Time in seconds: %.3f\n", end - start );
 524         fprintf(less, "------------------------------------\n");
 525
 526         pclose(less);
 527
 528         osrf_app_session_request_finish( session, req_id );
 529         osrf_app_session_disconnect( session );
 530         osrf_app_session_destroy( session );
 531
 532
 533         return 1;
 534
 535
 536 }
 537
 538 int handle_time( char* words[] ) {
 539
 540         if( ! words[1] ) {
 541
 542                 char buf[36];
 543                 memset(buf,0,36);
 544                 get_timestamp(buf);
 545                 printf( "%s\n", buf );
 546                 return 1;
 547         }
 548
 549         if( words[1] ) {
 550                 time_t epoch = (time_t)atoi( words[1] );
 551                 char* localtime = strdup( ctime( &epoch ) );
 552                 printf( "%s => %s", words[1], localtime );
 553                 free(localtime);
 554                 return 1;
 555         }
 556
 557         return 0;
 558
 559 }
 560
 561
 562
 563 int router_query_servers( char* router_server ) {
 564
 565         if( ! router_server || strlen(router_server) == 0 )
 566                 return 0;
 567
 568         char rbuf[256];
 569         memset(rbuf,0,256);
 570         sprintf(rbuf,"router@%s/router", router_server );
 571
 572         transport_message* send =
 573                 message_init( "servers", NULL, NULL, rbuf, NULL );
 574         message_set_router_info( send, NULL, NULL, NULL, "query", 0 );
 575
 576         client_send_message( client, send );
 577         message_free( send );
 578
 579         transport_message* recv = client_recv( client, -1 );
 580         if( recv == NULL ) {
 581                 fprintf(stderr, "NULL message received from router\n");
 582                 return 1;
 583         }
 584
 585         printf(
 586                         "---------------------------------------------------------------------------------\n"
 587                         "Received from 'server' query on %s\n"
 588                         "---------------------------------------------------------------------------------\n"
 589                         "original reg time | latest reg time | last used time | class | server\n"
 590                         "---------------------------------------------------------------------------------\n"
 591                         "%s"
 592                         "---------------------------------------------------------------------------------\n"
 593                         , router_server, recv->body );
 594
 595         message_free( recv );
 596
 597         return 1;
 598 }
 599
 600 int print_help() {
 601
 602         printf(
 603                         "---------------------------------------------------------------------------------\n"
 604                         "Commands:\n"
 605                         "---------------------------------------------------------------------------------\n"
 606                         "help                   - Display this message\n"
 607                         "!<command> [args] - Forks and runs the given command in the shell\n"
 608                         "time                   - Prints the current time\n"
 609                         "time <timestamp>       - Formats seconds since epoch into readable format\n"
 610                         "set <variable> <value> - set a srfsh variable (e.g. set pretty_print true )\n"
 611                         "print <variable>               - Displays the value of a srfsh variable\n"
 612                         "---------------------------------------------------------------------------------\n"
 613
 614                         "router query servers <server1 [, server2, ...]>\n"
 615                         "       - Returns stats on connected services\n"
 616                         "\n"
 617                         "\n"
 618                         "request <service> <method> [ <json formatted string of params> ]\n"
 619                         "       - Anything passed in will be wrapped in a json array,\n"
 620                         "               so add commas if there is more than one param\n"
 621                         "\n"
 622                         "\n"
 623                         "relay <service> <method>\n"
 624                         "       - Performs the requested query using the last received result as the param\n"
 625                         "\n"
 626                         "\n"
 627                         "math_bench <num_batches> [0|1|2]\n"
 628                         "       - 0 means don't reconnect, 1 means reconnect after each batch of 4, and\n"
 629                         "                2 means reconnect after every request\n"
 630                         "\n"
 631                         "introspect <service>\n"
 632                         "       - prints the API for the service\n"
 633                         "\n"
 634                         "\n"
 635                         "---------------------------------------------------------------------------------\n"
 636                         " Commands for Open-ILS\n"
 637                         "---------------------------------------------------------------------------------\n"
 638                         "login <username> <password>\n"
 639                         "       -       Logs into the 'server' and displays the session id\n"
 640                         "       - To view the session id later, enter: print login\n"
 641                         "---------------------------------------------------------------------------------\n"
 642                         "\n"
 643                         "\n"
 644                         "Note: long output is piped through 'less'.  To search in 'less', type: /<search>\n"
 645                         "---------------------------------------------------------------------------------\n"
 646                         "\n"
 647                         );
 648
 649         return 1;
 650 }
 651
 652
 653
 654 char* tabs(int count) {
 655         growing_buffer* buf = buffer_init(24);
 656         int i;
 657         for(i=0;i!=count;i++)
 658                 buffer_add(buf, "   ");
 659
 660         char* final = buffer_data( buf );
 661         buffer_free( buf );
 662         return final;
 663 }
 664
 665 char* json_printer( json* object ) {
 666
 667         if(object == NULL)
 668                 return NULL;
 669         char* string = json_object_get_string(object);
 670
 671         growing_buffer* buf = buffer_init(64);
 672         int i;
 673         int tab_var = 0;
 674         for(i=0; i!= strlen(string); i++) {
 675
 676                 if( string[i] == '{' ) {
 677
 678                         buffer_add(buf, "\n");
 679                         char* tab = tabs(tab_var);
 680                         buffer_add(buf, tab);
 681                         free(tab);
 682                         buffer_add( buf, "{");
 683                         tab_var++;
 684                         buffer_add( buf, "\n" );
 685                         tab = tabs(tab_var);
 686                         buffer_add( buf, tab );
 687                         free(tab);
 688
 689                 } else if( string[i] == '[' ) {
 690
 691                         buffer_add(buf, "\n");
 692                         char* tab = tabs(tab_var);
 693                         buffer_add(buf, tab);
 694                         free(tab);
 695                         buffer_add( buf, "[");
 696                         tab_var++;
 697                         buffer_add( buf, "\n" );
 698                         tab = tabs(tab_var);
 699                         buffer_add( buf, tab );
 700                         free(tab);
 701
 702                 } else if( string[i] == '}' ) {
 703
 704                         tab_var--;
 705                         buffer_add(buf, "\n");
 706                         char* tab = tabs(tab_var);
 707                         buffer_add(buf, tab);
 708                         free(tab);
 709                         buffer_add( buf, "}");
 710                         buffer_add( buf, "\n" );
 711                         tab = tabs(tab_var);
 712                         buffer_add( buf, tab );
 713                         free(tab);
 714
 715                 } else if( string[i] == ']' ) {
 716
 717                         tab_var--;
 718                         buffer_add(buf, "\n");
 719                         char* tab = tabs(tab_var);
 720                         buffer_add(buf, tab);
 721                         free(tab);
 722                         buffer_add( buf, "]");
 723                         buffer_add( buf, "\n" );
 724                         tab = tabs(tab_var);
 725                         buffer_add( buf, tab );
 726                         free(tab);
 727
 728                 } else if( string[i] == ',' ) {
 729
 730                         buffer_add( buf, ",");
 731                         buffer_add( buf, "\n" );
 732                         char* tab = tabs(tab_var);
 733                         buffer_add(buf, tab);
 734                         free(tab);
 735
 736                 } else {
 737
 738                         char b[2];
 739                         b[0] = string[i];
 740                         b[1] = '\0';
 741                         buffer_add( buf, b );
 742                 }
 743
 744         }
 745
 746         char* result = buffer_data(buf);
 747         buffer_free(buf);
 748         return result;
 749
 750 }
 751
 752 int handle_math( char* words[] ) {
 753         if( words[1] && words[2] )
 754                 return do_math( atoi(words[1]), atoi(words[2]) );
 755         return 0;
 756 }
 757
 758
 759 int do_math( int count, int style ) {
 760
 761         osrf_app_session* session = osrf_app_client_session_init(  "opensrf.math" );
 762
 763         json* params = json_object_new_array();
 764         json_object_array_add(params, json_object_new_string("1"));
 765         json_object_array_add(params, json_object_new_string("2"));
 766
 767         char* methods[] = { "add", "sub", "mult", "div" };
 768         char* answers[] = { "3", "-1", "2", "0.5" };
 769
 770         float times[ count * 4 ];
 771         memset(times,0,count*4);
 772
 773         int k;
 774         for(k=0;k!=100;k++) {
 775                 if(!(k%10))
 776                         fprintf(stderr,"|");
 777                 else
 778                         fprintf(stderr,".");
 779         }
 780
 781         fprintf(stderr,"\n\n");
 782
 783         int running = 0;
 784         int i;
 785         for(i=0; i!= count; i++) {
 786
 787                 int j;
 788                 for(j=0; j != 4; j++) {
 789
 790                         ++running;
 791                         struct timeb t1;
 792                         struct timeb t2;
 793
 794                         ftime(&t1);
 795                         int req_id = osrf_app_session_make_request( session, params, methods[j], 1, NULL );
 796
 797
 798                         osrf_message* omsg = osrf_app_session_request_recv( session, req_id, 5 );
 799
 800                         ftime(&t2);
 801
 802                         double start    = ( (int)t1.time        + ( ((float)t1.millitm) / 1000 ) );
 803                         double end              = ( (int)t2.time        + ( ((float)t2.millitm) / 1000 ) );
 804
 805                         times[(4*i) + j] = end - start;
 806
 807                         if(omsg) {
 808
 809                                 if(omsg->result_content) {
 810                                         char* jsn = json_object_get_string( omsg->result_content );
 811                                         if(!strcmp(jsn, answers[j]))
 812                                                 fprintf(stderr, "+");
 813                                         else
 814                                                 fprintf(stderr, "\n![%s] - should be %s\n", jsn, answers[j] );
 815                                 }
 816
 817                                 osrf_message_free(omsg);
 818
 819                         } else { fprintf( stderr, "\nempty message for tt: %d\n", req_id ); }
 820
 821                         osrf_app_session_request_finish( session, req_id );
 822
 823                         if(style == 2)
 824                                 osrf_app_session_disconnect( session );
 825
 826                         if(!(running%100))
 827                                 fprintf(stderr,"\n");
 828                 }
 829
 830                 if(style==1)
 831                         osrf_app_session_disconnect( session );
 832         }
 833
 834         osrf_app_session_destroy( session );
 835         json_object_put( params );
 836
 837         int c;
 838         float total = 0;
 839         for(c=0; c!= count*4; c++)
 840                 total += times[c];
 841
 842         float avg = total / (count*4);
 843         fprintf(stderr, "\n      Average round trip time: %f\n", avg );
 844
 845         return 1;
 846 }