void __connman_agent_cleanup(void)
{
DBusMessage *message;
DBG("");
if (connection == NULL)
return;
if (agent_watch > 0)
g_dbus_remove_watch(connection, agent_watch);
if (agent_path == NULL)
return;
message = dbus_message_new_method_call(agent_sender, agent_path,
CONNMAN_AGENT_INTERFACE, "Release");
if (message == NULL)
return;
dbus_message_set_no_reply(message, TRUE);
g_dbus_send_message(connection, message);
agent_free();
dbus_connection_unref(connection);
}
static DBusMessage *unregister_agent(DBusConnection *conn,
DBusMessage *msg, void *data)
{
const char *path, *sender;
if (!agent)
return agent_does_not_exist(msg);
if (!dbus_message_get_args(msg, NULL,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID))
return invalid_args(msg);
if (strcmp(agent->path, path) != 0)
return agent_does_not_exist(msg);
sender = dbus_message_get_sender(msg);
if (strcmp(agent->bus_name, sender) != 0)
return not_authorized(msg);
g_dbus_remove_watch(conn, agent->watch_id);
agent_free(agent);
agent = NULL;
DBG("Agent unregistered");
return dbus_message_new_method_return(msg);
}
static DBusMessage *unregister_agent(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct audio_device *device = data;
struct gateway *gw = device->gateway;
const char *path;
if (!gw->agent)
goto done;
if (strcmp(gw->agent->name, dbus_message_get_sender(msg)) != 0)
return btd_error_not_authorized(msg);
if (!dbus_message_get_args(msg, NULL,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID))
return btd_error_invalid_args(msg);
if (strcmp(gw->agent->path, path) != 0)
return btd_error_does_not_exist(msg);
g_dbus_remove_watch(conn, gw->agent->watch);
agent_free(gw->agent);
gw->agent = NULL;
done:
return dbus_message_new_method_return(msg);
}
static DBusMessage *am_agent_unregister(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
const char *sender, *path;
DBusMessageIter iter;
if (agent == NULL)
return __ofono_error_not_found(msg);
sender = dbus_message_get_sender(msg);
if (dbus_message_iter_init(msg, &iter) == FALSE)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &path);
if (strcmp(sender, agent->owner) != 0)
return __ofono_error_not_allowed(msg);
if (strcmp(path, agent->path) != 0)
return __ofono_error_not_found(msg);
agent_free(agent);
agent = NULL;
has_wideband = FALSE;
DBG("Agent %s unregistered", sender);
return dbus_message_new_method_return(msg);
}
static DBusMessage *release_agent(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct session_data *session = user_data;
struct agent_data *agent = session->agent;
const gchar *sender;
gchar *path;
if (dbus_message_get_args(message, NULL,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID) == FALSE)
return g_dbus_create_error(message,
"org.openobex.Error.InvalidArguments",
"Invalid arguments in method call");
sender = dbus_message_get_sender(message);
if (agent == NULL || g_str_equal(sender, agent->name) == FALSE ||
g_str_equal(path, agent->path) == FALSE)
return g_dbus_create_error(message,
"org.openobex.Error.NotAuthorized",
"Not Authorized");
agent_free(session);
return dbus_message_new_method_return(message);
}
static void agent_disconnected(DBusConnection *connection, void *user_data)
{
struct session_data *session = user_data;
session->agent->watch = 0;
agent_free(session);
}
static void agent_disconnect(DBusConnection *conn, void *user_data)
{
DBG("Agent %s disconnected", agent->owner);
agent_free(agent);
agent = NULL;
has_wideband = FALSE;
}
int agent_destroy(struct agent *agent, gboolean exited)
{
if (!agent)
return 0;
agent->exited = exited;
agent_free(agent);
return 0;
}
static void agent_exited(DBusConnection *conn, void *user_data)
{
struct agent *agent = user_data;
DBG("Agent exited without calling Unregister");
agent->exited = TRUE;
agent_free(agent);
}
static void agent_exited(DBusConnection *conn, void *data)
{
struct gateway *gateway = data;
struct hf_agent *agent = gateway->agent;
DBG("Agent %s exited", agent->name);
agent_free(agent);
gateway->agent = NULL;
}
INTERNAL void
agentman(EVENT_AGENTD_REQ *eagent) {
int pid, exitstat;
int me;
int rc;
AGENT_REQ *areq;
if (Debug)
printf("agentman: starting\n");
/* Copy arg data into active Agent list & unblock parent */
mp_lock(AgentLock);
printf("Allocating agent control block\n");
areq = agent_alloc();
if (!areq) {
fprintf(stderr, "agentman: can't start %s\n", eagent->module);
mp_exit(0);
}
printf("Initializing agent control block\\n");
memcpy(&areq->ereq, eagent, sizeof(EVENT_AGENTD_REQ));
mp_unlock(AgentLock);
/* Unblock parent thread */
mp_incsema(AgentInit);
if (Debug)
printf("agentman: starting as thread %d.%d\n", getpid(), mp_gettid());
areq->pid = 0;
areq->status = AGENTD_AGENT_INIT;
areq->start = event_clock();
if (areq->ereq.log[0] && areq->ereq.log[0] != ' ')
rc = start_logger(areq, areq->ereq.log, areq->ereq.module, areq->ereq.args, &pid);
else
rc = start_agent(areq, areq->ereq.module, areq->ereq.args, &pid);
if (Debug)
printf("agentman: thread (%d.%d) done and exiting\n",
getpid(), mp_gettid());
/* Copy to obiturary list */
if (++Nrip == MAX_RIP) Nrip = 0;
memcpy(Rip, areq, sizeof(AGENT_REQ));
/* Remove entry for this agent */
mp_lock(AgentLock);
agent_free(areq);
mp_unlock(AgentLock);
mp_exit(0);
}
void agent_destroy(Agent* agent)
{
if(agent!=NULL){
if(agent->agentID==sap_agent_id-1)
sap_agent_id--;
}
agent_detach_from_list(agent);
agent_manager_list_free(agent->first_manager);
delete_all_table_from_agent(agent);
delete_all_subtree_from_agent(agent);
delete_agent_from_resource_list(agent);
agent_free(agent);
}
static void agent_release(struct session_data *session)
{
struct agent_data *agent = session->agent;
DBusMessage *message;
message = dbus_message_new_method_call(agent->name,
agent->path, AGENT_INTERFACE, "Release");
dbus_message_set_no_reply(message, TRUE);
g_dbus_send_message(session->conn, message);
agent_free(session);
}
void manager_cleanup(void)
{
DBG("");
g_dbus_unregister_interface(connection, OBEX_MANAGER_PATH,
OBEX_MANAGER_INTERFACE);
/* FIXME: Release agent? */
if (agent)
agent_free(agent);
dbus_connection_unref(connection);
}
int connman_agent_unregister(const char *sender, const char *path)
{
DBG("sender %s path %s", sender, path);
if (agent_path == NULL)
return -ESRCH;
if (agent_watch > 0)
g_dbus_remove_watch(connection, agent_watch);
agent_free();
return 0;
}
void agent_list_delete()
{
Agent *ap = first_agent;
Agent *next;
while(ap)
{
next = ap->next_agent;
agent_free(ap);
ap = next;
}
first_agent = NULL;
return;
}
/**
* connman_agent_driver_unregister:
* @driver: Agent driver definition
*
* Remove a previously registered agent driver
*/
void connman_agent_driver_unregister(struct connman_agent_driver *driver)
{
GSList *list;
if (driver == NULL)
return;
DBG("Unregistering driver %p name %s", driver, driver->name);
if (agent_sender == NULL && agent_path == NULL)
goto out;
for (list = driver_list; list; list = list->next) {
DBusMessage *message;
if (driver != list->data)
continue;
DBG("Sending release to %s path %s iface %s", agent_sender,
agent_path, driver->interface);
message = dbus_message_new_method_call(agent_sender, agent_path,
driver->interface, "Release");
if (message != NULL) {
dbus_message_set_no_reply(message, TRUE);
g_dbus_send_message(connection, message);
}
agent_free();
/*
* ATM agent_free() unsets the agent_sender and agent_path
* variables so we can unregister only once.
* This needs proper fix later.
*/
break;
}
out:
driver_list = g_slist_remove(driver_list, driver);
}
void ofono_handsfree_audio_unref(void)
{
if (ref_count == 0) {
ofono_error("Error in handsfree audio manager ref counting");
return;
}
ref_count -= 1;
if (ref_count > 0)
return;
g_dbus_unregister_interface(ofono_dbus_get_connection(),
OFONO_MANAGER_PATH,
HFP_AUDIO_MANAGER_INTERFACE);
if (agent) {
agent_release(agent);
agent_free(agent);
}
__ofono_handsfree_audio_manager_cleanup();
}
/**
* @brief Deallocate a SSH session handle.
*
* @param[in] session The SSH session to free.
*
* @see ssh_disconnect()
* @see ssh_new()
*/
void ssh_free(ssh_session session) {
int i;
struct ssh_iterator *it;
if (session == NULL) {
return;
}
/*
* Delete all channels
*
* This needs the first thing we clean up cause if there is still an open
* channel we call ssh_channel_close() first. So we need a working socket
* and poll context for it.
*/
for (it = ssh_list_get_iterator(session->channels);
it != NULL;
it = ssh_list_get_iterator(session->channels)) {
ssh_channel_do_free(ssh_iterator_value(ssh_channel,it));
ssh_list_remove(session->channels, it);
}
ssh_list_free(session->channels);
session->channels = NULL;
#ifdef WITH_PCAP
if (session->pcap_ctx) {
ssh_pcap_context_free(session->pcap_ctx);
session->pcap_ctx = NULL;
}
#endif
ssh_socket_free(session->socket);
session->socket = NULL;
if (session->default_poll_ctx) {
ssh_poll_ctx_free(session->default_poll_ctx);
}
ssh_buffer_free(session->in_buffer);
ssh_buffer_free(session->out_buffer);
session->in_buffer = session->out_buffer = NULL;
if (session->in_hashbuf != NULL) {
ssh_buffer_free(session->in_hashbuf);
}
if (session->out_hashbuf != NULL) {
ssh_buffer_free(session->out_hashbuf);
}
crypto_free(session->current_crypto);
crypto_free(session->next_crypto);
#ifndef _WIN32
agent_free(session->agent);
#endif /* _WIN32 */
ssh_key_free(session->srv.dsa_key);
ssh_key_free(session->srv.rsa_key);
if (session->ssh_message_list) {
ssh_message msg;
for (msg = ssh_list_pop_head(ssh_message, session->ssh_message_list);
msg != NULL;
msg = ssh_list_pop_head(ssh_message, session->ssh_message_list)) {
ssh_message_free(msg);
}
ssh_list_free(session->ssh_message_list);
}
if (session->packet_callbacks) {
ssh_list_free(session->packet_callbacks);
}
/* options */
if (session->opts.identity) {
char *id;
for (id = ssh_list_pop_head(char *, session->opts.identity);
id != NULL;
id = ssh_list_pop_head(char *, session->opts.identity)) {
SAFE_FREE(id);
}
ssh_list_free(session->opts.identity);
}
static void agent_disconnect(DBusConnection *conn, void *data)
{
DBG("data %p", data);
agent_free();
}
static void agent_disconnected(DBusConnection *conn, void *user_data)
{
DBG("Agent exited");
agent_free(agent);
agent = NULL;
}
