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; }