/*
* Get the check sum of password and verify code.
*
* First, compute check sum of password for three times.
* Then, join the result with the capitalizaion of the verify code.
* Compute the chekc sum of the new string.
*/
GString* get_pwvc_md5(const gchar *pwd, const gchar *vc, GError **err)
{
guint8 buf[100];
gsize bsize = 100;
GChecksum *cs = g_checksum_new(G_CHECKSUM_MD5);
g_checksum_update(cs, (const guchar*)pwd, strlen(pwd));
g_checksum_get_digest(cs, buf, &bsize);
g_checksum_free(cs);
cs = g_checksum_new(G_CHECKSUM_MD5);
g_checksum_update(cs, buf, bsize);
g_checksum_get_digest(cs, buf, &bsize);
g_checksum_free(cs);
cs = g_checksum_new(G_CHECKSUM_MD5);
g_checksum_update(cs, buf, bsize);
const gchar * md5_3 = g_checksum_get_string(cs);
md5_3 = g_ascii_strup(md5_3, strlen(md5_3));
gchar buf2[100];
g_sprintf(buf2, "%s%s", md5_3, vc);
g_checksum_free(cs);
gchar *tmp1;
tmp1 = g_ascii_strup(buf2, strlen(buf2));
tmp1 = g_compute_checksum_for_string(G_CHECKSUM_MD5
, tmp1, -1);
tmp1 = g_ascii_strup(tmp1, strlen(tmp1));
GString *re = g_string_new(tmp1);
g_free(tmp1);
return re;
}
static gchar *
renren_signature (gchar *kar[], gchar *var[])
{
gsize i, len;
gchar **v, *str, *buf, *md5;
len = g_strv_length (kar);
if (g_strv_length (var) < len)
{
g_error ("value list is too short");
return NULL;
}
v = g_new (char *, len + 1);
g_return_val_if_fail (v, NULL);
for (i = 0; i < len; ++ i)
{
v[i] = g_strdup_printf ("%s=%s", kar[i], var[i]);
}
v[i] = NULL;
qsort (v, len, sizeof (char *), cmpstring);
str = g_strjoinv ("", v);
g_strfreev (v);
buf = g_strconcat (str, renren_secret, NULL);
g_free (str);
md5 = g_compute_checksum_for_string (G_CHECKSUM_MD5, buf, -1);
g_free (buf);
return md5;
}
/**
* Check memory using specified rsa key and signature
*
* arguments:
* (rsa_pubkey, rsa_signature, string)
*
* returns:
* true - if string match rsa signature
* false - otherwise
*/
static gint
lua_rsa_verify_memory (lua_State *L)
{
RSA *rsa;
rspamd_fstring_t *signature;
const gchar *data;
gchar *data_sig;
gint ret;
rsa = lua_check_rsa_pubkey (L, 1);
signature = lua_check_rsa_sign (L, 2);
data = luaL_checkstring (L, 3);
if (rsa != NULL && signature != NULL && data != NULL) {
data_sig = g_compute_checksum_for_string (G_CHECKSUM_SHA256, data, -1);
ret = RSA_verify (NID_sha1, data_sig, strlen (data_sig),
signature->str, signature->len, rsa);
if (ret == 0) {
msg_info ("cannot check rsa signature for data: %s",
ERR_error_string (ERR_get_error (), NULL));
lua_pushboolean (L, FALSE);
}
else {
lua_pushboolean (L, TRUE);
}
g_free (data_sig);
}
else {
lua_pushnil (L);
}
return 1;
}
void
file_share_write_out_password (const char *password)
{
char *to_hash;
char *ascii_digest;
char *line;
char *filename;
FILE *file;
to_hash = g_strdup_printf ("%s:%s:%s", USER, REALM, password);
ascii_digest = g_compute_checksum_for_string (G_CHECKSUM_MD5, to_hash, strlen (to_hash));
g_free (to_hash);
line = g_strdup_printf ("%s:%s:%s\n", USER, REALM, ascii_digest);
g_free (ascii_digest);
filename = g_build_filename (g_get_user_config_dir (), "user-share", "passwd", NULL);
file = fopen (filename, "w");
if (file != NULL) {
fwrite (line, strlen (line), 1, file);
fclose (file);
}
g_free (filename);
g_free (line);
}
/*
* Here we're gracefully (ahem) extending the fd.o thumbnail specification[1]
* with a size "huge", which is 512x512px.
*
* [1] http://people.freedesktop.org/~vuntz/thumbnail-spec-cache/directory.html
*/
static char *
get_thumbnail_path_for_uri (const char *uri)
{
char *basepath;
char *md5;
char *file;
char *path;
basepath = g_build_filename (g_get_home_dir (),
".thumbnails",
"x-huge",
NULL);
g_mkdir_with_parents (basepath, 0777);
md5 = g_compute_checksum_for_string (G_CHECKSUM_MD5, uri, -1);
file = g_strconcat (md5, ".png", NULL);
g_free (md5);
path = g_build_filename (basepath,
file,
NULL);
g_free (basepath);
g_free (file);
return path;
}
static char *scrobbler_get_signature(int nparams, API_Parameter *parameters) {
qsort(parameters, nparams, sizeof(API_Parameter), scrobbler_compare_API_Parameters);
char *all_params = NULL;
gchar *result = NULL;
gchar *api_sig = NULL;
size_t api_sig_length = strlen(SCROBBLER_SHARED_SECRET);
for (gint i = 0; i < nparams; i++) {
api_sig_length += strlen(parameters[i].paramName) + strlen(parameters[i].argument);
}
all_params = calloc(api_sig_length, sizeof(gchar));
for (int i = 0; i < nparams; i++) {
strcat(all_params, parameters[i].paramName);
strcat(all_params, parameters[i].argument);
}
api_sig = g_strconcat(all_params, SCROBBLER_SHARED_SECRET, NULL);
free(all_params);
result = g_compute_checksum_for_string(G_CHECKSUM_MD5, api_sig, -1);
g_free(api_sig);
return result;
}
GFile *
xdg_cache_cache_get_temp_file (const gchar *uri,
TumblerThumbnailFlavor *flavor)
{
const gchar *cachedir;
const gchar *dirname;
GTimeVal current_time = { 0, 0 };
GFile *file;
gchar *filename;
gchar *md5_hash;
gchar *path;
g_return_val_if_fail (uri != NULL && *uri != '\0', NULL);
g_return_val_if_fail (TUMBLER_IS_THUMBNAIL_FLAVOR (flavor), NULL);
cachedir = g_get_user_cache_dir ();
dirname = tumbler_thumbnail_flavor_get_name (flavor);
g_get_current_time (¤t_time);
md5_hash = g_compute_checksum_for_string (G_CHECKSUM_MD5, uri, -1);
filename = g_strdup_printf ("%s-%ld-%ld.png", md5_hash,
current_time.tv_sec, current_time.tv_usec);
path = g_build_filename (cachedir, "thumbnails", dirname, filename, NULL);
file = g_file_new_for_path (path);
g_free (path);
g_free (filename);
g_free (md5_hash);
return file;
}
static char*
waveform_get_peak_filename(const char* filename)
{
// filename should be absolute.
// caller must g_free the returned value.
if(wf->load_peak == wf_load_ardour_peak) {
gwarn("cannot automatically determine path of Ardour peakfile");
return NULL;
}
GError* error = NULL;
gchar* uri = g_filename_to_uri(filename, NULL, &error);
if(error) {
gwarn("%s", error->message);
return NULL;
}
dbg(1, "uri=%s", uri);
gchar* md5 = g_compute_checksum_for_string(G_CHECKSUM_MD5, uri, -1);
g_free(uri);
gchar* peak_basename = g_strdup_printf("%s.peak", md5);
g_free(md5);
char* cache_dir = get_cache_dir();
gchar* peak_filename = g_build_filename(cache_dir, peak_basename, NULL);
g_free(cache_dir);
dbg(1, "peak_filename=%s", peak_filename);
g_free(peak_basename);
return peak_filename;
}
static gchar *
get_avatar (const gchar *field) {
GMatchInfo *match_info = NULL;
gchar *avatar = NULL;
gchar *email;
gchar *email_hash;
gchar *lowercased_field;
static GRegex *email_regex = NULL;
if (!field) {
return NULL;
}
lowercased_field = g_utf8_strdown (field, -1);
if (!email_regex) {
email_regex = g_regex_new ("[\\w-]+@([\\w-]+\\.)+[\\w-]+", G_REGEX_OPTIMIZE, 0, NULL);
}
if (g_regex_match (email_regex, lowercased_field, 0, &match_info)) {
email = g_match_info_fetch (match_info, 0);
g_match_info_free (match_info);
email_hash = g_compute_checksum_for_string (G_CHECKSUM_MD5, email, -1);
avatar = g_strdup_printf (GRAVATAR_URL, email_hash);
g_free (email);
g_free (email_hash);
}
return avatar;
}
/**
* Register a plaintext description for a query container. The passed
* string will be modified to the checksum id of the container.
*
* @param id Originally contains the plaintext id which is replaced with
* the hashed id on return.
*/
void
rygel_media_export_query_container_factory_register_id (RygelMediaExportQueryContainerFactory *self,
gchar **id) {
gchar *md5;
gchar *tmp;
GeeAbstractMap *abstract_virtuals;
RygelMediaExportQueryContainerFactoryPrivate *priv;
g_return_if_fail (RYGEL_MEDIA_EXPORT_IS_QUERY_CONTAINER_FACTORY (self));
g_return_if_fail (id != NULL);
g_return_if_fail (*id != NULL);
priv = self->priv;
md5 = g_compute_checksum_for_string (G_CHECKSUM_MD5, *id, (gsize) (-1));
abstract_virtuals = GEE_ABSTRACT_MAP (priv->virtual_container_map);
if (!gee_abstract_map_has_key (abstract_virtuals, md5)) {
gee_abstract_map_set (abstract_virtuals, md5, *id);
g_debug ("Registering %s for %s", md5, *id);
}
tmp = g_strconcat (RYGEL_MEDIA_EXPORT_QUERY_CONTAINER_PREFIX, md5, NULL);
g_free (md5);
g_free (*id);
*id = tmp;
}
static char *
build_call_sig (GHashTable *params, const char *secret)
{
char *str = NULL;
char *sig, *temp;
GList *keys = g_hash_table_get_keys (params);
keys = g_list_sort (keys, (GCompareFunc)g_strcmp0);
while (keys) {
const char *value = (const char *) g_hash_table_lookup (params, keys->data);
if (str == NULL) {
str = g_strconcat((char *)keys->data, value, NULL);
} else {
temp = str;
str = g_strconcat(str, (char *)keys->data, value, NULL);
g_free (temp);
}
keys = keys->next;
}
temp = str;
str = g_strconcat(str, secret, NULL);
g_free (temp);
sig = g_compute_checksum_for_string (G_CHECKSUM_MD5, str, -1);
g_free (str);
g_list_free (keys);
return sig;
}
static void
ws_auth(sr_session_t *s)
{
struct sr_session_priv *priv = s->priv;
gchar *auth, *tmp;
gchar *auth_url;
SoupMessage *message;
gchar *params;
tmp = g_strdup_printf("%s%s", priv->user, priv->hash_pwd);
auth = g_compute_checksum_for_string(G_CHECKSUM_MD5, tmp, -1);
g_free(tmp);
ws_params(s, ¶ms,
"api_key", priv->api_key,
"authToken", auth,
"method", "auth.getMobileSession",
"username", priv->user,
NULL);
auth_url = g_strdup_printf("%s?%s",
priv->api_url,
params);
g_free(params);
message = soup_message_new("GET", auth_url);
soup_session_queue_message(priv->soup,
message,
ws_auth_cb,
s);
g_free(auth_url);
g_free(auth);
}
static void
update_from_state (IdolThumbnailPluginPrivate *priv,
IdolObject *idol,
const char *mrl)
{
GdkPixbuf *pixbuf = NULL;
GtkWindow *window = NULL;
char *file_basename, *file_name, *uri_md5;
GError *err = NULL;
g_return_if_fail (IDOL_IS_OBJECT (idol));
window = idol_get_main_window (idol);
if (mrl == NULL) {
set_icon_to_default (idol);
return;
}
uri_md5 = g_compute_checksum_for_string (G_CHECKSUM_MD5,
mrl,
strlen (mrl));
file_basename = g_strdup_printf ("%s.png", uri_md5);
file_name = g_build_filename (g_get_home_dir (),
".thumbnails",
"normal",
file_basename,
NULL);
pixbuf = gdk_pixbuf_new_from_file (file_name, &err);
/* Try loading from the "large" thumbnails if normal fails */
if (pixbuf == NULL && err != NULL && err->domain == G_FILE_ERROR) {
g_clear_error (&err);
g_free (file_name);
file_name= g_build_filename (g_get_home_dir (),
".thumbnails",
"large",
file_basename,
NULL);
pixbuf = gdk_pixbuf_new_from_file (file_name, &err);
}
g_free (uri_md5);
g_free (file_basename);
g_free (file_name);
if (pixbuf == NULL) {
if (err != NULL && err->domain != G_FILE_ERROR) {
g_printerr ("%s\n", err->message);
}
set_icon_to_default (idol);
return;
}
gtk_window_set_icon (window, pixbuf);
g_object_unref (pixbuf);
}
gchar* get_hexdigest(const gchar *salt, const gchar *raw_password)
{
gchar *str;
gchar *password;
str = g_strdup_printf("%s%s", salt, raw_password);
password = g_compute_checksum_for_string (G_CHECKSUM_SHA1, str, strlen(str));
g_free(str);
return password;
}
/*
* compute cache file's absolute name
*/
static gchar *
compute_data_file_name (GdaQuarkList *params, gboolean is_cache, const gchar *data_type)
{
/* real cache file name */
GString *string;
gchar *cfile, *evalue;
const gchar *base_dn;
const gchar *host;
const gchar *require_ssl;
const gchar *port;
gint rport;
gboolean use_ssl;
base_dn = gda_quark_list_find (params, "DB_NAME");
host = gda_quark_list_find (params, "HOST");
if (!host)
host = "127.0.0.1";
port = gda_quark_list_find (params, "PORT");
require_ssl = gda_quark_list_find (params, "USE_SSL");
use_ssl = (require_ssl && ((*require_ssl == 't') || (*require_ssl == 'T'))) ? TRUE : FALSE;
if (port && *port)
rport = atoi (port);
else {
if (use_ssl)
rport = LDAPS_PORT;
else
rport = LDAP_PORT;
}
string = g_string_new ("");
evalue = gda_rfc1738_encode (host);
g_string_append_printf (string, ",=%s", evalue);
g_free (evalue);
g_string_append_printf (string, ";PORT=%d", rport);
if (base_dn) {
evalue = gda_rfc1738_encode (base_dn);
g_string_append_printf (string, ";BASE_DN,=%s", evalue);
g_free (evalue);
}
evalue = g_compute_checksum_for_string (G_CHECKSUM_SHA1, string->str, -1);
g_string_free (string, TRUE);
if (is_cache)
cfile = g_strdup_printf ("%s_%s", evalue, data_type);
else
cfile = g_strdup_printf ("ldap-%s.%s", evalue, data_type);
g_free (evalue);
gchar *fname;
if (is_cache)
fname = g_build_path (G_DIR_SEPARATOR_S, g_get_user_cache_dir (),
"libgda", "ldap", cfile, NULL);
else
fname = g_build_path (G_DIR_SEPARATOR_S, g_get_user_data_dir (),
"libgda", cfile, NULL);
g_free (cfile);
return fname;
}
static gchar *
gs_screenshot_get_cachefn_for_url (const gchar *url)
{
g_autofree gchar *basename = NULL;
g_autofree gchar *checksum = NULL;
checksum = g_compute_checksum_for_string (G_CHECKSUM_SHA256, url, -1);
basename = g_path_get_basename (url);
return g_strdup_printf ("%s-%s", checksum, basename);
}
/**
* Sign file using specified rsa key and signature
*
* arguments:
* (rsa_privkey, rsa_signature, string)
*
* returns:
* true - if string match rsa signature
* false - otherwise
*/
static gint
lua_rsa_sign_file (lua_State *L)
{
RSA *rsa;
rspamd_fstring_t *signature, **psig;
const gchar *filename;
gchar *data = NULL, *data_sig;
gint ret, fd;
struct stat st;
rsa = lua_check_rsa_privkey (L, 1);
filename = luaL_checkstring (L, 2);
if (rsa != NULL && filename != NULL) {
fd = open (filename, O_RDONLY);
if (fd == -1) {
msg_err ("cannot open file %s: %s", filename, strerror (errno));
lua_pushnil (L);
}
else {
if (fstat (fd, &st) == -1 ||
(data =
mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd,
0)) == MAP_FAILED) {
msg_err ("cannot mmap file %s: %s", filename, strerror (errno));
lua_pushnil (L);
}
else {
signature = rspamd_fstring_sized_new (RSA_size (rsa));
data_sig = g_compute_checksum_for_string (G_CHECKSUM_SHA256,
data,
st.st_size);
ret = RSA_sign (NID_sha1, data_sig, strlen (data_sig),
signature->str, (guint *)&signature->len, rsa);
if (ret == 0) {
msg_info ("cannot make a signature for data: %s",
ERR_error_string (ERR_get_error (), NULL));
lua_pushnil (L);
rspamd_fstring_free (signature);
}
else {
psig = lua_newuserdata (L, sizeof (rspamd_fstring_t *));
rspamd_lua_setclass (L, "rspamd{rsa_signature}", -1);
*psig = signature;
}
g_free (data_sig);
munmap (data, st.st_size);
}
close (fd);
}
}
else {
lua_pushnil (L);
}
return 1;
}
/**
* mpl_utils_get_thumbnail_path:
* @uri: image uri
*
* Retrieves the path to thumbnail for an image identified by uri. The
* thumbnails are searched for in ~/.bk-thumbnails, ~/thumbnails/large and
* ~/thumbnails/normal, in that order.
*
* Return value: path to the thumbnail, or %NULL if thumbnail does not exist.
* The retured string must be freed with g_free() when no longer needed.
*/
gchar *
mpl_utils_get_thumbnail_path (const gchar *uri)
{
gchar *thumbnail_path;
gchar *thumbnail_filename = NULL;
gchar *csum;
csum = g_compute_checksum_for_string (G_CHECKSUM_MD5, uri, -1);
thumbnail_path = g_build_filename (g_get_home_dir (),
".bkl-thumbnails",
csum,
NULL);
if (g_file_test (thumbnail_path, G_FILE_TEST_EXISTS))
{
g_free (csum);
goto success;
}
g_free (thumbnail_path);
thumbnail_filename = g_strconcat (csum, ".png", NULL);
thumbnail_path = g_build_filename (g_get_home_dir (),
".thumbnails",
"large",
thumbnail_filename,
NULL);
g_free (csum);
if (g_file_test (thumbnail_path, G_FILE_TEST_EXISTS))
{
goto success;
} else {
g_free (thumbnail_path);
thumbnail_path = g_build_filename (g_get_home_dir (),
".thumbnails",
"normal",
thumbnail_filename,
NULL);
if (g_file_test (thumbnail_path, G_FILE_TEST_EXISTS))
{
goto success;
}
}
g_free (thumbnail_filename);
g_free (thumbnail_path);
return NULL;
success:
g_free (thumbnail_filename);
return thumbnail_path;
}
void sr_session_set_cred(sr_session_t *s,
char *user,
char *password)
{
struct sr_session_priv *priv = s->priv;
g_free(priv->user);
g_free(priv->hash_pwd);
priv->user = g_strdup(user);
priv->hash_pwd = g_compute_checksum_for_string(G_CHECKSUM_MD5, password, -1);
}
PurpleUtilFetchUrlData *
np_http_login0(NPSession *session,PurpleUtilFetchUrlCallback callback)
{
PurpleUtilFetchUrlData *url_data;
PurpleAccount *account;
account = session->account;
const char *username = account->username;
const char *pwd_md5 = g_compute_checksum_for_string(G_CHECKSUM_MD5,account->password,strlen(account->password));
const char *http_server = purple_account_get_string(session->account, "http_method_server", NP_HTTPCONN_SERVER);
const char *_ua = purple_account_get_string(session->account, "np_user_agent", NP_USER_AGENT);
char *login_url = g_strdup_printf("%s/%s",http_server,NP_LOGIN_0_PATH);
purple_debug_info("np", "login_url: %s",login_url);
const char *login_from = "niupai";
const char *login_device_id = purple_account_get_string(session->account, "device_id", "FAKE_DEVICE_ID_FROM_PURPLE");
char *plain_login_key = g_strdup_printf("%s%s",login_device_id,"nPiGa:#)");
char *login_key = g_compute_checksum_for_string(G_CHECKSUM_MD5,plain_login_key,strlen(plain_login_key));
purple_debug_info("np", "login_device_id: %s",login_device_id);
gchar *content = g_strdup_printf("account=%s&password=%s&login_from=%s&login_device_id=%s&login_key=%s&_ua=%s",
username,
pwd_md5,
login_from,
login_device_id,
login_key,
_ua,
NULL
);
url_data = np_util_post_url(login_url, content,TRUE, callback, session);
g_free(plain_login_key);
g_free(login_key);
g_free(login_url);
g_free(content);
return url_data;
}
static gboolean
gimp_test_get_file_state_verbose (const gchar *filename,
GimpTestFileState *filestate)
{
gboolean success = TRUE;
filestate->filename = g_strdup (filename);
/* Get checksum */
if (success)
{
gchar *contents = NULL;
gsize length = 0;
success = g_file_get_contents (filename,
&contents,
&length,
NULL);
if (success)
{
filestate->md5 = g_compute_checksum_for_string (G_CHECKSUM_MD5,
contents,
length);
}
g_free (contents);
}
/* Get modification time */
if (success)
{
GFile *file = g_file_new_for_path (filename);
GFileInfo *info = g_file_query_info (file,
G_FILE_ATTRIBUTE_TIME_MODIFIED, 0,
NULL, NULL);
if (info)
{
g_file_info_get_modification_time (info, &filestate->modtime);
success = TRUE;
g_object_unref (info);
}
else
{
success = FALSE;
}
g_object_unref (file);
}
if (! success)
g_printerr ("Failed to get initial file info for '%s'\n", filename);
return success;
}
static char *
build_request_filename (const char *uri)
{
char *hash = g_compute_checksum_for_string (G_CHECKSUM_MD5, uri, -1);
char *filename = g_strdup_printf ("%"G_GINT64_FORMAT "-%s.data",
g_get_monotonic_time (), hash);
g_free (hash);
return filename;
}
/**
* korva_upnp_host_data_get_id:
*
* Get a uniquish identifier for this #KorvaUPnPHostData.
* It is used to generate the URLs served by #KorvaUPnPFileServer.
*
* @self: An instance of #KorvaUPnPHostData
*
* Returns: (transfer full): A new string containing the id. Free after use.
*/
char *
korva_upnp_host_data_get_id (KorvaUPnPHostData *self)
{
char *hash, *uri;
uri = g_file_get_uri (self->priv->file);
hash = g_compute_checksum_for_string (G_CHECKSUM_MD5, uri, -1);
g_free (uri);
return hash;
}
static gchar *
get_nonce (void)
{
gchar *timestamp = get_timestamp();
guint rnd_number = g_random_int ();
gchar *rnd_str = g_strdup_printf ("%d_%s", rnd_number, timestamp);
gchar *nonce = g_compute_checksum_for_string (G_CHECKSUM_MD5, rnd_str, -1);
g_free (timestamp);
g_free (rnd_str);
return nonce;
}
void p2pserver_json_identupdate_response(char **response, json_t *json){
//Define local variables
char * local_response;
json_t *client_public_key;
//Begin local function logic
/** General Instruction Description
*
* Parse "json", check if this clients publickey is in the database
* if no: Add it to the database and send back our public key
* if yes: Update the users current "status"
**/
//JSON: Get the public_key value of the user.
client_public_key = json_object_get(json, "public_key");
const guchar * client_public_key_string;
client_public_key_string = g_strdup_printf("%s", json_string_value(client_public_key));
//SHA256: public_key
gchar * client_public_key_string_sha256;
client_public_key_string_sha256 = g_compute_checksum_for_string(G_CHECKSUM_SHA256, client_public_key_string, strlen(client_public_key_string));
//SQLite3: Search for the "sha256s" associated public key in the SQLite3 DB and match that found result with its public key (efficent search, less characters to match)
int client_public_key_exists = p2pserver_sql_client_pubkey_exists(client_public_key_string_sha256, client_public_key_string);
//Decision: If no: add it to the DB, if yes, update the current users "status" (Only if the status is signed and valid, of course)
if(client_public_key_exists == 1){
//TO DO: Update the clients "status" locally to DB
//Respond to the client with a return_code of 1001 (identupdate success)
local_response = g_strdup_printf("{\"return_code\":\"1001\", \"public_key\":\"%s\"}\n", p2pserver_rsa_active_identity);
}else if(client_public_key_exists == 0){
//This client is new, save it into the database
int add_client_locally_success = p2pserver_sql_add_client_identity(client_public_key_string_sha256, client_public_key_string);
local_response = g_strdup_printf("{\"return_code\":\"1002\", \"public_key\":\"%s\"}\n", p2pserver_rsa_active_identity);
}else{
//Error status invoked during the search
local_response = g_strdup_printf("{\"return_code\":\"-1000\"}\n");
}
g_print("%s\n", local_response);
//output with response
*response = local_response;
return;
}
static void
verify_user (SwService *service)
{
SwServiceLastfm *lastfm = SW_SERVICE_LASTFM (service);
SwServiceLastfmPrivate *priv = lastfm->priv;
char *hash_pw, *user_pass, *auth_token;
RestProxyCall *call;
RestParams *params;
GHashTable *params_t;
char *api_sig;
hash_pw = g_compute_checksum_for_string (G_CHECKSUM_MD5,
priv->password, -1);
user_pass = g_strconcat(priv->username, hash_pw, NULL);
auth_token = g_compute_checksum_for_string (G_CHECKSUM_MD5,
user_pass, -1);
call = rest_proxy_new_call (priv->proxy);
rest_proxy_call_add_params (call,
"api_key", priv->api_key,
"username", priv->username,
"authToken", auth_token,
"method", "auth.getMobileSession",
NULL);
params = rest_proxy_call_get_params (call);
params_t = rest_params_as_string_hash_table (params);
api_sig = build_call_sig (params_t, priv->api_secret);
rest_proxy_call_add_params (call,
"api_sig", api_sig,
NULL);
rest_proxy_call_async (call, _mobile_session_cb, (GObject*)lastfm, NULL, NULL);
g_hash_table_unref (params_t);
g_free (api_sig);
g_free (hash_pw);
g_free (user_pass);
g_free (auth_token);
}
/**
* gs_utils_get_user_hash:
* @error: A #GError, or %NULL
*
* This SHA1 hash is composed of the contents of machine-id and your
* usename and is also salted with a hardcoded value.
*
* This provides an identifier that can be used to identify a specific
* user on a machine, allowing them to cast only one vote or perform
* one review on each application.
*
* There is no known way to calculate the machine ID or username from
* the machine hash and there should be no privacy issue.
*
* Returns: The user hash, or %NULL on error
*/
gchar *
gs_utils_get_user_hash (GError **error)
{
g_autofree gchar *data = NULL;
g_autofree gchar *salted = NULL;
if (!g_file_get_contents ("/etc/machine-id", &data, NULL, error))
return NULL;
salted = g_strdup_printf ("gnome-software[%s:%s]",
g_get_user_name (), data);
return g_compute_checksum_for_string (G_CHECKSUM_SHA1, salted, -1);
}
static char *
oauth_create_nonce (GTimeVal *t)
{
char *s;
char *v;
s = g_strdup_printf ("%ld%u", t->tv_usec, g_random_int ());
v = g_compute_checksum_for_string (G_CHECKSUM_MD5, s, -1);
g_free (s);
return v;
}
static gboolean
slmock_check_login(GDBusConnection * session, slmock_table_t * slmockdata, gboolean clear_cache)
{
if (clear_cache) {
gchar *username_sha = g_compute_checksum_for_string (G_CHECKSUM_SHA256, slmockdata->username, -1);
gchar *file_path = g_build_path ("/", g_get_user_cache_dir(), "remote-logon-service", "cache", username_sha, NULL);
unlink (file_path);
g_free (username_sha);
g_free (file_path);
}
GVariant * retval = g_dbus_connection_call_sync(session,
"org.ArcticaProject.RemoteLogon",
"/org/ArcticaProject/RemoteLogon",
"org.ArcticaProject.RemoteLogon",
"GetServersForLogin",
g_variant_new("(sssb)",
"https://slmock.com/",
slmockdata->username,
slmockdata->password,
TRUE), /* params */
G_VARIANT_TYPE("(bsa(sssba(sbva{sv})a(si)))"), /* ret type */
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
NULL);
g_assert(retval != NULL);
g_assert(g_variant_n_children(retval) == 3);
GVariant * loggedin = g_variant_get_child_value(retval, 0);
g_assert(g_variant_get_boolean(loggedin));
g_variant_unref(loggedin); loggedin = NULL;
GVariant * data = g_variant_get_child_value(retval, 1);
g_assert(g_strcmp0(g_variant_get_string(data, NULL), "network") == 0);
g_variant_unref(data); data = NULL;
GVariant * array = g_variant_get_child_value(retval, 2);
int i;
// Check all servers should be in the result are in the result
for (i = 0; slmockdata->servers[i].name != NULL; i++) {
g_assert(find_server(array, &slmockdata->servers[i]));
}
// Check there is no more servers in the result than we expected
g_assert(i == g_variant_n_children(array));
g_variant_unref(array);
g_variant_unref(retval);
return TRUE;
}
static void
ws_params(sr_session_t *s, char **params, ...)
{
struct sr_session_priv *priv = s->priv;
GList *l = NULL;
va_list args;
GString *params_str, *tmp;
gchar *api_sig;
if (!params)
return;
params_str = g_string_sized_new(0x100);
va_start(args, params);
do {
const char *key, *value;
key = va_arg(args, char *);
if (!key)
break;
value = va_arg(args, char *);
if (!value)
break;
l = g_list_prepend(l, param_new(key, value));
g_string_append_printf(params_str, "&%s=%s", key, value);
} while (true);
va_end(args);
l = g_list_sort(l, (GCompareFunc) param_compare);
tmp = g_string_sized_new(0x100);
GList *c;
for (c = l; c; c = c->next) {
struct ws_param *p = c->data;
g_string_append_printf(tmp, "%s%s", p->key, p->value);
}
g_string_append(tmp, priv->api_secret);
api_sig = g_compute_checksum_for_string(G_CHECKSUM_MD5, tmp->str, -1);
g_string_free(tmp, TRUE);
g_list_foreach(l, (GFunc) free, NULL);
g_string_append_printf(params_str, "&api_sig=%s", api_sig);
g_free(api_sig);
*params = params_str->str;
g_string_free(params_str, FALSE);
}
