From cb6f8b989b10b8fb3f1683e3a1a7ec8a8f294ead Mon Sep 17 00:00:00 2001 From: Jason Boyer Date: Thu, 15 Dec 2022 15:55:47 -0500 Subject: [PATCH] LP1999823: Additional growing_buffer function names If mod_shib is installed on Ubuntu our apache modules will crash because of a function name collision with libssh. This patch adds additional names for our growing_buffer manipulation functions so the modules can use them but the old names are still available for other users. Signed-off-by: Jason Boyer Signed-off-by: Jeff Davis --- include/opensrf/osrf_utf8.h | 1 + include/opensrf/utils.h | 18 ++++- src/gateway/apachetools.c | 12 ++-- src/gateway/osrf_http_translator.c | 26 ++++---- src/gateway/osrf_json_gateway.c | 38 +++++------ src/libopensrf/jsonpush.c | 36 +++++----- src/libopensrf/osrf_app_session.c | 12 ++-- src/libopensrf/osrf_application.c | 14 ++-- src/libopensrf/osrf_json_object.c | 50 +++++++------- src/libopensrf/osrf_json_tools.c | 6 +- src/libopensrf/osrf_json_xml.c | 52 +++++++-------- src/libopensrf/osrf_legacy_json.c | 118 ++++++++++++++++----------------- src/libopensrf/osrf_parse_json.c | 12 ++-- src/libopensrf/osrf_prefork.c | 10 +-- src/libopensrf/osrf_utf8.c | 6 +- src/libopensrf/transport_session.c | 86 ++++++++++++------------ src/libopensrf/utils.c | 132 +++++++++++++++++++++++++++---------- 17 files changed, 354 insertions(+), 275 deletions(-) diff --git a/include/opensrf/osrf_utf8.h b/include/opensrf/osrf_utf8.h index 83dd7fb..dbc7f61 100644 --- a/include/opensrf/osrf_utf8.h +++ b/include/opensrf/osrf_utf8.h @@ -56,6 +56,7 @@ int is__utf8( int c ); // Translate a string, escaping as needed, and append the // result to a growing_buffer +int osrf_buffer_append_utf8( growing_buffer* buf, const char* string ); int buffer_append_utf8( growing_buffer* buf, const char* string ); #ifdef __cplusplus diff --git a/include/opensrf/utils.h b/include/opensrf/utils.h index f9e156c..deefcd3 100644 --- a/include/opensrf/utils.h +++ b/include/opensrf/utils.h @@ -98,7 +98,7 @@ extern "C" { if( _tl < _gb->size ) {\ strcpy( _gb->buf + _gb->n_used, _data ); \ _gb->n_used = _tl; \ - } else { buffer_add(_gb, _data); }\ + } else { osrf_buffer_add(_gb, _data); }\ }\ } while(0) @@ -119,7 +119,7 @@ extern "C" { memcpy( gb__->buf + gb__->n_used, data__, n__ ); \ gb__->buf[tl__] = '\0'; \ gb__->n_used = tl__; \ -} else { buffer_add_n(gb__, data__, n__); }\ +} else { osrf_buffer_add_n(gb__, data__, n__); }\ }\ } while(0) @@ -313,8 +313,22 @@ typedef struct growing_buffer_struct growing_buffer; @brief The length of the string stored by a growing_buffer. @param x A pointer to the growing buffer. */ +#define osrf_buffer_length(x) (x)->n_used #define buffer_length(x) (x)->n_used +growing_buffer* osrf_buffer_init( int initial_num_bytes); + +int osrf_buffer_add(growing_buffer* gb, const char* c); +int osrf_buffer_add_n(growing_buffer* gb, const char* data, size_t n); +int osrf_buffer_fadd(growing_buffer* gb, const char* format, ... ); +int osrf_buffer_reset( growing_buffer* gb); +char* osrf_buffer_data( const growing_buffer* gb); +char* osrf_buffer_release( growing_buffer* gb ); +int osrf_buffer_free( growing_buffer* gb ); +int osrf_buffer_add_char(growing_buffer* gb, char c); +char osrf_buffer_chomp(growing_buffer* gb); // removes the last character from the buffer + +// Add legacy exports for the above to avoid name collision issues on Ubuntu with mod_shib installed. growing_buffer* buffer_init( int initial_num_bytes); int buffer_add(growing_buffer* gb, const char* c); diff --git a/src/gateway/apachetools.c b/src/gateway/apachetools.c index b6db557..78016a3 100644 --- a/src/gateway/apachetools.c +++ b/src/gateway/apachetools.c @@ -6,7 +6,7 @@ osrfStringArray* apacheParseParms(request_rec* r) { char* arg = NULL; apr_pool_t *p = r->pool; /* memory pool */ - growing_buffer* buffer = buffer_init(1025); + growing_buffer* buffer = osrf_buffer_init(1025); /* gather the post args and append them to the url query string */ if( !strcmp(r->method,"POST") ) { @@ -21,7 +21,7 @@ osrfStringArray* apacheParseParms(request_rec* r) { /* Start with url query string, if any */ if(r->args && r->args[0]) - buffer_add(buffer, r->args); + osrf_buffer_add(buffer, r->args); char body[1025]; @@ -39,7 +39,7 @@ osrfStringArray* apacheParseParms(request_rec* r) { } body[bread] = '\0'; - buffer_add( buffer, body ); + osrf_buffer_add( buffer, body ); osrfLogDebug(OSRF_LOG_MARK, "gateway read %ld bytes: %d bytes of data so far", bread, buffer->n_used); @@ -47,7 +47,7 @@ osrfStringArray* apacheParseParms(request_rec* r) { if(buffer->n_used > APACHE_TOOLS_MAX_POST_SIZE) { osrfLogError(OSRF_LOG_MARK, "gateway received POST larger " "than %d bytes. dropping request", APACHE_TOOLS_MAX_POST_SIZE); - buffer_free(buffer); + osrf_buffer_free(buffer); return NULL; } } @@ -58,7 +58,7 @@ osrfStringArray* apacheParseParms(request_rec* r) { } else { /* GET */ if(r->args && r->args[0]) - buffer_add(buffer, r->args); + osrf_buffer_add(buffer, r->args); } @@ -66,7 +66,7 @@ osrfStringArray* apacheParseParms(request_rec* r) { arg = apr_pstrdup(p, buffer->buf); else arg = NULL; - buffer_free(buffer); + osrf_buffer_free(buffer); if( !arg || !arg[0] ) { /* we received no request */ return NULL; diff --git a/src/gateway/osrf_http_translator.c b/src/gateway/osrf_http_translator.c index ec8a685..65257a6 100644 --- a/src/gateway/osrf_http_translator.c +++ b/src/gateway/osrf_http_translator.c @@ -270,9 +270,9 @@ static char* osrfHttpTranslatorParseRequest(osrfHttpTranslator* trans) { case REQUEST: { const jsonObject* params = msg->_params; - growing_buffer* act = buffer_init(128); + growing_buffer* act = osrf_buffer_init(128); char* method = msg->method_name; - buffer_fadd(act, "[%s] [%s] %s %s", trans->remoteHost, "", + osrf_buffer_fadd(act, "[%s] [%s] %s %s", trans->remoteHost, "", trans->service, method); const jsonObject* obj = NULL; @@ -287,21 +287,21 @@ static char* osrfHttpTranslatorParseRequest(osrfHttpTranslator* trans) { } } if(redactParams) { - OSRF_BUFFER_ADD(act, " **PARAMS REDACTED**"); + osrf_buffer_add(act, " **PARAMS REDACTED**"); } else { i = 0; while((obj = jsonObjectGetIndex(params, i++))) { str = jsonObjectToJSON(obj); if( i == 1 ) - OSRF_BUFFER_ADD(act, " "); + osrf_buffer_add(act, " "); else - OSRF_BUFFER_ADD(act, ", "); - OSRF_BUFFER_ADD(act, str); + osrf_buffer_add(act, ", "); + osrf_buffer_add(act, str); free((void *)str); } } osrfLogActivity(OSRF_LOG_MARK, "%s", act->buf); - buffer_free(act); + osrf_buffer_free(act); break; } @@ -474,20 +474,20 @@ static int osrfHttpTranslatorProcess(osrfHttpTranslator* trans) { osrfListPush(trans->messages, msg->body); if(trans->complete || trans->connectOnly) { - growing_buffer* buf = buffer_init(128); + growing_buffer* buf = osrf_buffer_init(128); unsigned int i; - OSRF_BUFFER_ADD(buf, osrfListGetIndex(trans->messages, 0)); + osrf_buffer_add(buf, osrfListGetIndex(trans->messages, 0)); for(i = 1; i < trans->messages->size; i++) { - buffer_chomp(buf); // chomp off the closing array bracket + osrf_buffer_chomp(buf); // chomp off the closing array bracket char* body = osrfListGetIndex(trans->messages, i); char newbuf[strlen(body)]; sprintf(newbuf, "%s", body+1); // chomp off the opening array bracket - OSRF_BUFFER_ADD_CHAR(buf, ','); - OSRF_BUFFER_ADD(buf, newbuf); + osrf_buffer_add_char(buf, ','); + osrf_buffer_add(buf, newbuf); } ap_rputs(buf->buf, trans->apreq); - buffer_free(buf); + osrf_buffer_free(buf); } } } diff --git a/src/gateway/osrf_json_gateway.c b/src/gateway/osrf_json_gateway.c index 783ebc9..834c152 100644 --- a/src/gateway/osrf_json_gateway.c +++ b/src/gateway/osrf_json_gateway.c @@ -204,18 +204,18 @@ static int osrf_json_gateway_method_handler (request_rec *r) { if (param_locale) { - growing_buffer* osrf_locale_buf = buffer_init(16); + growing_buffer* osrf_locale_buf = osrf_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] ); + osrf_buffer_add_char( osrf_locale_buf, param_locale[i] ); } else { - buffer_add( osrf_locale_buf, param_locale ); + osrf_buffer_add( osrf_locale_buf, param_locale ); } free(param_locale); - osrf_locale = buffer_release( osrf_locale_buf ); + osrf_locale = osrf_buffer_release( osrf_locale_buf ); } else { osrf_locale = strdup( osrf_json_default_locale ); } @@ -292,12 +292,12 @@ static int osrf_json_gateway_method_handler (request_rec *r) { /* 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); + growing_buffer* act = osrf_buffer_init(128); #ifdef APACHE_MIN_24 - buffer_fadd(act, "[%s] [%s] [%s] %s %s", r->connection->client_ip, + osrf_buffer_fadd(act, "[%s] [%s] [%s] %s %s", r->connection->client_ip, authtoken, osrf_locale, service, method ); #else - buffer_fadd(act, "[%s] [%s] [%s] %s %s", r->connection->remote_ip, + osrf_buffer_fadd(act, "[%s] [%s] [%s] %s %s", r->connection->remote_ip, authtoken, osrf_locale, service, method ); #endif @@ -311,22 +311,22 @@ static int osrf_json_gateway_method_handler (request_rec *r) { } } if(redact_params) { - OSRF_BUFFER_ADD(act, " **PARAMS REDACTED**"); + osrf_buffer_add(act, " **PARAMS REDACTED**"); } else { i = 0; while( (str = osrfStringArrayGetString(mparams, i++)) ) { if( i == 1 ) { - OSRF_BUFFER_ADD(act, " "); - OSRF_BUFFER_ADD(act, str); + osrf_buffer_add(act, " "); + osrf_buffer_add(act, str); } else { - OSRF_BUFFER_ADD(act, ", "); - OSRF_BUFFER_ADD(act, str); + osrf_buffer_add(act, ", "); + osrf_buffer_add(act, str); } } } osrfLogActivity( OSRF_LOG_MARK, "%s", act->buf ); - buffer_free(act); + osrf_buffer_free(act); /* ----------------------------------------------------------------- */ @@ -392,24 +392,24 @@ static int osrf_json_gateway_method_handler (request_rec *r) { /* 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 ); - growing_buffer* buf = buffer_init(512); + growing_buffer* buf = osrf_buffer_init(512); if (isXML) - buffer_fadd(buf, "\"%s : %s\"", statusname, statustext); + osrf_buffer_fadd(buf, "\"%s : %s\"", statusname, statustext); else { - buffer_fadd(buf, "%s : %s", statusname, statustext); + osrf_buffer_fadd(buf, "%s : %s", statusname, statustext); jsonObject* tmp = jsonNewObject(buf->buf); char* j = jsonToStringFunc(tmp); - buffer_reset(buf); - buffer_fadd(buf, ",\"debug\": %s", j); + osrf_buffer_reset(buf); + osrf_buffer_fadd(buf, ",\"debug\": %s", j); free(j); jsonObjectFree(tmp); } ap_rputs(buf->buf, r); - buffer_free(buf); + osrf_buffer_free(buf); free(statusname); free(statustext); } diff --git a/src/libopensrf/jsonpush.c b/src/libopensrf/jsonpush.c index 6eb42b3..55ad4bc 100644 --- a/src/libopensrf/jsonpush.c +++ b/src/libopensrf/jsonpush.c @@ -144,7 +144,7 @@ JSONPushParser* jsonNewPushParser( const JSONHandlerMap* map, void* blob ) parser->pos = 1; parser->state = PP_BEGIN; parser->again = '\0'; - parser->buf = buffer_init( 64 ); + parser->buf = osrf_buffer_init( 64 ); parser->state_stack = NULL; parser->free_states = NULL; parser->word_idx = 0; @@ -451,7 +451,7 @@ static int do_begin( JSONPushParser* parser, char c ) { if( isspace( (unsigned char) c ) ) // skip white space ; else if( '\"' == c ) { // Found a string - buffer_reset( parser->buf ); + osrf_buffer_reset( parser->buf ); push_pp_state( parser, PP_END ); parser->state = PP_STR; } else if( '[' == c ) { // Found an array @@ -483,8 +483,8 @@ static int do_begin( JSONPushParser* parser, char c ) { || '.' == c || 'e' == c || 'E' == c ) { // Found a number - buffer_reset( parser->buf ); - buffer_add_char( parser->buf, c ); + osrf_buffer_reset( parser->buf ); + osrf_buffer_add_char( parser->buf, c ); push_pp_state( parser, PP_END ); parser->state = PP_NUM; } else { @@ -533,7 +533,7 @@ static int do_str ( JSONPushParser* parser, char c ) { (unsigned int) c ); rc = 1; } else { - buffer_add_char( parser->buf, c ); + osrf_buffer_add_char( parser->buf, c ); } return rc; @@ -693,7 +693,7 @@ static int do_num ( JSONPushParser* parser, char c ) { || '.' == c || 'e' == c || 'E' == c ) { - buffer_add_char( parser->buf, c ); + osrf_buffer_add_char( parser->buf, c ); } else { const char* num_str = OSRF_BUFFER_C_STR( parser->buf ); @@ -736,7 +736,7 @@ static int do_array_begin( JSONPushParser* parser, char c ) { if( isspace( (unsigned char) c ) ) // skip white space ; else if( '\"' == c ) { // Found a string - buffer_reset( parser->buf ); + osrf_buffer_reset( parser->buf ); push_pp_state( parser, PP_ARRAY_VALUE ); parser->state = PP_STR; } else if( '[' == c ) { // Found a nested array @@ -773,8 +773,8 @@ static int do_array_begin( JSONPushParser* parser, char c ) { || '.' == c || 'e' == c || 'E' == c ) { - buffer_reset( parser->buf ); - buffer_add_char( parser->buf, c ); + osrf_buffer_reset( parser->buf ); + osrf_buffer_add_char( parser->buf, c ); push_pp_state( parser, PP_ARRAY_VALUE ); parser->state = PP_NUM; } else { @@ -828,7 +828,7 @@ static int do_array_comma( JSONPushParser* parser, char c ) { if( isspace( (unsigned char) c ) ) // skip white space ; else if( '\"' == c ) { // Found a string - buffer_reset( parser->buf ); + osrf_buffer_reset( parser->buf ); push_pp_state( parser, PP_ARRAY_VALUE ); parser->state = PP_STR; } else if( '[' == c ) { // Found a nested array @@ -860,8 +860,8 @@ static int do_array_comma( JSONPushParser* parser, char c ) { || '.' == c || 'e' == c || 'E' == c ) { - buffer_reset( parser->buf ); - buffer_add_char( parser->buf, c ); + osrf_buffer_reset( parser->buf ); + osrf_buffer_add_char( parser->buf, c ); push_pp_state( parser, PP_ARRAY_VALUE ); parser->state = PP_NUM; } else { @@ -886,7 +886,7 @@ static int do_obj_begin( JSONPushParser* parser, char c ) { if( isspace( (unsigned char) c ) ) // skip white space ; else if( '\"' == c ) { // Found a string - buffer_reset( parser->buf ); + osrf_buffer_reset( parser->buf ); push_pp_state( parser, PP_OBJ_KEY ); parser->state = PP_STR; } else if( '}' == c ) { // End of object @@ -939,7 +939,7 @@ static int do_obj_colon( JSONPushParser* parser, char c ) { if( isspace( (unsigned char) c ) ) // skip white space ; else if( '\"' == c ) { // Found a string - buffer_reset( parser->buf ); + osrf_buffer_reset( parser->buf ); push_pp_state( parser, PP_OBJ_VALUE ); parser->state = PP_STR; } else if( '[' == c ) { // Found a nested array @@ -971,8 +971,8 @@ static int do_obj_colon( JSONPushParser* parser, char c ) { || '.' == c || 'e' == c || 'E' == c ) { - buffer_reset( parser->buf ); - buffer_add_char( parser->buf, c ); + osrf_buffer_reset( parser->buf ); + osrf_buffer_add_char( parser->buf, c ); push_pp_state( parser, PP_OBJ_VALUE ); parser->state = PP_NUM; } else { @@ -1026,7 +1026,7 @@ static int do_obj_comma( JSONPushParser* parser, char c ) { if( isspace( (unsigned char) c ) ) // skip white space ; else if( '\"' == c ) { // Found a string - buffer_reset( parser->buf ); + osrf_buffer_reset( parser->buf ); push_pp_state( parser, PP_OBJ_KEY ); parser->state = PP_STR; } else { @@ -1262,7 +1262,7 @@ static void report_pp_error( JSONPushParser* parser, const char* msg, ... ) { */ void jsonPushParserFree( JSONPushParser* parser ) { if( parser ) { - buffer_free( parser->buf ); + osrf_buffer_free( parser->buf ); // Pop off all the StateNodes, and then free them while( parser->state_stack ) { diff --git a/src/libopensrf/osrf_app_session.c b/src/libopensrf/osrf_app_session.c index df83e3e..18ca953 100644 --- a/src/libopensrf/osrf_app_session.c +++ b/src/libopensrf/osrf_app_session.c @@ -103,7 +103,7 @@ static void _osrf_app_request_free( osrfAppRequest * req ) { } if (req->part_response_buffer) - buffer_free(req->part_response_buffer); + osrf_buffer_free(req->part_response_buffer); free( req ); } @@ -128,7 +128,7 @@ static void _osrf_app_request_push_queue( osrfAppRequest* req, osrfMessage* resu // assume the max_chunk_size of the server matches ours for // buffer initialization, since the setting will usually be // a site-wide value. - req->part_response_buffer = buffer_init(OSRF_MSG_CHUNK_SIZE + 1); + req->part_response_buffer = osrf_buffer_init(OSRF_MSG_CHUNK_SIZE + 1); } const char* partial = jsonObjectGetString(result->_result_content); @@ -138,7 +138,7 @@ static void _osrf_app_request_push_queue( osrfAppRequest* req, osrfMessage* resu "adding %d bytes to response buffer", strlen(partial)); // add the partial contents of the message to the buffer - buffer_add(req->part_response_buffer, partial); + osrf_buffer_add(req->part_response_buffer, partial); } // all done. req and result are freed by the caller @@ -160,7 +160,7 @@ static void _osrf_app_request_push_queue( osrfAppRequest* req, osrfMessage* resu result, req->part_response_buffer->buf); // free string, keep the buffer - buffer_reset(req->part_response_buffer); + osrf_buffer_reset(req->part_response_buffer); } else { osrfLogDebug(OSRF_LOG_MARK, @@ -701,7 +701,7 @@ osrfAppSession* osrf_app_server_session_init( session->request_hash[ i ] = NULL; session->panic = 0; - session->outbuf = buffer_init( 4096 ); + session->outbuf = osrf_buffer_init( 4096 ); _osrf_app_session_push_session( session ); return session; @@ -1292,7 +1292,7 @@ void osrfAppSessionFree( osrfAppSession* session ){ } if( session->outbuf ) - buffer_free( session->outbuf ); + osrf_buffer_free( session->outbuf ); free(session); } diff --git a/src/libopensrf/osrf_application.c b/src/libopensrf/osrf_application.c index b8cb7c1..82c1e9e 100644 --- a/src/libopensrf/osrf_application.c +++ b/src/libopensrf/osrf_application.c @@ -669,14 +669,14 @@ static int flush_responses( osrfAppSession* ses, growing_buffer* outbuf ) { osrf_app_session_queue_wait( ses, 0, NULL ); int rc = 0; - if( buffer_length( outbuf ) > 0 ) { // If there's anything to send... - buffer_add_char( outbuf, ']' ); // Close the JSON array + if( osrf_buffer_length( outbuf ) > 0 ) { // If there's anything to send... + osrf_buffer_add_char( outbuf, ']' ); // Close the JSON array if( osrfSendTransportPayload( ses, OSRF_BUFFER_C_STR( ses->outbuf ))) { osrfLogError( OSRF_LOG_MARK, "Unable to flush response buffer" ); rc = -1; } } - buffer_reset( ses->outbuf ); + osrf_buffer_reset( ses->outbuf ); return rc; } @@ -692,9 +692,9 @@ static int flush_responses( osrfAppSession* ses, growing_buffer* outbuf ) { */ static inline void append_msg( growing_buffer* outbuf, const char* msg ) { if( outbuf && msg ) { - char prefix = buffer_length( outbuf ) > 0 ? ',' : '['; - buffer_add_char( outbuf, prefix ); - buffer_add( outbuf, msg ); + char prefix = osrf_buffer_length( outbuf ) > 0 ? ',' : '['; + osrf_buffer_add_char( outbuf, prefix ); + osrf_buffer_add( outbuf, msg ); } } @@ -771,7 +771,7 @@ static int _osrfAppRespond( osrfMethodContext* ctx, const jsonObject* data, int osrfMessageFree( msg ); // If the new message would overflow the buffer, flush the output buffer first - int len_so_far = buffer_length( ctx->session->outbuf ); + int len_so_far = osrf_buffer_length( ctx->session->outbuf ); if( len_so_far && (strlen( json ) + len_so_far + 3 >= ctx->method->max_bundle_size )) { if( flush_responses( ctx->session, ctx->session->outbuf )) return -1; diff --git a/src/libopensrf/osrf_json_object.c b/src/libopensrf/osrf_json_object.c index 954bc8a..e880908 100644 --- a/src/libopensrf/osrf_json_object.c +++ b/src/libopensrf/osrf_json_object.c @@ -512,7 +512,7 @@ static void add_json_to_buffer( const jsonObject* obj, OSRF_BUFFER_ADD( buf, JSON_DATA_KEY ); OSRF_BUFFER_ADD( buf, "\":" ); add_json_to_buffer( obj, buf, 1, 1 ); - buffer_add_char( buf, '}' ); + osrf_buffer_add_char( buf, '}' ); return; } } @@ -536,7 +536,7 @@ static void add_json_to_buffer( const jsonObject* obj, case JSON_STRING: OSRF_BUFFER_ADD_CHAR(buf, '"'); - buffer_append_utf8(buf, obj->value.s); + osrf_buffer_append_utf8(buf, obj->value.s); OSRF_BUFFER_ADD_CHAR(buf, '"'); break; @@ -564,7 +564,7 @@ static void add_json_to_buffer( const jsonObject* obj, while( (item = osrfHashIteratorNext(itr)) ) { if(i++ > 0) OSRF_BUFFER_ADD_CHAR(buf, ','); OSRF_BUFFER_ADD_CHAR(buf, '"'); - buffer_append_utf8(buf, osrfHashIteratorKey(itr)); + osrf_buffer_append_utf8(buf, osrfHashIteratorKey(itr)); OSRF_BUFFER_ADD(buf, "\":"); add_json_to_buffer( item, buf, do_classname, second_pass ); } @@ -585,9 +585,9 @@ static void add_json_to_buffer( const jsonObject* obj, */ char* jsonObjectToJSONRaw( const jsonObject* obj ) { if(!obj) return NULL; - growing_buffer* buf = buffer_init(32); + growing_buffer* buf = osrf_buffer_init(32); add_json_to_buffer( obj, buf, 0, 0 ); - return buffer_release( buf ); + return osrf_buffer_release( buf ); } /** @@ -603,9 +603,9 @@ char* jsonObjectToJSONRaw( const jsonObject* obj ) { */ char* jsonObjectToJSON( const jsonObject* obj ) { if(!obj) return NULL; - growing_buffer* buf = buffer_init(32); + growing_buffer* buf = osrf_buffer_init(32); add_json_to_buffer( obj, buf, 1, 0 ); - return buffer_release( buf ); + return osrf_buffer_release( buf ); } /** @@ -1162,7 +1162,7 @@ int jsonIsNumeric( const char* s ) { char* jsonScrubNumber( const char* s ) { if( !s || !*s ) return NULL; - growing_buffer* buf = buffer_init( 64 ); + growing_buffer* buf = osrf_buffer_init( 64 ); // Skip leading white space, if present @@ -1172,7 +1172,7 @@ char* jsonScrubNumber( const char* s ) { if( '-' == *s ) { - buffer_add_char( buf, '-' ); + osrf_buffer_add_char( buf, '-' ); ++s; } else if( '+' == *s ) @@ -1181,7 +1181,7 @@ char* jsonScrubNumber( const char* s ) { if( '\0' == *s ) { // No digits found - buffer_free( buf ); + osrf_buffer_free( buf ); return NULL; } // Skip any leading zeros @@ -1194,12 +1194,12 @@ char* jsonScrubNumber( const char* s ) { int left_digit = 0; // boolean if( isdigit( (unsigned char) *s ) ) { - buffer_add_char( buf, *s++ ); + osrf_buffer_add_char( buf, *s++ ); left_digit = 1; } while( isdigit( (unsigned char) *s ) ) - buffer_add_char( buf, *s++ ); + osrf_buffer_add_char( buf, *s++ ); // Now we expect to see a decimal point, // an exponent, or end-of-string. @@ -1213,22 +1213,22 @@ char* jsonScrubNumber( const char* s ) { // Add a single leading zero, if we need to if( ! left_digit ) - buffer_add_char( buf, '0' ); - buffer_add_char( buf, '.' ); + osrf_buffer_add_char( buf, '0' ); + osrf_buffer_add_char( buf, '.' ); ++s; if( ! left_digit && ! isdigit( (unsigned char) *s ) ) { // No digits on either side of decimal - buffer_free( buf ); + osrf_buffer_free( buf ); return NULL; } // Collect digits to right of decimal while( isdigit( (unsigned char) *s ) ) - buffer_add_char( buf, *s++ ); + osrf_buffer_add_char( buf, *s++ ); break; } @@ -1240,46 +1240,46 @@ char* jsonScrubNumber( const char* s ) { // to its left if( ! left_digit ) - buffer_add_char( buf, '1' ); + osrf_buffer_add_char( buf, '1' ); break; default : // Unexpected character; bail out - buffer_free( buf ); + osrf_buffer_free( buf ); return NULL; } if( '\0' == *s ) // Are we done yet? - return buffer_release( buf ); + return osrf_buffer_release( buf ); if( 'e' != *s && 'E' != *s ) { // Unexpected character: bail out - buffer_free( buf ); + osrf_buffer_free( buf ); return NULL; } // We have an exponent. Load the e or E, // and the sign if there is one. - buffer_add_char( buf, *s++ ); + osrf_buffer_add_char( buf, *s++ ); if( '+' == *s || '-' == *s ) - buffer_add_char( buf, *s++ ); + osrf_buffer_add_char( buf, *s++ ); // Collect digits of the exponent while( isdigit( (unsigned char) *s ) ) - buffer_add_char( buf, *s++ ); + osrf_buffer_add_char( buf, *s++ ); // There better not be anything left if( *s ) { - buffer_free( buf ); + osrf_buffer_free( buf ); return NULL; } - return buffer_release( buf ); + return osrf_buffer_release( buf ); } diff --git a/src/libopensrf/osrf_json_tools.c b/src/libopensrf/osrf_json_tools.c index 2e6893d..901dfa1 100644 --- a/src/libopensrf/osrf_json_tools.c +++ b/src/libopensrf/osrf_json_tools.c @@ -32,7 +32,7 @@ static void append_indentation( growing_buffer* buf, int depth ) { size_t n = 2 * depth; char indent[ n ]; memset( indent, ' ', n ); - buffer_add_n( buf, indent, n ); + osrf_buffer_add_n( buf, indent, n ); } /** @@ -53,7 +53,7 @@ static void append_indentation( growing_buffer* buf, int depth ) { char* jsonFormatString( const char* string ) { if( !string ) return strdup( "" ); - growing_buffer* buf = buffer_init( 64 ); + growing_buffer* buf = osrf_buffer_init( 64 ); int i; int depth = 0; int in_quote = 0; // boolean; true if in a string literal @@ -112,7 +112,7 @@ char* jsonFormatString( const char* string ) { } } - return buffer_release( buf ); + return osrf_buffer_release( buf ); } diff --git a/src/libopensrf/osrf_json_xml.c b/src/libopensrf/osrf_json_xml.c index ef5b306..2f8cce8 100644 --- a/src/libopensrf/osrf_json_xml.c +++ b/src/libopensrf/osrf_json_xml.c @@ -237,10 +237,10 @@ char* jsonObjectToXML(const jsonObject* obj) { if (!obj) return strdup(""); - growing_buffer * res_xml = buffer_init(1024); + growing_buffer * res_xml = osrf_buffer_init(1024); _recurse_jsonObjectToXML( obj, res_xml ); - return buffer_release(res_xml); + return osrf_buffer_release(res_xml); } @@ -254,9 +254,9 @@ int _recurse_jsonObjectToXML(const jsonObject* obj, growing_buffer* res_xml) { if(obj->type == JSON_NULL) { if (hint) - buffer_fadd(res_xml, "",hint); + osrf_buffer_fadd(res_xml, "",hint); else - buffer_add(res_xml, ""); + osrf_buffer_add(res_xml, ""); } else if(obj->type == JSON_BOOL) { @@ -267,18 +267,18 @@ int _recurse_jsonObjectToXML(const jsonObject* obj, growing_buffer* res_xml) { bool_val = "false"; if (hint) - buffer_fadd(res_xml, "", bool_val, hint); + osrf_buffer_fadd(res_xml, "", bool_val, hint); else - buffer_fadd(res_xml, "", bool_val); + osrf_buffer_fadd(res_xml, "", bool_val); } else if (obj->type == JSON_STRING) { if (hint) { char * t = _escape_xml(jsonObjectGetString(obj)); - buffer_fadd(res_xml,"%s", hint, t); + osrf_buffer_fadd(res_xml,"%s", hint, t); free(t); } else { char * t = _escape_xml(jsonObjectGetString(obj)); - buffer_fadd(res_xml,"%s", t); + osrf_buffer_fadd(res_xml,"%s", t); free(t); } @@ -286,46 +286,46 @@ int _recurse_jsonObjectToXML(const jsonObject* obj, growing_buffer* res_xml) { double x = jsonObjectGetNumber(obj); if (hint) { if (x == (int)x) - buffer_fadd(res_xml,"%d", hint, (int)x); + osrf_buffer_fadd(res_xml,"%d", hint, (int)x); else - buffer_fadd(res_xml,"%lf", hint, x); + osrf_buffer_fadd(res_xml,"%lf", hint, x); } else { if (x == (int)x) - buffer_fadd(res_xml,"%d", (int)x); + osrf_buffer_fadd(res_xml,"%d", (int)x); else - buffer_fadd(res_xml,"%lf", x); + osrf_buffer_fadd(res_xml,"%lf", x); } } else if (obj->type == JSON_ARRAY) { if (hint) - buffer_fadd(res_xml,"", hint); + osrf_buffer_fadd(res_xml,"", hint); else - buffer_add(res_xml,""); + osrf_buffer_add(res_xml,""); int i; for ( i = 0; i!= obj->size; i++ ) _recurse_jsonObjectToXML(jsonObjectGetIndex(obj,i), res_xml); - buffer_add(res_xml,""); + osrf_buffer_add(res_xml,""); } else if (obj->type == JSON_HASH) { if (hint) - buffer_fadd(res_xml,"", hint); + osrf_buffer_fadd(res_xml,"", hint); else - buffer_add(res_xml,""); + osrf_buffer_add(res_xml,""); jsonIterator* itr = jsonNewIterator(obj); const jsonObject* tmp; while( (tmp = jsonIteratorNext(itr)) ) { - buffer_fadd(res_xml,"",itr->key); + osrf_buffer_fadd(res_xml,"",itr->key); _recurse_jsonObjectToXML(tmp, res_xml); - buffer_add(res_xml,""); + osrf_buffer_add(res_xml,""); } jsonIteratorFree(itr); - buffer_add(res_xml,""); + osrf_buffer_add(res_xml,""); } if (hint) @@ -335,20 +335,20 @@ int _recurse_jsonObjectToXML(const jsonObject* obj, growing_buffer* res_xml) { } static char* _escape_xml (const char* text) { - growing_buffer* b = buffer_init(256); + growing_buffer* b = osrf_buffer_init(256); int len = strlen(text); int i; for (i = 0; i < len; i++) { if (text[i] == '&') - buffer_add(b,"&"); + osrf_buffer_add(b,"&"); else if (text[i] == '<') - buffer_add(b,"<"); + osrf_buffer_add(b,"<"); else if (text[i] == '>') - buffer_add(b,">"); + osrf_buffer_add(b,">"); else - buffer_add_char(b,text[i]); + osrf_buffer_add_char(b,text[i]); } - return buffer_release(b); + return osrf_buffer_release(b); } #endif diff --git a/src/libopensrf/osrf_legacy_json.c b/src/libopensrf/osrf_legacy_json.c index 1ed4555..faa7240 100644 --- a/src/libopensrf/osrf_legacy_json.c +++ b/src/libopensrf/osrf_legacy_json.c @@ -210,31 +210,31 @@ int json_parse_json_bool(char* string, unsigned long* index, jsonObject* obj, in int json_parse_json_number(char* string, unsigned long* index, jsonObject* obj, int current_strlen) { if( ! string || ! obj || *index >= current_strlen ) return -1; - growing_buffer* buf = buffer_init(64); + growing_buffer* buf = osrf_buffer_init(64); char c = string[*index]; int done = 0; int dot_seen = 0; /* negative number? */ - if(c == '-') { buffer_add(buf, "-"); (*index)++; } + if(c == '-') { osrf_buffer_add(buf, "-"); (*index)++; } c = string[*index]; while(*index < current_strlen) { if(isdigit(c)) { - buffer_add_char(buf, c); + osrf_buffer_add_char(buf, c); } else if( c == '.' ) { if(dot_seen) { - buffer_free(buf); + osrf_buffer_free(buf); return json_handle_error(string, index, "json_parse_json_number(): malformed json number"); } dot_seen = 1; - buffer_add_char(buf, c); + osrf_buffer_add_char(buf, c); } else { done = 1; break; } @@ -245,7 +245,7 @@ int json_parse_json_number(char* string, unsigned long* index, jsonObject* obj, } obj->type = JSON_NUMBER; - obj->value.s = buffer_release(buf); + obj->value.s = osrf_buffer_release(buf); return 0; } @@ -405,7 +405,7 @@ int json_parse_json_string(char* string, unsigned long* index, jsonObject* obj, int in_escape = 0; int done = 0; - growing_buffer* buf = buffer_init(64); + growing_buffer* buf = osrf_buffer_init(64); while(*index < current_strlen) { @@ -415,7 +415,7 @@ int json_parse_json_string(char* string, unsigned long* index, jsonObject* obj, case '\\': if(in_escape) { - buffer_add(buf, "\\"); + osrf_buffer_add(buf, "\\"); in_escape = 0; } else in_escape = 1; @@ -423,7 +423,7 @@ int json_parse_json_string(char* string, unsigned long* index, jsonObject* obj, case '"': if(in_escape) { - buffer_add(buf, "\""); + osrf_buffer_add(buf, "\""); in_escape = 0; } else done = 1; @@ -431,42 +431,42 @@ int json_parse_json_string(char* string, unsigned long* index, jsonObject* obj, case 't': if(in_escape) { - buffer_add(buf,"\t"); + osrf_buffer_add(buf,"\t"); in_escape = 0; } else - buffer_add_char(buf, c); + osrf_buffer_add_char(buf, c); break; case 'b': if(in_escape) { - buffer_add(buf,"\b"); + osrf_buffer_add(buf,"\b"); in_escape = 0; } else - buffer_add_char(buf, c); + osrf_buffer_add_char(buf, c); break; case 'f': if(in_escape) { - buffer_add(buf,"\f"); + osrf_buffer_add(buf,"\f"); in_escape = 0; } else - buffer_add_char(buf, c); + osrf_buffer_add_char(buf, c); break; case 'r': if(in_escape) { - buffer_add(buf,"\r"); + osrf_buffer_add(buf,"\r"); in_escape = 0; } else - buffer_add_char(buf, c); + osrf_buffer_add_char(buf, c); break; case 'n': if(in_escape) { - buffer_add(buf,"\n"); + osrf_buffer_add(buf,"\n"); in_escape = 0; } else - buffer_add_char(buf, c); + osrf_buffer_add_char(buf, c); break; case 'u': @@ -474,7 +474,7 @@ int json_parse_json_string(char* string, unsigned long* index, jsonObject* obj, (*index)++; if(*index >= (current_strlen - 4)) { - buffer_free(buf); + osrf_buffer_free(buf); return json_handle_error(string, index, "json_parse_json_string(): truncated escaped unicode"); } @@ -494,18 +494,18 @@ int json_parse_json_string(char* string, unsigned long* index, jsonObject* obj, if (ucs_char < 0x80) { utf_out[0] = ucs_char; - buffer_add(buf, (char*) utf_out); + osrf_buffer_add(buf, (char*) utf_out); } else if (ucs_char < 0x800) { utf_out[0] = 0xc0 | (ucs_char >> 6); utf_out[1] = 0x80 | (ucs_char & 0x3f); - buffer_add(buf, (char*) utf_out); + osrf_buffer_add(buf, (char*) utf_out); } else { utf_out[0] = 0xe0 | (ucs_char >> 12); utf_out[1] = 0x80 | ((ucs_char >> 6) & 0x3f); utf_out[2] = 0x80 | (ucs_char & 0x3f); - buffer_add(buf, (char*) utf_out); + osrf_buffer_add(buf, (char*) utf_out); } /* ----------------------------------------------------------------------- */ /* ----------------------------------------------------------------------- */ @@ -515,13 +515,13 @@ int json_parse_json_string(char* string, unsigned long* index, jsonObject* obj, } else { - buffer_add_char(buf, c); + osrf_buffer_add_char(buf, c); } break; default: - buffer_add_char(buf, c); + osrf_buffer_add_char(buf, c); } (*index)++; @@ -529,7 +529,7 @@ int json_parse_json_string(char* string, unsigned long* index, jsonObject* obj, } jsonObjectSetString(obj, buf->buf); - buffer_free(buf); + osrf_buffer_free(buf); return 0; } @@ -599,7 +599,7 @@ int json_eat_comment(char* string, unsigned long* index, char** buffer, int pars - growing_buffer* buf = buffer_init(64); + growing_buffer* buf = osrf_buffer_init(64); int first_dash = 0; int second_dash = 0; @@ -632,7 +632,7 @@ int json_eat_comment(char* string, unsigned long* index, char** buffer, int pars } if(second_dash && in_hint) { - buffer_add_char(buf, c); + osrf_buffer_add_char(buf, c); break; } @@ -647,7 +647,7 @@ int json_eat_comment(char* string, unsigned long* index, char** buffer, int pars } if(second_dash && in_hint) { - buffer_add_char(buf, c); + osrf_buffer_add_char(buf, c); break; } @@ -665,7 +665,7 @@ int json_eat_comment(char* string, unsigned long* index, char** buffer, int pars default: on_star = 0; if(in_hint) - buffer_add_char(buf, c); + osrf_buffer_add_char(buf, c); } (*index)++; @@ -673,9 +673,9 @@ int json_eat_comment(char* string, unsigned long* index, char** buffer, int pars } if( buf->n_used > 0 && buffer) - *buffer = buffer_data(buf); + *buffer = osrf_buffer_data(buf); - buffer_free(buf); + osrf_buffer_free(buf); return 0; } @@ -703,82 +703,82 @@ char* legacy_jsonObjectToJSON( const jsonObject* obj ) { if(obj == NULL) return strdup("null"); - growing_buffer* buf = buffer_init(64); + growing_buffer* buf = osrf_buffer_init(64); /* add class hints if we have a class name */ if(obj->classname) { - buffer_add(buf,"/*--S "); - buffer_add(buf,obj->classname); - buffer_add(buf, "--*/"); + osrf_buffer_add(buf,"/*--S "); + osrf_buffer_add(buf,obj->classname); + osrf_buffer_add(buf, "--*/"); } switch( obj->type ) { case JSON_BOOL: - if(obj->value.b) buffer_add(buf, "true"); - else buffer_add(buf, "false"); + if(obj->value.b) osrf_buffer_add(buf, "true"); + else osrf_buffer_add(buf, "false"); break; case JSON_NUMBER: { - buffer_add(buf, obj->value.s); + osrf_buffer_add(buf, obj->value.s); break; } case JSON_NULL: - buffer_add(buf, "null"); + osrf_buffer_add(buf, "null"); break; case JSON_STRING: - buffer_add(buf, "\""); + osrf_buffer_add(buf, "\""); char* data = obj->value.s; int len = strlen(data); char* output = uescape(data, len, 1); - buffer_add(buf, output); + osrf_buffer_add(buf, output); free(output); - buffer_add(buf, "\""); + osrf_buffer_add(buf, "\""); break; case JSON_ARRAY: - buffer_add(buf, "["); + osrf_buffer_add(buf, "["); int i; for( i = 0; i!= obj->size; i++ ) { const jsonObject* x = jsonObjectGetIndex(obj,i); char* data = legacy_jsonObjectToJSON(x); - buffer_add(buf, data); + osrf_buffer_add(buf, data); free(data); if(i != obj->size - 1) - buffer_add(buf, ","); + osrf_buffer_add(buf, ","); } - buffer_add(buf, "]"); + osrf_buffer_add(buf, "]"); break; case JSON_HASH: - buffer_add(buf, "{"); + osrf_buffer_add(buf, "{"); jsonIterator* itr = jsonNewIterator(obj); jsonObject* tmp; while( (tmp = jsonIteratorNext(itr)) ) { - buffer_add(buf, "\""); + osrf_buffer_add(buf, "\""); const char* key = itr->key; int len = strlen(key); char* output = uescape(key, len, 1); - buffer_add(buf, output); + osrf_buffer_add(buf, output); free(output); - buffer_add(buf, "\":"); + osrf_buffer_add(buf, "\":"); char* data = legacy_jsonObjectToJSON(tmp); - buffer_add(buf, data); + osrf_buffer_add(buf, data); if(jsonIteratorHasNext(itr)) - buffer_add(buf, ","); + osrf_buffer_add(buf, ","); free(data); } jsonIteratorFree(itr); - buffer_add(buf, "}"); + osrf_buffer_add(buf, "}"); break; default: @@ -789,13 +789,13 @@ char* legacy_jsonObjectToJSON( const jsonObject* obj ) { /* close out the object hint */ if(obj->classname) { - buffer_add(buf, "/*--E "); - buffer_add(buf, obj->classname); - buffer_add(buf, "--*/"); + osrf_buffer_add(buf, "/*--E "); + osrf_buffer_add(buf, obj->classname); + osrf_buffer_add(buf, "--*/"); } - char* data = buffer_data(buf); - buffer_free(buf); + char* data = osrf_buffer_data(buf); + osrf_buffer_free(buf); return data; } diff --git a/src/libopensrf/osrf_parse_json.c b/src/libopensrf/osrf_parse_json.c index 2ea7f52..ea660a2 100644 --- a/src/libopensrf/osrf_parse_json.c +++ b/src/libopensrf/osrf_parse_json.c @@ -149,7 +149,7 @@ static jsonObject* parse_it( const char* s, int decode ) { obj = NULL; } - buffer_free( parser.str_buf ); + osrf_buffer_free( parser.str_buf ); return obj; } @@ -219,9 +219,9 @@ static jsonObject* get_json_node( Parser* parser, char firstc ) { static const char* get_string( Parser* parser ) { if( parser->str_buf ) - buffer_reset( parser->str_buf ); + osrf_buffer_reset( parser->str_buf ); else - parser->str_buf = buffer_init( 64 ); + parser->str_buf = osrf_buffer_init( 64 ); growing_buffer* gb = parser->str_buf; @@ -284,9 +284,9 @@ static const char* get_string( Parser* parser ) { static jsonObject* get_number( Parser* parser, char firstc ) { if( parser->str_buf ) - buffer_reset( parser->str_buf ); + osrf_buffer_reset( parser->str_buf ); else - parser->str_buf = buffer_init( 64 ); + parser->str_buf = osrf_buffer_init( 64 ); growing_buffer* gb = parser->str_buf; OSRF_BUFFER_ADD_CHAR( gb, firstc ); @@ -309,7 +309,7 @@ static jsonObject* get_number( Parser* parser, char firstc ) { } } - char* s = buffer_data( gb ); + char* s = osrf_buffer_data( gb ); if( ! jsonIsNumeric( s ) ) { char* temp = jsonScrubNumber( s ); free( s ); diff --git a/src/libopensrf/osrf_prefork.c b/src/libopensrf/osrf_prefork.c index 845a64e..4ef164c 100644 --- a/src/libopensrf/osrf_prefork.c +++ b/src/libopensrf/osrf_prefork.c @@ -1251,7 +1251,7 @@ static int check_children( prefork_simple* forker, int forever ) { static void prefork_child_wait( prefork_child* child ) { int i,n; - growing_buffer* gbuf = buffer_init( READ_BUFSIZE ); + growing_buffer* gbuf = osrf_buffer_init( READ_BUFSIZE ); char buf[READ_BUFSIZE]; for( i = 0; i < child->max_requests; i++ ) { @@ -1268,7 +1268,7 @@ static void prefork_child_wait( prefork_child* child ) { set_fl( child->read_data_fd, O_NONBLOCK ); gotdata = 1; } - buffer_add_n( gbuf, buf, n ); + osrf_buffer_add_n( gbuf, buf, n ); } if( errno == EAGAIN ) @@ -1290,7 +1290,7 @@ static void prefork_child_wait( prefork_child* child ) { // Process the request osrfLogDebug( OSRF_LOG_MARK, "Prefork child got a request.. processing.." ); terminate_now = prefork_child_process_request( child, gbuf->buf ); - buffer_reset( gbuf ); + osrf_buffer_reset( gbuf ); } if( terminate_now ) { @@ -1308,13 +1308,13 @@ static void prefork_child_wait( prefork_child* child ) { osrfLogError( OSRF_LOG_MARK, "Drone terminating: unable to notify listener of availability: %s", strerror( errno )); - buffer_free( gbuf ); + osrf_buffer_free( gbuf ); osrf_prefork_child_exit( child ); } } } - buffer_free( gbuf ); + osrf_buffer_free( gbuf ); osrfLogDebug( OSRF_LOG_MARK, "Child with max-requests=%d, num-served=%d exiting...[%ld]", child->max_requests, i, (long) getpid()); diff --git a/src/libopensrf/osrf_utf8.c b/src/libopensrf/osrf_utf8.c index e83be28..443dd40 100644 --- a/src/libopensrf/osrf_utf8.c +++ b/src/libopensrf/osrf_utf8.c @@ -344,7 +344,7 @@ typedef enum { for a JSON string -- including escaped hex values and surrogate pairs where needed. Append the result to a growing_buffer. */ -int buffer_append_utf8( growing_buffer* buf, const char* string ) { +int osrf_buffer_append_utf8( growing_buffer* buf, const char* string ) { utf8_state state = S_BEGIN; unsigned long utf8_char = 0; const unsigned char* s = (unsigned char *) string; @@ -542,6 +542,10 @@ int buffer_append_utf8( growing_buffer* buf, const char* string ) { return rc; } +int buffer_append_utf8( growing_buffer* buf, const char* string ) { + return osrf_buffer_append_utf8(buf, string); +} + /** Break a code point up into two pieces, and format each piec in hex. as a surrogate pair. Append the results to a growing_buffer. diff --git a/src/libopensrf/transport_session.c b/src/libopensrf/transport_session.c index ff2b358..b31bd79 100644 --- a/src/libopensrf/transport_session.c +++ b/src/libopensrf/transport_session.c @@ -127,23 +127,23 @@ transport_session* init_transport( const char* server, session->component = component; /* initialize the data buffers */ - session->body_buffer = buffer_init( JABBER_BODY_BUFSIZE ); - session->subject_buffer = buffer_init( JABBER_SUBJECT_BUFSIZE ); - session->thread_buffer = buffer_init( JABBER_THREAD_BUFSIZE ); - session->from_buffer = buffer_init( JABBER_JID_BUFSIZE ); - session->status_buffer = buffer_init( JABBER_STATUS_BUFSIZE ); - session->recipient_buffer = buffer_init( JABBER_JID_BUFSIZE ); - session->message_error_type = buffer_init( JABBER_JID_BUFSIZE ); - session->session_id = buffer_init( 64 ); + session->body_buffer = osrf_buffer_init( JABBER_BODY_BUFSIZE ); + session->subject_buffer = osrf_buffer_init( JABBER_SUBJECT_BUFSIZE ); + session->thread_buffer = osrf_buffer_init( JABBER_THREAD_BUFSIZE ); + session->from_buffer = osrf_buffer_init( JABBER_JID_BUFSIZE ); + session->status_buffer = osrf_buffer_init( JABBER_STATUS_BUFSIZE ); + session->recipient_buffer = osrf_buffer_init( JABBER_JID_BUFSIZE ); + session->message_error_type = osrf_buffer_init( JABBER_JID_BUFSIZE ); + session->session_id = osrf_buffer_init( 64 ); session->message_error_code = 0; /* for OpenSRF extensions */ - session->router_to_buffer = buffer_init( JABBER_JID_BUFSIZE ); - session->router_from_buffer = buffer_init( JABBER_JID_BUFSIZE ); - session->osrf_xid_buffer = buffer_init( JABBER_JID_BUFSIZE ); - session->router_class_buffer = buffer_init( JABBER_JID_BUFSIZE ); - session->router_command_buffer = buffer_init( JABBER_JID_BUFSIZE ); + session->router_to_buffer = osrf_buffer_init( JABBER_JID_BUFSIZE ); + session->router_from_buffer = osrf_buffer_init( JABBER_JID_BUFSIZE ); + session->osrf_xid_buffer = osrf_buffer_init( JABBER_JID_BUFSIZE ); + session->router_class_buffer = osrf_buffer_init( JABBER_JID_BUFSIZE ); + session->router_command_buffer = osrf_buffer_init( JABBER_JID_BUFSIZE ); session->router_broadcast = 0; @@ -228,19 +228,19 @@ int session_discard( transport_session* session ) { xmlDictCleanup(); xmlCleanupParser(); - buffer_free(session->body_buffer); - buffer_free(session->subject_buffer); - buffer_free(session->thread_buffer); - buffer_free(session->from_buffer); - buffer_free(session->recipient_buffer); - buffer_free(session->status_buffer); - buffer_free(session->message_error_type); - buffer_free(session->router_to_buffer); - buffer_free(session->router_from_buffer); - buffer_free(session->osrf_xid_buffer); - buffer_free(session->router_class_buffer); - buffer_free(session->router_command_buffer); - buffer_free(session->session_id); + osrf_buffer_free(session->body_buffer); + osrf_buffer_free(session->subject_buffer); + osrf_buffer_free(session->thread_buffer); + osrf_buffer_free(session->from_buffer); + osrf_buffer_free(session->recipient_buffer); + osrf_buffer_free(session->status_buffer); + osrf_buffer_free(session->message_error_type); + osrf_buffer_free(session->router_to_buffer); + osrf_buffer_free(session->router_from_buffer); + osrf_buffer_free(session->osrf_xid_buffer); + osrf_buffer_free(session->router_class_buffer); + osrf_buffer_free(session->router_command_buffer); + osrf_buffer_free(session->session_id); free(session->server); free(session->unix_path); @@ -423,7 +423,7 @@ int session_connect( transport_session* session, /* server acknowledges our existence, now see if we can login */ if( session->state_machine->connecting == CONNECTING_2 ) { - int ss = buffer_length( session->session_id ) + strlen( password ) + 5; + int ss = osrf_buffer_length( session->session_id ) + strlen( password ) + 5; char hashstuff[ss]; snprintf( hashstuff, sizeof(hashstuff), "%s%s", OSRF_BUFFER_C_STR( session->session_id ), password ); @@ -486,7 +486,7 @@ int session_connect( transport_session* session, } else if( auth_type == AUTH_DIGEST ) { - int ss = buffer_length( session->session_id ) + strlen( password ) + 5; + int ss = osrf_buffer_length( session->session_id ) + strlen( password ) + 5; char hashstuff[ss]; snprintf( hashstuff, sizeof(hashstuff), "%s%s", OSRF_BUFFER_C_STR( session->session_id ), password ); @@ -578,8 +578,8 @@ static void startElementHandler( if( strcmp( (char*) name, "message" ) == 0 ) { ses->state_machine->in_message = 1; - buffer_add( ses->from_buffer, get_xml_attr( atts, "from" ) ); - buffer_add( ses->recipient_buffer, get_xml_attr( atts, "to" ) ); + osrf_buffer_add( ses->from_buffer, get_xml_attr( atts, "from" ) ); + osrf_buffer_add( ses->recipient_buffer, get_xml_attr( atts, "to" ) ); return; } @@ -587,11 +587,11 @@ static void startElementHandler( if( ses->state_machine->in_message ) { if( strcmp( (char*) name, "opensrf" ) == 0 ) { - buffer_add( ses->router_from_buffer, get_xml_attr( atts, "router_from" ) ); - buffer_add( ses->osrf_xid_buffer, get_xml_attr( atts, "osrf_xid" ) ); - buffer_add( ses->router_to_buffer, get_xml_attr( atts, "router_to" ) ); - buffer_add( ses->router_class_buffer, get_xml_attr( atts, "router_class" ) ); - buffer_add( ses->router_command_buffer, get_xml_attr( atts, "router_command" ) ); + osrf_buffer_add( ses->router_from_buffer, get_xml_attr( atts, "router_from" ) ); + osrf_buffer_add( ses->osrf_xid_buffer, get_xml_attr( atts, "osrf_xid" ) ); + osrf_buffer_add( ses->router_to_buffer, get_xml_attr( atts, "router_to" ) ); + osrf_buffer_add( ses->router_class_buffer, get_xml_attr( atts, "router_class" ) ); + osrf_buffer_add( ses->router_command_buffer, get_xml_attr( atts, "router_command" ) ); const char* broadcast = get_xml_attr( atts, "broadcast" ); if( broadcast ) ses->router_broadcast = atoi( broadcast ); @@ -618,8 +618,8 @@ static void startElementHandler( if( strcmp( (char*) name, "presence" ) == 0 ) { ses->state_machine->in_presence = 1; - buffer_add( ses->from_buffer, get_xml_attr( atts, "from" ) ); - buffer_add( ses->recipient_buffer, get_xml_attr( atts, "to" ) ); + osrf_buffer_add( ses->from_buffer, get_xml_attr( atts, "from" ) ); + osrf_buffer_add( ses->recipient_buffer, get_xml_attr( atts, "to" ) ); return; } @@ -641,7 +641,7 @@ static void startElementHandler( if( strcmp( (char*) name, "stream:stream" ) == 0 ) { if( ses->state_machine->connecting == CONNECTING_1 ) { ses->state_machine->connecting = CONNECTING_2; - buffer_add( ses->session_id, get_xml_attr(atts, "id") ); + osrf_buffer_add( ses->session_id, get_xml_attr(atts, "id") ); } return; } @@ -656,7 +656,7 @@ static void startElementHandler( if( strcmp( (char*) name, "error" ) == 0 ) { char *code = NULL; ses->state_machine->in_message_error = 1; - buffer_add( ses->message_error_type, get_xml_attr( atts, "type" ) ); + osrf_buffer_add( ses->message_error_type, get_xml_attr( atts, "type" ) ); code = get_xml_attr( atts, "code" ); if (code) ses->message_error_code = atoi( code ); @@ -925,21 +925,21 @@ static void characterHandler( if( machine->in_message ) { if( machine->in_message_body ) { - buffer_add_n( ses->body_buffer, p, len ); + osrf_buffer_add_n( ses->body_buffer, p, len ); } if( machine->in_subject ) { - buffer_add_n( ses->subject_buffer, p, len ); + osrf_buffer_add_n( ses->subject_buffer, p, len ); } if( machine->in_thread ) { - buffer_add_n( ses->thread_buffer, p, len ); + osrf_buffer_add_n( ses->thread_buffer, p, len ); } } /* set the presence status */ if( machine->in_presence && ses->state_machine->in_status ) { - buffer_add_n( ses->status_buffer, p, len ); + osrf_buffer_add_n( ses->status_buffer, p, len ); } if( machine->in_error ) { diff --git a/src/libopensrf/utils.c b/src/libopensrf/utils.c index 6b1d9aa..fe7f03c 100644 --- a/src/libopensrf/utils.c +++ b/src/libopensrf/utils.c @@ -264,10 +264,10 @@ char* va_list_to_string(const char* format, ...) { the string will ever be. However the guess doesn't have to accurate, because more memory will be allocated as needed. - The calling code is responsible for freeing the growing_buffer by calling buffer_free() - or buffer_release(). + The calling code is responsible for freeing the growing_buffer by calling osrf_buffer_free() + or osrf_buffer_release(). */ -growing_buffer* buffer_init(int num_initial_bytes) { +growing_buffer* osrf_buffer_init(int num_initial_bytes) { if( num_initial_bytes > BUFFER_MAX_SIZE ) return NULL; @@ -283,6 +283,10 @@ growing_buffer* buffer_init(int num_initial_bytes) { return gb; } +growing_buffer* buffer_init( int initial_num_bytes) { + return osrf_buffer_init(initial_num_bytes); +} + /** @brief Allocate more memory for a growing_buffer. @@ -293,7 +297,7 @@ growing_buffer* buffer_init(int num_initial_bytes) { This function fails if it is asked to allocate BUFFER_MAX_SIZE or more bytes. */ -static int buffer_expand( growing_buffer* gb, size_t total_len ) { +static int osrf_buffer_expand( growing_buffer* gb, size_t total_len ) { // We do not check to see if the buffer is already big enough. It is the //responsibility of the calling function to call this only when necessary. @@ -303,7 +307,7 @@ static int buffer_expand( growing_buffer* gb, size_t total_len ) { if( total_len >= BUFFER_MAX_SIZE ) { fprintf(stderr, "Buffer reached MAX_SIZE of %lu", (unsigned long) BUFFER_MAX_SIZE ); - buffer_free( gb ); + osrf_buffer_free( gb ); return 1; } @@ -330,6 +334,9 @@ static int buffer_expand( growing_buffer* gb, size_t total_len ) { return 0; } +static int buffer_expand( growing_buffer* gb, size_t total_len ) { + return osrf_buffer_expand(gb, total_len); +} /** @brief Append a formatted string to a growing_buffer. @@ -341,27 +348,51 @@ static int buffer_expand( growing_buffer* gb, size_t total_len ) { This function fails if either of the first two parameters is NULL, or if the resulting string requires BUFFER_MAX_SIZE or more bytes. */ +int osrf_buffer_fadd(growing_buffer* gb, const char* format, ... ) { + + if(!gb || !format) return -1; + + long len = 0; + va_list args; + va_list a_copy; + + va_copy(a_copy, args); + + va_start(args, format); + len = va_list_size(format, args); + + char buf[len]; + osrf_clearbuf(buf, sizeof(buf)); + + va_start(a_copy, format); + vsnprintf(buf, len - 1, format, a_copy); + va_end(a_copy); + + return osrf_buffer_add(gb, buf); +} + +/* Just repeating this wholesale because varargs is *handwave* unhappy *handwave* about something. */ int buffer_fadd(growing_buffer* gb, const char* format, ... ) { - if(!gb || !format) return -1; + if(!gb || !format) return -1; - long len = 0; - va_list args; - va_list a_copy; + long len = 0; + va_list args; + va_list a_copy; - va_copy(a_copy, args); + va_copy(a_copy, args); - va_start(args, format); - len = va_list_size(format, args); + va_start(args, format); + len = va_list_size(format, args); - char buf[len]; - osrf_clearbuf(buf, sizeof(buf)); + char buf[len]; + osrf_clearbuf(buf, sizeof(buf)); - va_start(a_copy, format); - vsnprintf(buf, len - 1, format, a_copy); - va_end(a_copy); + va_start(a_copy, format); + vsnprintf(buf, len - 1, format, a_copy); + va_end(a_copy); - return buffer_add(gb, buf); + return osrf_buffer_add(gb, buf); } @@ -371,7 +402,7 @@ int buffer_fadd(growing_buffer* gb, const char* format, ... ) { @param data A pointer to the string to be appended. @return If successful, the length of the resulting string; or if not, -1. */ -int buffer_add(growing_buffer* gb, const char* data) { +int osrf_buffer_add(growing_buffer* gb, const char* data) { if(!(gb && data)) return -1; int data_len = strlen( data ); @@ -381,7 +412,7 @@ int buffer_add(growing_buffer* gb, const char* data) { int total_len = data_len + gb->n_used; if( total_len >= gb->size ) { - if( buffer_expand( gb, total_len ) ) + if( osrf_buffer_expand( gb, total_len ) ) return -1; } @@ -390,6 +421,10 @@ int buffer_add(growing_buffer* gb, const char* data) { return total_len; } +int buffer_add(growing_buffer* gb, const char* c) { + return osrf_buffer_add(gb, c); +} + /** @brief Append a specified number of characters to a growing_buffer. @param gb A pointer to the growing_buffer. @@ -400,7 +435,7 @@ int buffer_add(growing_buffer* gb, const char* data) { If the characters to be appended include an embedded nul byte, it will be appended along with the others. The results are likely to be unpleasant. */ -int buffer_add_n(growing_buffer* gb, const char* data, size_t n) { +int osrf_buffer_add_n(growing_buffer* gb, const char* data, size_t n) { if(!(gb && data)) return -1; if(n == 0) return 0; @@ -408,7 +443,7 @@ int buffer_add_n(growing_buffer* gb, const char* data, size_t n) { int total_len = n + gb->n_used; if( total_len >= gb->size ) { - if( buffer_expand( gb, total_len ) ) + if( osrf_buffer_expand( gb, total_len ) ) return -1; } @@ -418,13 +453,16 @@ int buffer_add_n(growing_buffer* gb, const char* data, size_t n) { return total_len; } +int buffer_add_n(growing_buffer* gb, const char* data, size_t n) { + return osrf_buffer_add_n(gb, data, n); +} /** @brief Reset a growing_buffer so that it contains an empty string. @param gb A pointer to the growing_buffer. @return 0 if successful, -1 if not. */ -int buffer_reset( growing_buffer *gb){ +int osrf_buffer_reset( growing_buffer *gb){ if( gb == NULL ) { return -1; } if( gb->buf == NULL ) { return -1; } osrf_clearbuf( gb->buf, gb->size ); @@ -433,6 +471,10 @@ int buffer_reset( growing_buffer *gb){ return gb->n_used; } +int buffer_reset( growing_buffer* gb) { + return osrf_buffer_reset(gb); +} + /** @brief Free a growing_buffer and return a pointer to the string inside. @param gb A pointer to the growing_buffer. @@ -440,22 +482,26 @@ int buffer_reset( growing_buffer *gb){ The calling code is responsible for freeing the string. - This function is equivalent to buffer_data() followed by buffer_free(). However + This function is equivalent to osrf_buffer_data() followed by osrf_buffer_free(). However it is more efficient, because it avoids calls to strudup and free(). */ -char* buffer_release( growing_buffer* gb) { +char* osrf_buffer_release( growing_buffer* gb) { char* s = gb->buf; s[gb->n_used] = '\0'; free( gb ); return s; } +char* buffer_release( growing_buffer* gb ) { + return osrf_buffer_release(gb); +} + /** @brief Free a growing_buffer and its contents. @param gb A pointer to the growing_buffer. @return 1 if successful, or 0 if not (because the input parameter is NULL). */ -int buffer_free( growing_buffer* gb ) { +int osrf_buffer_free( growing_buffer* gb ) { if( gb == NULL ) return 0; free( gb->buf ); @@ -463,6 +509,10 @@ int buffer_free( growing_buffer* gb ) { return 1; } +int buffer_free( growing_buffer* gb ) { + return osrf_buffer_free(gb); +} + /** @brief Create a copy of the string inside a growing_buffer. @param gb A pointer to the growing_buffer. @@ -472,16 +522,20 @@ int buffer_free( growing_buffer* gb ) { The calling code is responsible for freeing the string. */ -char* buffer_data( const growing_buffer *gb) { +char* osrf_buffer_data( const growing_buffer *gb) { return strdup( gb->buf ); } +char* buffer_data( const growing_buffer* gb) { + return osrf_buffer_data(gb); +} + /** @brief Remove the last character from a growing_buffer. @param gb A pointer to the growing_buffer. @return The character removed (or a nul byte if the string is already empty). */ -char buffer_chomp(growing_buffer* gb) { +char osrf_buffer_chomp(growing_buffer* gb) { char c = '\0'; if(gb && gb->n_used > 0) { gb->n_used--; @@ -491,6 +545,9 @@ char buffer_chomp(growing_buffer* gb) { return c; } +char buffer_chomp(growing_buffer* gb) { + return osrf_buffer_chomp(gb); +} /** @brief Append a single character to a growing_buffer. @@ -501,13 +558,13 @@ char buffer_chomp(growing_buffer* gb) { If the character appended is a nul byte it will still be appended as if it were a normal character. The results are likely to be unpleasant. */ -int buffer_add_char(growing_buffer* gb, char c ) { +int osrf_buffer_add_char(growing_buffer* gb, char c ) { if(gb && gb->buf) { int total_len = gb->n_used + 1; if( total_len >= gb->size ) { - if( buffer_expand( gb, total_len ) ) + if( osrf_buffer_expand( gb, total_len ) ) return -1; } @@ -518,6 +575,9 @@ int buffer_add_char(growing_buffer* gb, char c ) { return 0; } +int buffer_add_char(growing_buffer* gb, char c) { + return osrf_buffer_add_char(gb, c); +} /** @brief Translate a UTF8 string into escaped ASCII, suitable for JSON. @@ -527,7 +587,7 @@ int buffer_add_char(growing_buffer* gb, char c ) { special characters. @return A pointer to the translated version of the string. - Deprecated. Use buffer_append_utf8() instead. + Deprecated. Use osrf_buffer_append_utf8() instead. If full_escape is non-zero, the translation will escape certain certain characters with a backslash, according to the conventions @@ -547,7 +607,7 @@ char* uescape( const char* string, int size, int full_escape ) { if( NULL == string ) return NULL; - growing_buffer* buf = buffer_init(size + 64); + growing_buffer* buf = osrf_buffer_init(size + 64); int clen = 0; int idx = 0; unsigned long int c = 0x0; @@ -581,10 +641,10 @@ char* uescape( const char* string, int size, int full_escape ) { } - buffer_fadd(buf, "\\u%04x", c); + osrf_buffer_fadd(buf, "\\u%04x", c); } else { - buffer_free(buf); + osrf_buffer_free(buf); return NULL; } @@ -630,7 +690,7 @@ char* uescape( const char* string, int size, int full_escape ) { break; default: - if( c < 32 ) buffer_fadd(buf, "\\u%04x", c); + if( c < 32 ) osrf_buffer_fadd(buf, "\\u%04x", c); else OSRF_BUFFER_ADD_CHAR(buf, c); } @@ -642,7 +702,7 @@ char* uescape( const char* string, int size, int full_escape ) { idx++; } - return buffer_release(buf); + return osrf_buffer_release(buf); } -- 2.11.0