// 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
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)
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)
@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);
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") ) {
/* 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];
}
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);
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;
}
}
} else { /* GET */
if(r->args && r->args[0])
- buffer_add(buffer, r->args);
+ osrf_buffer_add(buffer, r->args);
}
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;
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;
}
}
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;
}
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);
}
}
}
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 );
}
/* 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
}
}
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);
/* ----------------------------------------------------------------- */
/* 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, "<debug>\"%s : %s\"</debug>", statusname, statustext);
+ osrf_buffer_fadd(buf, "<debug>\"%s : %s\"</debug>", 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);
}
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;
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
|| '.' == 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 {
(unsigned int) c );
rc = 1;
} else {
- buffer_add_char( parser->buf, c );
+ osrf_buffer_add_char( parser->buf, c );
}
return rc;
|| '.' == 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 );
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
|| '.' == 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 {
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
|| '.' == 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 {
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
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
|| '.' == 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 {
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 {
*/
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 ) {
}
if (req->part_response_buffer)
- buffer_free(req->part_response_buffer);
+ osrf_buffer_free(req->part_response_buffer);
free( req );
}
// 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);
"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
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,
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;
}
if( session->outbuf )
- buffer_free( session->outbuf );
+ osrf_buffer_free( session->outbuf );
free(session);
}
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;
}
*/
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 );
}
}
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;
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;
}
}
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;
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 );
}
*/
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 );
}
/**
*/
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 );
}
/**
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
if( '-' == *s )
{
- buffer_add_char( buf, '-' );
+ osrf_buffer_add_char( buf, '-' );
++s;
}
else if( '+' == *s )
if( '\0' == *s ) {
// No digits found
- buffer_free( buf );
+ osrf_buffer_free( buf );
return NULL;
}
// Skip any leading zeros
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.
// 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;
}
// 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 );
}
size_t n = 2 * depth;
char indent[ n ];
memset( indent, ' ', n );
- buffer_add_n( buf, indent, n );
+ osrf_buffer_add_n( buf, indent, n );
}
/**
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
}
}
- return buffer_release( buf );
+ return osrf_buffer_release( buf );
}
if (!obj)
return strdup("<null/>");
- 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);
}
if(obj->type == JSON_NULL) {
if (hint)
- buffer_fadd(res_xml, "<null class_hint=\"%s\"/>",hint);
+ osrf_buffer_fadd(res_xml, "<null class_hint=\"%s\"/>",hint);
else
- buffer_add(res_xml, "<null/>");
+ osrf_buffer_add(res_xml, "<null/>");
} else if(obj->type == JSON_BOOL) {
bool_val = "false";
if (hint)
- buffer_fadd(res_xml, "<boolean value=\"%s\" class_hint=\"%s\"/>", bool_val, hint);
+ osrf_buffer_fadd(res_xml, "<boolean value=\"%s\" class_hint=\"%s\"/>", bool_val, hint);
else
- buffer_fadd(res_xml, "<boolean value=\"%s\"/>", bool_val);
+ osrf_buffer_fadd(res_xml, "<boolean value=\"%s\"/>", bool_val);
} else if (obj->type == JSON_STRING) {
if (hint) {
char * t = _escape_xml(jsonObjectGetString(obj));
- buffer_fadd(res_xml,"<string class_hint=\"%s\">%s</string>", hint, t);
+ osrf_buffer_fadd(res_xml,"<string class_hint=\"%s\">%s</string>", hint, t);
free(t);
} else {
char * t = _escape_xml(jsonObjectGetString(obj));
- buffer_fadd(res_xml,"<string>%s</string>", t);
+ osrf_buffer_fadd(res_xml,"<string>%s</string>", t);
free(t);
}
double x = jsonObjectGetNumber(obj);
if (hint) {
if (x == (int)x)
- buffer_fadd(res_xml,"<number class_hint=\"%s\">%d</number>", hint, (int)x);
+ osrf_buffer_fadd(res_xml,"<number class_hint=\"%s\">%d</number>", hint, (int)x);
else
- buffer_fadd(res_xml,"<number class_hint=\"%s\">%lf</number>", hint, x);
+ osrf_buffer_fadd(res_xml,"<number class_hint=\"%s\">%lf</number>", hint, x);
} else {
if (x == (int)x)
- buffer_fadd(res_xml,"<number>%d</number>", (int)x);
+ osrf_buffer_fadd(res_xml,"<number>%d</number>", (int)x);
else
- buffer_fadd(res_xml,"<number>%lf</number>", x);
+ osrf_buffer_fadd(res_xml,"<number>%lf</number>", x);
}
} else if (obj->type == JSON_ARRAY) {
if (hint)
- buffer_fadd(res_xml,"<array class_hint=\"%s\">", hint);
+
osrf_buffer_fadd(res_xml,"<array class_hint=\"%s\">", hint);
else
- buffer_add(res_xml,"<array>");
+
osrf_buffer_add(res_xml,"<array>");
int i;
for ( i = 0; i!= obj->size; i++ )
_recurse_jsonObjectToXML(jsonObjectGetIndex(obj,i), res_xml);
- buffer_add(res_xml,"</array>");
+ osrf_buffer_add(res_xml,"</array>");
} else if (obj->type == JSON_HASH) {
if (hint)
- buffer_fadd(res_xml,"<object class_hint=\"%s\">", hint);
+ osrf_buffer_fadd(res_xml,"<object class_hint=\"%s\">", hint);
else
- buffer_add(res_xml,"<object>");
+ osrf_buffer_add(res_xml,"<object>");
jsonIterator* itr = jsonNewIterator(obj);
const jsonObject* tmp;
while( (tmp = jsonIteratorNext(itr)) ) {
- buffer_fadd(res_xml,"<element key=\"%s\">",itr->key);
+ osrf_buffer_fadd(res_xml,"<element key=\"%s\">",itr->key);
_recurse_jsonObjectToXML(tmp, res_xml);
- buffer_add(res_xml,"</element>");
+ osrf_buffer_add(res_xml,"</element>");
}
jsonIteratorFree(itr);
- buffer_add(res_xml,"</object>");
+ osrf_buffer_add(res_xml,"</object>");
}
if (hint)
}
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
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;
}
}
obj->type = JSON_NUMBER;
- obj->value.s = buffer_release(buf);
+ obj->value.s = osrf_buffer_release(buf);
return 0;
}
int in_escape = 0;
int done = 0;
- growing_buffer* buf = buffer_init(64);
+ growing_buffer* buf = osrf_buffer_init(64);
while(*index < current_strlen) {
case '\\':
if(in_escape) {
- buffer_add(buf, "\\");
+ osrf_buffer_add(buf, "\\");
in_escape = 0;
} else
in_escape = 1;
case '"':
if(in_escape) {
- buffer_add(buf, "\"");
+ osrf_buffer_add(buf, "\"");
in_escape = 0;
} else
done = 1;
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':
(*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"); }
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);
}
/* ----------------------------------------------------------------------- */
/* ----------------------------------------------------------------------- */
} 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)++;
}
jsonObjectSetString(obj, buf->buf);
- buffer_free(buf);
+ osrf_buffer_free(buf);
return 0;
}
- growing_buffer* buf = buffer_init(64);
+ growing_buffer* buf = osrf_buffer_init(64);
int first_dash = 0;
int second_dash = 0;
}
if(second_dash && in_hint) {
- buffer_add_char(buf, c);
+ osrf_buffer_add_char(buf, c);
break;
}
}
if(second_dash && in_hint) {
- buffer_add_char(buf, c);
+ osrf_buffer_add_char(buf, c);
break;
}
default:
on_star = 0;
if(in_hint)
- buffer_add_char(buf, c);
+ osrf_buffer_add_char(buf, c);
}
(*index)++;
}
if( buf->n_used > 0 && buffer)
- *buffer = buffer_data(buf);
+ *buffer = osrf_buffer_data(buf);
- buffer_free(buf);
+ osrf_buffer_free(buf);
return 0;
}
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:
/* 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;
}
obj = NULL;
}
- buffer_free( parser.str_buf );
+ osrf_buffer_free( parser.str_buf );
return obj;
}
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;
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 );
}
}
- char* s = buffer_data( gb );
+ char* s = osrf_buffer_data( gb );
if( ! jsonIsNumeric( s ) ) {
char* temp = jsonScrubNumber( s );
free( s );
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++ ) {
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 )
// 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 ) {
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());
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;
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.
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;
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);
/* 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 );
} 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 );
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;
}
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 );
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;
}
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;
}
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 );
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 ) {
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;
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.
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.
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;
}
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.
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);
}
@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 );
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;
}
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.
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;
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;
}
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 );
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.
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 );
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.
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--;
return c;
}
+char buffer_chomp(growing_buffer* gb) {
+ return osrf_buffer_chomp(gb);
+}
/**
@brief Append a single character to a growing_buffer.
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;
}
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.
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
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;
}
- buffer_fadd(buf, "\\u%04x", c);
+ osrf_buffer_fadd(buf, "\\u%04x", c);
} else {
- buffer_free(buf);
+ osrf_buffer_free(buf);
return NULL;
}
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);
}
idx++;
}
- return buffer_release(buf);
+ return osrf_buffer_release(buf);
}
projects / working / OpenSRF.git / commitdiff