std::string string_printf(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
std::string ret = string_vprintf(fmt, args);
va_end(args);
return ret;
}
void throw_error(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
std::string msg = string_vprintf(fmt, args);
va_end(args);
throw std::runtime_error(msg);
}
void string_printf(string_ptr str, const char *fmt, ...)
{
va_list vp;
va_start(vp, fmt);
string_vprintf(str, fmt, vp);
va_end(vp);
}
/* OpenColumnRead
* VOpenColumnRead
* open a column for read
*
* "col" [ OUT ] - return parameter for newly opened column
*
* "path" [ IN ] - NUL terminated string in UTF-8 giving path to col
* where "." acts as a structure name separator, i.e. struct.member
*/
static
rc_t KDBManagerVOpenColumnReadInt ( const KDBManager *self,
const KColumn **colp, const KDirectory *wd, bool try_srapath,
const char *path, va_list args )
{
char colpath [ 4096 ];
rc_t rc;
size_t z;
/* rc = KDirectoryVResolvePath ( wd, 1,
colpath, sizeof colpath, path, args ); */
rc = string_vprintf( colpath, sizeof colpath, &z, path, args );
if ( rc == 0 )
{
KColumn *col;
const KDirectory *dir;
/* open table directory */
rc = KDBOpenPathTypeRead ( self, wd, colpath, &dir, kptColumn, NULL, try_srapath );
if ( rc == 0 )
{
rc = KColumnMakeRead ( & col, dir, colpath );
if ( rc == 0 )
{
col -> mgr = KDBManagerAttach ( self );
* colp = col;
return 0;
}
KDirectoryRelease ( dir );
}
}
return rc;
}
rc_t vds_append_fmt( p_dump_str s, const size_t aprox_len, const char *fmt, ... )
{
rc_t rc = 0;
if ( s == NULL || fmt == NULL )
{
rc = RC( rcVDB, rcNoTarg, rcInserting, rcParam, rcNull );
}
else if ( fmt[ 0 ] == 0 )
{
rc = RC( rcVDB, rcNoTarg, rcInserting, rcParam, rcEmpty );
}
else if ( ( s->str_limit > 0 )&&( s->str_len >= s->str_limit ) )
{
s->truncated = true;
}
else
{
rc = vds_inc_buffer( s, aprox_len );
if ( rc == 0 )
{
va_list argp;
size_t num_writ;
va_start( argp, fmt );
rc = string_vprintf( s->buf + s->str_len, s->buf_size - 1, &num_writ, fmt, argp );
va_end( argp );
if ( rc == 0 )
rc = vds_truncate( s, num_writ ); /* adjusts str_len */
}
}
return rc;
}
static
rc_t test_vprintf ( const char *expected, const char *fmt, va_list args )
{
rc_t rc;
size_t num_writ;
char buff [ 4096 ];
rc = string_vprintf ( buff, sizeof buff, & num_writ, fmt, args );
if ( rc != 0 )
{
/* report return code */
pLogErr ( klogErr, rc, "string_vprintf returned non-zero rc with format '$(fmt)'", "fmt=%s", fmt );
}
else
{
size_t buff_size;
/* verify results. they are:
1. string itself
2. number of characters in "num_writ"
*/
if ( strcmp ( buff, expected ) != 0 )
{
/* set an appropriate return code */
rc = RC ( rcExe, rcString, rcFormatting, rcData, rcIncorrect );
/* report discrepancy */
pLogErr ( klogErr, rc,
"string_vprintf result differs from expected:\n"
" format - '$(format)'\n"
" expected - '$(expected)'\n"
" observed - '$(observed)'"
, "format=%s,expected=%s,observed=%s"
, fmt
, expected
, buff
);
}
buff_size = strlen ( buff );
if ( buff_size != num_writ )
{
/* report discrepancy */
pLogMsg ( klogErr,
"string_vprintf size differs from expected:\n"
" expected - $(expected)\n"
" observed - $(observed)"
, "expected=%zu,observed=%zu"
, buff_size
, num_writ
);
}
#if 1
rc = 0;
#endif
}
return rc;
}
const char *string_printf(const char *format, ...) {
va_list valist;
va_start(valist, format);
const char *ret = string_vprintf(format, valist);
va_end(valist);
return ret;
}
/* with an RC and a printf-style error message
* records rc, filename and lineno
* uses string_vprintf to build error_msg from fmt + args
*/
Exception :: Exception ( rc_t _rc, const char * _filename, uint32_t _lineno, const char *fmt, ... )
throw ()
: filename ( _filename )
, lineno ( _lineno )
, rc ( _rc )
{
try
{
va_list args;
va_start ( args, fmt );
size_t msg_size;
char msg [ 4096 ];
rc_t print_rc = string_vprintf ( msg, sizeof msg, & msg_size, fmt, args );
va_end ( args );
if ( print_rc == 0 )
error_msg = std :: string ( msg, msg_size );
else
error_msg = std :: string ( "INTERNAL ERROR" );
}
catch ( ... )
{
}
}
rc_t add_cgi_request_param( struct cgi_request * request, const char * fmt, ... )
{
rc_t rc;
if ( request == NULL || fmt == NULL )
rc = RC( rcVDB, rcNoTarg, rcConstructing, rcParam, rcNull );
else
{
va_list args;
char buffer[ 4096 ];
size_t num_writ;
va_start ( args, fmt );
rc = string_vprintf( buffer, sizeof buffer, &num_writ, fmt, args );
if ( rc != 0 )
ErrMsg( "string_vprintf( '%s' ) -> %R", fmt, rc );
else
{
DBGMSG ( DBG_APP, DBG_FLAG ( DBG_APP_1 ), ( "\t%s\n", buffer ) );
rc = VNamelistAppend( request->params, buffer );
if ( rc != 0 )
ErrMsg( "VNamelistAppend( '%s' ) -> %R", buffer, rc );
}
va_end ( args );
}
return rc;
}
LIB_EXPORT rc_t CC KNSManagerVSetHTTPProxyPath ( KNSManager * self, const char * fmt, va_list args )
{
rc_t rc = 0;
if ( self == NULL )
rc = RC ( rcNS, rcMgr, rcUpdating, rcSelf, rcNull );
else
{
uint16_t proxy_port = 0;
const String * proxy = NULL;
if ( fmt != NULL && fmt [ 0 ] != 0 )
{
size_t psize;
char path [ 4096 ];
rc = string_vprintf ( path, sizeof path, & psize, fmt, args );
if ( rc == 0 && psize != 0 )
{
char * colon = string_rchr ( path, psize, ':' );
if ( colon != NULL )
{
char * end;
const char * port_spec = colon + 1;
/* it is true that some day we might read symbolic port names... */
long port_num = strtol ( port_spec, & end, 10 );
if ( port_num <= 0 || port_num >= 0x10000 || end [ 0 ] != 0 )
rc = RC ( rcNS, rcMgr, rcUpdating, rcPath, rcInvalid );
else
{
proxy_port = ( uint64_t ) port_num;
psize = colon - path;
}
}
if ( rc == 0 )
{
String tmp;
StringInit ( & tmp, path, psize, string_len ( path, psize ) );
rc = StringCopy ( & proxy, & tmp );
}
}
}
if ( rc == 0 )
{
if ( self -> http_proxy != NULL )
{
StringWhack ( self -> http_proxy );
self -> http_proxy_port = 0;
}
self -> http_proxy = proxy;
self -> http_proxy_enabled = ( proxy != NULL );
self -> http_proxy_port = proxy_port;
}
}
return rc;
}
std::string string_printf(const char *format, ...)
{
va_list ap;
va_start(ap, format);
std::string s = string_vprintf(format, ap);
va_end(ap);
return s;
}
format (const char *fmt, ...)
{
va_list vp;
va_start (vp, fmt);
std::string result = string_vprintf (fmt, vp);
va_end (vp);
return result;
}
/* VThrow
*/
static
void ErrorVThrow ( JNIEnv * jenv, jclass jexcept_cls,
ctx_t ctx, uint32_t lineno, const char * fmt, va_list args )
{
const char * msg;
/* if the error was from C code, get message */
if ( FAILED () )
msg = WHAT ();
else
{
/* otherwise, use provided message */
rc_t rc;
size_t msg_size = 0;
char msg_buffer [ 4096 ];
#if _DEBUGGING
size_t i;
const char * fname = ctx -> loc -> func;
assert ( fname != NULL );
if ( memcmp ( fname, "Java_", sizeof "Java_" - 1 ) == 0 )
fname += sizeof "Java_" - 1;
rc = string_printf ( msg_buffer, sizeof msg_buffer, & msg_size, "%s:%u ", fname, lineno );
for ( i = 0; i < msg_size; ++ i )
{
if ( msg_buffer [ i ] == '_' )
msg_buffer [ i ] = '.';
}
#endif
rc = string_vprintf ( & msg_buffer [ msg_size ], sizeof msg_buffer - msg_size, NULL, fmt, args );
if ( rc != 0 )
string_printf ( & msg_buffer [ msg_size ], sizeof msg_buffer - msg_size, NULL, "** BAD MESSAGE STRING **" );
msg = msg_buffer;
}
/* create error object, put JVM thread into Exception state */
( ( * jenv ) -> ThrowNew ) ( jenv, jexcept_cls, msg );
/* if error was from C code, pull out stack trace */
if ( FAILED () )
{
jthrowable x = ( * jenv ) -> ExceptionOccurred ( jenv );
if ( x != NULL )
{
/* get the stack depth */
/* allocate array of StackTraceElement */
/* access stack trace from C */
/* walk stack trace, filling in array */
/* set StackTraceElement on "x" */
}
/* don't leave exception on C thread state */
CLEAR ();
}
}
void
gdbscm_printf (SCM port, const char *format, ...)
{
va_list args;
va_start (args, format);
std::string string = string_vprintf (format, args);
va_end (args);
scm_puts (string.c_str (), port);
}
void error(const char *format, ...) {
va_list va;
char *old = error_string;
va_start(va, format);
error_string = string_vprintf(format, va);
va_end(va);
if (old) {
free(old);
}
}
string_ptr string_alloc_format(const char *fmt, ...)
{
string_ptr res = string_alloc_size(128);
va_list vp;
va_start(vp, fmt);
string_vprintf(res, fmt, vp);
va_end(vp);
return res;
}
void
serial_printf (struct serial *desc, const char *format, ...)
{
va_list args;
va_start (args, format);
std::string buf = string_vprintf (format, args);
serial_write (desc, buf.c_str (), buf.length ());
va_end (args);
}
rc_t make_lookup_reader( const KDirectory *dir, const struct index_reader * index,
struct lookup_reader ** reader, size_t buf_size, const char * fmt, ... )
{
rc_t rc;
const struct KFile * f = NULL;
va_list args;
va_start ( args, fmt );
rc = KDirectoryVOpenFileRead( dir, &f, fmt, args );
if ( rc != 0 )
{
char tmp[ 4096 ];
size_t num_writ;
rc_t rc1 = string_vprintf( tmp, sizeof tmp, &num_writ, fmt, args );
if ( rc1 != 0 )
ErrMsg( "make_lookup_reader.KDirectoryVOpenFileRead( '?' ) -> %R", rc );
else
ErrMsg( "make_lookup_reader.KDirectoryVOpenFileRead( '%s' ) -> %R", tmp, rc );
}
else
{
const struct KFile * temp_file = NULL;
rc = KBufFileMakeRead( &temp_file, f, buf_size );
KFileRelease( f );
if ( rc != 0 )
{
ErrMsg( "make_lookup_reader.KBufFileMakeRead() -> %R", rc );
}
else
{
lookup_reader * r = calloc( 1, sizeof * r );
if ( r == NULL )
{
KFileRelease( temp_file );
rc = RC( rcVDB, rcNoTarg, rcConstructing, rcMemory, rcExhausted );
ErrMsg( "make_lookup_reader.calloc( %d ) -> %R", ( sizeof * r ), rc );
}
else
{
r->f = temp_file;
r->index = index;
rc = make_SBuffer( &r->buf, 4096 );
if ( rc == 0 )
*reader = r;
else
release_lookup_reader( r );
}
}
}
va_end ( args );
return rc;
}
static rc_t KNSManagerVMakeUndyingHttpFile(const KNSManager *self, const KFile **file,
struct KStream *conn, ver_t vers, const char *url, va_list args)
{
char buffer[PATH_MAX] = "";
size_t num_writ = 0;
rc_t rc = 0;
KHttpUndyingFile *f = NULL;
if (file == NULL) {
return RC(rcNS, rcFile, rcConstructing, rcParam, rcNull);
}
*file = NULL;
f = calloc(1, sizeof *f);
if (f == NULL) {
return RC(rcNS, rcFile, rcConstructing, rcMemory, rcExhausted);
}
rc = string_vprintf(buffer, sizeof buffer, &num_writ, url, args);
if (rc == 0) {
f->url = string_dup_measure(url, NULL);
}
if (f->url == NULL) {
rc = RC(rcNS, rcFile, rcConstructing, rcMemory, rcExhausted);
}
f->vers = vers;
if (rc == 0) {
rc = KNSManagerAddRef(self);
if (rc == 0) {
f->mgr = self;
}
}
if (rc == 0) {
assert(conn == NULL);
rc = Revive(f);
}
if (rc == 0) {
KHttpUndyingFileSize(f, &f->size);
DBGMSG(DBG_KNS, DBG_FLAG(DBG_KNS_MGR), (
"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@4 %s KNSManagerMakeUndyingHttpFile: size = %ld"
"\n", __FUNCTION__, f->size));
}
if (rc == 0) {
rc = KFileInit(&f->dad, (const KFile_vt*)&vtKHttpFile,
"KHttpUndyingFile", url, true, false);
}
if (rc == 0) {
*file = &f->dad;
}
else {
KHttpUndyingFileDestroy(f);
}
return rc;
}
SCM
gdbscm_scm_from_printf (const char *format, ...)
{
va_list args;
SCM result;
va_start (args, format);
std::string string = string_vprintf (format, args);
va_end (args);
result = scm_from_latin1_string (string.c_str ());
return result;
}
doc_pos_t doc_cprintf(doc_ptr doc, byte a, const char *fmt, ...)
{
string_ptr s = string_alloc();
va_list vp;
va_start(vp, fmt);
string_vprintf(s, fmt, vp);
va_end(vp);
doc_insert_text(doc, a, string_buffer(s));
string_free(s);
return doc->cursor;
}
static int _SilentSystem(const char *fmt, ...) {
rc_t rc = 0;
char buffer[4096];
size_t num_writ = 0;
va_list args;
va_start(args, fmt);
rc = string_vprintf(buffer, sizeof buffer, &num_writ, fmt, args);
va_end(args);
if (rc != 0) {
LOGERR(klogInt, rc, "while making ascp command line");
return 1;
}
return silent_system(buffer);
}
void istring_printf(String& str, size_t level, const char* format, ...)
{
string_append_printf(str, "%*s", int(level * 4), "");
//printf("%*s", int(level * 4), "");
va_list ap;
va_start(ap, format);
String data = string_vprintf(format, ap);
va_end(ap);
str.append(data);
return;
}
/* Make
*/
static
KThreadEvent * KThreadEventMake ( ctx_t ctx,
uint32_t lineno, xc_sev_t severity, xc_org_t origin,
xc_t xc, const char * msg, va_list args )
{
KThreadEvent * evt;
KTime_t ts = KTimeStamp ();
char * c;
size_t num_writ;
char msg_buffer [ 4096 ];
rc_t rc = string_vprintf ( msg_buffer, sizeof msg_buffer, & num_writ, msg, args );
if ( rc != 0 || num_writ >= sizeof msg_buffer )
string_printf ( msg_buffer, sizeof msg_buffer, & num_writ, "** BAD MESSAGE STRING **" );
if ( num_writ > 0 && msg_buffer [ num_writ - 1 ] == '.' )
msg_buffer [ -- num_writ ] = 0;
evt = malloc ( sizeof * evt + num_writ + 1 );
if ( evt == NULL )
{
/* ATTEMPT TO DUMP TO LOG */
KThreadEventDump ( ctx, ts, ctx -> loc, lineno, severity, origin, xc, msg_buffer, NULL );
exit ( -1 );
}
evt -> node = NULL;
evt -> next = NULL;
evt -> xc = ( const XCErr * ) xc;
evt -> timestamp = ts;
evt -> severity = severity;
evt -> origin = origin;
evt -> lineno = lineno;
c = ( char* ) ( evt + 1 );
memmove ( c, msg_buffer, num_writ + 1 );
StringInit ( & evt -> message, c, num_writ, string_len ( c, num_writ ) );
return evt;
}
LIB_EXPORT rc_t CC KNSManagerSetUserAgent ( KNSManager * self, const char * fmt, ... )
{
/* 6/18/14 - don't check "self", since the current implementation
is actually static. Later implementations will not be... */
rc_t rc = 0;
if ( fmt == NULL )
rc = RC( rcNS, rcMgr, rcUpdating, rcParam, rcNull );
else
{
size_t bytes;
char scratch [ sizeof kns_manager_user_agent ];
va_list args;
va_start ( args, fmt );
rc = string_vprintf ( scratch, sizeof scratch, & bytes, fmt, args );
va_end ( args );
if ( rc == 0 )
string_copy ( kns_manager_user_agent, sizeof kns_manager_user_agent, scratch, bytes );
}
return rc;
}
ParseError::ParseError(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
m_what = string_vprintf(fmt, args);
va_end(args);
}
LIB_EXPORT rc_t CC SRAMgrVCreateTable ( SRAMgr *self, SRATable **rslt,
const char *typespec, const char *spec, va_list args )
{
rc_t rc;
if ( rslt == NULL )
rc = RC ( rcSRA, rcTable, rcConstructing, rcParam, rcNull );
else
{
if ( self == NULL )
rc = RC ( rcSRA, rcTable, rcConstructing, rcSelf, rcNull );
else if ( spec == NULL )
rc = RC ( rcSRA, rcTable, rcConstructing, rcString, rcNull );
else if ( spec [ 0 ] == 0 )
rc = RC ( rcSRA, rcTable, rcConstructing, rcString, rcEmpty );
else
{
char path [ 4097 ];
size_t act_size = 0;
rc = string_vprintf(path, 4097, &act_size, spec, args);
path[act_size] = '\0';
if ( rc == 0 )
{
VTable *vtbl;
rc = VDBManagerCreateTable ( self -> vmgr, & vtbl, self -> schema,
typespec, ( self -> mode & kcmBitMask ) | kcmCreate, "%s", path );
if ( rc == 0 )
{
rc = VTableColumnCreateParams ( vtbl, kcmCreate, kcsCRC32, 0 );
if ( rc == 0 )
{
SRATable *tbl = calloc ( 1, sizeof * tbl );
if ( tbl == NULL )
rc = RC ( rcSRA, rcTable, rcConstructing, rcMemory, rcExhausted );
else
{
tbl -> vtbl = vtbl;
rc = VTableOpenMetadataUpdate ( vtbl, & tbl -> meta );
if ( rc == 0 )
rc = KMetadataVersion ( tbl -> meta, & tbl -> metavers );
if ( rc == 0 )
rc = VTableCreateCursorWrite ( vtbl, & tbl -> curs, kcmInsert );
if ( rc == 0 )
{
tbl -> mgr = SRAMgrAttach ( self );
tbl -> mode = self -> mode;
tbl -> read_only = false;
KRefcountInit ( & tbl -> refcount, 1, "SRATable", "OpenTableUpdate", path );
VectorInit ( & tbl -> wcol, 0, 16 );
* rslt = tbl;
return 0;
}
vtbl = NULL;
SRATableWhack ( tbl );
}
}
VTableRelease ( vtbl );
}
}
}
* rslt = NULL;
}
return rc;
}
/* OpenDBRead
* VOpenDBRead
* open a database for read
*
* "db" [ OUT ] - return parameter for newly opened database
*
* "path" [ IN ] - NUL terminated string in
* wd-native character set giving path to database
*/
static
rc_t KDBManagerVOpenDBReadInt ( const KDBManager *cself,
const KDatabase **dbp, KDirectory *wd,
const char *path, va_list args, bool *cached, bool try_srapath )
{
rc_t rc;
char dbpath [4096];
size_t z;
rc = string_vprintf (dbpath, sizeof dbpath, &z, path, args);
if ( rc == 0 )
{
KSymbol *sym;
/* if already open */
sym = KDBManagerOpenObjectFind (cself, dbpath);
if (sym != NULL)
{
const KDatabase *cdb;
rc_t obj;
if ( cached != NULL )
* cached = true;
switch (sym->type)
{
case kptDatabase:
cdb = (KDatabase*)sym->u.obj;
/* if open for update, refuse */
if ( cdb -> read_only )
{
/* attach a new reference and we're gone */
rc = KDatabaseAddRef ( cdb );
if ( rc == 0 )
* dbp = cdb;
return rc;
}
obj = rcDatabase;
break;
default:
obj = rcPath;
break;
case kptTable:
obj = rcTable;
break;
case kptColumn:
obj = rcColumn;
break;
case kptIndex:
obj = rcIndex;
break;
case kptMetadata:
obj = rcMetadata;
break;
}
rc = RC (rcDB, rcMgr, rcOpening, obj, rcBusy);
}
else
{
const KDirectory *dir;
if ( cached != NULL )
* cached = false;
/* open the directory if its a database */
rc = KDBOpenPathTypeRead ( cself, wd, dbpath, &dir, kptDatabase, NULL, try_srapath );
if ( rc == 0 )
{
KDatabase *db;
rc = KDatabaseMake ( &db, dir, dbpath, NULL, true );
if ( rc == 0 )
{
KDBManager *self = ( KDBManager* ) cself;
rc = KDBManagerInsertDatabase ( self, db );
if ( rc == 0 )
{
* dbp = db;
return 0;
}
free (db);
}
KDirectoryRelease (dir);
}
}
}
return rc;
}
static
rc_t CC sts_print(KFmtHandler* formatter, const KStsFmtFlags flags, KWrtHandler* writer, const char* msg, va_list args)
{
rc_t rc = 0;
char* nbuffer;
size_t num_writ, remaining;
uint32_t envc = 0;
wrt_nvp_t envs[5];
char ebuffer[2048];
char mbuffer[2048];
KFmtWriter fmtwrt;
assert(formatter != NULL);
assert(writer != NULL);
fmtwrt = formatter->formatter;
if( fmtwrt == NULL ) {
fmtwrt = KStsDefaultFormatter;
}
if( fmtwrt == KStsDefaultFormatter && writer->writer == NULL ) {
/* default formatting with NULL writer -> silence */
return rc;
}
nbuffer = (char*)ebuffer;
remaining = sizeof(ebuffer);
do {
#define FIX_UP() if(rc){break;} remaining -= num_writ; nbuffer += num_writ
if( flags & (kstsFmtTimestamp | kstsFmtLocalTimestamp) ) {
if( flags & kstsFmtLocalTimestamp ) {
rc = LogSimpleTimestamp(nbuffer, remaining, &num_writ);
} else {
rc = LogTimestamp(nbuffer, remaining, &num_writ);
}
nbuffer[num_writ++] = '\0';
envs[envc].name = "timestamp";
envs[envc++].value = nbuffer;
FIX_UP();
}
if( flags & kstsFmtPid ) {
rc = LogPID(nbuffer, remaining, &num_writ);
nbuffer[num_writ++] = '\0';
envs[envc].name = "pid";
envs[envc++].value = nbuffer;
FIX_UP();
}
if( flags & kstsFmtAppName ) {
rc = LogAppName(nbuffer, remaining, &num_writ);
nbuffer[num_writ++] = '\0';
envs[envc].name = "app";
envs[envc++].value = nbuffer;
FIX_UP();
}
if( flags & kstsFmtAppVersion ) {
rc = LogAppVersion(nbuffer, remaining, &num_writ);
nbuffer[num_writ++] = '\0';
envs[envc].name = "version";
envs[envc++].value = nbuffer;
FIX_UP();
}
#undef FIX_UP
} while(false);
/* env must have one spare element for message added text below */
if( rc == 0 && envc >= (sizeof(envs)/sizeof(envs[0])) ) {
rc = RC(rcRuntime, rcLog, rcLogging, rcTable, rcInsufficient);
}
nbuffer = (char*)mbuffer;
remaining = sizeof(mbuffer);
if( rc == 0 ) {
if( flags & kstsFmtMessage ) {
if( msg == NULL || msg[0] == '\0' ) {
msg = "empty status message";
}
do {
va_list args_copy;
va_copy(args_copy, args);
rc = string_vprintf(nbuffer, remaining, &num_writ, msg, args_copy);
va_end(args_copy);
if( num_writ > remaining ) {
if(nbuffer != mbuffer) {
free(nbuffer);
}
nbuffer = malloc(remaining = num_writ);
if( nbuffer == NULL ) {
rc = RC(rcRuntime, rcLog, rcLogging, rcMemory, rcExhausted);
}
} else {
if( rc == 0 ) {
envs[envc].name = "message";
envs[envc++].value = nbuffer;
}
break;
}
} while( rc == 0 );
}
}
if( rc != 0 ) {
/* print reason for failure */
rc = string_printf((char*)mbuffer, sizeof(mbuffer), NULL, "status failure: %R in '%s'", rc, msg);
envs[envc].name = "message";
envs[envc++].value = mbuffer;
}
wrt_nvp_sort(envc, envs);
rc = fmtwrt(formatter->data, writer, 0, NULL, envc, envs);
if(nbuffer != mbuffer) {
free(nbuffer);
}
return rc;
}
static __inline__
rc_t KQuickMountDirVMakePath (const KQuickMountDir * self, enum RCContext ctx,
bool canon, char * buffer, size_t path_max,
const char * path, va_list args)
{
size_t psize;
size_t bsize;
rc_t rc;
if ( path == NULL )
return RC ( rcFS, rcDirectory, ctx, rcPath, rcNull );
if ( path [ 0 ] == 0 )
return RC ( rcFS, rcDirectory, ctx, rcPath, rcInvalid );
if ( args != NULL && path [ 0 ] == '%' )
{
rc = string_vprintf (buffer, path_max, &psize, path, args);
if (psize > path_max)
return RC ( rcFS, rcDirectory, ctx, rcPath, rcExcessive );
if (rc)
return rc;
if ( buffer [ 0 ] != '/' )
{
bsize = (self->mount - self->path) - 1;
if ( bsize + psize >= path_max )
return RC ( rcFS, rcDirectory, ctx, rcPath, rcExcessive );
memmove ( buffer + bsize, buffer, psize + 1 );
assert ( self -> path [ bsize - 1 ] == '/' );
memcpy ( buffer, self -> path, bsize );
}
else if ( ( bsize = self -> root ) != 0 )
{
if ( bsize + psize >= path_max )
return RC ( rcFS, rcDirectory, ctx, rcPath, rcExcessive );
memmove ( buffer + bsize, buffer, psize + 1 );
assert ( self -> path [ bsize - 1 ] != '/' );
memcpy ( buffer, self -> path, bsize );
}
}
else
{
if ( path [ 0 ] != '/' )
{
/* assert ( self -> path [ self -> size - 1 ] == '/' ); */
memcpy ( buffer, self -> path, bsize = (self->mount - self->path) - 1 );
}
else if ( ( bsize = self -> root ) != 0 )
{
assert ( self -> path [ bsize - 1 ] != '/' );
memcpy ( buffer, self -> path, bsize );
}
rc = string_vprintf ( buffer + bsize, path_max - bsize, &psize, path, args );
if (bsize + psize >= path_max)
return RC ( rcFS, rcDirectory, ctx, rcPath, rcExcessive );
if (rc)
return rc;
}
if ( buffer [ bsize + psize ] == '/' )
buffer [ bsize + -- psize ] = 0;
if ( psize > 0 && ( canon || self -> root != 0 ) )
return KQuickMountDirCanonPath ( self, ctx, buffer, bsize + psize );
return 0;
}
