Exemplo n.º 1
0
static void
ide_clang_service__get_build_flags_cb (GObject      *object,
                                       GAsyncResult *result,
                                       gpointer      user_data)
{
  IdeBuildSystem *build_system = (IdeBuildSystem *)object;
  g_autoptr(GTask) task = user_data;
  ParseRequest *request;
  gchar **argv;
  GError *error = NULL;

  g_assert (IDE_IS_BUILD_SYSTEM (build_system));
  g_assert (G_IS_TASK (task));

  request = g_task_get_task_data (task);

  argv = ide_build_system_get_build_flags_finish (build_system, result, &error);

  if (!argv)
    {
      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
        g_message ("%s", error->message);
      g_clear_error (&error);
      argv = g_new0 (gchar*, 1);
    }

  request->command_line_args = argv;

#ifdef IDE_ENABLE_TRACE
  {
    gchar *cflags;

    cflags = g_strjoinv (" ", argv);
    IDE_TRACE_MSG ("CFLAGS = %s", cflags);
    g_free (cflags);
  }
#endif

  ide_thread_pool_push_task (IDE_THREAD_POOL_COMPILER,
                             task,
                             ide_clang_service_parse_worker);
}
Exemplo n.º 2
0
static void
send_announcements (NMArpingManager *self, const char *mode_arg)
{
    NMArpingManagerPrivate *priv = NM_ARPING_MANAGER_GET_PRIVATE (self);
    const char *argv[] = { NULL, mode_arg, "-q", "-I", NULL, "-c", "1", NULL, NULL };
    int ip_arg = G_N_ELEMENTS (argv) - 2;
    GError *error = NULL;
    GHashTableIter iter;
    AddressInfo *info;

    argv[4] = nm_platform_link_get_name (NM_PLATFORM_GET, priv->ifindex);
    g_return_if_fail (argv[4]);

    argv[0] = nm_utils_find_helper ("arping", NULL, NULL);
    if (!argv[0]) {
        _LOGW ("arping could not be found; no ARPs will be sent");
        return;
    }

    g_hash_table_iter_init (&iter, priv->addresses);

    while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &info)) {
        gs_free char *tmp_str = NULL;
        gboolean success;

        if (info->duplicate)
            continue;

        argv[ip_arg] = nm_utils_inet4_ntop (info->address, NULL);
        _LOGD ("run %s", (tmp_str = g_strjoinv (" ", (char **) argv)));

        success = g_spawn_async (NULL, (char **) argv, NULL,
                                 G_SPAWN_STDOUT_TO_DEV_NULL |
                                 G_SPAWN_STDERR_TO_DEV_NULL,
                                 NULL, NULL, NULL, &error);
        if (!success) {
            _LOGW ("could not send ARP for address %s: %s", argv[ip_arg],
                   error->message);
            g_clear_error (&error);
        }
    }
}
Exemplo n.º 3
0
static gboolean
run_helper (char **argv, guint which, gpointer user_data, GError **error)
{
	const char *helper_path;
	int exit_status = 0;
	gboolean success;
	char *errmsg = NULL, *outmsg = NULL;
	char *cmdline;

	helper_path = nm_utils_find_helper ((which == DCBTOOL) ? "dcbtool" : "fcoeadm", NULL, error);
	if (!helper_path)
		return FALSE;

	argv[0] = (char *) helper_path;
	cmdline = g_strjoinv (" ", argv);
	nm_log_dbg (LOGD_DCB, "%s", cmdline);

	success = g_spawn_sync ("/", argv, NULL, 0 /*G_SPAWN_DEFAULT*/,
	                        NULL, NULL,
	                        &outmsg, &errmsg, &exit_status, error);
	/* Log any stderr output */
	if (success && WIFEXITED (exit_status) && WEXITSTATUS (exit_status) && (errmsg || outmsg)) {
		gboolean ignore_error = FALSE;

		/* Ignore fcoeadm "success" errors like when FCoE is already set up */
		if (errmsg && strstr (errmsg, "Connection already created"))
			ignore_error = TRUE;

		if (ignore_error == FALSE) {
			nm_log_warn (LOGD_DCB, "'%s' failed: '%s'",
			             cmdline, (errmsg && strlen (errmsg)) ? errmsg : outmsg);
			g_set_error (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_FAILED,
			             "Failed to run '%s'", cmdline);
			success = FALSE;
		}
	}

	g_free (outmsg);
	g_free (errmsg);
	g_free (cmdline);
	return success;
}
Exemplo n.º 4
0
Arquivo: oilutil.c Projeto: cee1/oil
/**
 * oil_flags_to_string:
 * @flags: the flags, see #OilCPUFlagBits
 *
 * Get the string description of the @flags
 * 
 * Returns: a newly created string description of the @flags
 */
