static bool KNSProxiesHttpProxyInitFromKfg ( KNSProxies * self,
const KConfig * kfg )
{
bool fromKfg = false;
const KConfigNode * proxy;
rc_t rc = KConfigOpenNodeRead ( kfg, & proxy, "/http/proxy" );
if ( rc == 0 ) {
const KConfigNode * proxy_path;
rc = KConfigNodeOpenNodeRead ( proxy, & proxy_path, "path" );
if ( rc == 0 ) {
String * path;
rc = KConfigNodeReadString ( proxy_path, & path );
if ( rc == 0 ) {
DBGMSG ( DBG_KNS, DBG_FLAG ( DBG_KNS_PROXY ),
( "Loading proxy '%S' from configuration\n", path ) );
rc = KNSProxiesAddHTTPProxyPath ( self, "%S", path );
if ( rc == 0 )
fromKfg = true;
StringWhack ( path );
}
KConfigNodeRelease ( proxy_path );
}
KConfigNodeRelease ( proxy );
}
return fromKfg;
}
static
void KNSManagerHttpProxyInit ( KNSManager * self )
{
const KConfigNode * proxy;
rc_t rc = KConfigOpenNodeRead ( self -> kfg, & proxy, "http/proxy" );
if ( rc == 0 )
{
const KConfigNode * proxy_path;
rc = KConfigNodeOpenNodeRead ( proxy, & proxy_path, "path" );
if ( rc == 0 )
{
String * path;
rc = KConfigNodeReadString ( proxy_path, & path );
if ( rc == 0 )
{
rc = KNSManagerSetHTTPProxyPath ( self, "%S", path );
if ( rc == 0 )
{
const KConfigNode * proxy_enabled;
rc = KConfigNodeOpenNodeRead ( proxy, & proxy_enabled, "enabled" );
if ( rc == 0 )
{
rc = KConfigNodeReadBool ( proxy_enabled, & self -> http_proxy_enabled );
KConfigNodeRelease ( proxy_enabled );
}
else if ( GetRCState ( rc ) == rcNotFound )
{
rc = 0;
}
if ( rc != 0 )
{
KNSManagerSetHTTPProxyPath ( self, NULL );
assert ( self -> http_proxy_enabled == false );
}
}
StringWhack ( path );
}
KConfigNodeRelease ( proxy_path );
}
KConfigNodeRelease ( proxy );
}
}
/* CacheEnabled
* discover whether the repository supports caching
*/
LIB_EXPORT bool CC KRepositoryCacheEnabled ( const KRepository *self )
{
if ( self != NULL )
{
const KConfigNode *node;
rc_t rc = KConfigNodeOpenNodeRead ( self -> node, & node, "cache-enabled" );
if ( rc == 0 )
{
bool enabled = false;
rc = KConfigNodeReadBool ( node, & enabled );
KConfigNodeRelease ( node );
if ( rc == 0 )
return enabled;
}
}
return false;
}
static
rc_t KRepositoryMgrCategoryRepositories ( const KConfigNode *cat,
KRepCategory category, KRepositoryVector *repositories )
{
KNamelist *sub_names;
rc_t rc = KConfigNodeListChildren ( cat, & sub_names );
if ( rc == 0 )
{
uint32_t i, count;
rc = KNamelistCount ( sub_names, & count );
for ( i = 0; i < count && rc == 0; ++ i )
{
const char *sub_name;
rc = KNamelistGet ( sub_names, i, & sub_name );
if ( rc == 0 )
{
KRepSubCategory subcategory = krepBadSubCategory;
if ( strcmp ( "main", sub_name ) == 0 )
subcategory = krepMainSubCategory;
else if ( strcmp ( "aux", sub_name ) == 0 )
subcategory = krepAuxSubCategory;
else if ( strcmp ( "protected", sub_name ) == 0 )
subcategory = krepProtectedSubCategory;
if ( subcategory != krepBadSubCategory )
{
const KConfigNode *sub;
rc = KConfigNodeOpenNodeRead ( cat, & sub, sub_name );
if ( rc == 0 )
{
rc = KRepositoryMgrSubCategoryRepositories ( sub, category, subcategory, repositories );
KConfigNodeRelease ( sub );
}
}
}
}
KNamelistRelease ( sub_names );
}
return rc;
}
static
rc_t KRepositoryMgrSubCategoryRepositories ( const KConfigNode *sub,
KRepCategory category, KRepSubCategory subcategory, KRepositoryVector *repositories )
{
KNamelist *repo_names;
rc_t rc = KConfigNodeListChildren ( sub, & repo_names );
if ( rc == 0 )
{
uint32_t i, count;
rc = KNamelistCount ( repo_names, & count );
for ( i = 0; i < count && rc == 0; ++ i )
{
const char *repo_name;
rc = KNamelistGet ( repo_names, i, & repo_name );
if ( rc == 0 )
{
const KConfigNode *node;
rc = KConfigNodeOpenNodeRead ( sub, & node, repo_name );
if ( rc == 0 )
{
KRepository *repo;
rc = KRepositoryMake ( & repo, node, repo_name, category, subcategory );
if ( rc == 0 )
{
rc = VectorAppend ( repositories, NULL, repo );
if ( rc != 0 )
KRepositoryWhack ( repo );
}
KConfigNodeRelease ( node );
}
}
}
KNamelistRelease ( repo_names );
}
return rc;
}
/* DisplayName
* get the repository display name,
* if different from its actual name
*
* attempts to copy NUL-terminated name into provided buffer
*
* "buffer" [ OUT ] and "bsize" [ IN ] - name output parameter
*
* "name_size" [ OUT, NULL OKAY ] - returns the name size in
* bytes, excluding any NUL termination.
*/
LIB_EXPORT rc_t CC KRepositoryDisplayName ( const KRepository *self,
char *buffer, size_t bsize, size_t *name_size )
{
rc_t rc;
if ( self == NULL )
rc = RC ( rcKFG, rcNode, rcAccessing, rcSelf, rcNull );
else
{
const KConfigNode *node;
if ( name_size != NULL )
* name_size = 0;
rc = KConfigNodeOpenNodeRead ( self -> node, & node, "display-name" );
if ( rc != 0 )
rc = KRepositoryName ( self, buffer, bsize, name_size );
else
{
size_t num_read, remaining;
rc = KConfigNodeRead ( node, 0, buffer, bsize, & num_read, & remaining );
KConfigNodeRelease ( node );
if ( rc == 0 )
{
if ( name_size != NULL )
* name_size = num_read + remaining;
if ( remaining != 0 )
rc = RC ( rcKFG, rcNode, rcAccessing, rcBuffer, rcInsufficient );
else if ( num_read < bsize )
buffer [ num_read ] = 0;
}
}
}
return rc;
}
/* EncryptionKeyFile
* return path to any associated encryption key file
*
* attempts to copy NUL-terminated path into provided buffer
*
* "buffer" [ OUT ] and "bsize" [ IN ] - key file path output parameter
*
* "path_size" [ OUT, NULL OKAY ] - returns the path size in
* bytes, excluding any NUL termination.
*/
LIB_EXPORT rc_t CC KRepositoryEncryptionKeyFile ( const KRepository *self,
char *buffer, size_t bsize, size_t *path_size )
{
rc_t rc;
if ( self == NULL )
rc = RC ( rcKFG, rcNode, rcAccessing, rcSelf, rcNull );
else
{
const KConfigNode *node;
if ( path_size != NULL )
* path_size = 0;
rc = KConfigNodeOpenNodeRead ( self -> node, & node, "encryption-key-path" );
if ( rc == 0 )
{
size_t num_read, remaining;
rc = KConfigNodeRead ( node, 0, buffer, bsize, & num_read, & remaining );
KConfigNodeRelease ( node );
if ( rc == 0 )
{
if ( path_size != NULL )
* path_size = num_read + remaining;
if ( remaining != 0 )
rc = RC ( rcKFG, rcNode, rcAccessing, rcBuffer, rcInsufficient );
else if ( num_read < bsize )
buffer [ num_read ] = 0;
}
}
}
return rc;
}
static rc_t KConfigNodePrintChildNames(bool xml, const KConfigNode* self,
const char* name, int indent, const char* aFullpath)
{
rc_t rc = 0;
uint32_t count = 0;
int i = 0;
char buffer[512] = "";
size_t num_read = 0;
bool hasChildren = false;
bool hasData = false;
const KConfigNode* node = NULL;
KNamelist* names = NULL;
assert(self && name);
if (rc == 0)
{ rc = KConfigNodeOpenNodeRead(self, &node, name); }
if (rc == 0) {
rc = KConfigNodeReadData(node, buffer, sizeof buffer, &num_read);
hasData = num_read;
if (hasData) {
/* VDB_CONGIG_OUTMSG(("\n%s = \"%.*s\"\n\n", aFullpath, num_read, buffer)); */
}
}
if (rc == 0)
{ rc = KConfigNodeListChild(node, &names); }
if (rc == 0) {
rc = KNamelistCount(names, &count);
hasChildren = count;
}
Indent(xml, indent);
VDB_CONGIG_OUTMSG(("<%s", name));
if (!hasChildren && !hasData)
{ VDB_CONGIG_OUTMSG(("/>\n")); }
else
{ VDB_CONGIG_OUTMSG((">")); }
if (hasData) {
if (xml) {
VDB_CONGIG_OUTMSG(("%.*s", (int)num_read, buffer));
}
else
{ OUTMSG(("%s = \"%.*s\"\n", aFullpath, (int)num_read, buffer)); }
}
if (hasChildren)
{ VDB_CONGIG_OUTMSG(("\n"));}
if (hasChildren) {
for (i = 0; i < count && rc == 0; ++i) {
char* fullpath = NULL;
const char* name = NULL;
rc = KNamelistGet(names, i, &name);
if (rc == 0) {
fullpath = malloc(strlen(aFullpath) + 1 + strlen(name) + 1);
if (fullpath == NULL) {
rc = RC
(rcExe, rcStorage, rcAllocating, rcMemory, rcExhausted);
}
else {
sprintf(fullpath, "%s/%s", aFullpath, name);
}
}
if (rc == 0) {
rc = KConfigNodePrintChildNames
(xml, node, name, indent + 1, fullpath);
}
free(fullpath);
}
}
if (hasChildren)
{ Indent(xml, indent); }
if (hasChildren || hasData)
{ VDB_CONGIG_OUTMSG(("</%s>\n",name)); }
RELEASE(KNamelist, names);
RELEASE(KConfigNode, node);
return rc;
}
static
void KNSManagerLoadAWS ( struct KNSManager *self )
{
rc_t rc;
const KConfigNode *aws_node;
const KConfig *kfg = self -> kfg;
if ( self == NULL )
return;
rc = KConfigOpenNodeRead ( kfg, &aws_node, "AWS" );
if ( rc == 0 )
{
do
{
String *access_key_id = NULL, *secret_access_key = NULL, *region = NULL, *output = NULL;
const KConfigNode *access_key_id_node, *secret_access_key_node, *region_node, *output_node;
rc = KConfigNodeOpenNodeRead ( aws_node, &access_key_id_node, "aws_access_key_id" );
if ( rc == 0 )
{
rc = KConfigNodeReadString ( access_key_id_node, &access_key_id );
KConfigNodeRelease ( access_key_id_node );
if( rc != 0 )
break;
}
rc = KConfigNodeOpenNodeRead ( aws_node, &secret_access_key_node, "aws_secret_access_key" );
if ( rc == 0 )
{
rc = KConfigNodeReadString ( secret_access_key_node, &secret_access_key );
KConfigNodeRelease ( secret_access_key_node );
if ( rc != 0 )
break;
}
rc = KConfigNodeOpenNodeRead ( aws_node, ®ion_node, "region" );
if ( rc == 0 )
{
rc = KConfigNodeReadString ( region_node, ®ion );
KConfigNodeRelease ( region_node );
if ( rc != 0 )
break;
}
rc = KConfigNodeOpenNodeRead ( aws_node, &output_node, "output" );
if ( rc == 0 )
{
rc = KConfigNodeReadString ( output_node, &output );
KConfigNodeRelease ( output_node );
if ( rc != 0 )
break;
}
self -> aws_access_key_id = access_key_id;
self -> aws_secret_access_key = secret_access_key;
self -> aws_region = region;
self -> aws_output = output;
} while ( 0 );
KConfigNodeRelease ( aws_node );
}
}
/* EncryptionKey
* return any associated encryption key
*
* attempts to copy NUL-terminated key into provided buffer
*
* "buffer" [ OUT ] and "bsize" [ IN ] - encryption key output parameter
*
* "key_size" [ OUT, NULL OKAY ] - returns the key size in
* bytes, excluding any NUL termination.
*/
LIB_EXPORT rc_t CC KRepositoryEncryptionKey ( const KRepository *self,
char *buffer, size_t bsize, size_t *key_size )
{
rc_t rc;
if ( self == NULL )
rc = RC ( rcKFG, rcNode, rcAccessing, rcSelf, rcNull );
else
{
const KConfigNode *node;
if ( key_size != NULL )
* key_size = 0;
rc = KConfigNodeOpenNodeRead ( self -> node, & node, "encryption-key" );
if ( rc == 0 )
{
size_t num_read, remaining;
rc = KConfigNodeRead ( node, 0, buffer, bsize, & num_read, & remaining );
KConfigNodeRelease ( node );
if ( rc == 0 )
{
if ( key_size != NULL )
* key_size = num_read + remaining;
if ( remaining != 0 )
rc = RC ( rcKFG, rcNode, rcAccessing, rcBuffer, rcInsufficient );
else if ( num_read < bsize )
memset ( & buffer [ num_read ], 0, bsize - num_read );
}
}
else if ( GetRCState ( rc ) == rcNotFound )
{
char path [ 4096 ];
rc_t rc2 = KRepositoryEncryptionKeyFile ( self, path, sizeof path, NULL );
if ( rc2 == 0 )
{
KDirectory *wd;
rc2 = KDirectoryNativeDir ( & wd );
if ( rc2 == 0 )
{
const KFile *keyFile;
rc2 = KDirectoryOpenFileRead ( wd, & keyFile, path );
KDirectoryRelease ( wd );
if ( rc2 == 0 )
{
size_t num_read;
rc = KFileReadAll ( keyFile, 0, buffer, bsize, & num_read );
if ( rc == 0 )
{
if ( num_read == bsize )
{
uint64_t eof;
rc = KFileSize ( keyFile, & eof );
if ( rc == 0 )
num_read = ( size_t ) eof;
else
num_read = 0;
rc = RC ( rcKFG, rcFile, rcReading, rcBuffer, rcInsufficient );
memset ( buffer, 0, bsize );
}
else if ( num_read == 0 )
{
rc = RC ( rcKFG, rcFile, rcReading, rcFile, rcEmpty );
memset ( buffer, 0, bsize );
}
else
{
char *eoln = string_chr ( buffer, num_read, '\n' );
if ( eoln != NULL )
{
if ( eoln == buffer )
num_read = 0;
else if ( eoln [ -1 ] == '\r' )
num_read = eoln - buffer - 1;
else
num_read = eoln - buffer;
}
if ( key_size != NULL )
* key_size = num_read;
memset ( & buffer [ num_read ], 0, bsize - num_read );
}
}
KFileRelease ( keyFile );
}
}
}
}
}
return rc;
}
