Beispiel #1
0
service_container::service_ptr_t
service_container::resolve_service_dependencies(string id)
{
    logtrace << "service_container::resolve_service_dependencies('" << id << "')";

    service_ptr_t service = this->services_.find(id);

    logtrace << " » found service: " << service->id()
             << ", got a " << service->get_service_definition_type_name();

    if (service->was_visited())
        return service;
    else if (service->is_resolving_in_progress())
        return nullptr; // todo: throw ex. ? is this a cycle ?

    logtrace << " » resolving dependencies...";

    service->set_resolving_in_progress(true);

    auto dependencies = service->get_dependencies_map();

    logtrace << " » dependencies map contains "
             << dependencies.size() << " elements.";

    for (auto pair : dependencies) {
        auto depdecl = pair.second;

        logtrace << "     - depends on service "
                 << depdecl->get_service_id()
                 << ", type: " << depdecl->get_service_type().pretty_name();

        service_ptr_t serv = this->resolve_service_dependencies(
                                 depdecl->get_service_id()
                             );

        logtrace << " » " << service->id()
                 << " : finished processing dep. : " << depdecl->get_service_id();

        depdecl->set_service(serv);
    }

    logtrace << " » " << service->id() << " : end of dependencies resolution.";
    logtrace << " » " << service->id() << " : about to construct service.";

    service->construct();

    logtrace << " » " << service->id() << " : construct() done.";

    service->set_resolving_in_progress(false);
    service->set_visited(true);

    return service;
}
Beispiel #2
0
int connection_register(struct btd_service *service)
{
	struct btd_device *device = btd_service_get_device(service);
	struct network_peer *peer;
	struct network_conn *nc;
	uint16_t id = get_service_id(service);

	DBG("%s id %u", device_get_path(device), id);

	peer = find_peer(peers, device);
	if (!peer) {
		peer = create_peer(device);
		if (!peer)
			return -1;
		peers = g_slist_append(peers, peer);
	}

	nc = g_new0(struct network_conn, 1);
	nc->id = id;
	nc->service = btd_service_ref(service);
	nc->state = DISCONNECTED;
	nc->peer = peer;

	btd_service_set_user_data(service, nc);

	DBG("id %u registered", id);

	peer->connections = g_slist_append(peer->connections, nc);

	return 0;
}
Beispiel #3
0
/* Connect and initiate BNEP session */
int connection_connect(struct btd_service *service)
{
	struct network_conn *nc = btd_service_get_user_data(service);
	struct network_peer *peer = nc->peer;
	uint16_t id = get_service_id(service);
	GError *err = NULL;
	const bdaddr_t *src;
	const bdaddr_t *dst;

	DBG("id %u", id);

	if (nc->state != DISCONNECTED)
		return -EALREADY;

	src = btd_adapter_get_address(device_get_adapter(peer->device));
	dst = device_get_address(peer->device);

	nc->io = bt_io_connect(connect_cb, nc,
				NULL, &err,
				BT_IO_OPT_SOURCE_BDADDR, src,
				BT_IO_OPT_DEST_BDADDR, dst,
				BT_IO_OPT_PSM, BNEP_PSM,
				BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_MEDIUM,
				BT_IO_OPT_OMTU, BNEP_MTU,
				BT_IO_OPT_IMTU, BNEP_MTU,
				BT_IO_OPT_INVALID);
	if (!nc->io)
		return -EIO;

	nc->state = CONNECTING;

	return 0;
}
Beispiel #4
0
static gboolean save_accounts(GtkTreeModel *model, GtkTreePath *path,
	GtkTreeIter *iter, gpointer data)
{
	FILE *fp = data;

	int tmp_connect = 0;
	char *service, *user, *pass;
	int id;

	gtk_tree_model_get(GTK_TREE_MODEL(account_list_store), iter,
		CONNECT, &tmp_connect,
		SERVICE_TYPE, &service, USER_NAME, &user, PASSWORD, &pass, -1);

	id = get_service_id(service);
	if (accounts && (ela = find_local_account_by_handle(user, id))) {
		LList *config = NULL;
		config = eb_services[id].sc->write_local_config(ela);
		config = value_pair_remove(config, "SCREEN_NAME");
		config = value_pair_add(config, "SCREEN_NAME", user);
		config = value_pair_remove(config, "PASSWORD");
		config = value_pair_add(config, "PASSWORD", pass);
		config = value_pair_remove(config, "CONNECT");
		config = value_pair_add(config, "CONNECT",
			tmp_connect ? "1" : "0");
		fprintf(fp, "<ACCOUNT %s>\n", service);
		value_pair_print_values(config, fp, 1);
		fprintf(fp, "</ACCOUNT>\n");
		existing_accounts = l_list_append(existing_accounts, ela);
	} else {
		LList *config = NULL;
		eb_debug(DBG_CORE,
			"Adding new account %s service %s\n", user, service);
		pairs = value_pair_add(NULL, "SCREEN_NAME", user);
		pairs = value_pair_add(pairs, "PASSWORD", pass);
		save_account_info(service, pairs);
		ela = eb_services[id].sc->read_local_account_config(pairs);

		if (ela != NULL) {
			/* Is this an account for which a module is not loaded? */
			if (ela->service_id == -1)
				ela->service_id = id;
			new_accounts = l_list_append(new_accounts, ela);
			config = eb_services[id].sc->write_local_config(ela);
			config = value_pair_remove(config, "CONNECT");
			config = value_pair_add(config, "CONNECT",
				tmp_connect ? "1" : "0");

			fprintf(fp, "<ACCOUNT %s>\n", service);
			value_pair_print_values(config, fp, 1);
			fprintf(fp, "</ACCOUNT>\n");
		} else
			ay_do_error(_("Invalid Service"),
				_("Can't add account : unknown service"));
	}

	return FALSE;
}
Beispiel #5
0
/* Callback for Add Button */
static void add_callback(GtkWidget *widget, gpointer data)
{
	const gchar *text[4];
	char *error_message = NULL;
	GtkTreeIter insert;

	text[CONNECT] = "";
	text[USER_NAME] = gtk_entry_get_text(GTK_ENTRY(username));
	text[PASSWORD] = gtk_entry_get_text(GTK_ENTRY(password));
	text[SERVICE_TYPE] =
		gtk_combo_box_get_active_text(GTK_COMBO_BOX(service_type));

	error_message = check_login_validity(text);
	if (error_message) {
		char *buf =
			g_strdup_printf(_
			("This account is not a valid %s account: \n\n %s"),
			(text[SERVICE_TYPE] ? text[SERVICE_TYPE] : ""),
			error_message);
		g_free(error_message);
		ay_do_error(_("Invalid Account"), buf);
		g_free(buf);
		return;
	}

	if (!can_multiaccount(eb_services[get_service_id(text[SERVICE_TYPE])])) {
		service_exists = FALSE;
		gtk_tree_model_foreach(GTK_TREE_MODEL(account_list_store),
			find_existing_account_add, (gchar *)text[SERVICE_TYPE]);

		if (service_exists) {
			char *buf =
				g_strdup_printf(_
				("You already have an account for %s service.\n\n"
					"Multiple accounts on this service aren't supported yet."),
				text[SERVICE_TYPE]);
			ay_do_error(_("Invalid Account"), buf);
			g_free(buf);
			return;
		}
	}

	gtk_list_store_append(account_list_store, &insert);
	gtk_list_store_set(account_list_store, &insert,
		CONNECT,
		gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
			(connect_at_startup)), SERVICE_TYPE, text[SERVICE_TYPE],
		USER_NAME, text[USER_NAME], PASSWORD, text[PASSWORD], -1);

	num_accounts++;
	eb_debug(DBG_CORE, "num_accounts %d\n", num_accounts);
	gtk_entry_set_text(GTK_ENTRY(username), "");
	gtk_entry_set_text(GTK_ENTRY(password), "");
	gtk_combo_box_set_active(GTK_COMBO_BOX(service_type), -1);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(connect_at_startup),
		FALSE);
}
Beispiel #6
0
gboolean find_existing_account_mod(GtkTreeModel *model, GtkTreePath *path,
	GtkTreeIter *iter, gpointer data)
{
	gpointer serv;

	GtkTreeSelection *selection =
		gtk_tree_view_get_selection(GTK_TREE_VIEW(account_list));

	gtk_tree_model_get(model, iter, SERVICE_TYPE, &serv, -1);

	if (!gtk_tree_selection_path_is_selected(selection, path)
		&& !strcasecmp(serv, data)
		&& !can_multiaccount(eb_services[get_service_id(data)])) {
		return (service_exists = TRUE);
	}

	return (service_exists = FALSE);
}
Beispiel #7
0
void connection_unregister(struct btd_service *service)
{
	struct btd_device *device = btd_service_get_device(service);
	struct network_conn *conn = btd_service_get_user_data(service);
	struct network_peer *peer = conn->peer;
	uint16_t id = get_service_id(service);

	DBG("%s id %u", device_get_path(device), id);

	peer->connections = g_slist_remove(peer->connections, conn);
	connection_free(conn);

	if (peer->connections != NULL)
		return;

	g_dbus_unregister_interface(btd_get_dbus_connection(),
						device_get_path(device),
						NETWORK_PEER_INTERFACE);
}
Beispiel #8
0
static char *check_login_validity(const gchar *text[])
{
	LList *services = get_service_list();
	LList *l = services;

	if (text[USER_NAME] == NULL || strlen(text[USER_NAME]) == 0)
		return strdup(_("Please enter an account name."));

	if (text[SERVICE_TYPE] == NULL || strlen(text[SERVICE_TYPE]) == 0)
		return strdup(_("Please select an account type."));

	while (l) {
		if (!strcmp(l->data, text[SERVICE_TYPE]))
			return eb_services[get_service_id(l->data)].
				sc->check_login(text[USER_NAME],
				text[PASSWORD]);
		l = l->next;
	}

	return NULL;
}
Beispiel #9
0
void ayttm_prefs_read_file(char *file)
{
	const int buffer_size = 1024;
	char buff[buffer_size];
	char *const param = buff;	/* just another name for buff... */
	FILE *fp = NULL;

	snprintf(buff, buffer_size, "%s", file);

	fp = fopen(buff, "r");

	if (fp == NULL) {
		char tmp[1024];
		snprintf(tmp, 1024, "%sprefs", config_dir);
		if (!strcmp(file, tmp)) {
			printf("Creating prefs file [%s]\n", buff);
			ayttm_prefs_write();
		}
		return;
	}

	fgets(param, buffer_size, fp);

	while (!feof(fp)) {
		int pref_type = CORE_PREF;
		char *val = buff;

		s_strip_whitespace(param);

		if (!strcasecmp(param, "plugins"))
			pref_type = PLUGIN_PREF;
		else if (!strcasecmp(param, "connections"))
			pref_type = SERVICE_PREF;

		if (pref_type != CORE_PREF) {
			for (;;) {
				int id = -1;
				char *plugin_name = NULL;
				LList *session_prefs = NULL;

				fgets(param, buffer_size, fp);

				s_strip_whitespace(param);

				if (!strcasecmp(param, "end"))
					break;

				switch (pref_type) {
				case PLUGIN_PREF:
					plugin_name = strdup(param);
					break;

				case SERVICE_PREF:
					id = get_service_id(param);
					break;

				default:
					assert(FALSE);
					break;
				}

				for (;;) {
					LList *old_session_prefs = NULL;

					fgets(param, buffer_size, fp);

					s_strip_whitespace(param);

					if (!strcasecmp(param, "end")) {
						switch (pref_type) {
						case PLUGIN_PREF:
							old_session_prefs =
								SetPref
								(plugin_name,
								session_prefs);

							free(plugin_name);
							break;

						case SERVICE_PREF:
							old_session_prefs =
								SetPref
								(get_service_name
								(id),
								session_prefs);
							break;

						default:
							assert(FALSE);
							break;
						}

						if (old_session_prefs != NULL) {
							eb_debug(DBG_CORE,
								"Freeing old_session_prefs\n");
							value_pair_free
								(old_session_prefs);
						}
						break;
					} else {
						val = param;

						while (*val != 0 && *val != '=')
							val++;

						if (*val == '=') {
							*val = '\0';
							val++;
						}

						/* strip off quotes */
						if (*val == '"') {
							val++;
							val[strlen(val) - 1] =
								'\0';
						}

						eb_debug(DBG_CORE,
							"Adding %s:%s to session_prefs\n",
							param, val);
						session_prefs =
							value_pair_add
							(session_prefs, param,
							val);
					}
				}
			}
			continue;
		}
		/* if(pref_type != CORE_PREF) */
		val = param;

		while (*val != 0 && *val != '=')
			val++;

		if (*val == '=') {
			*val = '\0';
			val++;
		}

		cSetLocalPref(param, val);

		fgets(param, buffer_size, fp);
	}

	fclose(fp);

	if (iGetLocalPref("do_proxy_auth") != 0)
		ay_proxy_set_default(iGetLocalPref("proxy_type"),
			cGetLocalPref("proxy_host"),
			iGetLocalPref("proxy_port"),
			cGetLocalPref("proxy_user"),
			cGetLocalPref("proxy_password"));
	else
		ay_proxy_set_default(iGetLocalPref("proxy_type"),
			cGetLocalPref("proxy_host"),
			iGetLocalPref("proxy_port"), NULL, NULL);
}