gchar *oil_flags_to_string (guint flags)
{
    gchar *flagv[OIL_FLAGBIT_NR + 1] = {0, };
    gchar *content = "no flag";
    gchar *ret;

    guint i, j;
    for (i = 0, j = 0; i < OIL_FLAGBIT_NR; i++) {
        if (flags & OIL_FLAG(i)) {
            flagv[j] = (gchar *) oil_cpu_flag_to_string (OIL_FLAG(i));
            j++;
        }
    }

    if (j) content = g_strjoinv (", ", flagv);
    ret = g_strdup_printf ("[%s]", content);
    if (j) g_free (content);

    return ret;
}
Exemplo n.º 5
0
static gboolean
write_config_file (GArray *array, GError **err)
{
    GError *e = NULL;
    gchar *conf, *contents;

    g_assert (!err || !*err);
    if (!err)
        err = &e;
    
    conf = find_config_file (FALSE, err);
    if (conf == NULL)
        return FALSE;

    contents = g_strjoinv ("\n", (gchar**)(array->data));
    bastile_util_write_file_private (conf, contents, err);
    g_free (contents);

    return *err ? FALSE : TRUE;
}
Exemplo n.º 6
0
static gchar *
lbc_readfile(const gchar * filename)
{
    gchar *buf;
    gchar **split;

    if (!g_file_get_contents(filename, &buf, NULL, NULL)) {
#if DEBUG
        g_message("Failed to read \"%s\"\n", filename);
#endif                          /* DEBUG */
        return NULL;
    }

    split = g_strsplit(buf, "\\\\ ", 0);
    g_free(buf);
    buf = g_strjoinv("\\ ", split);
    g_strfreev(split);

    return buf;
}
Exemplo n.º 7
0
static void
photos_application_launch_search (PhotosApplication *self, const gchar* const *terms, guint timestamp)
{
  PhotosApplicationPrivate *priv = self->priv;
  GVariant *state;
  gchar *str;

  photos_application_create_window (self);
  photos_mode_controller_set_window_mode (priv->mode_cntrlr, PHOTOS_WINDOW_MODE_OVERVIEW);

  str = g_strjoinv (" ", (gchar **) terms);
  photos_search_controller_set_string (priv->state->srch_cntrlr, str);
  g_free (str);

  state = g_variant_new ("b", TRUE);
  g_action_group_change_action_state (G_ACTION_GROUP (self), "search", state);

  priv->activation_timestamp = timestamp;
  g_application_activate (G_APPLICATION (self));
}
int
main(int argc, char **argv)
{
	char *message;
	int result;

	gtk_init(&argc, &argv);

	if (argc > 1) {
		message = g_strjoinv(" ", argv + 1);
	} else {
		message = g_strdup("Enter your OpenSSH passphrase:");
	}

	setvbuf(stdout, 0, _IONBF, 0);
	result = passphrase_dialog(message);
	g_free(message);

	return (result);
}
Exemplo n.º 9
0
static void pk_backend_search_files_thread(PkBackendJob *job, GVariant *params, gpointer user_data) {
	gchar **vals, *search;
	gchar *query;
	sqlite3_stmt *stmt;
	PkInfoEnum ret;
	PkBackendKatjaJobData *job_data = pk_backend_job_get_user_data(job);

	pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
	pk_backend_job_set_percentage(job, 0);

	g_variant_get(params, "(t^a&s)", NULL, &vals);
	search = g_strjoinv("%", vals);

	query = sqlite3_mprintf("SELECT (p.name || ';' || p.ver || ';' || p.arch || ';' || r.repo), p.summary, "
							"p.full_name FROM filelist AS f NATURAL JOIN pkglist AS p NATURAL JOIN repos AS r "
							"WHERE f.filename LIKE '%%%q%%' GROUP BY f.full_name", search);

	if ((sqlite3_prepare_v2(job_data->db, query, -1, &stmt, NULL) == SQLITE_OK)) {
		/* Now we're ready to output all packages */
		while (sqlite3_step(stmt) == SQLITE_ROW) {
			ret = katja_pkg_is_installed((gchar *) sqlite3_column_text(stmt, 2));
			if ((ret == PK_INFO_ENUM_INSTALLED) || (ret == PK_INFO_ENUM_UPDATING)) {
				pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED,
										(gchar *) sqlite3_column_text(stmt, 0),
										(gchar *) sqlite3_column_text(stmt, 1));
			} else if (ret == PK_INFO_ENUM_INSTALLING) {
				pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE,
										(gchar *) sqlite3_column_text(stmt, 0),
										(gchar *) sqlite3_column_text(stmt, 1));
			}
		}
		sqlite3_finalize(stmt);
	} else {
		pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db));
	}
	sqlite3_free(query);
	g_free(search);

	pk_backend_job_set_percentage(job, 100);
	pk_backend_job_finished (job);
}
Exemplo n.º 10
0
void
server_pool_entry_build_connection_string (ServerPoolEntry* entry,
        const gchar *username,
        const gchar *password,
        gchar **conn_string)
{
    g_return_if_fail (IS_SERVER_POOL_ENTRY (entry));

    gchar **conn_keywords, **conn_values;

    server_pool_entry_build_connection_params (entry, username, password,
            &conn_keywords, &conn_values);

    gchar **ptr = conn_keywords;
    int key_count = 0;
    while (*ptr++)
        key_count++;


    gchar **key_value_arr = (gchar**)g_malloc0 (sizeof (gchar**) * (key_count + 1) );

    while (--key_count >= 0) {
        DEBG_MSG ("Key count is %d", key_count);
        key_value_arr [key_count] = g_strjoin ("=",
                                               conn_keywords[key_count],
                                               conn_values[key_count],
                                               NULL);

    }


    gchar *result = g_strjoinv (" ", key_value_arr);



    g_strfreev (conn_keywords);
    g_strfreev (conn_values);
    g_strfreev (key_value_arr);

    *conn_string = result;
}
Exemplo n.º 11
0
static void hilight_print(int index, HILIGHT_REC *rec)
{
	char *chans, *levelstr;
	GString *options;

	options = g_string_new(NULL);
	if (!rec->nick || !rec->word) {
		if (rec->nick) g_string_append(options, "-nick ");
		if (rec->word) g_string_append(options, "-word ");
	}

	if (rec->nickmask) g_string_append(options, "-nickmask ");
	if (rec->fullword) g_string_append(options, "-fullword ");
	if (rec->regexp) {
		g_string_append(options, "-regexp ");
#ifdef HAVE_REGEX_H
		if (!rec->regexp_compiled)
			g_string_append(options, "[INVALID!] ");
#endif
	}

	if (rec->priority != 0)
		g_string_sprintfa(options, "-priority %d ", rec->priority);
	if (rec->color != NULL)
		g_string_sprintfa(options, "-color %s ", rec->color);
	if (rec->act_color != NULL)
		g_string_sprintfa(options, "-actcolor %s ", rec->act_color);

	chans = rec->channels == NULL ? NULL :
		g_strjoinv(",", rec->channels);
	levelstr = rec->level == 0 ? NULL :
		bits2level(rec->level);
	printformat(NULL, NULL, MSGLEVEL_CLIENTCRAP,
		    TXT_HILIGHT_LINE, index, rec->text,
		    chans != NULL ? chans : "",
		    levelstr != NULL ? levelstr : "",
		    options->str);
	g_free_not_null(chans);
	g_free_not_null(levelstr);
	g_string_free(options, TRUE);
}
Exemplo n.º 12
0
static GRegex *
re_url (void)
{
	static GRegex *url_ret;
	char *grist;
	char *scheme;

	if (url_ret) return url_ret;

	scheme = g_strjoinv ("|", prefix);
	grist = g_strdup_printf (
		"("	/* URL or HOST */
			"("
				SCHEME HOST OPT_PORT
				"("	/* Optional "/path?query_string#fragment_id" */
					"/"	/* Must start with slash */
					"("	
						"(" LPAR NOPARENS RPAR ")"
						"|"
						"(" NOPARENS ")"
					")*"	/* Zero or more occurrences of either of these */
					"(?<![.,?!\\]])"	/* Not allowed to end with these */
				")?"	/* Zero or one of this /path?query_string#fragment_id thing */
			")|("
				HOST OPT_PORT "/"
				"("	/* Optional "path?query_string#fragment_id" */
					"("
						"(" LPAR NOPARENS RPAR ")"
						"|"
						"(" NOPARENS ")"
					")*"	/* Zero or more occurrences of either of these */
					"(?<![.,?!\\]])"	/* Not allowed to end with these */
				")?"	/* Zero or one of this /path?query_string#fragment_id thing */
			")"
		")"
		, scheme
	);
	url_ret = make_re (grist, "re_url");
	g_free (scheme);
	return url_ret;
}
Exemplo n.º 13
0
/* Convert flags to string */
static char *
ap_wpa_rsn_flags_to_string (guint32 flags)
{
	char *flags_str[16]; /* Enough space for flags and terminating NULL */
	char *ret_str;
	int i = 0;

	if (flags & NM_802_11_AP_SEC_PAIR_WEP40)
		flags_str[i++] = g_strdup ("pair_wpe40");
	if (flags & NM_802_11_AP_SEC_PAIR_WEP104)
		flags_str[i++] = g_strdup ("pair_wpe104");
	if (flags & NM_802_11_AP_SEC_PAIR_TKIP)
		flags_str[i++] = g_strdup ("pair_tkip");
	if (flags & NM_802_11_AP_SEC_PAIR_CCMP)
		flags_str[i++] = g_strdup ("pair_ccmp");
	if (flags & NM_802_11_AP_SEC_GROUP_WEP40)
		flags_str[i++] = g_strdup ("group_wpe40");
	if (flags & NM_802_11_AP_SEC_GROUP_WEP104)
		flags_str[i++] = g_strdup ("group_wpe104");
	if (flags & NM_802_11_AP_SEC_GROUP_TKIP)
		flags_str[i++] = g_strdup ("group_tkip");
	if (flags & NM_802_11_AP_SEC_GROUP_CCMP)
		flags_str[i++] = g_strdup ("group_ccmp");
	if (flags & NM_802_11_AP_SEC_KEY_MGMT_PSK)
		flags_str[i++] = g_strdup ("psk");
	if (flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X)
		flags_str[i++] = g_strdup ("802.1X");

	if (i == 0)
		flags_str[i++] = g_strdup ("none");

	flags_str[i] = NULL;

	ret_str = g_strjoinv (" ", flags_str);

	i = 0;
	while (flags_str[i])
		 g_free (flags_str[i++]);

	return ret_str;
}
Exemplo n.º 14
0
Arquivo: prefs.c Projeto: phako/ignuit
static gchar*
prefs_schedules_to_csvstr (Prefs *p)
{
    gchar *s, *v[N_GROUPS + 1];
    gint i;


    /* Return a newly allocated string of comma separated schedules. */

    for (i = 0; i < N_GROUPS; i++)
        v[i] = g_strdup_printf ("%d", p->schedule[i]);

    v[N_GROUPS] = NULL;

    s = g_strjoinv (",", v);

    for (i = 0; i < N_GROUPS; i++)
        g_free (v[i]);

    return s;
}
static gchar *
extractable_check_id (GType type, const gchar * id)
{

  gchar *ret, **strv = g_strsplit (id, "!", -1);

  if (g_strv_length (strv) != 2) {
    g_strfreev (strv);

    return NULL;
  }

  /* Remove any whitespace */
  strv[0] = g_strstrip (strv[0]);
  strv[1] = g_strstrip (strv[1]);
  ret = g_strjoinv ("!", strv);

  g_strfreev (strv);

  return ret;
}
Exemplo n.º 16
0
static gboolean
asb_package_alpm_ensure_license (AsbPackage *pkg, GError **error)
{
	AsbPackageAlpm *pkg_alpm = ASB_PACKAGE_ALPM (pkg);
	AsbPackageAlpmPrivate *priv = GET_PRIVATE (pkg_alpm);
	
	alpm_list_t *alpm_licenses;
	GPtrArray *licenses;
	gchar *license;

	alpm_licenses = alpm_pkg_get_licenses (priv->package);
	licenses = asb_package_alpm_list_to_array (alpm_licenses);
	/* TODO: translate licenses to SPDX licenses (makes licenses clickable
	 * is GNOME Software) */
	license = g_strjoinv (" AND ", (gchar **)(licenses->pdata));

	asb_package_set_license (pkg, license);

	g_ptr_array_free (licenses, TRUE);
	return TRUE;
}
Exemplo n.º 17
0
gchar*
codeslayer_utils_strreplace (const gchar *string, 
                             const gchar *search,
                             const gchar *replacement)
{
  gchar *str, **arr;

  g_return_val_if_fail (string != NULL, NULL);
  g_return_val_if_fail (search != NULL, NULL);
  g_return_val_if_fail (replacement != NULL, NULL);

  arr = g_strsplit (string, search, -1);
  if (arr != NULL && arr[0] != NULL) 
    str = g_strjoinv (replacement, arr);
  else 
    str = g_strdup (string);

  g_strfreev (arr);

  return str;
}
Exemplo n.º 18
0
/*  Clean up a scheme options string for use in a key/value file.
 *  This function removes all full line comments, removes all blank
 *  lines, and removes all leading/trailing white space. */
