void SG_getopt__print_option(SG_context* pCtx, SG_console_stream cs, SG_getopt_option* opt, const char * overrideDesc)
{
SG_string *opts;
if (opt == NULL)
{
SG_ERR_IGNORE( SG_console(pCtx, cs, "?") );
return;
}
SG_ERR_CHECK( SG_string__alloc(pCtx, &opts) );
/* We have a valid option which may or may not have a "short
name" (a single-character alias for the long option). */
if (opt->optch <= 255)
SG_ERR_CHECK( SG_string__sprintf(pCtx, opts, "-%c [--%s]", opt->optch, opt->pStringName) );
else
SG_ERR_CHECK( SG_string__sprintf(pCtx, opts, "--%s", opt->pStringName) );
if (opt->has_arg)
SG_ERR_CHECK( SG_string__append__sz(pCtx, opts, " ARG") );
if (overrideDesc)
SG_ERR_IGNORE( SG_console(pCtx, cs, "%-20s : %s\n", SG_string__sz(opts), overrideDesc) );
else
SG_ERR_IGNORE( SG_console(pCtx, cs, "%-20s : %s\n", SG_string__sz(opts), opt->pStringDescription) );
fail:
SG_STRING_NULLFREE(pCtx, opts);
}
void SG_localsettings__varray__append(SG_context * pCtx, const char* psz_path, const char* pValue)
{
SG_jsondb* p = NULL;
SG_string* pstr = NULL;
SG_varray* pva = NULL;
SG_string* pstr_path_found = NULL;
SG_ASSERT(pCtx);
SG_NONEMPTYCHECK_RETURN(psz_path);
SG_ERR_CHECK( SG_closet__get_localsettings(pCtx, &p) );
SG_ERR_CHECK( SG_localsettings__get__varray(pCtx, psz_path, NULL, &pva, &pstr_path_found) );
if (!pstr_path_found)
{
// this came from factory defaults.
SG_ERR_CHECK( SG_string__alloc(pCtx, &pstr_path_found) );
SG_ERR_CHECK( SG_string__sprintf(pCtx, pstr_path_found, "%s/%s", SG_LOCALSETTING__SCOPE__MACHINE, psz_path) );
SG_ERR_CHECK( SG_localsettings__update__varray(pCtx, SG_string__sz(pstr_path_found), pva) );
}
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &pstr) );
SG_ERR_CHECK( SG_string__sprintf(pCtx, pstr, "%s/#", SG_string__sz(pstr_path_found)) );
SG_ERR_CHECK( SG_jsondb__update__string__sz(pCtx, p, SG_string__sz(pstr), SG_TRUE, pValue) );
fail:
SG_STRING_NULLFREE(pCtx, pstr);
SG_JSONDB_NULLFREE(pCtx, p);
SG_VARRAY_NULLFREE(pCtx, pva);
SG_STRING_NULLFREE(pCtx, pstr_path_found);
}
void SG_localsettings__varray__remove_first_match(SG_context * pCtx, const char* psz_path, const char* psz_val)
{
SG_jsondb* p = NULL;
SG_string* pstr_path_element = NULL;
SG_varray* pva = NULL;
SG_uint32 ndx = 0;
SG_uint32 count = 0;
SG_uint32 i = 0;
SG_bool b_found = SG_FALSE;
SG_string* pstr_path_found = NULL;
SG_ASSERT(pCtx);
SG_NONEMPTYCHECK_RETURN(psz_path);
SG_ERR_CHECK( SG_closet__get_localsettings(pCtx, &p) );
SG_ERR_CHECK( SG_localsettings__get__varray(pCtx, psz_path, NULL, &pva, &pstr_path_found) );
if (pva)
{
if (!pstr_path_found)
{
// this came from factory defaults.
SG_ERR_CHECK( SG_string__alloc(pCtx, &pstr_path_found) );
SG_ERR_CHECK( SG_string__sprintf(pCtx, pstr_path_found, "%s/%s", SG_LOCALSETTING__SCOPE__MACHINE, psz_path) );
SG_ERR_CHECK( SG_localsettings__update__varray(pCtx, SG_string__sz(pstr_path_found), pva) );
}
SG_ERR_CHECK( SG_varray__count(pCtx, pva, &count) );
for (i=0; i<count; i++)
{
const char* psz = NULL;
SG_ERR_CHECK( SG_varray__get__sz(pCtx, pva, i, &psz) );
if (0 == strcmp(psz, psz_val))
{
b_found = SG_TRUE;
ndx = i;
break;
}
}
if (b_found)
{
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &pstr_path_element) );
SG_ERR_CHECK( SG_string__sprintf(pCtx, pstr_path_element, "%s/%d", SG_string__sz(pstr_path_found), ndx) );
SG_ERR_CHECK( SG_jsondb__remove(pCtx, p, SG_string__sz(pstr_path_element)) );
}
}
fail:
SG_VARRAY_NULLFREE(pCtx, pva);
SG_STRING_NULLFREE(pCtx, pstr_path_found);
SG_STRING_NULLFREE(pCtx, pstr_path_element);
SG_JSONDB_NULLFREE(pCtx, p);
}
void SG_repo__dag__find_direct_path_from_root(
SG_context * pCtx,
SG_repo* pRepo,
SG_uint64 dagnum,
const char* psz_csid,
SG_varray** ppva
)
{
SG_varray* new_pva = NULL;
#if SG_DOUBLE_CHECK__PATH_TO_ROOT
SG_varray* old_pva = NULL;
SG_dagnode* pdn = NULL;
char* psz_cur = NULL;
SG_string* pstr1 = NULL;
SG_string* pstr2 = NULL;
#endif
SG_ERR_CHECK( SG_repo__find_dag_path(pCtx, pRepo, dagnum, NULL, psz_csid, &new_pva) );
#if SG_DOUBLE_CHECK__PATH_TO_ROOT
SG_ERR_CHECK( SG_VARRAY__ALLOC(pCtx, &old_pva) );
SG_ERR_CHECK( SG_STRDUP(pCtx, psz_csid, &psz_cur) );
while (1)
{
SG_uint32 count_parents = 0;
const char** a_parents = NULL;
SG_ERR_CHECK( SG_repo__fetch_dagnode(pCtx, pRepo, dagnum, psz_cur, &pdn) );
SG_ERR_CHECK( SG_varray__append__string__sz(pCtx, old_pva, psz_cur) );
SG_ERR_CHECK( SG_dagnode__get_parents__ref(pCtx, pdn, &count_parents, &a_parents) );
if (0 == count_parents)
{
break;
}
SG_NULLFREE(pCtx, psz_cur);
SG_ERR_CHECK( SG_STRDUP(pCtx, a_parents[0], &psz_cur) );
SG_DAGNODE_NULLFREE(pCtx, pdn);
}
SG_ERR_CHECK( SG_varray__append__string__sz(pCtx, old_pva, "") );
SG_ERR_CHECK( SG_string__alloc(pCtx, &pstr1) );
SG_ERR_CHECK( SG_string__alloc(pCtx, &pstr2) );
SG_ERR_CHECK( SG_varray__to_json(pCtx, old_pva, pstr1) );
SG_ERR_CHECK( SG_varray__to_json(pCtx, new_pva, pstr2) );
if (0 != strcmp(SG_string__sz(pstr1), SG_string__sz(pstr2)))
{
// a failure here isn't actually ALWAYS bad. there can be more than one path
// to root.
fprintf(stderr, "old way:\n");
SG_VARRAY_STDERR(old_pva);
fprintf(stderr, "new way:\n");
SG_VARRAY_STDERR(new_pva);
SG_ERR_THROW( SG_ERR_UNSPECIFIED );
}
#endif
*ppva = new_pva;
new_pva = NULL;
fail:
SG_VARRAY_NULLFREE(pCtx, new_pva);
#if SG_DOUBLE_CHECK__PATH_TO_ROOT
SG_STRING_NULLFREE(pCtx, pstr1);
SG_STRING_NULLFREE(pCtx, pstr2);
SG_VARRAY_NULLFREE(pCtx, old_pva);
SG_DAGNODE_NULLFREE(pCtx, pdn);
SG_NULLFREE(pCtx, psz_cur);
#endif
}
static void SG_db__make_delta_from_path(
SG_context* pCtx,
SG_repo* pRepo,
SG_uint64 dagnum,
SG_varray* pva_path,
SG_uint32 flags,
SG_vhash* pvh_add,
SG_vhash* pvh_remove
)
{
#if SG_DOUBLE_CHECK__CALC_DELTA
SG_int64 t1 = -1;
SG_int64 t2 = -1;
SG_vhash* new_pvh_add = NULL;
SG_vhash* new_pvh_remove = NULL;
SG_vhash* old_pvh_add = NULL;
SG_vhash* old_pvh_remove = NULL;
SG_string* old_pstr = NULL;
SG_string* new_pstr = NULL;
SG_ERR_CHECK( SG_vhash__alloc__copy(pCtx, &new_pvh_add, pvh_add) );
SG_ERR_CHECK( SG_vhash__alloc__copy(pCtx, &new_pvh_remove, pvh_remove) );
SG_ERR_CHECK( SG_vhash__alloc__copy(pCtx, &old_pvh_add, pvh_add) );
SG_ERR_CHECK( SG_vhash__alloc__copy(pCtx, &old_pvh_remove, pvh_remove) );
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &t1) );
SG_ERR_CHECK( old_SG_db__make_delta_from_path(
pCtx,
pRepo,
dagnum,
pva_path,
old_pvh_add,
old_pvh_remove
) );
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &t2) );
{
SG_uint32 path_length = 0;
SG_ERR_CHECK( SG_varray__count(pCtx, pva_path, &path_length) );
fprintf(stderr, "make_delta_from_path (%d)\n", path_length);
}
fprintf(stderr, " time old %d ms\n", (int) (t2 - t1));
SG_ERR_CHECK( SG_vhash__sort(pCtx, old_pvh_add, SG_FALSE, SG_vhash_sort_callback__increasing) );
SG_ERR_CHECK( SG_vhash__sort(pCtx, old_pvh_remove, SG_FALSE, SG_vhash_sort_callback__increasing) );
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &t1) );
SG_ERR_CHECK( SG_repo__dbndx__make_delta_from_path(
pCtx,
pRepo,
dagnum,
pva_path,
0,
new_pvh_add,
new_pvh_remove
) );
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &t2) );
fprintf(stderr, " time new %d ms\n", (int) (t2 - t1));
SG_ERR_CHECK( SG_vhash__sort(pCtx, new_pvh_add, SG_FALSE, SG_vhash_sort_callback__increasing) );
SG_ERR_CHECK( SG_vhash__sort(pCtx, new_pvh_remove, SG_FALSE, SG_vhash_sort_callback__increasing) );
SG_ERR_CHECK( SG_string__alloc(pCtx, &old_pstr) );
SG_ERR_CHECK( SG_vhash__to_json(pCtx, old_pvh_add, old_pstr) );
SG_ERR_CHECK( SG_string__alloc(pCtx, &new_pstr) );
SG_ERR_CHECK( SG_vhash__to_json(pCtx, new_pvh_add, new_pstr) );
if (0 != strcmp(SG_string__sz(old_pstr), SG_string__sz(new_pstr)))
{
fprintf(stderr, "oldway:\n");
SG_VHASH_STDERR(old_pvh_add);
fprintf(stderr, "new:\n");
SG_VHASH_STDERR(new_pvh_add);
SG_ERR_THROW( SG_ERR_UNSPECIFIED );
}
SG_STRING_NULLFREE(pCtx, old_pstr);
SG_STRING_NULLFREE(pCtx, new_pstr);
SG_ERR_CHECK( SG_string__alloc(pCtx, &old_pstr) );
SG_ERR_CHECK( SG_vhash__to_json(pCtx, old_pvh_remove, old_pstr) );
SG_ERR_CHECK( SG_string__alloc(pCtx, &new_pstr) );
SG_ERR_CHECK( SG_vhash__to_json(pCtx, new_pvh_remove, new_pstr) );
if (0 != strcmp(SG_string__sz(old_pstr), SG_string__sz(new_pstr)))
{
fprintf(stderr, "oldway:\n");
SG_VHASH_STDERR(old_pvh_remove);
fprintf(stderr, "new:\n");
SG_VHASH_STDERR(new_pvh_remove);
SG_ERR_THROW( SG_ERR_UNSPECIFIED );
}
#endif
#if SG_DOUBLE_CHECK__CALC_DELTA
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &t1) );
#endif
SG_ERR_CHECK( SG_repo__dbndx__make_delta_from_path(
pCtx,
pRepo,
dagnum,
pva_path,
flags,
pvh_add,
pvh_remove
) );
#if SG_DOUBLE_CHECK__CALC_DELTA
SG_ERR_CHECK( SG_time__get_milliseconds_since_1970_utc(pCtx, &t2) );
fprintf(stderr, " time NEW %d ms\n", (int) (t2 - t1));
#endif
fail:
#if SG_DOUBLE_CHECK__CALC_DELTA
SG_STRING_NULLFREE(pCtx, old_pstr);
SG_STRING_NULLFREE(pCtx, new_pstr);
SG_VHASH_NULLFREE(pCtx, old_pvh_add);
SG_VHASH_NULLFREE(pCtx, old_pvh_remove);
SG_VHASH_NULLFREE(pCtx, new_pvh_add);
SG_VHASH_NULLFREE(pCtx, new_pvh_remove);
#endif
;
}
void SG_password__get(
SG_context *pCtx,
const char *szRepoSpec,
const char *szUsername,
SG_string **ppstrPassword)
{
SG_string* pstrTarget = NULL;
SG_string* pstrPassword = NULL;
LPWSTR pwszTarget = NULL;
SG_byte* pbPassword = NULL;
PCREDENTIAL pCred = NULL;
BOOL result = FALSE;
SG_NULLARGCHECK_RETURN(szRepoSpec);
SG_NULLARGCHECK_RETURN(szUsername);
SG_NULLARGCHECK_RETURN(ppstrPassword);
_get_key(pCtx, szRepoSpec, szUsername, &pstrTarget);
if (SG_CONTEXT__HAS_ERR(pCtx))
{
SG_error err, err2;
err2 = SG_context__get_err(pCtx, &err);
if (SG_IS_ERROR(err2))
{
SG_ERR_DISCARD;
SG_ERR_THROW(err2);
}
if (err & __SG_ERR__GETLASTERROR__)
SG_ERR_DISCARD;
else
SG_ERR_RETHROW;
}
if (pstrTarget)
{
SG_ERR_CHECK( SG_utf8__extern_to_os_buffer__wchar(pCtx, SG_string__sz(pstrTarget), &pwszTarget, NULL) );
result = CredReadW(pwszTarget, CRED_TYPE_GENERIC, 0, &pCred);
if (!result)
{
DWORD err = GetLastError();
if (err != ERROR_NOT_FOUND && err != ERROR_NO_SUCH_LOGON_SESSION)
SG_ERR_THROW2( SG_ERR_GETLASTERROR(GetLastError()), (pCtx, "%s", "unable to retrieve saved credentials") );
}
else
{
SG_uint32 size = pCred->CredentialBlobSize+sizeof(wchar_t);
SG_ERR_CHECK( SG_allocN(pCtx, pCred->CredentialBlobSize+sizeof(wchar_t), pbPassword) );
memcpy(pbPassword, pCred->CredentialBlob, size);
SG_ERR_CHECK( SG_string__alloc(pCtx, &pstrPassword) );
SG_ERR_CHECK( SG_utf8__intern_from_os_buffer__wchar(pCtx, pstrPassword, (const LPWSTR)pbPassword) );
*ppstrPassword = pstrPassword;
pstrPassword = NULL;
}
}
/* fall through */
fail:
SG_STRING_NULLFREE(pCtx, pstrTarget);
SG_STRING_NULLFREE(pCtx, pstrPassword);
SG_NULLFREE(pCtx, pwszTarget);
SG_NULLFREE(pCtx, pbPassword);
if (pCred)
CredFree(pCred);
}
