static LassiConnection* connection_add(LassiServer *ls, DBusConnection *c, gboolean we_are_client) {
LassiConnection *lc;
dbus_bool_t b;
DBusMessage *m;
gint32 ag, og, cg;
int fd, one = 1;
g_assert(ls);
g_assert(c);
lc = g_new(LassiConnection, 1);
lc->dbus_connection = dbus_connection_ref(c);
lc->server = ls;
lc->id = lc->address = NULL;
lc->we_are_client = we_are_client;
lc->delayed_welcome = FALSE;
ls->connections = g_list_prepend(ls->connections, lc);
ls->n_connections++;
dbus_connection_setup_with_g_main(c, NULL);
b = dbus_connection_add_filter(c, message_function, lc, NULL);
g_assert(b);
m = dbus_message_new_signal("/", LASSI_INTERFACE, "Hello");
g_assert(m);
ag = ls->active_generation;
og = ls->order_generation;
cg = ls->clipboard_generation;
b = dbus_message_append_args(
m,
DBUS_TYPE_STRING, &ls->id,
DBUS_TYPE_STRING, &ls->address,
DBUS_TYPE_INT32, &ag,
DBUS_TYPE_INT32, &og,
DBUS_TYPE_INT32, &cg,
DBUS_TYPE_INVALID);
g_assert(b);
fd = -1;
dbus_connection_get_socket(c, &fd);
g_assert(fd >= 0);
if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one)) < 0)
g_warning("Failed to enable TCP_NODELAY");
b = dbus_connection_send(c, m, NULL);
g_assert(b);
dbus_message_unref(m);
lassi_tray_update(&ls->tray_info, ls->n_connections);
return lc;
}
BusAppArmorConfinement*
bus_apparmor_init_connection_confinement (DBusConnection *connection,
DBusError *error)
{
#ifdef HAVE_APPARMOR
BusAppArmorConfinement *confinement;
char *label, *mode;
int fd;
if (!apparmor_enabled)
return NULL;
_dbus_assert (connection != NULL);
if (!dbus_connection_get_socket (connection, &fd))
{
dbus_set_error (error, DBUS_ERROR_FAILED,
"Failed to get socket file descriptor of connection");
return NULL;
}
if (aa_getpeercon (fd, &label, &mode) == -1)
{
if (errno == ENOMEM)
BUS_SET_OOM (error);
else
dbus_set_error (error, _dbus_error_from_errno (errno),
"Failed to get AppArmor confinement information of socket peer: %s",
_dbus_strerror (errno));
return NULL;
}
confinement = bus_apparmor_confinement_new (label, mode);
if (confinement == NULL)
{
BUS_SET_OOM (error);
free (label);
return NULL;
}
return confinement;
#else
return NULL;
#endif /* HAVE_APPARMOR */
}
void registerService()
{
DBusMessage* msg;
DBusMessageIter args;
DBusConnection* conn;
DBusError err;
DBusPendingCall* pending;
dbus_uint32_t level;
int fd;
char path[PATH_MAX];
const char *ret_string = 0;
// initialiset the errors
dbus_error_init(&err);
conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Connection Error (%s)\n", err.message);
dbus_error_free(&err);
return;
}
// create a new method call and check for errors
msg = dbus_message_new_method_call("org.bluez", // target for the method call
"/", // object to call on
"org.bluez.Manager", // interface to call on
"DefaultAdapter"); // method name
if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) {
fprintf(stderr, "dbus-send failed: Out Of Memory!\n");
return;
}
dbus_connection_flush(conn);
dbus_message_unref(msg);
dbus_pending_call_block(pending);
msg = dbus_pending_call_steal_reply(pending);
dbus_pending_call_unref(pending);
if (!dbus_message_iter_init(msg, &args))
fprintf(stderr, "Message has no arguments!\n");
else if (DBUS_TYPE_OBJECT_PATH != dbus_message_iter_get_arg_type(&args))
fprintf(stderr, "Argument is not an object path!\n");
else
dbus_message_iter_get_basic(&args, &ret_string);
if(!ret_string){
fprintf(stderr, "Failed to get bluez path\n");
return;
}
strcpy(path, ret_string);
// change path to use any
strcpy(rindex(path, '/'), "/any");
printf("Using path: %s\n", path);
dbus_message_unref(msg);
// create a new method call and check for errors
msg = dbus_message_new_method_call("org.bluez", // target for the method call
path, // object to call on
"org.bluez.Service", // interface to call on
"AddRecord"); // method name
if(!dbus_message_append_args(msg, DBUS_TYPE_STRING, &xmldefn, DBUS_TYPE_INVALID)){
fprintf(stderr, "Failed to append args\n");
return;
}
// send message and get a handle for a reply
if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
dbus_connection_flush(conn);
// free message
dbus_message_unref(msg);
// block until we receive a reply
dbus_pending_call_block(pending);
// get the reply message
msg = dbus_pending_call_steal_reply(pending);
if (NULL == msg) {
fprintf(stderr, "Reply Null\n");
return;
}
// free the pending message handle
dbus_pending_call_unref(pending);
// read the parameters
if (!dbus_message_iter_init(msg, &args))
fprintf(stderr, "Message has no arguments!\n");
else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args))
fprintf(stderr, "Argument is not int!\n");
else
dbus_message_iter_get_basic(&args, &level);
printf("Got handle: 0x%x\n", level);
// free reply
dbus_message_unref(msg);
dbus_connection_get_socket(conn, &fd);
addfd(head, fd, POLLHUP|POLLNVAL, dbus_error, 0x0);
}
int
main (int argc,
char *argv[])
{
char ** args;
DBusConnection * conn;
int fd, optval = 1, exitval = 1, ret;
DBusMessage *message = NULL, *reply = NULL;
DBusMessageIter iter;
dbus_uint32_t serial;;
nih_main_init (argv[0]);
nih_option_set_synopsis (_("Control group client"));
args = nih_option_parser (NULL, argc, argv, options, FALSE);
if (! args)
exit (1);
if (!controller)
usage(argv[0]);
if (pid == -1)
pid = getpid();
conn = nih_dbus_connect("unix:path=/tmp/cgmanager", NULL);
nih_assert (conn != NULL);
message = dbus_message_new_method_call(dbus_bus_get_unique_name(conn),
"/org/linuxcontainers/cgmanager",
"org.linuxcontainers.cgmanager0_0", "getPidCgroup");
if (!dbus_connection_get_socket(conn, &fd)) {
nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,
"Could not get socket");
return -1;
}
if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &optval, sizeof(optval)) == -1) {
perror("setsockopt");
return -1;
}
dbus_message_iter_init_append(message, &iter);
if (! dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING,
&controller)) {
nih_error_raise_no_memory ();
return -1;
}
dbus_message_iter_init_append(message, &iter);
if (! dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32,
&pid)) {
nih_error_raise_no_memory ();
return -1;
}
if (!dbus_connection_send(conn, message, &serial)) {
nih_error("failed to send dbus message");
return -1;
}
dbus_connection_flush(conn);
/* If we're sending our own pid, or if we're root, then
* we can send an SCM_CREDENTIAL
*/
if (pid == getpid() || geteuid() == 0) {
if (send_pid(fd, pid)) {
nih_error("Error sending pid over SCM_CREDENTIAL");
goto out;
}
}
while (!(reply = dbus_connection_pop_message(conn)))
dbus_connection_read_write(conn, -1);
if (dbus_message_get_reply_serial(reply) != serial) {
nih_error("wrong serial on reply");
goto out;
}
dbus_message_iter_init(reply, &iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) {
nih_error("Got bad reply type: %d", dbus_message_iter_get_arg_type(&iter));
goto out;
}
char *str_value;
dbus_message_iter_get_basic(&iter, &str_value);
printf("%s\n", str_value);
exitval = 0;
out:
if (message)
dbus_message_unref(message);
if (reply)
dbus_message_unref(reply);
dbus_connection_unref (conn);
exit(exitval);
}