gchar *gnc_guile_strip_comments (const gchar *raw_text)
{
    gchar *text, **splits;
    gint i, j;

    splits = g_strsplit(raw_text, "\n", -1);
    for (i = j = 0; splits[i]; i++)
    {
        if ((splits[i][0] == ';') || (splits[i][0] == '\0'))
        {
            g_free(splits[i]);
            continue;
        }
        splits[j++] = g_strstrip(splits[i]);
    }
    splits[j] = NULL;

    text = g_strjoinv(" ", splits);
    g_strfreev(splits);
    return text;
}
Exemplo n.º 19
0
gchar* dt_util_glist_to_str(const gchar* separator, GList * items, const unsigned int count)
{
  if(count == 0)
    return NULL;

  gchar *result = NULL;

  // add the entries to an char* array
  items = g_list_first(items);
  gchar** strings = g_malloc(sizeof(gchar*) * (count+1));
  if(items != NULL)
  {
    int i = 0;
    do
    {
      strings[i++] = items->data;
    }
    while((items=g_list_next(items)) != NULL);
    strings[i] = NULL;
  }

  // join them into a single string
  result = g_strjoinv(separator, strings);

  // free the GList and the array
  items = g_list_first(items);
  if(items != NULL)
  {
    do
    {
      g_free(items->data);
    }
    while((items=g_list_next(items)) != NULL);
  }
  g_list_free(items);
  if(strings != NULL)
    g_free(strings);

  return result;
}
Exemplo n.º 20
0
GError *
oio_sqlx_client__execute_statement (struct oio_sqlx_client_s *self,
		const char *in_stmt, gchar **in_params,
		struct oio_sqlx_output_ctx_s *out_ctx, gchar ***out_lines)
{
	GError *err = NULL;
	struct oio_sqlx_batch_s *batch = NULL;
	struct oio_sqlx_batch_result_s *result = NULL;

