gboolean
lsq_tempfs_make_root_dir ( LSQArchive *archive )
{
gint error = 0;
gchar dirname[256];
g_return_val_if_fail( LSQ_IS_ARCHIVE( archive ), FALSE );
if ( NULL != archive->temp_dir )
{
return TRUE;
}
g_snprintf( dirname, 256, "%s/" PACKAGE "-%s/", g_get_tmp_dir(), g_get_user_name() );
if ( 0 != g_mkdir_with_parents( dirname, 0700 ) )
{
return FALSE;
}
do
{
g_snprintf( dirname, 256, "%s/" PACKAGE "-%s/cache-%d/", g_get_tmp_dir(), g_get_user_name(), suffix++ );
error = g_mkdir( dirname, 0700 );
}
while ( 0 != error && EEXIST == errno );
if ( 0 == error )
{
archive->temp_dir = g_strdup( dirname );
return TRUE;
}
return FALSE;
}
gboolean
gebr_comm_is_address_equal(const gchar *_addr1, const gchar *_addr2)
{
gchar *u1, *u2;
gchar *a1, *a2;
a1 = strchr(_addr1, '@');
a2 = strchr(_addr2, '@');
if (!a1) {
u1 = g_strdup(g_get_user_name());
a1 = g_strdup(_addr1);
} else {
u1 = g_strndup(_addr1, (a1 - _addr1) / sizeof(gchar));
a1 = g_strdup(a1 + 1);
}
if (!a2) {
u2 = g_strdup(g_get_user_name());
a2 = g_strdup(_addr2);
} else {
u2 = g_strndup(_addr2, (a2 - _addr2) / sizeof(gchar));
a2 = g_strdup(a2 + 1);
}
gboolean ret = g_strcmp0(a1, a2) == 0 && g_strcmp0(u1, u2) == 0;
g_free(a1);
g_free(a2);
g_free(u1);
g_free(u2);
return ret;
}
gchar *
lsq_archive_request_temp_file (
LSQArchive *archive,
const gchar *sfx
)
{
gchar dirname[256];
gint handle;
g_return_val_if_fail( LSQ_IS_ARCHIVE( archive ), NULL );
g_snprintf( dirname, 256, "%s/" PACKAGE "-%s/", g_get_tmp_dir(), g_get_user_name() );
if ( 0 != g_mkdir_with_parents( dirname, 0700 ) )
{
return NULL;
}
g_snprintf( dirname, 256, "%s/" PACKAGE "-%s/file-XXXXXX%s", g_get_tmp_dir(), g_get_user_name(), ( NULL != sfx ) ? sfx : "" );
handle = g_mkstemp( dirname );
if ( -1 == handle )
{
return NULL;
}
close( handle );
return g_strdup( dirname );
}
static void
setup (TestCase *tc,
gconstpointer data)
{
GPtrArray *ptr = g_ptr_array_new ();
const TestFixture *fix = data;
const gchar *old_val = g_getenv ("XDG_CONFIG_DIRS");
gint i;
g_setenv ("XDG_CONFIG_DIRS", config_dir, TRUE);
tc->cert_dir = g_build_filename (config_dir, "cockpit", "ws-certs.d", NULL);
/* make sure we start clean */
delete_all(tc);
g_ptr_array_add (ptr, "certificate");
g_ptr_array_add (ptr, "--user");
g_ptr_array_add (ptr, (gchar *) g_get_user_name ());
g_ptr_array_add (ptr, "--group");
g_ptr_array_add (ptr, (gchar *) g_get_user_name ());
for (i = 0; fix->files[i] != NULL; i++)
g_ptr_array_add (ptr, (gchar *) fix->files[i]);
if (fix->expected_message)
cockpit_expect_message (fix->expected_message);
tc->ret = cockpit_remotectl_certificate (ptr->len, (gchar **) ptr->pdata);
g_ptr_array_free (ptr, TRUE);
if (old_val)
g_setenv ("XDG_CONFIG_DIRS", old_val, TRUE);
else
g_unsetenv ("XDG_CONFIG_DIRS");
}
static void
setup (TestCase *tc,
gconstpointer data)
{
GPtrArray *ptr = g_ptr_array_new ();
const TestFixture *fix = data;
const gchar *old_val = g_getenv ("XDG_CONFIG_DIRS");
gint i;
struct group *gr = NULL;
g_setenv ("XDG_CONFIG_DIRS", config_dir, TRUE);
tc->cert_dir = g_build_filename (config_dir, "cockpit", "ws-certs.d", NULL);
/* make sure we start clean */
delete_all(tc);
if (fix->readonly_dir)
{
g_assert (g_mkdir_with_parents (tc->cert_dir, 0755) == 0);
g_assert (g_chmod (tc->cert_dir, 0555) == 0);
}
g_ptr_array_add (ptr, "certificate");
if (fix->ensure)
{
cockpit_expect_info ("Generating temporary certificate*");
cockpit_expect_info ("Error generating temporary dummy cert using sscg, falling back to openssl*");
g_ptr_array_add (ptr, "--ensure");
}
g_ptr_array_add (ptr, "--user");
g_ptr_array_add (ptr, (gchar *) g_get_user_name ());
gr = getgrnam (g_get_user_name ());
if (gr != NULL)
{
g_ptr_array_add (ptr, "--group");
g_ptr_array_add (ptr, (gchar *) g_get_user_name ());
}
for (i = 0; fix->files[i] != NULL; i++)
g_ptr_array_add (ptr, (gchar *) fix->files[i]);
if (fix->expected_message)
cockpit_expect_message (fix->expected_message);
tc->ret = cockpit_remotectl_certificate (ptr->len, (gchar **) ptr->pdata);
g_ptr_array_free (ptr, TRUE);
if (old_val)
g_setenv ("XDG_CONFIG_DIRS", old_val, TRUE);
else
g_unsetenv ("XDG_CONFIG_DIRS");
}
char*
girara_get_home_directory(const char* user)
{
if (user == NULL || g_strcmp0(user, g_get_user_name()) == 0) {
return g_strdup(g_get_home_dir());
}
// XXX: The following code is very unportable.
struct passwd pwd;
struct passwd* result = NULL;
#ifdef _SC_GETPW_R_SIZE_MAX
int bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
if (bufsize < 0) {
bufsize = 4096;
}
#else
int bufsize = 4096;
#endif
char* buffer = g_try_malloc0(sizeof(char) * bufsize);
if (buffer == NULL) {
return NULL;
}
getpwnam_r(user, &pwd, buffer, bufsize, &result);
if (result == NULL) {
g_free(buffer);
return NULL;
}
char* dir = g_strdup(pwd.pw_dir);
g_free(buffer);
return dir;
}
static gboolean
on_handle_stream_socket (CockpitWebServer *server,
const gchar *path,
GIOStream *io_stream,
GHashTable *headers,
GByteArray *input,
guint in_length,
gpointer user_data)
{
CockpitTransport *transport;
const gchar *query = NULL;
CockpitCreds *creds;
CockpitPipe *pipe;
gchar *value;
gchar **env;
if (!g_str_has_prefix (path, "/cockpit/socket"))
return FALSE;
if (path[15] == '?')
query = path + 16;
else if (path[15] != '\0')
return FALSE;
if (service)
{
g_object_ref (service);
}
else
{
value = g_strdup_printf ("%d", server_port);
env = g_environ_setenv (g_get_environ (), "COCKPIT_TEST_SERVER_PORT", value, TRUE);
creds = cockpit_creds_new (g_get_user_name (), "test",
COCKPIT_CRED_CSRF_TOKEN, "myspecialtoken",
NULL);
pipe = cockpit_pipe_spawn ((const gchar **)bridge_argv, (const gchar **)env, NULL, FALSE);
transport = cockpit_pipe_transport_new (pipe);
service = cockpit_web_service_new (creds, transport);
cockpit_creds_unref (creds);
g_object_unref (transport);
g_object_unref (pipe);
g_free (value);
g_strfreev (env);
/* Clear the pointer automatically when service is done */
g_object_add_weak_pointer (G_OBJECT (service), (gpointer *)&service);
}
if (query)
cockpit_channel_socket_open (service, "/cockpit/socket", query, io_stream, headers, input);
else
cockpit_web_service_socket (service, "/cockpit/socket", io_stream, headers, input);
/* Keeps ref on itself until it closes */
g_object_unref (service);
return TRUE;
}
/**
* 创建命令数据.
* @param command 命令字
* @param attach 附加数据
*/
void Command::CreateCommand(uint32_t command, const char *attach)
{
const gchar *env;
char *ptr;
snprintf(buf, MAX_UDPLEN, "%s", IPTUX_VERSION);
size = strlen(buf);
ptr = buf + size;
snprintf(ptr, MAX_UDPLEN - size, ":%" PRIu32, packetn);
packetn++;
size += strlen(ptr);
ptr = buf + size;
env = g_get_user_name();
snprintf(ptr, MAX_UDPLEN - size, ":%s", env);
size += strlen(ptr);
ptr = buf + size;
env = g_get_host_name();
snprintf(ptr, MAX_UDPLEN - size, ":%s", env);
size += strlen(ptr);
ptr = buf + size;
if(command == IPMSG_GETFILEDATA)
snprintf(ptr, MAX_UDPLEN - size, ":%d", command);
else
snprintf(ptr, MAX_UDPLEN - size, ":%" PRIu32, command);
size += strlen(ptr);
ptr = buf + size;
snprintf(ptr, MAX_UDPLEN - size, ":%s", attach ? attach : "");
size += strlen(ptr) + 1;
}
/* copied directly from xmms_connect_to_session */
int
gaim_remote_session_connect(int session)
{
gint fd;
uid_t stored_uid, euid;
struct sockaddr_un saddr;
if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) != -1)
{
saddr.sun_family = AF_UNIX;
stored_uid = getuid();
euid = geteuid();
setuid(euid);
sprintf(saddr.sun_path, "%s/gaim_%s.%d",
g_get_tmp_dir(), g_get_user_name(), session);
setreuid(stored_uid, euid);
if (connect(fd, (struct sockaddr *) &saddr, sizeof (saddr)) != -1)
return fd;
}
close(fd);
return -1;
}
void
test_already_launched (void)
{
const gchar *packet;
gsize packet_size;
GString *output;
GString *expected_packet;
const gchar command_line[] = "/bin/cat";
const gchar *user_name;
user_name = g_get_user_name();
milter_manager_launch_command_encoder_encode_launch(command_encoder,
&packet, &packet_size,
command_line, user_name);
cut_trace(write_packet(packet, packet_size));
cut_trace(write_packet(packet, packet_size));
pump_all_events();
milter_manager_reply_encoder_encode_success(reply_encoder,
&packet, &packet_size);
expected_packet = g_string_new_len(packet, packet_size);
milter_manager_reply_encoder_encode_error(reply_encoder,
&packet, &packet_size,
"already launched: </bin/cat>");
g_string_append_len(expected_packet, packet, packet_size);
output = gcut_string_io_channel_get_string(output_channel);
cut_assert_equal_memory(expected_packet->str, expected_packet->len,
output->str, output->len);
}
static void
on_synchronization_complete(InfSession* session,
InfXmlConnection* connection,
gpointer user_data)
{
InfTestGtkBrowserWindow* test;
InfAdoptedAlgorithm* algorithm;
test = (InfTestGtkBrowserWindow*)user_data;
session = infc_session_proxy_get_session(test->proxy);
algorithm = inf_adopted_session_get_algorithm(INF_ADOPTED_SESSION(session));
g_signal_connect(
G_OBJECT(algorithm),
"can-undo-changed",
G_CALLBACK(on_can_undo_changed),
test
);
g_signal_connect(
G_OBJECT(algorithm),
"can-redo-changed",
G_CALLBACK(on_can_redo_changed),
test
);
request_join(test, g_get_user_name());
}
static void
on_bus_acquired(GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
MediaPlayerList * playerlist = NULL;
IndicatorSoundOptions * options = NULL;
VolumeControlPulse * volume = NULL;
AccountsServiceUser * accounts = NULL;
VolumeWarning * warning = NULL;
AccountsServiceAccess * accounts_service_access = NULL;
if (g_strcmp0("lightdm", g_get_user_name()) == 0) {
playerlist = MEDIA_PLAYER_LIST(media_player_list_greeter_new());
} else {
playerlist = MEDIA_PLAYER_LIST(media_player_list_mpris_new());
accounts = accounts_service_user_new();
}
pgloop = pa_glib_mainloop_new(NULL);
options = indicator_sound_options_gsettings_new();
accounts_service_access = accounts_service_access_new();
volume = volume_control_pulse_new(options, pgloop, accounts_service_access);
warning = volume_warning_pulse_new(options, pgloop);
service = indicator_sound_service_new (playerlist, volume, accounts, options, warning, accounts_service_access);
g_clear_object(&playerlist);
g_clear_object(&options);
g_clear_object(&volume);
g_clear_object(&accounts);
g_clear_object(&warning);
}
/******************************************************************************
* Name
* on_live_chat_activate
*
* Synopsis
* #include "gui/main_menu.h"
*
* void on_live_chat_activate(GtkMenuItem * menuitem,
* gpointer user_data)
*
* Description
* open web browser to freenode irc chat
*
* Return value
* void
*/
G_MODULE_EXPORT void
on_live_chat_activate(GtkMenuItem *menuitem, gpointer user_data)
{
gchar *user = g_strdup_printf("%s", g_get_user_name()), *s, *url;
gchar version[] = VERSION;
int i;
gchar platform =
#ifdef WIN32
'W'
#else
'L'
#endif
;
/* no periods in irc nicks. */
for (i = 0; version[i]; ++i)
if (version[i] == '.')
version[i] = '-';
/* mibbit nick length limit = 16 chars. */
/* cut name off at 8, leaving 8 for "|platform+version". */
if (strlen(user) > 8)
user[8] = '\0';
/* no blanks in irc nicks. */
for (s = strchr(user, ' '); s; s = strchr(s, ' '))
*s = '_';
url =
g_strdup_printf("http://webchat.freenode.net/?nick=%s|%c%s&channels=xiphos&prompt=1",
user, platform, version);
xiphos_open_default(url);
g_free(url);
g_free(user);
}
static void
account_widget_irc_setup (EmpathyAccountWidgetIrc *settings)
{
const gchar *nick = NULL;
const gchar *fullname = NULL;
EmpathyAccountSettings *ac_settings;
g_object_get (settings->self, "settings", &ac_settings, NULL);
nick = empathy_account_settings_get_string (ac_settings, "account");
fullname = empathy_account_settings_get_string (ac_settings,
"fullname");
if (!nick)
{
nick = g_strdup (g_get_user_name ());
empathy_account_settings_set_string (ac_settings,
"account", nick);
}
if (!fullname)
{
fullname = g_strdup (g_get_real_name ());
if (!fullname)
{
fullname = g_strdup (nick);
}
empathy_account_settings_set_string (ac_settings,
"fullname", fullname);
}
}
/* Called by @server when handling HTTP requests to /socket - runs in a separate
* thread dedicated to the request so it may do blocking I/O
*/
static gboolean
on_handle_stream_socket (CockpitWebServer *server,
CockpitWebServerRequestType reqtype,
const gchar *resource,
GIOStream *io_stream,
GHashTable *headers,
GByteArray *input,
guint in_length,
gpointer user_data)
{
CockpitWebService *service;
CockpitCreds *creds;
if (!g_str_equal (resource, "/socket"))
return FALSE;
creds = cockpit_creds_new (g_get_user_name (), NULL);
service = cockpit_web_service_new (creds, NULL);
cockpit_web_service_socket (service, io_stream, headers, input);
/* Keeps ref on itself until it closes */
g_object_unref (service);
cockpit_creds_unref (creds);
return TRUE;
}
JS_EXPORT_API
const gchar* lock_get_username ()
{
username = g_get_user_name ();
return username;
}
void testRapidFireAuthentication()
{
m_greeterpriv->authenticationUser = QString::fromUtf8(g_get_user_name());
for (int i = 0; i < 100; i++) {
m_greeterpriv->handleAuthenticate();
}
}
void
dir_set_value (Dir* d, const gchar* relative_key,
const GConfValue* value, GError** err)
{
Entry* e;
if (d->doc == NULL)
dir_load_doc(d, err);
if (d->doc == NULL)
{
g_return_if_fail( (err == NULL) || (*err != NULL) );
return;
}
e = g_hash_table_lookup(d->entry_cache, relative_key);
if (e == NULL)
e = dir_make_new_entry(d, relative_key);
entry_set_value(e, value);
d->last_access = time(NULL);
entry_set_mod_time(e, d->last_access);
entry_set_mod_user(e, g_get_user_name());
d->dirty = TRUE;
}
int
main (int argc,
char **argv)
{
GError *error = NULL;
gboolean verbose = TRUE;
char *nolock_reason = NULL;
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR);
# ifdef HAVE_BIND_TEXTDOMAIN_CODESET
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
# endif
textdomain (GETTEXT_PACKAGE);
#endif
gs_auth_set_verbose (verbose);
if (! privileged_initialization ())
{
exit (1);
}
if (! gtk_init_with_args (&argc, &argv, NULL, NULL, NULL, &error))
{
fprintf (stderr, "%s", error->message);
g_error_free (error);
exit (1);
}
if (! lock_initialization (&nolock_reason))
{
if (nolock_reason)
{
g_warning ("Screen locking disabled: %s", nolock_reason);
g_free (nolock_reason);
}
exit (1);
}
again:
error = NULL;
if (gs_auth_verify_user (g_get_user_name (), g_getenv ("DISPLAY"), auth_message_handler, NULL, &error))
{
printf ("Correct!\n");
}
else
{
if (error != NULL)
{
fprintf (stderr, "ERROR: %s\n", error->message);
g_error_free (error);
}
printf ("Incorrect\n");
goto again;
}
return 0;
}
/*
* For backwards compatibility we need to normalize some host params
* so they can be matched against.
*
* Some sessions shouldn't be shared by multiple channels, such as those that
* explicitly specify a host-key or specific user. This changed over time
* so modify things to make it a simple match.
*
* If the given user is the current user, remove it. Preserves the current
* behavior.
*
*/
static void
cockpit_router_normalize_host_params (JsonObject *options)
{
const gchar *sharable = NULL;
const gchar *user = NULL;
gboolean needs_private = FALSE;
if (!cockpit_json_get_string (options, "session", NULL, &sharable))
sharable = NULL;
if (!cockpit_json_get_string (options, "user", NULL, &user))
user = NULL;
if (!sharable)
{
/* Fallback to older ways of indicating this */
if (user || json_object_has_member (options, "host-key"))
needs_private = TRUE;
if (json_object_has_member (options, "temp-session"))
{
if (needs_private && !cockpit_json_get_bool (options, "temp-session",
TRUE, &needs_private))
needs_private = TRUE;
json_object_remove_member (options, "temp-session");
}
}
if (g_strcmp0 (user, g_get_user_name ()) == 0)
json_object_remove_member (options, "user");
if (needs_private)
json_object_set_string_member (options, "session", "private");
}
/* initializes server record but doesn't start connecting */
void server_connect_init(SERVER_REC *server)
{
const char *str;
g_return_if_fail(server != NULL);
MODULE_DATA_INIT(server);
server->type = module_get_uniq_id("SERVER", 0);
server_ref(server);
server->nick = g_strdup(server->connrec->nick);
if (server->connrec->username == NULL || *server->connrec->username == '\0') {
g_free_not_null(server->connrec->username);
str = g_get_user_name();
if (*str == '\0') str = "unknown";
server->connrec->username = g_strdup(str);
}
if (server->connrec->realname == NULL || *server->connrec->realname == '\0') {
g_free_not_null(server->connrec->realname);
str = g_get_real_name();
if (*str == '\0') str = server->connrec->username;
server->connrec->realname = g_strdup(str);
}
server->tag = server_create_tag(server->connrec);
server->connect_tag = -1;
}
static gboolean
check_if_port_is_busy(const gchar *addr,
gint port,
const gchar *curr_version,
const gchar *version_contents)
{
if (!gebr_comm_listen_socket_is_local_port_available(port) || gebr_comm_listen_socket_listen_on_port(port, addr)) {
if (g_strcmp0(curr_version, version_contents) == 0) { //It is running in the same version
gchar *new_addr;
const gchar *username = g_get_user_name();
if (username && *username)
new_addr = g_strdup_printf("%s@%s", username, addr);
else
new_addr = g_strdup(addr);
g_print("%s%d\n%s%s\n",
GEBR_PORT_PREFIX, port,
GEBR_ADDR_PREFIX, new_addr);
g_free(new_addr);
return TRUE;
} else { //It is running in a different version
gebr_kill_by_port(port);
}
}
return FALSE;
}
static gboolean
check_samba_installed (void)
{
gboolean installed;
gboolean permitted;
gchar *id_cmd;
gchar *output;
installed = g_file_test ("/usr/sbin/smbd", G_FILE_TEST_IS_EXECUTABLE);
id_cmd = g_strdup_printf ("id -Gn %s", g_get_user_name ());
output = NULL;
permitted = FALSE;
if (g_spawn_command_line_sync (id_cmd,
&output,
NULL,
NULL,
NULL)) {
permitted = g_strstr_len (output, -1, "sambashare") != NULL;
g_free (output);
}
g_free (id_cmd);
return installed && permitted;
}
static void
render_hostname (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gpointer data)
{
const char *text;
gs_free char *entry_username = NULL;
gs_free char *entry_hostname = NULL;
const char *local_username = g_get_user_name ();
gtk_tree_model_get (tree_model, iter,
HOTSSH_HOSTDB_COLUMN_USERNAME,
&entry_username,
HOTSSH_HOSTDB_COLUMN_HOSTNAME,
&entry_hostname,
-1);
text = entry_hostname;
if (entry_username && strcmp (entry_username, local_username) != 0)
text = g_strconcat (entry_username, "@", entry_hostname, NULL);
g_object_set (cell, "text", text, NULL);
}
const char *
libre_impuesto_file_tmp_dir (void)
{
if (tmp_dir == NULL)
{
char *partial_name;
char *full_name;
partial_name = g_strconcat ("epiphany-", g_get_user_name (),
"-XXXXXX", NULL);
full_name = g_build_filename (g_get_tmp_dir (), partial_name,
NULL);
#ifdef HAVE_MKDTEMP
tmp_dir = mkdtemp (full_name);
#else
#error no mkdtemp implementation
#endif
g_free (partial_name);
if (tmp_dir == NULL)
{
g_free (full_name);
}
}
return tmp_dir;
}
static gint check_mail()
{
static off_t oldsize = 0;
gchar *filename;
off_t newsize;
struct stat s;
gint ret = 0;
filename = g_strdup(g_getenv("MAIL"));
if (!filename)
filename = g_strconcat("/var/spool/mail/", g_get_user_name(), NULL);
if (g_stat(filename, &s) < 0) {
g_free(filename);
return -1;
}
newsize = s.st_size;
if (newsize) ret |= ANY_MAIL;
if (s.st_mtime > s.st_atime && newsize) ret |= UNREAD_MAIL;
if (newsize != oldsize && (ret & UNREAD_MAIL)) ret |= NEW_MAIL;
oldsize = newsize;
g_free(filename);
return ret;
}
/**
* Collect user information.
*/
static void
entropy_collect_user(SHA1Context *ctx)
{
const char *str[3];
str[0] = gethomedir();
#if GLIB_CHECK_VERSION(2,6,0)
/*
* These functions cannot be used with an unpatched GLib 1.2 on some
* systems as they trigger a bug in GLib causing a crash. On Darwin
* there's still a problem before GLib 2.6 due to a bug in Darwin though.
*/
str[1] = g_get_user_name();
str[2] = g_get_real_name();
entropy_array_string_collect(ctx, str, G_N_ELEMENTS(str));
#else
{
char user[UINT32_DEC_BUFLEN];
char real[UINT32_DEC_BUFLEN];
uint32_to_string_buf(entropy_rand31(), user, sizeof user);
uint32_to_string_buf(entropy_rand31(), real, sizeof real);
str[1] = user;
str[2] = real;
entropy_array_string_collect(ctx, str, G_N_ELEMENTS(str));
}
#endif /* GLib >= 2.0 */
}
static void remmina_file_editor_ssh_enabled_check_on_toggled(GtkToggleButton* togglebutton, RemminaFileEditor* gfe)
{
gboolean enabled = TRUE;
if (gfe->priv->ssh_enabled_check)
{
enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gfe->priv->ssh_enabled_check));
if (gfe->priv->ssh_loopback_check)
gtk_widget_set_sensitive(gfe->priv->ssh_loopback_check, enabled);
if (gfe->priv->ssh_server_default_radio)
gtk_widget_set_sensitive(gfe->priv->ssh_server_default_radio, enabled);
if (gfe->priv->ssh_server_custom_radio)
gtk_widget_set_sensitive(gfe->priv->ssh_server_custom_radio, enabled);
remmina_file_editor_ssh_server_custom_radio_on_toggled(NULL, gfe);
gtk_widget_set_sensitive(gfe->priv->ssh_charset_combo, enabled);
gtk_widget_set_sensitive(gfe->priv->ssh_username_entry, enabled);
gtk_widget_set_sensitive(gfe->priv->ssh_auth_password_radio, enabled);
gtk_widget_set_sensitive(gfe->priv->ssh_auth_publickey_radio, enabled);
gtk_widget_set_sensitive(gfe->priv->ssh_auth_auto_publickey_radio, enabled);
}
remmina_file_editor_ssh_auth_publickey_radio_on_toggled(NULL, gfe);
if (enabled && gtk_entry_get_text(GTK_ENTRY(gfe->priv->ssh_username_entry)) [0] == '\0')
{
gtk_entry_set_text(GTK_ENTRY(gfe->priv->ssh_username_entry), g_get_user_name());
}
}
static gboolean
add_share (ShareInfo *info, GError **error)
{
char *argv[7];
int argc;
ShareInfo *copy;
GKeyFile *key_file;
GError *real_error;
gboolean supports_success;
gboolean supports_guest_ok;
gboolean net_usershare_success;
/* g_message ("add_share() start"); */
if (throw_error_on_add) {
g_set_error (error,
SHARES_ERROR,
SHARES_ERROR_FAILED,
_("Failed"));
g_message ("add_share() end FAIL");
return FALSE;
}
supports_success = shares_supports_guest_ok (&supports_guest_ok, error);
if (!supports_success)
return FALSE;
argv[0] = "add";
argv[1] = "-l";
argv[2] = info->share_name;
argv[3] = info->path;
argv[4] = info->comment;
argv[5] = info->is_writable ? "Everyone:F" : g_strdup_printf ("Everyone:R,%s:F", g_get_user_name ());
if (supports_guest_ok) {
argv[6] = info->guest_ok ? "guest_ok=y" : "guest_ok=n";
argc = 7;
} else
argc = 6;
real_error = NULL;
net_usershare_success = net_usershare_run (argc, argv, &key_file, &real_error);
if (!info->is_writable) g_free (argv[5]);
if (!net_usershare_success) {
g_message ("Called \"net usershare add\" but it failed: %s", real_error->message);
g_propagate_error (error, real_error);
return FALSE;
}
replace_shares_from_key_file (key_file);
copy = copy_share_info (info);
add_share_info_to_hashes (copy);
/* g_message ("add_share() end SUCCESS"); */
return TRUE;
}
gboolean
remmina_ssh_init_from_file (RemminaSSH *ssh, RemminaFile *remminafile)
{
const gchar *ssh_server;
const gchar *ssh_username;
const gchar *ssh_privatekey;
const gchar *server;
gchar *s;
ssh->session = NULL;
ssh->callback = NULL;
ssh->authenticated = FALSE;
ssh->error = NULL;
pthread_mutex_init (&ssh->ssh_mutex, NULL);
/* Parse the address and port */
ssh_server = remmina_file_get_string (remminafile, "ssh_server");
ssh_username = remmina_file_get_string (remminafile, "ssh_username");
ssh_privatekey = remmina_file_get_string (remminafile, "ssh_privatekey");
server = remmina_file_get_string (remminafile, "server");
if (ssh_server)
{
remmina_public_get_server_port (ssh_server, 22, &ssh->server, &ssh->port);
if (ssh->server[0] == '\0')
{
g_free(ssh->server);
remmina_public_get_server_port (server, 0, &ssh->server, NULL);
}
}
else if (server == NULL)
{
ssh->server = g_strdup ("localhost");
ssh->port = 22;
}
else
{
remmina_public_get_server_port (server, 0, &ssh->server, NULL);
ssh->port = 22;
}
ssh->user = g_strdup (ssh_username ? ssh_username : g_get_user_name ());
ssh->password = NULL;
ssh->auth = remmina_file_get_int (remminafile, "ssh_auth", 0);
ssh->charset = g_strdup (remmina_file_get_string (remminafile, "ssh_charset"));
/* Public/Private keys */
s = (ssh_privatekey ? g_strdup (ssh_privatekey) : remmina_ssh_find_identity ());
if (s)
{
ssh->privkeyfile = remmina_ssh_identity_path (s);
g_free(s);
}
else
{
ssh->privkeyfile = NULL;
}
return TRUE;
}
