void SetProfileSettings(
SG_context* pCtx,
const char* szProfile,
const char* pszDest,
const char* pszSrc,
SG_int64 lSyncIntervalMinutes)
{
SG_string* pstrConfigPath = NULL;
SG_ERR_CHECK( SG_string__alloc__format(pCtx, &pstrConfigPath, "%s/%s/%s", CONFIG_ROOT, szProfile, CONFIG_DEST) );
SG_ERR_CHECK( SG_localsettings__update__sz(pCtx, SG_string__sz(pstrConfigPath), pszDest) );
SG_ERR_CHECK( SG_string__clear(pCtx, pstrConfigPath) );
SG_ERR_CHECK( SG_string__append__format(pCtx, pstrConfigPath, "%s/%s/%s", CONFIG_ROOT, szProfile, CONFIG_SRC) );
SG_ERR_CHECK( SG_localsettings__update__sz(pCtx, SG_string__sz(pstrConfigPath), pszSrc) );
SG_ERR_CHECK( SG_string__clear(pCtx, pstrConfigPath) );
SG_ERR_CHECK( SG_string__append__format(pCtx, pstrConfigPath, "%s/%s/%s", CONFIG_ROOT, szProfile, CONFIG_INTERVAL) );
SG_ERR_CHECK( SG_localsettings__update__int64(pCtx, SG_string__sz(pstrConfigPath), lSyncIntervalMinutes) );
/* common cleanup */
fail:
SG_STRING_NULLFREE(pCtx, pstrConfigPath);
}
void sg_wc_db__path__generate_backup_path(SG_context * pCtx,
const sg_wc_db * pDb,
const char * pszGid,
const char * pszEntryname,
SG_pathname ** ppPathBackup)
{
SG_pathname * pPath = NULL;
SG_string * pString = NULL;
SG_uint32 k = 0;
SG_bool bExists;
// TODO 2011/10/25 assert no slashes in entryname.
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &pString) );
for (k=0; k<100; k++)
{
SG_ERR_CHECK( SG_string__clear(pCtx, pString) );
SG_ERR_CHECK( SG_string__sprintf(pCtx, pString, SG_BACKUP_FORMAT, pszGid, pszEntryname, k) );
SG_ERR_CHECK( SG_PATHNAME__ALLOC__PATHNAME_SZ(pCtx, &pPath, pDb->pPathWorkingDirectoryTop, SG_string__sz(pString)) );
SG_ERR_CHECK( SG_fsobj__exists__pathname(pCtx, pPath, &bExists, NULL, NULL) );
if (!bExists)
break;
SG_PATHNAME_NULLFREE(pCtx, pPath);
}
if (k == 100)
{
SG_ERR_THROW2( SG_ERR_TOO_MANY_BACKUP_FILES, (pCtx, "%s", pszEntryname) );
}
*ppPathBackup = pPath;
pPath = NULL;
fail:
SG_PATHNAME_NULLFREE(pCtx, pPath);
SG_STRING_NULLFREE(pCtx, pString);
}
void GetProfileSettings(
SG_context* pCtx,
const char* szProfile,
char** ppszDest,
char** ppszSrc,
SG_int64* plSyncIntervalMinutes,
LPWSTR* ppwszErr)
{
static const LPWSTR ERR_NO_DEST = L"No destination repository is configured.";
static const LPWSTR ERR_NO_SRC = L"No source repository is configured.";
char* pszDest = NULL;
char* pszSrc = NULL;
SG_variant* pvMinutes = NULL;
SG_string* pstrConfigPath = NULL;
SG_uint64 lMinutes;
LPWSTR pwszErr = NULL;
/* It's kind of icky, but we copy these error strings so the balloon code that displays them doesn't have to
be very smart and can always free the message string. (Generic unhandled errors aren't constant, so it has
to free those.) I'm not sure making the balloon code more complexso this can be simpler is a net win, so I'm
leaving this be. But it is icky. */
SG_ERR_CHECK( SG_string__alloc__format(pCtx, &pstrConfigPath, "%s/%s/%s", CONFIG_ROOT, szProfile, CONFIG_DEST) );
SG_ERR_CHECK( SG_localsettings__get__sz(pCtx, SG_string__sz(pstrConfigPath), NULL, &pszDest, NULL) );
SG_ERR_CHECK( SG_string__clear(pCtx, pstrConfigPath) );
if (!pszDest || !pszDest[0])
{
size_t len_in_chars = 0;
if (FAILED( StringCchLength(ERR_NO_DEST, STRSAFE_MAX_CCH, &len_in_chars) ))
SG_ERR_THROW(SG_ERR_GETLASTERROR(GetLastError()));
pwszErr = (LPWSTR)malloc(sizeof(wchar_t) * (len_in_chars + 1));
if (FAILED( StringCchCopy(pwszErr, len_in_chars + 1, ERR_NO_DEST) ))
SG_ERR_THROW(SG_ERR_GETLASTERROR(GetLastError()));
}
SG_ERR_CHECK( SG_string__append__format(pCtx, pstrConfigPath, "%s/%s/%s", CONFIG_ROOT, szProfile, CONFIG_SRC) );
SG_ERR_CHECK( SG_localsettings__get__sz(pCtx, SG_string__sz(pstrConfigPath), NULL, &pszSrc, NULL) );
SG_ERR_CHECK( SG_string__clear(pCtx, pstrConfigPath) );
if (!pwszErr)
{
if (!pszSrc || !pszSrc[0])
{
size_t len_in_chars = 0;
if (FAILED( StringCchLength(ERR_NO_SRC, STRSAFE_MAX_CCH, &len_in_chars) ))
SG_ERR_THROW(SG_ERR_GETLASTERROR(GetLastError()));
pwszErr = (LPWSTR)malloc(sizeof(wchar_t) * (len_in_chars + 1));
if (FAILED( StringCchCopy(pwszErr, len_in_chars + 1, ERR_NO_SRC) ))
SG_ERR_THROW(SG_ERR_GETLASTERROR(GetLastError()));
}
}
SG_ERR_CHECK( SG_string__append__format(pCtx, pstrConfigPath, "%s/%s/%s", CONFIG_ROOT, szProfile, CONFIG_INTERVAL) );
SG_ERR_CHECK( SG_localsettings__get__variant(pCtx, SG_string__sz(pstrConfigPath), NULL, &pvMinutes, NULL) );
if (!pvMinutes)
lMinutes = DEFAULT_SYNC_EVERY_N_MINUTES;
else
SG_ERR_CHECK( SG_variant__get__uint64(pCtx, pvMinutes, &lMinutes) );
if (plSyncIntervalMinutes)
*plSyncIntervalMinutes = lMinutes;
SG_RETURN_AND_NULL(pszDest, ppszDest);
SG_RETURN_AND_NULL(pszSrc, ppszSrc);
SG_RETURN_AND_NULL(pwszErr, ppwszErr);
/* common cleanup */
fail:
SG_NULLFREE(pCtx, pszDest);
SG_NULLFREE(pCtx, pszSrc);
SG_VARIANT_NULLFREE(pCtx, pvMinutes);
SG_STRING_NULLFREE(pCtx, pstrConfigPath);
if (pwszErr)
free(pwszErr);
}
void SG_cmd_util__get_username_for_repo(
SG_context *pCtx,
const char *szRepoName,
char **ppUsername
)
{
SG_string * pUsername = NULL;
SG_repo * pRepo = NULL;
char * psz_username = NULL;
SG_curl * pCurl = NULL;
SG_string * pUri = NULL;
SG_string * pResponse = NULL;
SG_int32 responseStatusCode = 0;
SG_vhash * pRepoInfo = NULL;
char * psz_userid = NULL;
SG_varray * pUsers = NULL;
SG_NULLARGCHECK_RETURN(ppUsername);
if(!szRepoName)
{
// Look up username based on 'whoami' of repo associated with cwd.
SG_ERR_IGNORE( SG_cmd_util__get_repo_from_cwd(pCtx, &pRepo, NULL) );
if(pRepo)
SG_ERR_IGNORE( SG_user__get_username_for_repo(pCtx, pRepo, &psz_username) );
SG_REPO_NULLFREE(pCtx, pRepo);
}
else if(SG_sz__starts_with(szRepoName, "http://") || SG_sz__starts_with(szRepoName, "https://"))
{
// Look up username based on 'whoami' of admin id of remote repo.
SG_ERR_CHECK( SG_curl__alloc(pCtx, &pCurl) );
SG_ERR_CHECK( SG_STRING__ALLOC__SZ(pCtx, &pUri, szRepoName) );
SG_ERR_CHECK( SG_string__append__sz(pCtx, pUri, ".json") );
SG_ERR_CHECK( SG_curl__reset(pCtx, pCurl) );
SG_ERR_CHECK( SG_curl__setopt__sz(pCtx, pCurl, CURLOPT_URL, SG_string__sz(pUri)) );
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &pResponse) );
SG_ERR_CHECK( SG_curl__set__write_string(pCtx, pCurl, pResponse) );
SG_ERR_CHECK( SG_curl__perform(pCtx, pCurl) );
SG_ERR_CHECK( SG_curl__getinfo__int32(pCtx, pCurl, CURLINFO_RESPONSE_CODE, &responseStatusCode) );
if(responseStatusCode==200)
{
const char * szAdminId = NULL;
SG_ERR_CHECK( SG_VHASH__ALLOC__FROM_JSON__STRING(pCtx, &pRepoInfo, pResponse) );
SG_ERR_CHECK( SG_vhash__get__sz(pCtx, pRepoInfo, SG_SYNC_REPO_INFO_KEY__ADMIN_ID, &szAdminId) );
SG_ERR_CHECK( SG_string__clear(pCtx, pUri) );
SG_ERR_CHECK( SG_string__append__format(pCtx, pUri, "/admin/%s/whoami/userid", szAdminId) );
SG_ERR_IGNORE( SG_localsettings__get__sz(pCtx, SG_string__sz(pUri), NULL, &psz_userid, NULL) );
if(psz_userid)
{
// We now have the userid. Look up the username.
SG_ERR_CHECK( SG_string__clear(pCtx, pUri) );
SG_ERR_CHECK( SG_string__append__format(pCtx, pUri, "%s/users.json", szRepoName) );
SG_ERR_CHECK( SG_curl__reset(pCtx, pCurl) );
SG_ERR_CHECK( SG_curl__setopt__sz(pCtx, pCurl, CURLOPT_URL, SG_string__sz(pUri)) );
SG_ERR_CHECK( SG_string__clear(pCtx, pResponse) );
SG_ERR_CHECK( SG_curl__set__write_string(pCtx, pCurl, pResponse) );
SG_ERR_CHECK( SG_curl__perform(pCtx, pCurl) );
SG_ERR_CHECK( SG_curl__getinfo__int32(pCtx, pCurl, CURLINFO_RESPONSE_CODE, &responseStatusCode) );
if(responseStatusCode==200)
{
SG_uint32 i, nUsers;
SG_ERR_CHECK( SG_VARRAY__ALLOC__FROM_JSON__STRING(pCtx, &pUsers, pResponse) );
SG_ERR_CHECK( SG_varray__count(pCtx, pUsers, &nUsers) );
for(i=0; i<nUsers; ++i)
{
SG_vhash * pUser = NULL;
const char * psz_recid = NULL;
SG_ERR_CHECK( SG_varray__get__vhash(pCtx, pUsers, i, &pUser) );
SG_ERR_CHECK( SG_vhash__get__sz(pCtx, pUser, "recid", &psz_recid) );
if(!strcmp(psz_recid, psz_userid))
{
const char * psz_name = NULL;
SG_ERR_CHECK( SG_vhash__get__sz(pCtx, pUser, "name", &psz_name) );
SG_ERR_CHECK( SG_STRDUP(pCtx, psz_name, &psz_username) );
break;
}
}
SG_VARRAY_NULLFREE(pCtx, pUsers);
}
SG_NULLFREE(pCtx, psz_userid);
}
SG_VHASH_NULLFREE(pCtx, pRepoInfo);
}
SG_STRING_NULLFREE(pCtx, pResponse);
SG_STRING_NULLFREE(pCtx, pUri);
SG_CURL_NULLFREE(pCtx, pCurl);
}
else
{
// Look up username based on 'whoami' of repo provided.
SG_ERR_CHECK( SG_REPO__OPEN_REPO_INSTANCE(pCtx, szRepoName, &pRepo) );
SG_ERR_IGNORE( SG_user__get_username_for_repo(pCtx, pRepo, &psz_username) );
SG_REPO_NULLFREE(pCtx, pRepo);
}
*ppUsername = psz_username;
return;
fail:
SG_STRING_NULLFREE(pCtx, pUsername);
SG_REPO_NULLFREE(pCtx, pRepo);
SG_NULLFREE(pCtx, psz_username);
SG_CURL_NULLFREE(pCtx, pCurl);
SG_STRING_NULLFREE(pCtx, pUri);
SG_STRING_NULLFREE(pCtx, pResponse);
SG_VHASH_NULLFREE(pCtx, pRepoInfo);
SG_NULLFREE(pCtx, psz_userid);
SG_VARRAY_NULLFREE(pCtx, pUsers);
}
static void _templatize(
SG_context *pCtx,
SG_string *content,
const _request_headers *pRequestHeaders,
_replacer_cb replacer)
{
SG_string *instr = NULL;
const char *next = NULL;
SG_string *piece = NULL;
SG_string *replacement = NULL;
SG_string *inclusion = NULL;
SG_string *replaceRaw = NULL;
SG_ERR_CHECK( SG_STRING__ALLOC__COPY(pCtx, &instr, content) );
SG_ERR_CHECK( SG_string__clear(pCtx, content) );
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &piece) );
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &replacement) );
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &replaceRaw) );
next = SG_string__sz(instr);
while (*next)
{
const char *delim = strstr(next, "{{{");
if (delim == NULL)
{
SG_ERR_CHECK( SG_string__append__sz(pCtx, content, next) );
break;
}
else
{
const char *rest = delim + 3;
const char *end = strstr(rest, "}}}");
if (end == NULL)
{
SG_ERR_CHECK( SG_string__append__sz(pCtx, content, next) );
break;
}
SG_ERR_CHECK( SG_string__append__buf_len(pCtx, content, (const SG_byte *)next, (delim - next) * sizeof(char)) );
SG_ERR_CHECK( SG_string__clear(pCtx, piece) );
SG_ERR_CHECK( SG_string__clear(pCtx, replacement) );
SG_ERR_CHECK( SG_string__append__buf_len(pCtx, piece, (const SG_byte *)rest, (end - rest) * sizeof(char)) );
SG_ERR_CHECK( SG_string__append__string(pCtx, replacement, piece) );
if (SG_string__sz(piece)[0] == '<')
{
SG_string__remove(pCtx, piece, 0, 1);
SG_ASSERT(inclusion == NULL);
SG_ERR_CHECK( _read_template_file(pCtx, SG_string__sz(piece), &inclusion, pRequestHeaders, replacer) );
SG_STRING_NULLFREE(pCtx, replacement);
replacement = inclusion;
inclusion = NULL;
}
else
{
SG_bool needEncoding = SG_TRUE;
SG_ERR_CHECK( replacer(pCtx, pRequestHeaders, piece, replaceRaw) );
// no verb-specific replacement? try generics
if (sgeq(piece, replacement))
{
SG_ERR_CHECK( _default_replacer(pCtx, pRequestHeaders, piece, replaceRaw, &needEncoding) );
}
if (needEncoding)
SG_ERR_CHECK( SG_htmlencode(pCtx, replaceRaw, replacement) );
else
SG_ERR_CHECK( SG_string__set__string(pCtx, replacement, replaceRaw) );
}
SG_ERR_CHECK( SG_string__append__string(pCtx, content, replacement) );
next = end + 3;
}
}
fail:
SG_STRING_NULLFREE(pCtx, instr);
SG_STRING_NULLFREE(pCtx, piece);
SG_STRING_NULLFREE(pCtx, replacement);
SG_STRING_NULLFREE(pCtx, replaceRaw);
SG_STRING_NULLFREE(pCtx, inclusion);
}
static void _fillInUserSelection(
SG_context *pCtx,
SG_string *pstrRepoDescriptorName,
SG_string *replacement)
{
SG_repo *repo = NULL;
SG_varray *users = NULL;
SG_vhash *user = NULL;
SG_uint32 i = 0;
SG_uint32 count;
SG_string *semail = NULL;
SG_string *suid = NULL;
SG_string *entry = NULL;
SG_string *curuid = NULL;
SG_ERR_CHECK( SG_string__clear(pCtx, replacement) );
SG_ERR_CHECK( SG_repo__open_repo_instance(pCtx, SG_string__sz(pstrRepoDescriptorName), &repo) );
SG_ERR_CHECK( SG_user__list_all(pCtx, repo, &users) );
SG_ERR_CHECK( SG_varray__count(pCtx, users, &count) );
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &semail) );
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &suid) );
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &entry) );
SG_ERR_CHECK( SG_STRING__ALLOC(pCtx, &curuid) );
SG_ERR_CHECK( _getUserId(pCtx, repo, curuid) );
for ( i = 0; i < count; ++i )
{
const char *uid = NULL;
const char *email = NULL;
const char *selected = NULL;
SG_ERR_CHECK( SG_varray__get__vhash(pCtx, users, i, &user) );
SG_ERR_CHECK( SG_vhash__get__sz(pCtx, user, "recid", &uid) );
SG_ERR_CHECK( SG_vhash__get__sz(pCtx, user, "email", &email) );
SG_ERR_CHECK( _getEncoded(pCtx, uid, suid) );
SG_ERR_CHECK( _getEncoded(pCtx, email, semail) );
if (eq(SG_string__sz(curuid), uid))
{
selected = " selected='selected' ";
}
else
{
selected = "";
}
SG_ERR_CHECK( SG_string__sprintf(pCtx, entry, "<option value=\"%s\" %s>%s</option>",
SG_string__sz(suid), selected, SG_string__sz(semail)) );
SG_ERR_CHECK( SG_string__append__string(pCtx, replacement, entry) );
}
fail:
SG_VARRAY_NULLFREE(pCtx, users);
SG_REPO_NULLFREE(pCtx, repo);
SG_STRING_NULLFREE(pCtx, semail);
SG_STRING_NULLFREE(pCtx, suid);
SG_STRING_NULLFREE(pCtx, entry);
SG_STRING_NULLFREE(pCtx, curuid);
}
