int
keyring_info(const char *keyname)
{
#ifndef HAVE_GNOME_KEYRING_GET_INFO
print_error(10, "WARNING", "\nThis feature not supported.\n");
return TRUE;
#endif
if (keyname == NULL)
{
print_error(GNOME_KEYRING_RESULT_NO_SUCH_KEYRING, "ERROR", "\nInvalid keyring.\n");
return FALSE;
}
if (!gnome_keyring_is_available())
{
print_error(GNOME_KEYRING_RESULT_NO_KEYRING_DAEMON, "ERROR",
"\nFailed to communicate with a gnome-keyring-daemon.\n");
return FALSE;
}
loop = g_main_loop_new(NULL, FALSE);
gnome_keyring_get_info(keyname,
(GnomeKeyringOperationGetKeyringInfoCallback) callback__get_info,
"info", NULL);
g_main_loop_run(loop);
return exit_status;
}
int main( int argc, char **argv ) {
if ( argc < 4 ) {
g_print("Usage: %s url user password\n",argv[0]);
return 1;
}
if ( gnome_keyring_is_available() ) {
guint32 item_id; gchar *cleaned = cleanurl(argv[1]);
gnome_keyring_set_network_password_sync(NULL,
argv[2],
"midori",
cleaned,
NULL,
NULL,
NULL,
0,
argv[3],
&item_id);
g_free(cleaned);
g_print("Created Gnome Keyring entry # %d\n",item_id);
} else {
g_print("Gnome Keyring not available!\n");
return 1;
}
return 0;
}
int
keyring_delete(const char *keyname)
{
#ifndef HAVE_GNOME_KEYRING_DELETE
print_error(10, "WARNING", "\nThis feature not supported.\n");
return TRUE;
#endif
if (keyname == NULL)
{
print_error(GNOME_KEYRING_RESULT_NO_SUCH_KEYRING, "ERROR", "\nInvalid keyring.\n");
return FALSE;
}
if (!gnome_keyring_is_available())
{
print_error(GNOME_KEYRING_RESULT_NO_KEYRING_DAEMON, "ERROR",
"\nFailed to communicate with a gnome-keyring-daemon.\n");
return FALSE;
}
loop = g_main_loop_new(NULL, FALSE);
gnome_keyring_delete(keyname,
(GnomeKeyringOperationDoneCallback) callback__done, "delete", NULL);
g_main_loop_run(loop);
if (exit_status)
fprintf(stderr, "Deleted '%s' keyring.\n", keyname);
return exit_status;
}
static void
connect_to_server (DialogData *data)
{
if (data->conn == NULL) {
data->conn = google_connection_new (GOOGLE_SERVICE_PICASA_WEB_ALBUM);
data->progress_dialog = gth_progress_dialog_new (GTK_WINDOW (data->browser));
gth_progress_dialog_add_task (GTH_PROGRESS_DIALOG (data->progress_dialog), GTH_TASK (data->conn));
}
#ifdef HAVE_GNOME_KEYRING
if ((data->password == NULL) && gnome_keyring_is_available ()) {
gnome_keyring_find_password (GNOME_KEYRING_NETWORK_PASSWORD,
find_password_cb,
data,
NULL,
"user", data->email,
"server", "picasaweb.google.com",
"protocol", "http",
NULL);
return;
}
#endif
connect_to_server_step2 (data);
}
static PyObject*
gnome_keyring_password_set(PyObject *self, PyObject *args)
{
const char *realmstring;
const char *username;
const char *password;
if (!PyArg_ParseTuple(args, "sss", &realmstring, &username, &password)){
PyErr_Clear();
PyErr_SetString(PyExc_TypeError,
"password_set() must be called as (servicename,username,password)");
return NULL;
}
if ((! dbus_bus_get(DBUS_BUS_SESSION,NULL)) ||
(!gnome_keyring_is_available())){
PyErr_Clear();
PyErr_SetString(PyExc_OSError,
"Can's access the keyring now");
return NULL;
}
GnomeKeyringResult result;
guint32 item_id;
result = gnome_keyring_set_network_password_sync(NULL, username, realmstring,
NULL, NULL, NULL, NULL, 0, password, &item_id);
Py_RETURN_NONE;
}
int
keyring_modify(const char *keyname,
const char *password,
const char *new_password)
{
char *pass = NULL;
char *new_pass = NULL;
#ifndef HAVE_GNOME_KEYRING_CHANGE_PASSWORD
print_error(10, "WARNING", "\nThis feature not supported.\n");
return TRUE;
#endif
if (keyname == NULL)
{
print_error(GNOME_KEYRING_RESULT_NO_SUCH_KEYRING, "ERROR", "\nInvalid keyring.\n");
return FALSE;
}
if (!gnome_keyring_is_available())
{
print_error(GNOME_KEYRING_RESULT_NO_KEYRING_DAEMON, "ERROR",
"\nFailed to communicate with a gnome-keyring-daemon.\n");
return FALSE;
}
pass = ask__password(keyname, password, "Enter password for '%s' keyring: ");
if (! pass)
return FALSE;
new_pass = ask__password(keyname, new_password,
"Enter new password for '%s' keyring: ");
if (! new_pass)
{
free(pass);
return FALSE;
}
loop = g_main_loop_new(NULL, FALSE);
gnome_keyring_change_password(keyname, pass, new_pass,
(GnomeKeyringOperationDoneCallback) callback__done,
"modify", NULL);
g_main_loop_run(loop);
if (exit_status)
fprintf(stderr, "Changed '%s' keyring password.\n", keyname);
if (pass) free(pass);
if (new_pass) free(new_pass);
return exit_status;
}
static PyObject*
gnome_keyring_password_get(PyObject *self, PyObject *args)
{
const char *realmstring;
const char *username;
const char *password;
if (!PyArg_ParseTuple(args, "ss", &realmstring, &username)){
PyErr_Clear();
PyErr_SetString(PyExc_TypeError,
"password_get() must be called as (servicename,username)");
return NULL;
}
if ((! dbus_bus_get(DBUS_BUS_SESSION,NULL)) ||
(!gnome_keyring_is_available())){
PyErr_Clear();
PyErr_SetString(PyExc_OSError, "Can's access the keyring now");
return NULL;
}
GnomeKeyringResult result;
GList *items;
result = gnome_keyring_find_network_password_sync(username, realmstring,
NULL, NULL, NULL, NULL, 0, &items);
int status = 0;
if (result == GNOME_KEYRING_RESULT_OK){
if (items && items->data){
GnomeKeyringNetworkPasswordData *item;
item = (GnomeKeyringNetworkPasswordData *)items->data;
if (item->password){
size_t len = strlen(item->password);
password = string_dump(item->password, len);
status = 1;
}
gnome_keyring_network_password_list_free(items);
}
}
if (!status){
PyErr_Clear();
PyErr_SetString(PyExc_OSError, "Can't fech password from system");
return NULL;
}
return Py_BuildValue("s",password);
}
static void
connection_ready_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
DialogData *data = user_data;
GoogleConnection *conn = GOOGLE_CONNECTION (source_object);
GError *error = NULL;
if (! google_connection_connect_finish (conn, result, &error)) {
if (g_error_matches (error, GOOGLE_CONNECTION_ERROR, GOOGLE_CONNECTION_ERROR_CAPTCHA_REQUIRED)) {
challange_account_dialog (data);
}
else if (g_error_matches (error, GOOGLE_CONNECTION_ERROR, GOOGLE_CONNECTION_ERROR_BAD_AUTHENTICATION)) {
account_properties_dialog (data, data->email);
}
else {
if (data->conn != NULL)
gth_task_dialog (GTH_TASK (data->conn), TRUE);
_gtk_error_dialog_from_gerror_show (GTK_WINDOW (data->browser), _("Could not connect to the server"), &error);
gtk_dialog_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_DELETE_EVENT);
}
return;
}
if (! g_list_find_custom (data->accounts, data->email, (GCompareFunc) strcmp))
data->accounts = g_list_append (data->accounts, g_strdup (data->email));
#ifdef HAVE_GNOME_KEYRING
if (gnome_keyring_is_available ()) {
gnome_keyring_store_password (GNOME_KEYRING_NETWORK_PASSWORD,
NULL,
_("Picasa Web Album"),
data->password,
store_password_done_cb,
data,
NULL,
"user", data->email,
"server", "picasaweb.google.com",
"protocol", "http",
NULL);
return;
}
#endif
get_album_list (data);
}
SG_bool SG_password__supported()
{
SG_bool haveDaemon = (SG_bool)gnome_keyring_is_available();
if (haveDaemon)
{
char *keyring = NULL;
GnomeKeyringResult res = gnome_keyring_get_default_keyring_sync(&keyring);
if (keyring)
g_free(keyring);
if (res == GNOME_KEYRING_RESULT_OK)
return( SG_TRUE );
}
return SG_FALSE;
}
int
keyring_getdef(void)
{
#ifndef HAVE_GNOME_KEYRING_GET_DEFAULT_KEYRING
print_error(10, "WARNING", "\nThis feature not supported.\n");
return TRUE;
#endif
if (!gnome_keyring_is_available())
{
print_error(GNOME_KEYRING_RESULT_NO_KEYRING_DAEMON, "ERROR",
"\nFailed to communicate with a gnome-keyring-daemon.\n");
return FALSE;
}
loop = g_main_loop_new(NULL, FALSE);
gnome_keyring_get_default_keyring(
(GnomeKeyringOperationGetStringCallback) callback__get_str, "getdef", NULL);
g_main_loop_run(loop);
return exit_status;
}
int
keyring_list(void)
{
#ifndef HAVE_GNOME_KEYRING_LIST_KEYRING_NAMES
print_error(10, "WARNING", "\nThis feature not supported.\n");
return TRUE;
#endif
if (!gnome_keyring_is_available())
{
print_error(GNOME_KEYRING_RESULT_NO_KEYRING_DAEMON, "ERROR",
"\nFailed to communicate with a gnome-keyring-daemon.\n");
return FALSE;
}
loop = g_main_loop_new(NULL, FALSE);
gnome_keyring_list_keyring_names(
(GnomeKeyringOperationGetListCallback) callback__get_list, "list", NULL);
g_main_loop_run(loop);
return exit_status;
}
int main(int argc, char **argv) {
GnomeKeyringResult result;
GList *results;
char *host;
int i, tried, verbose = 0, remove = 0, list = 0;
int set_domain = 0, set_host = 0, set_server = 0;
int set_protocol = 0, set_port = 0, set_passfd = 0;
int dry = 0;
char *user = default_user();
char *domain = NULL;
char *server = NULL;
char *object = NULL;
char *protocol = NULL;
char *authtype = NULL;
guint32 port = 0;
int passfd = 0;
char *use_keyring = GNOME_KEYRING_DEFAULT;
for (i = 1; i < argc; i++) {
if (ARG(u) || LARG(user)) {
S_OPT(user);
} else if (ARG(h) || LARG(host)) {
S_OPT_Q(host);
} else if (ARG(s) || LARG(server)) {
S_OPT_Q(server);
} else if (ARG(d) || LARG(domain)) {
S_OPT_Q(domain);
} else if (ARG(P) || LARG(protocol)) {
S_OPT_Q(protocol);
} else if (ARG(p) || LARG(port)) {
I_OPT_Q(port);
} else if (LARG(passfd)) {
I_OPT_Q(passfd);
} else if (ARG(v) || LARG(verbose)) {
verbose = 1;
} else if (ARG(R) || LARG(remove)) {
MODE(remove);
} else if (ARG(l) || LARG(list)) {
MODE(list);
} else if (ARG(n) || LARG(dry)) {
dry = 1;
verbose++;
} else if (ARG(k) || LARG(keyring)) {
S_OPT(use_keyring);
} else if (LARG(help)) {
usage();
return 0;
} else {
fprintf(stderr, "Unknown argument: %s\n", argv[i]);
return 1;
}
}
if (set_host && !(set_domain && set_server)) {
char *dot = index(host, '.');
if (dot) {
dot[0] = '\0';
dot++;
if (!set_domain) domain = dot;
if (!set_server) server = host;
} else {
server = host;
domain = "";
}
} else if (set_domain && set_server) {
host = NULL;
} else if (!list) {
fprintf(stderr, "Must set --host or (--server and --domain)\n");
return 1;
}
if ((set_port + set_protocol) == 1) {
if (set_protocol) {
set_port_by_protocol(&port, protocol);
} else if (set_port) {
set_protocol_by_port(&protocol, port);
}
} else if (!(set_port || set_protocol || list)) {
fprintf(stderr, "Must set at least one of --port or --protocol\n");
return 1;
}
if (set_protocol && !port) {
fprintf(stderr, "Couldn't determine port for --protocol %s\n", protocol);
return 1;
}
if (verbose && !list) {
#define VALUE(X) printf("%s: %s\n", #X, X ? X : "(null)")
VALUE(user);
VALUE(domain);
VALUE(server);
VALUE(host);
VALUE(protocol);
#undef VALUE
printf("port: %d\n", port);
if (dry)
return 0;
}
if (!gnome_keyring_is_available()) {
fprintf(stderr, "No keyring available\n");
return 1;
}
if (list)
return key_listing(verbose);
for (tried = 0; tried < 2; tried++) {
result = gnome_keyring_find_network_password_sync(
user, domain, server, object, protocol, authtype, port,
&results
);
if (verbose) printf("attempt #%d: ", tried);
if (result == OK) {
GList *current;
GnomeKeyringNetworkPasswordData *passdata;
char *password;
for (i = 0, current = results; current; i++, current = current->next) {
passdata = (GnomeKeyringNetworkPasswordData *)current->data;
password = passdata->password;
if (verbose) {
printf("Result[%d]=%s\n", i, password);
continue;
}
if (remove) {
result = gnome_keyring_item_delete_sync(
passdata->keyring,
passdata->item_id
);
if (verbose)
printf("Remove %s %d -> %s\n", passdata->keyring, passdata->item_id, result == OK ? "OK" : "NOT OK");
if (!current->next)
return 0;
continue;
}
printf("%s", password);
return 0;
}
if (password)
break;
}
if (remove) {
printf("No such password\n");
return 1;
}
if (verbose) printf("nope\n");
if (!tried) {
char *password;
if (set_passfd) {
password = password_from(passfd);
} else {
password = password_prompt(user, server, domain, protocol, port);
}
if (password) {
guint32 item_id;
gnome_keyring_set_network_password_sync(
use_keyring,
user, domain, server, object, protocol, authtype, port,
password, &item_id
);
if (verbose) printf("Stored password? %s\n", item_id ? "yes" : "no");
}
}
}
return 0;
}
static const gchar*
tny_gnome_keyring_password_getter_get_password (TnyPasswordGetter *self, const gchar *aid, const gchar *prompt, gboolean *cancel)
{
gchar *retval = NULL;
GList *list;
GnomeKeyringResult keyringret;
gchar *keyring;
gnome_keyring_get_default_keyring_sync (&keyring);
keyringret = gnome_keyring_find_network_password_sync (aid, "Mail",
aid /* hostname */,
"password", aid /* proto */,
"PLAIN", 0, &list);
if ((keyringret != GNOME_KEYRING_RESULT_OK) || (list == NULL))
{
gboolean canc = FALSE;
GnomePasswordDialog *dialog = GNOME_PASSWORD_DIALOG
(gnome_password_dialog_new
(_("Enter password"), prompt,
NULL,
NULL, TRUE));
gnome_password_dialog_set_domain (dialog, "Mail");
gnome_password_dialog_set_remember (dialog,
GNOME_PASSWORD_DIALOG_REMEMBER_FOREVER);
gnome_password_dialog_set_readonly_username (dialog, TRUE);
/* gnome_password_dialog_set_username (dialog,
tny_account_get_user (account)); */
gnome_password_dialog_set_show_username (dialog, FALSE);
gnome_password_dialog_set_show_remember (dialog,
gnome_keyring_is_available ());
gnome_password_dialog_set_show_domain (dialog, FALSE);
gnome_password_dialog_set_show_userpass_buttons (dialog, FALSE);
canc = gnome_password_dialog_run_and_block (dialog);
if (canc)
{
guint32 item_id;
GnomePasswordDialogRemember r;
retval = gnome_password_dialog_get_password (dialog);
mlock (retval, strlen (retval));
r = gnome_password_dialog_get_remember (dialog);
if (r == GNOME_PASSWORD_DIALOG_REMEMBER_FOREVER)
{
gnome_keyring_set_network_password_sync (keyring,
aid /* user */,
"Mail", aid /* hostname */,
"password", aid /* proto */,
"PLAIN", 0, retval, &item_id);
}
} else retval = NULL;
*cancel = (!canc);
/* this causes warnings, but should be done afaik */
gtk_object_destroy (GTK_OBJECT (dialog));
while (gtk_events_pending ())
gtk_main_iteration ();
} else {
GnomeKeyringNetworkPasswordData *pwd_data;
pwd_data = list->data;
retval = g_strdup (pwd_data->password);
*cancel = FALSE;
gnome_keyring_network_password_list_free (list);
}
return retval;
}
bool GnomeKeychain::isAvailable() {
return gnome_keyring_is_available();
}
int
gnome_keyring_isavailable() {
// gnome_key
return gnome_keyring_is_available();
}