	GRID_TRACE("%s (%p, %s)", __FUNCTION__, self, in_stmt);

	(void) oio_sqlx_client_factory__batch (NULL, &batch);
	oio_sqlx_batch__add (batch, in_stmt, in_params);
	err = oio_sqlx_client__execute_batch (self, batch, &result);
	oio_sqlx_batch__destroy (batch);

	if (err) {
		g_assert (result == NULL);
		return err;
	}

	g_assert (result != NULL);
	guint count = oio_sqlx_batch_result__count_statements (result);
	g_assert (count == 1);
	guint count_lines = 0;
	err = oio_sqlx_batch_result__get_statement (result, 0, &count_lines, out_ctx);
	if (!err && out_lines) {
		GPtrArray *tmp = g_ptr_array_new ();
		for (guint i=0; i<count_lines ;++i) {
			gchar **fields = oio_sqlx_batch_result__get_row (result, 0, i);
			g_ptr_array_add (tmp, g_strjoinv (",", fields));
			g_strfreev (fields);
		}
		g_ptr_array_add (tmp, NULL);
		*out_lines = (gchar**) g_ptr_array_free (tmp, FALSE);
	}
	oio_sqlx_batch_result__destroy (result);

	return err;
}
Exemplo n.º 21
0
Arquivo: config.c Projeto: ork/bcw-ng
void args_execute(int argc, char* argv[])
{
    GError* error = NULL;

    g_option_context_parse(context, &argc, &argv, &error);
    g_option_context_free(context);

    if (error != NULL) {
        g_error("option parsing failed: %s\n", error->message);
    }

    /* Change debug level */
    if (verbose) {
        gboolean applied = g_setenv("G_MESSAGES_DEBUG", "all", TRUE);
        if (!applied) {
            g_error("Verbosity level could not be changed");
        }
    }

    /* Use a default PPD file if not specified */
    if (!definition) {
        definition = g_strdup_printf("/usr/share/cups/model/%s.ppd");
    }

    if (!g_file_test(definition, G_FILE_TEST_EXISTS)) {
        g_error("PPD file could not be located: %s");
    }

    /* Concatenate remaining argument as a single string to feed brprintconfig */
    if (remaining != NULL) {
        commandline = g_strjoinv(" ", remaining);
        g_strfreev(remaining);
    } else {
        commandline = g_strdup("NULL COMMAND LINE");
    }

    g_debug("Using printer model: %s", model);
    g_debug("Using PPD file: %s", definition);
    g_debug("Using brprintconf command line: %s", commandline);
}
Exemplo n.º 22
0
gchar*
eh_render_command_str (const int argc, const char* argv[])
{
   gchar* str = NULL;

   eh_require( argv!=NULL );

   if ( argv )
   {
      gint    i;
      gchar** str_array = NULL;

      for ( i=0 ; i<argc ; i++ )
         eh_strv_append (&str_array, g_strdup (argv[i]));

      str = g_strjoinv( " " , str_array );
      
      g_strfreev (str_array);
   }

   return str;
}
Exemplo n.º 23
0
Arquivo: rbd.c Projeto: nikunjad/qemu
static char *qemu_rbd_mon_host(QDict *options, Error **errp)
{
    const char **vals = g_new(const char *, qdict_size(options) + 1);
    char keybuf[32];
    const char *host, *port;
    char *rados_str;
    int i;

    for (i = 0;; i++) {
        sprintf(keybuf, "server.%d.host", i);
        host = qdict_get_try_str(options, keybuf);
        qdict_del(options, keybuf);
        sprintf(keybuf, "server.%d.port", i);
        port = qdict_get_try_str(options, keybuf);
        qdict_del(options, keybuf);
        if (!host && !port) {
            break;
        }
        if (!host) {
            error_setg(errp, "Parameter server.%d.host is missing", i);
            rados_str = NULL;
            goto out;
        }

        if (strchr(host, ':')) {
            vals[i] = port ? g_strdup_printf("[%s]:%s", host, port)
                : g_strdup_printf("[%s]", host);
        } else {
            vals[i] = port ? g_strdup_printf("%s:%s", host, port)
                : g_strdup(host);
        }
    }
    vals[i] = NULL;

    rados_str = i ? g_strjoinv(";", (char **)vals) : NULL;
out:
    g_strfreev((char **)vals);
    return rados_str;
}
Exemplo n.º 24
0
// we already have the lock
// remove the lock
void
write_cmdfile(
    cmddatas_t *cmddatas)
{
    GPtrArray *lines = g_ptr_array_sized_new(100);
    char *buffer;

    // generate
    g_ptr_array_add(lines, g_strdup_printf("VERSION %d\n", cmddatas->version));
    g_ptr_array_add(lines, g_strdup_printf("ID %d\n", cmddatas->max_id));
    g_hash_table_foreach(cmddatas->cmdfile, &cmdfile_write, lines);
    g_ptr_array_add(lines, NULL);
    buffer = g_strjoinv(NULL, (gchar **)lines->pdata);
    g_ptr_array_free_full(lines);

    // write
    file_lock_write(cmddatas->lock, buffer, strlen(buffer));
    g_free(buffer);

    // unlock
    file_lock_unlock(cmddatas->lock);
}
Exemplo n.º 25
0
int
main(int argc, char **argv)
{
    char *message;
    int result;

    gtk_init(&argc, &argv);

    gtk_window_set_default_icon_from_file ("/usr/share/pixmaps/ssh-askpass-gnome.png", NULL);

    if (argc > 1) {
        message = g_strjoinv(" ", argv + 1);
    } else {
        message = g_strdup("Enter your OpenSSH passphrase:");
    }

    setvbuf(stdout, 0, _IONBF, 0);
    result = passphrase_dialog(message);
    g_free(message);

    return (result);
}
Exemplo n.º 26
0
static void irc_cmd_oper_hack( irc_t *irc, char **cmd )
{
	char *password = g_strjoinv( " ", cmd + 2 );
	
	/* /OPER can now also be used to enter IM/identify passwords without
	   echoing. It's a hack but the extra password security is worth it. */
	if( irc->status & OPER_HACK_ACCOUNT_ADD )
	{
		account_t *a;
		
		for( a = irc->b->accounts; a; a = a->next )
			if( strcmp( a->pass, PASSWORD_PENDING ) == 0 )
			{
				set_setstr( &a->set, "password", password );
				irc_usermsg( irc, "Password added to IM account "
				             "%s(%s)", a->prpl->name, a->user );
				/* The IRC client may expect this. 491 suggests the OPER
				   password was wrong, so the client won't expect a +o.
				   It may however repeat the password prompt. We'll see. */
				irc_send_num( irc, 491, ":Password added to IM account "
				              "%s(%s)", a->prpl->name, a->user );
			}
	}
	else if( irc->status & OPER_HACK_IDENTIFY )
	{
		char *send_cmd[] = { "identify", password, NULL };
		irc_send_num( irc, 491, ":Trying to identify" );
		root_command( irc, send_cmd );
	}
	else if( irc->status & OPER_HACK_REGISTER )
	{
		char *send_cmd[] = { "register", password, NULL };
		irc_send_num( irc, 491, ":Trying to identify" );
		root_command( irc, send_cmd );
	}
	
	irc->status &= ~OPER_HACK_ANY;
	g_free( password );
}
Exemplo n.º 27
0
static void
gst_avdtp_src_start_avrcp (GstAvdtpSrc * src)
{
  gchar *path, **strv;
  int i;

  /* Strip out the /fdX in /org/bluez/dev_.../fdX */
  strv = g_strsplit (src->conn.transport, "/", -1);

  for (i = 0; strv[i]; i++);
  g_return_if_fail (i > 0);

  g_free (strv[i - 1]);
  strv[i - 1] = NULL;

  path = g_strjoinv ("/", strv);
  g_strfreev (strv);

  src->avrcp = gst_avrcp_connection_new (path, avrcp_metadata_cb, src, NULL);

  g_free (path);
}
Exemplo n.º 28
0
/** Returns the gconf schema config source path, usually
 * "$prefix/etc/gconf/gconf.xml.defaults".
 *
 * @returns A newly allocated string. */
