ef16ce5a4f8f4e14ebe833b3ab943baf10ee3e85
[OpenSRF.git] / src / libopensrf / osrf_app_session.c
1 #include <opensrf/osrf_app_session.h>
2 #include <time.h>
3
4 /* the global app_session cache */
5 osrfHash* osrfAppSessionCache = NULL;
6
7 // --------------------------------------------------------------------------
8 // --------------------------------------------------------------------------
9 // Request API
10 // --------------------------------------------------------------------------
11
12 /** Allocation and initializes a new app_request object */
13 osrf_app_request* _osrf_app_request_init( 
14                 osrf_app_session* session, osrf_message* msg ) {
15
16         osrf_app_request* req = 
17                 (osrf_app_request*) safe_malloc(sizeof(osrf_app_request));
18
19         req->session            = session;
20         req->request_id = msg->thread_trace;
21         req->complete           = 0;
22         req->payload            = msg;
23         req->result                     = NULL;
24
25         return req;
26
27 }
28
29
30 void osrfAppSessionCleanup() {
31         osrfHashFree(osrfAppSessionCache);      
32 }
33
34
35
36 /** Frees memory used by an app_request object */
37 void _osrf_app_request_free( void * req ){
38         if( req == NULL ) return;
39         osrfAppRequest* r = (osrfAppRequest*) req;
40         if( r->payload ) osrf_message_free( r->payload );
41         free( r );
42 }
43
44 /** Pushes the given message onto the list of 'responses' to this request */
45 void _osrf_app_request_push_queue( osrf_app_request* req, osrf_message* result ){
46         if(req == NULL || result == NULL) return;
47         osrfLogDebug( OSRF_LOG_MARK,  "App Session pushing request [%d] onto request queue", result->thread_trace );
48         if(req->result == NULL) {
49                 req->result = result;
50
51         } else {
52                 
53                 osrf_message* ptr = req->result;
54                 osrf_message* ptr2 = req->result->next;
55                 while( ptr2 ) {
56                         ptr = ptr2;
57                         ptr2 = ptr2->next;
58                 }
59                 ptr->next = result;
60         }
61 }
62
63 /** Removes this app_request from our session request set */
64 void osrf_app_session_request_finish( 
65                 osrf_app_session* session, int req_id ){
66
67         if(session == NULL) return;
68         osrf_app_request* req = OSRF_LIST_GET_INDEX( session->request_queue, req_id );
69         if(req == NULL) return;
70         osrfListRemove( req->session->request_queue, req->request_id );
71 }
72
73
74 void osrf_app_session_request_reset_timeout( osrf_app_session* session, int req_id ) {
75         if(session == NULL) return;
76         osrfLogDebug( OSRF_LOG_MARK, "Resetting request timeout %d", req_id );
77         osrf_app_request* req = OSRF_LIST_GET_INDEX( session->request_queue, req_id );
78         if(req == NULL) return;
79         req->reset_timeout = 1;
80 }
81
82 /** Checks the receive queue for messages.  If any are found, the first
83   * is popped off and returned.  Otherwise, this method will wait at most timeout 
84   * seconds for a message to appear in the receive queue.  Once it arrives it is returned.
85   * If no messages arrive in the timeout provided, null is returned.
86   */
87 osrf_message* _osrf_app_request_recv( osrf_app_request* req, int timeout ) {
88
89         if(req == NULL) return NULL;
90
91         if( req->result != NULL ) {
92                 /* pop off the first message in the list */
93                 osrf_message* tmp_msg = req->result;
94                 req->result = req->result->next;
95                 return tmp_msg;
96         }
97
98         time_t start = time(NULL);      
99         time_t remaining = (time_t) timeout;
100
101         while( remaining >= 0 ) {
102                 /* tell the session to wait for stuff */
103                 osrfLogDebug( OSRF_LOG_MARK,  "In app_request receive with remaining time [%d]", (int) remaining );
104
105                 osrf_app_session_queue_wait( req->session, 0, NULL );
106
107                 if( req->result != NULL ) { /* if we received anything */
108                         /* pop off the first message in the list */
109                         osrfLogDebug( OSRF_LOG_MARK,  "app_request_recv received a message, returning it");
110                         osrf_message* ret_msg = req->result;
111                         osrf_message* tmp_msg = ret_msg->next;
112                         req->result = tmp_msg;
113                         if (ret_msg->sender_locale) {
114                                 if (req->session->session_locale)
115                                         free(req->session->session_locale);
116                                 req->session->session_locale = strdup(ret_msg->sender_locale);
117                         }
118                         return ret_msg;
119                 }
120
121                 if( req->complete )
122                         return NULL;
123
124                 osrf_app_session_queue_wait( req->session, (int) remaining, NULL );
125
126                 if( req->result != NULL ) { /* if we received anything */
127                         /* pop off the first message in the list */
128                         osrfLogDebug( OSRF_LOG_MARK,  "app_request_recv received a message, returning it");
129                         osrf_message* ret_msg = req->result;
130                         osrf_message* tmp_msg = ret_msg->next;
131                         req->result = tmp_msg;
132                         if (ret_msg->sender_locale) {
133                                 if (req->session->session_locale)
134                                         free(req->session->session_locale);
135                                 req->session->session_locale = strdup(ret_msg->sender_locale);
136                         }
137                         return ret_msg;
138                 }
139                 if( req->complete )
140                         return NULL;
141
142                 if(req->reset_timeout) {
143                         remaining = (time_t) timeout;
144                         req->reset_timeout = 0;
145                         osrfLogDebug( OSRF_LOG_MARK, "Recevied a timeout reset");
146                 } else {
147                         remaining -= (int) (time(NULL) - start);
148                 }
149         }
150
151         osrfLogInfo( OSRF_LOG_MARK, "Returning NULL from app_request_recv after timeout");
152         return NULL;
153 }
154
155 /** Resend this requests original request message */
156 int _osrf_app_request_resend( osrf_app_request* req ) {
157         if(req == NULL) return 0;
158         if(!req->complete) {
159                 osrfLogDebug( OSRF_LOG_MARK,  "Resending request [%d]", req->request_id );
160                 return _osrf_app_session_send( req->session, req->payload );
161         }
162         return 1;
163 }
164
165
166
167 // --------------------------------------------------------------------------
168 // --------------------------------------------------------------------------
169 // Session API
170 // --------------------------------------------------------------------------
171
172 /** returns a session from the global session hash */
173 char* osrf_app_session_set_locale( osrf_app_session* session, const char* locale ) {
174         if (!session || !locale)
175                 return NULL;
176
177         if(session->session_locale)
178                 free(session->session_locale);
179
180         session->session_locale = strdup( locale );
181         return session->session_locale;
182 }
183
184 /** returns a session from the global session hash */
185 osrf_app_session* osrf_app_session_find_session( char* session_id ) {
186         if(session_id) return osrfHashGet(osrfAppSessionCache, session_id);
187         return NULL;
188 }
189
190
191 /** adds a session to the global session cache */
192 void _osrf_app_session_push_session( osrf_app_session* session ) {
193         if(!session) return;
194         if( osrfAppSessionCache == NULL ) osrfAppSessionCache = osrfNewHash();
195         if( osrfHashGet( osrfAppSessionCache, session->session_id ) ) return;
196         osrfHashSet( osrfAppSessionCache, session, session->session_id );
197 }
198
199 /** Allocates a initializes a new app_session */
200
201 osrf_app_session* osrfAppSessionClientInit( char* remote_service ) {
202         return osrf_app_client_session_init( remote_service );
203 }
204
205 osrf_app_session* osrf_app_client_session_init( char* remote_service ) {
206
207         osrf_app_session* session = safe_malloc(sizeof(osrf_app_session));      
208
209         session->transport_handle = osrf_system_get_transport_client();
210         if( session->transport_handle == NULL ) {
211                 osrfLogWarning( OSRF_LOG_MARK, "No transport client for service 'client'");
212                 free( session );
213                 return NULL;
214         }
215
216         char target_buf[512];
217         target_buf[ 0 ] = '\0';
218
219         osrfStringArray* arr = osrfNewStringArray(8);
220         osrfConfigGetValueList(NULL, arr, "/domains/domain");
221         char* domain = osrfStringArrayGetString(arr, 0);
222         char* router_name = osrfConfigGetValue(NULL, "/router_name");
223         
224         int len = snprintf( target_buf, 512, "%s@%s/%s",
225                         router_name ? router_name : "(null)",
226                         domain ? domain : "(null)",
227                         remote_service ? remote_service : "(null)" );
228         osrfStringArrayFree(arr);
229         //free(domain);
230         free(router_name);
231
232         if( len >= sizeof( target_buf ) ) {
233                 osrfLogWarning( OSRF_LOG_MARK, "Buffer overflow for remote_id");
234                 free( session );
235                 return NULL;
236         }
237
238         session->request_queue = osrfNewList();
239         session->request_queue->freeItem = &_osrf_app_request_free;
240         session->remote_id = strdup(target_buf);
241         session->orig_remote_id = strdup(session->remote_id);
242         session->remote_service = strdup(remote_service);
243         session->session_locale = NULL;
244
245         #ifdef ASSUME_STATELESS
246         session->stateless = 1;
247         osrfLogDebug( OSRF_LOG_MARK, "%s session is stateless", remote_service );
248         #else
249         session->stateless = 0;
250         osrfLogDebug( OSRF_LOG_MARK, "%s session is NOT stateless", remote_service );
251         #endif
252
253         /* build a chunky, random session id */
254         char id[256];
255         memset(id,0,256);
256
257         sprintf(id, "%f.%d%ld", get_timestamp_millis(), (int)time(NULL), (long) getpid());
258         session->session_id = strdup(id);
259         osrfLogDebug( OSRF_LOG_MARK,  "Building a new client session with id [%s] [%s]", 
260                         session->remote_service, session->session_id );
261
262         session->thread_trace = 0;
263         session->state = OSRF_SESSION_DISCONNECTED;
264         session->type = OSRF_SESSION_CLIENT;
265         //session->next = NULL;
266         _osrf_app_session_push_session( session );
267         return session;
268 }
269
270 osrf_app_session* osrf_app_server_session_init( 
271                 char* session_id, char* our_app, char* remote_id ) {
272
273         osrfLogDebug( OSRF_LOG_MARK, "Initing server session with session id %s, service %s,"
274                         " and remote_id %s", session_id, our_app, remote_id );
275
276         osrf_app_session* session = osrf_app_session_find_session( session_id );
277         if(session) return session;
278
279         session = safe_malloc(sizeof(osrf_app_session));        
280
281         session->transport_handle = osrf_system_get_transport_client();
282         if( session->transport_handle == NULL ) {
283                 osrfLogWarning( OSRF_LOG_MARK, "No transport client for service '%s'", our_app );
284                 return NULL;
285         }
286
287         int stateless = 0;
288         char* statel = osrf_settings_host_value("/apps/%s/stateless", our_app );
289         if(statel) stateless = atoi(statel);
290         free(statel);
291
292
293         session->request_queue = osrfNewList();
294         session->request_queue->freeItem = &_osrf_app_request_free;
295         session->remote_id = strdup(remote_id);
296         session->orig_remote_id = strdup(remote_id);
297         session->session_id = strdup(session_id);
298         session->remote_service = strdup(our_app);
299         session->stateless = stateless;
300
301         #ifdef ASSUME_STATELESS
302         session->stateless = 1;
303         #endif
304
305         session->thread_trace = 0;
306         session->state = OSRF_SESSION_DISCONNECTED;
307         session->type = OSRF_SESSION_SERVER;
308
309         _osrf_app_session_push_session( session );
310         return session;
311
312 }
313
314
315
316 /** frees memory held by a session */
317 void _osrf_app_session_free( osrf_app_session* session ){
318         if(session==NULL)
319                 return;
320
321         if( session->userDataFree && session->userData ) 
322                 session->userDataFree(session->userData);
323         
324         if(session->session_locale)
325                 free(session->session_locale);
326
327         free(session->remote_id);
328         free(session->orig_remote_id);
329         free(session->session_id);
330         free(session->remote_service);
331         osrfListFree(session->request_queue);
332         free(session);
333 }
334
335 int osrfAppSessionMakeRequest(
336                 osrf_app_session* session, jsonObject* params, 
337                 char* method_name, int protocol, string_array* param_strings ) {
338
339         return osrf_app_session_make_locale_req( session, params, 
340                         method_name, protocol, param_strings, NULL );
341 }
342
343 int osrfAppSessionMakeLocaleRequest(
344                 osrf_app_session* session, jsonObject* params, 
345                 char* method_name, int protocol, string_array* param_strings, char* locale ) {
346
347         return osrf_app_session_make_locale_req( session, params, 
348                         method_name, protocol, param_strings, locale );
349 }
350
351 int osrf_app_session_make_req( 
352                 osrf_app_session* session, jsonObject* params, 
353                 char* method_name, int protocol, string_array* param_strings) {
354
355         return osrf_app_session_make_locale_req(session, params,
356                         method_name, protocol, param_strings, NULL);
357 }
358
359 int osrf_app_session_make_locale_req( 
360                 osrf_app_session* session, jsonObject* params, 
361                 char* method_name, int protocol, string_array* param_strings, char* locale ) {
362         if(session == NULL) return -1;
363
364         osrfLogMkXid();
365
366         osrf_message* req_msg = osrf_message_init( REQUEST, ++(session->thread_trace), protocol );
367         osrf_message_set_method(req_msg, method_name);
368
369         if (locale) {
370                 osrf_message_set_locale(req_msg, locale);
371         } else if (session->session_locale) {
372                 osrf_message_set_locale(req_msg, session->session_locale);
373         }
374
375         if(params) {
376                 osrf_message_set_params(req_msg, params);
377
378         } else {
379
380                 if(param_strings) {
381                         int i;
382                         for(i = 0; i!= param_strings->size ; i++ ) {
383                                 osrf_message_add_param(req_msg,
384                                         string_array_get_string(param_strings,i));
385                         }
386                 }
387         }
388
389         osrf_app_request* req = _osrf_app_request_init( session, req_msg );
390         if(_osrf_app_session_send( session, req_msg ) ) {
391                 osrfLogWarning( OSRF_LOG_MARK,  "Error sending request message [%d]", session->thread_trace );
392                 return -1;
393         }
394
395         osrfLogDebug( OSRF_LOG_MARK,  "Pushing [%d] onto requeust queue for session [%s] [%s]",
396                         req->request_id, session->remote_service, session->session_id );
397         osrfListSet( session->request_queue, req, req->request_id ); 
398         return req->request_id;
399 }
400
401 void osrf_app_session_set_complete( osrf_app_session* session, int request_id ) {
402         if(session == NULL)
403                 return;
404
405         osrf_app_request* req = OSRF_LIST_GET_INDEX( session->request_queue, request_id );
406         if(req) req->complete = 1;
407 }
408
409 int osrf_app_session_request_complete( osrf_app_session* session, int request_id ) {
410         if(session == NULL)
411                 return 0;
412         osrf_app_request* req = OSRF_LIST_GET_INDEX( session->request_queue, request_id );
413         if(req)
414                 return req->complete;
415         return 0;
416 }
417
418
419 /** Resets the remote connection id to that of the original*/
420 void osrf_app_session_reset_remote( osrf_app_session* session ){
421         if( session==NULL )
422                 return;
423
424         free(session->remote_id);
425         osrfLogDebug( OSRF_LOG_MARK,  "App Session [%s] [%s] resetting remote id to %s",
426                         session->remote_service, session->session_id, session->orig_remote_id );
427
428         session->remote_id = strdup(session->orig_remote_id);
429 }
430
431 void osrf_app_session_set_remote( osrf_app_session* session, char* remote_id ) {
432         if(session == NULL)
433                 return;
434         if( session->remote_id )
435                 free(session->remote_id );
436         session->remote_id = strdup( remote_id );
437 }
438
439 /** pushes the given message into the result list of the app_request
440   with the given request_id */
441 int osrf_app_session_push_queue( 
442                 osrf_app_session* session, osrf_message* msg ){
443         if(session == NULL || msg == NULL) return 0;
444
445         osrf_app_request* req = OSRF_LIST_GET_INDEX( session->request_queue, msg->thread_trace );
446         if(req == NULL) return 0;
447         _osrf_app_request_push_queue( req, msg );
448
449         return 0;
450 }
451
452 int osrfAppSessionConnect( osrf_app_session* session ) { 
453         return osrf_app_session_connect(session);
454 }
455
456
457 /** Attempts to connect to the remote service */
458 int osrf_app_session_connect(osrf_app_session* session){
459         
460         if(session == NULL)
461                 return 0;
462
463         if(session->state == OSRF_SESSION_CONNECTED) {
464                 return 1;
465         }
466
467         int timeout = 5; /* XXX CONFIG VALUE */
468
469         osrfLogDebug( OSRF_LOG_MARK,  "AppSession connecting to %s", session->remote_id );
470
471         /* defaulting to protocol 1 for now */
472         osrf_message* con_msg = osrf_message_init( CONNECT, session->thread_trace, 1 );
473         osrf_app_session_reset_remote( session );
474         session->state = OSRF_SESSION_CONNECTING;
475         int ret = _osrf_app_session_send( session, con_msg );
476         osrf_message_free(con_msg);
477         if(ret) return 0;
478
479         time_t start = time(NULL);      
480         time_t remaining = (time_t) timeout;
481
482         while( session->state != OSRF_SESSION_CONNECTED && remaining >= 0 ) {
483                 osrf_app_session_queue_wait( session, remaining, NULL );
484                 remaining -= (int) (time(NULL) - start);
485         }
486
487         if(session->state == OSRF_SESSION_CONNECTED)
488                 osrfLogDebug( OSRF_LOG_MARK, " * Connected Successfully to %s", session->remote_service );
489
490         if(session->state != OSRF_SESSION_CONNECTED)
491                 return 0;
492
493         return 1;
494 }
495
496
497
498 /** Disconnects from the remote service */
499 int osrf_app_session_disconnect( osrf_app_session* session){
500         if(session == NULL)
501                 return 1;
502
503         if(session->state == OSRF_SESSION_DISCONNECTED)
504                 return 1;
505
506         if(session->stateless && session->state != OSRF_SESSION_CONNECTED) {
507                 osrfLogDebug( OSRF_LOG_MARK,  
508                                 "Exiting disconnect on stateless session %s", 
509                                 session->session_id);
510                 return 1;
511         }
512
513         osrfLogDebug(OSRF_LOG_MARK,  "AppSession disconnecting from %s", session->remote_id );
514
515         osrf_message* dis_msg = osrf_message_init( DISCONNECT, session->thread_trace, 1 );
516         _osrf_app_session_send( session, dis_msg );
517         session->state = OSRF_SESSION_DISCONNECTED;
518
519         osrf_message_free( dis_msg );
520         osrf_app_session_reset_remote( session );
521         return 1;
522 }
523
524 int osrf_app_session_request_resend( osrf_app_session* session, int req_id ) {
525         osrf_app_request* req = OSRF_LIST_GET_INDEX( session->request_queue, req_id );
526         return _osrf_app_request_resend( req );
527 }
528
529
530 int osrfAppSessionSendBatch( osrfAppSession* session, osrf_message* msgs[], int size ) {
531
532         if( !(session && msgs && size > 0) ) return 0;
533         int retval = 0;
534
535         osrfMessage* msg = msgs[0];
536
537         if(msg) {
538
539                 osrf_app_session_queue_wait( session, 0, NULL );
540
541                 if(session->state != OSRF_SESSION_CONNECTED)  {
542
543                         if(session->stateless) { /* stateless session always send to the root listener */
544                                 osrf_app_session_reset_remote(session);
545
546                         } else { 
547
548                                 /* do an auto-connect if necessary */
549                                 if( ! session->stateless &&
550                                         (msg->m_type != CONNECT) && 
551                                         (msg->m_type != DISCONNECT) &&
552                                         (session->state != OSRF_SESSION_CONNECTED) ) {
553
554                                         if(!osrf_app_session_connect( session )) 
555                                                 return 0;
556                                 }
557                         }
558                 }
559         }
560
561         char* string = osrfMessageSerializeBatch(msgs, size);
562
563         if( string ) {
564
565                 transport_message* t_msg = message_init( 
566                                 string, "", session->session_id, session->remote_id, NULL );
567       message_set_osrf_xid( t_msg, osrfLogGetXid() );
568
569                 retval = client_send_message( session->transport_handle, t_msg );
570
571                 if( retval ) osrfLogError(OSRF_LOG_MARK, "client_send_message failed");
572
573                 osrfLogInfo(OSRF_LOG_MARK, "[%s] sent %d bytes of data to %s",
574                         session->remote_service, strlen(string), t_msg->recipient );
575
576                 osrfLogDebug(OSRF_LOG_MARK, "Sent: %s", string );
577
578                 free(string);
579                 message_free( t_msg );
580         }
581
582         return retval; 
583 }
584
585
586
587 int _osrf_app_session_send( osrf_app_session* session, osrf_message* msg ){
588         if( !(session && msg) ) return 0;
589         osrfMessage* a[1];
590         a[0] = msg;
591         return osrfAppSessionSendBatch( session, a, 1 );
592 }
593
594
595
596
597 /**  Waits up to 'timeout' seconds for some data to arrive.
598   * Any data that arrives will be processed according to its
599   * payload and message type.  This method will return after
600   * any data has arrived.
601   */
602 int osrf_app_session_queue_wait( osrf_app_session* session, int timeout, int* recvd ){
603         if(session == NULL) return 0;
604         int ret_val = 0;
605         osrfLogDebug(OSRF_LOG_MARK,  "AppSession in queue_wait with timeout %d", timeout );
606         ret_val = osrf_stack_entry_point(session->transport_handle, timeout, recvd);
607         return ret_val;
608 }
609
610 /** Disconnects (if client) and removes the given session from the global session cache 
611   * ! This free's all attached app_requests ! 
612   */
613 void osrfAppSessionFree( osrfAppSession* ses ) {
614         osrf_app_session_destroy( ses );
615 }
616
617
618 void osrf_app_session_destroy( osrf_app_session* session ){
619         if(session == NULL) return;
620
621         osrfLogDebug(OSRF_LOG_MARK,  "AppSession [%s] [%s] destroying self and deleting requests", 
622                         session->remote_service, session->session_id );
623         if(session->type == OSRF_SESSION_CLIENT 
624                         && session->state != OSRF_SESSION_DISCONNECTED ) { /* disconnect if we're a client */
625                 osrf_message* dis_msg = osrf_message_init( DISCONNECT, session->thread_trace, 1 );
626                 _osrf_app_session_send( session, dis_msg ); 
627                 osrf_message_free(dis_msg);
628         }
629
630         osrfHashRemove( osrfAppSessionCache, session->session_id );
631         _osrf_app_session_free( session );
632 }
633
634 osrf_message* osrfAppSessionRequestRecv(
635                 osrf_app_session* session, int req_id, int timeout ) {
636         return osrf_app_session_request_recv( session, req_id, timeout );
637 }
638 osrf_message* osrf_app_session_request_recv( 
639                 osrf_app_session* session, int req_id, int timeout ) {
640         if(req_id < 0 || session == NULL)
641                 return NULL;
642         osrf_app_request* req = OSRF_LIST_GET_INDEX( session->request_queue, req_id );
643         return _osrf_app_request_recv( req, timeout );
644 }
645
646
647
648 int osrfAppRequestRespond( osrfAppSession* ses, int requestId, jsonObject* data ) {
649         if(!ses || ! data ) return -1;
650
651         osrf_message* msg = osrf_message_init( RESULT, requestId, 1 );
652         osrf_message_set_status_info( msg, NULL, "OK", OSRF_STATUS_OK );
653         char* json = jsonObjectToJSON( data );
654
655         osrf_message_set_result_content( msg, json );
656         _osrf_app_session_send( ses, msg ); 
657
658         free(json);
659         osrf_message_free( msg );
660
661         return 0;
662 }
663
664
665 int osrfAppRequestRespondComplete( 
666                 osrfAppSession* ses, int requestId, jsonObject* data ) {
667
668         osrf_message* payload = osrf_message_init( RESULT, requestId, 1 );
669         osrf_message_set_status_info( payload, NULL, "OK", OSRF_STATUS_OK );
670
671         osrf_message* status = osrf_message_init( STATUS, requestId, 1);
672         osrf_message_set_status_info( status, "osrfConnectStatus", "Request Complete", OSRF_STATUS_COMPLETE );
673         
674         if (data) {
675                 char* json = jsonObjectToJSON( data );
676                 osrf_message_set_result_content( payload, json );
677                 free(json);
678
679                 osrfMessage* ms[2];
680                 ms[0] = payload;
681                 ms[1] = status;
682
683                 osrfAppSessionSendBatch( ses, ms, 2 );
684
685                 osrf_message_free( payload );
686         } else {
687                 osrfAppSessionSendBatch( ses, &status, 1 );
688         }
689
690         osrf_message_free( status );
691
692         return 0;
693 }
694
695 int osrfAppSessionStatus( osrfAppSession* ses, int type, char* name, int reqId, char* message ) {
696
697         if(ses) {
698                 osrf_message* msg = osrf_message_init( STATUS, reqId, 1);
699                 osrf_message_set_status_info( msg, name, message, type );
700                 _osrf_app_session_send( ses, msg ); 
701                 osrf_message_free( msg );
702                 return 0;
703         }
704         return -1;
705 }
706
707
708
709
710
711