static int osrf_json_gateway_method_handler (request_rec *r) { /* make sure we're needed first thing*/ if (strcmp(r->handler, MODULE_NAME )) return DECLINED; osrf_json_gateway_dir_config* dir_conf = ap_get_module_config(r->per_dir_config, &osrf_json_gateway_module); /* provide 2 different JSON parsers and serializers to support legacy JSON */ jsonObject* (*parseJSONFunc) (const char*) = legacy_jsonParseString; char* (*jsonToStringFunc) (const jsonObject*) = legacy_jsonObjectToJSON; if(dir_conf->legacyJSON) { ap_log_rerror( APLOG_MARK, APLOG_DEBUG, 0, r, "Using legacy JSON"); } else { parseJSONFunc = jsonParse; jsonToStringFunc = jsonObjectToJSON; } osrfLogDebug(OSRF_LOG_MARK, "osrf gateway: entered request handler"); /* verify we are connected */ if( !bootstrapped || !osrfSystemGetTransportClient()) { ap_log_rerror( APLOG_MARK, APLOG_ERR, 0, r, "Cannot process request " "because the OpenSRF JSON gateway has not been bootstrapped..."); usleep( 100000 ); /* 100 milliseconds */ exit(1); } osrfLogSetAppname("osrf_json_gw"); char* osrf_locale = NULL; char* param_locale = NULL; /* locale for this call */ char* service = NULL; /* service to connect to */ char* method = NULL; /* method to perform */ char* format = NULL; /* method to perform */ char* a_l = NULL; /* request api level */ char* input_format = NULL; /* POST data format, defaults to 'format' */ int isXML = 0; int api_level = 1; r->allowed |= (AP_METHOD_BIT << M_GET); r->allowed |= (AP_METHOD_BIT << M_POST); osrfLogDebug(OSRF_LOG_MARK, "osrf gateway: parsing URL params"); osrfStringArray* mparams = NULL; osrfStringArray* params = apacheParseParms(r); /* free me */ param_locale = apacheGetFirstParamValue( params, "locale" ); service = apacheGetFirstParamValue( params, "service" ); method = apacheGetFirstParamValue( params, "method" ); format = apacheGetFirstParamValue( params, "format" ); input_format = apacheGetFirstParamValue( params, "input_format" ); a_l = apacheGetFirstParamValue( params, "api_level" ); mparams = apacheGetParamValues( params, "param" ); /* free me */ if(format == NULL) format = strdup( "json" ); if(input_format == NULL) input_format = strdup( format ); /* set the user defined timeout value */ int timeout = 60; char* tout = apacheGetFirstParamValue( params, "timeout" ); /* request timeout in seconds */ if( tout ) { timeout = atoi(tout); osrfLogDebug(OSRF_LOG_MARK, "Client supplied timeout of %d", timeout); free( tout ); } if (a_l) { api_level = atoi(a_l); free( a_l ); } if (!strcasecmp(format, "xml")) { isXML = 1; ap_set_content_type(r, "application/xml"); } else { ap_set_content_type(r, "text/plain"); } free( format ); int ret = OK; /* ----------------------------------------------------------------- */ /* Grab the requested locale using the Accept-Language header*/ if ( !param_locale ) { if ( apr_table_get(r->headers_in, "X-OpenSRF-Language") ) { param_locale = strdup( apr_table_get(r->headers_in, "X-OpenSRF-Language") ); } else if ( apr_table_get(r->headers_in, "Accept-Language") ) { param_locale = strdup( apr_table_get(r->headers_in, "Accept-Language") ); } } if (param_locale) { growing_buffer* osrf_locale_buf = buffer_init(16); if (index(param_locale, ',')) { int ind = index(param_locale, ',') - param_locale; int i; for ( i = 0; i < ind && i < 128; i++ ) buffer_add_char( osrf_locale_buf, param_locale[i] ); } else { buffer_add( osrf_locale_buf, param_locale ); } free(param_locale); osrf_locale = buffer_release( osrf_locale_buf ); } else { osrf_locale = strdup( osrf_json_default_locale ); } /* ----------------------------------------------------------------- */ if(!(service && method)) { osrfLogError(OSRF_LOG_MARK, "Service [%s] not found or not allowed", service); ret = HTTP_NOT_FOUND; } else { /* This will log all heaers to the apache error log const apr_array_header_t* arr = apr_table_elts(r->headers_in); const void* ptr; while( (ptr = apr_array_pop(arr)) ) { apr_table_entry_t* e = (apr_table_entry_t*) ptr; fprintf(stderr, "Table entry: %s : %s\n", e->key, e->val ); } fflush(stderr); */ osrfAppSession* session = osrfAppSessionClientInit(service); osrf_app_session_set_locale(session, osrf_locale); double starttime = get_timestamp_millis(); int req_id = -1; if(!strcasecmp(input_format, "json")) { jsonObject * arr = jsonNewObject(NULL); const char* str; int i = 0; while( (str = osrfStringArrayGetString(mparams, i++)) ) jsonObjectPush(arr, parseJSONFunc(str)); req_id = osrfAppSessionSendRequest( session, arr, method, api_level ); jsonObjectFree(arr); } else { /** * If we receive XML method params, convert each param to a JSON object * and pass the array of JSON object params to the method */ if(!strcasecmp(input_format, "xml")) { jsonObject* jsonParams = jsonNewObject(NULL); const char* str; int i = 0; while( (str = osrfStringArrayGetString(mparams, i++)) ) { jsonObjectPush(jsonParams, jsonXMLToJSONObject(str)); } req_id = osrfAppSessionSendRequest( session, jsonParams, method, api_level ); jsonObjectFree(jsonParams); } } if( req_id == -1 ) { osrfLogError(OSRF_LOG_MARK, "I am unable to communicate with opensrf..going away..."); osrfAppSessionFree(session); /* we don't want to spawn an intense re-forking storm * if there is no jabber server.. so give it some time before we die */ usleep( 100000 ); /* 100 milliseconds */ exit(1); } /* ----------------------------------------------------------------- */ /* log all requests to the activity log */ const char* authtoken = apr_table_get(r->headers_in, "X-OILS-Authtoken"); if(!authtoken) authtoken = ""; growing_buffer* act = buffer_init(128); buffer_fadd(act, "[%s] [%s] [%s] %s %s", r->connection->remote_ip, authtoken, osrf_locale, service, method ); const char* str; int i = 0; while( (str = osrfStringArrayGetString(mparams, i++)) ) { if( i == 1 ) { OSRF_BUFFER_ADD(act, " "); OSRF_BUFFER_ADD(act, str); } else { OSRF_BUFFER_ADD(act, ", "); OSRF_BUFFER_ADD(act, str); } } osrfLogActivity( OSRF_LOG_MARK, act->buf ); buffer_free(act); /* ----------------------------------------------------------------- */ osrfMessage* omsg = NULL; int statuscode = 200; /* kick off the object */ if (isXML) ap_rputs( "<response xmlns=\"http://opensrf.org/-/namespaces/gateway/v1\"><payload>", r ); else ap_rputs("{\"payload\":[", r); int morethan1 = 0; char* statusname = NULL; char* statustext = NULL; char* output = NULL; while((omsg = osrfAppSessionRequestRecv( session, req_id, timeout ))) { statuscode = omsg->status_code; const jsonObject* res; if( ( res = osrfMessageGetResult(omsg)) ) { if (isXML) { output = jsonObjectToXML( res ); } else { output = jsonToStringFunc( res ); if( morethan1 ) ap_rputs(",", r); /* comma between JSON array items */ } ap_rputs(output, r); free(output); morethan1 = 1; } else { if( statuscode > 299 ) { /* the request returned a low level error */ statusname = omsg->status_name ? strdup(omsg->status_name) : strdup("Unknown Error"); statustext = omsg->status_text ? strdup(omsg->status_text) : strdup("No Error Message"); osrfLogError( OSRF_LOG_MARK, "Gateway received error: %s", statustext ); } } osrfMessageFree(omsg); if(statusname) break; } double duration = get_timestamp_millis() - starttime; osrfLogDebug(OSRF_LOG_MARK, "gateway request took %f seconds", duration); if (isXML) ap_rputs("</payload>", r); else ap_rputs("]",r); /* finish off the payload array */ if(statusname) { /* add a debug field if the request died */ ap_log_rerror( APLOG_MARK, APLOG_INFO, 0, r, "OpenSRF JSON Request returned error: %s -> %s", statusname, statustext ); int l = strlen(statusname) + strlen(statustext) + 32; char buf[l]; if (isXML) snprintf( buf, sizeof(buf), "<debug>\"%s : %s\"</debug>", statusname, statustext ); else { char bb[l]; snprintf(bb, sizeof(bb), "%s : %s", statusname, statustext); jsonObject* tmp = jsonNewObject(bb); char* j = jsonToStringFunc(tmp); snprintf( buf, sizeof(buf), ",\"debug\": %s", j); free(j); jsonObjectFree(tmp); } ap_rputs(buf, r); free(statusname); free(statustext); } /* insert the status code */ char buf[32]; if (isXML) snprintf(buf, sizeof(buf), "<status>%d</status>", statuscode ); else snprintf(buf, sizeof(buf), ",\"status\":%d", statuscode ); ap_rputs( buf, r ); if (isXML) ap_rputs("</response>", r); else ap_rputs( "}", r ); /* finish off the object */ osrfAppSessionFree(session); } osrfLogInfo(OSRF_LOG_MARK, "Completed processing service=%s, method=%s", service, method); osrfStringArrayFree(params); osrfStringArrayFree(mparams); free( osrf_locale ); free( input_format ); free( method ); free( service ); osrfLogDebug(OSRF_LOG_MARK, "Gateway served %d requests", ++numserved); osrfLogClearXid(); return ret; }
/** * Parse opensrf request and relay the request to the opensrf network. */ static size_t on_message_handler_body(void *data, const WebSocketServer *server, const int type, unsigned char *buffer, const size_t buffer_size) { request_rec *r = server->request(server); jsonObject *msg_wrapper = NULL; // free me const jsonObject *tmp_obj = NULL; const jsonObject *osrf_msg = NULL; const char *service = NULL; const char *thread = NULL; const char *log_xid = NULL; char *msg_body = NULL; char *recipient = NULL; int i; if (buffer_size <= 0) return OK; // generate a new log trace for this request. it // may be replaced by a client-provided trace below. osrfLogMkXid(); osrfLogDebug(OSRF_LOG_MARK, "WS received message size=%d", buffer_size); // buffer may not be \0-terminated, which jsonParse requires char buf[buffer_size + 1]; memcpy(buf, buffer, buffer_size); buf[buffer_size] = '\0'; osrfLogInternal(OSRF_LOG_MARK, "WS received inbound message: %s", buf); msg_wrapper = jsonParse(buf); if (msg_wrapper == NULL) { osrfLogWarning(OSRF_LOG_MARK, "WS Invalid JSON: %s", buf); return HTTP_BAD_REQUEST; } osrf_msg = jsonObjectGetKeyConst(msg_wrapper, "osrf_msg"); if (tmp_obj = jsonObjectGetKeyConst(msg_wrapper, "service")) service = jsonObjectGetString(tmp_obj); if (tmp_obj = jsonObjectGetKeyConst(msg_wrapper, "thread")) thread = jsonObjectGetString(tmp_obj); if (tmp_obj = jsonObjectGetKeyConst(msg_wrapper, "log_xid")) log_xid = jsonObjectGetString(tmp_obj); if (log_xid) { // use the caller-provide log trace id if (strlen(log_xid) > MAX_THREAD_SIZE) { osrfLogWarning(OSRF_LOG_MARK, "WS log_xid exceeds max length"); return HTTP_BAD_REQUEST; } osrfLogForceXid(log_xid); } if (thread) { if (strlen(thread) > MAX_THREAD_SIZE) { osrfLogWarning(OSRF_LOG_MARK, "WS thread exceeds max length"); return HTTP_BAD_REQUEST; } // since clients can provide their own threads at session start time, // the presence of a thread does not guarantee a cached recipient recipient = (char*) apr_hash_get( trans->stateful_session_cache, thread, APR_HASH_KEY_STRING); if (recipient) { osrfLogDebug(OSRF_LOG_MARK, "WS found cached recipient %s", recipient); } } if (!recipient) { if (service) { int size = snprintf(recipient_buf, RECIP_BUF_SIZE - 1, "%s@%s/%s", trans->osrf_router, trans->osrf_domain, service); recipient_buf[size] = '\0'; recipient = recipient_buf; } else { osrfLogWarning(OSRF_LOG_MARK, "WS Unable to determine recipient"); return HTTP_BAD_REQUEST; } } osrfLogDebug(OSRF_LOG_MARK, "WS relaying message to opensrf thread=%s, recipient=%s", thread, recipient); msg_body = extract_inbound_messages( r, service, thread, recipient, osrf_msg); osrfLogInternal(OSRF_LOG_MARK, "WS relaying inbound message: %s", msg_body); transport_message *tmsg = message_init( msg_body, NULL, thread, recipient, NULL); message_set_osrf_xid(tmsg, osrfLogGetXid()); client_send_message(osrf_handle, tmsg); osrfLogClearXid(); message_free(tmsg); jsonObjectFree(msg_wrapper); free(msg_body); last_activity_time = time(NULL); return OK; }