gchar *gnc_path_get_gconfdir(gboolean force_slashes)
{
    gchar *sysconfdir = gnc_gbr_find_etc_dir (SYSCONFDIR);
    gchar *separator = G_DIR_SEPARATOR_S;
    gchar *result;

    if (force_slashes)
    {
        gchar **splitted;
        splitted = g_strsplit (sysconfdir, "\\", -1);
        g_free (sysconfdir);
        sysconfdir = g_strjoinv ("/", splitted);
        g_strfreev (splitted);
        separator = "/";
    }

    result = g_build_path (separator, sysconfdir, "gconf", "gconf.xml.defaults",
                           (gchar*)NULL);
    g_free (sysconfdir);
    //printf("Returning gconfdir %s\n", result);
    return result;
}
Exemplo n.º 29
0
static gchar *
ui_manager_filter_ui (EUIManager *ui_manager,
                      const gchar *ui_definition)
{
	gchar **lines;
	gchar *filtered;
	gboolean express_mode;
	gboolean include = TRUE;
	gint ii;

	express_mode = e_ui_manager_get_express_mode (ui_manager);

	/*
	 * Very simple C style pre-processing in-line in the XML:
	 * #if [!]EXPRESS\n ... \n#endif\n
	 */
	lines = g_strsplit (ui_definition, "\n", -1);

	for (ii = 0; lines[ii] != NULL; ii++) {
		if (lines[ii][0] == '#') {
			if (!strncmp (lines[ii], "#if ", 4)) {
				gboolean not_express = lines[ii][4] == '!';
				include = express_mode ^ not_express;
				lines[ii][0] = '\0';
			} else if (!strncmp (lines[ii], "#endif", 6)) {
				lines[ii][0] = '\0';
				include = TRUE;
			}
		}
		if (!include)
			lines[ii][0] = '\0';
	}

	filtered = g_strjoinv ("\n", lines);

	g_strfreev (lines);

	return filtered;
}
Exemplo n.º 30
0
gint gmpv_mpv_obj_command(GmpvMpvObj *mpv, const gchar **cmd)
{
	gint rc = MPV_ERROR_UNINITIALIZED;

	if(mpv->mpv_ctx)
	{
		rc = mpv_command(mpv->mpv_ctx, cmd);
	}

	if(rc < 0)
	{
		gchar *cmd_str = g_strjoinv(" ", (gchar **)cmd);

		g_warning(	"Failed to run mpv command \"%s\". Reason: %s.",
				cmd_str,
				mpv_error_string(rc) );

		g_free(cmd_str);
	}

	return rc;
}