1 /* 2 * QEMU DBus display 3 * 4 * Copyright (c) 2021 Marc-André Lureau <marcandre.lureau@redhat.com> 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 #include "qemu/osdep.h" 25 #include "trace.h" 26 #include "qapi/error.h" 27 #include "qemu/config-file.h" 28 #include "qemu/option.h" 29 30 #include <gio/gunixfdlist.h> 31 32 #include "dbus.h" 33 34 static char * 35 dbus_display_chardev_path(DBusChardev *chr) 36 { 37 return g_strdup_printf(DBUS_DISPLAY1_ROOT "/Chardev_%s", 38 CHARDEV(chr)->label); 39 } 40 41 static void 42 dbus_display_chardev_export(DBusDisplay *dpy, DBusChardev *chr) 43 { 44 g_autoptr(GDBusObjectSkeleton) sk = NULL; 45 g_autofree char *path = dbus_display_chardev_path(chr); 46 47 if (chr->exported) { 48 return; 49 } 50 51 sk = g_dbus_object_skeleton_new(path); 52 g_dbus_object_skeleton_add_interface( 53 sk, G_DBUS_INTERFACE_SKELETON(chr->iface)); 54 g_dbus_object_manager_server_export(dpy->server, sk); 55 chr->exported = true; 56 } 57 58 static void 59 dbus_display_chardev_unexport(DBusDisplay *dpy, DBusChardev *chr) 60 { 61 g_autofree char *path = dbus_display_chardev_path(chr); 62 63 if (!chr->exported) { 64 return; 65 } 66 67 g_dbus_object_manager_server_unexport(dpy->server, path); 68 chr->exported = false; 69 } 70 71 static int 72 dbus_display_chardev_foreach(Object *obj, void *data) 73 { 74 DBusDisplay *dpy = DBUS_DISPLAY(data); 75 76 if (!CHARDEV_IS_DBUS(obj)) { 77 return 0; 78 } 79 80 dbus_display_chardev_export(dpy, DBUS_CHARDEV(obj)); 81 82 return 0; 83 } 84 85 static void 86 dbus_display_on_notify(Notifier *notifier, void *data) 87 { 88 DBusDisplay *dpy = container_of(notifier, DBusDisplay, notifier); 89 DBusDisplayEvent *event = data; 90 91 switch (event->type) { 92 case DBUS_DISPLAY_CHARDEV_OPEN: 93 dbus_display_chardev_export(dpy, event->chardev); 94 break; 95 case DBUS_DISPLAY_CHARDEV_CLOSE: 96 dbus_display_chardev_unexport(dpy, event->chardev); 97 break; 98 } 99 } 100 101 void 102 dbus_chardev_init(DBusDisplay *dpy) 103 { 104 dpy->notifier.notify = dbus_display_on_notify; 105 dbus_display_notifier_add(&dpy->notifier); 106 107 object_child_foreach(container_get(object_get_root(), "/chardevs"), 108 dbus_display_chardev_foreach, dpy); 109 } 110 111 static gboolean 112 dbus_chr_register( 113 DBusChardev *dc, 114 GDBusMethodInvocation *invocation, 115 GUnixFDList *fd_list, 116 GVariant *arg_stream, 117 QemuDBusDisplay1Chardev *object) 118 { 119 g_autoptr(GError) err = NULL; 120 int fd; 121 122 fd = g_unix_fd_list_get(fd_list, g_variant_get_handle(arg_stream), &err); 123 if (err) { 124 g_dbus_method_invocation_return_error( 125 invocation, 126 DBUS_DISPLAY_ERROR, 127 DBUS_DISPLAY_ERROR_FAILED, 128 "Couldn't get peer FD: %s", err->message); 129 return DBUS_METHOD_INVOCATION_HANDLED; 130 } 131 132 if (qemu_chr_add_client(CHARDEV(dc), fd) < 0) { 133 g_dbus_method_invocation_return_error(invocation, 134 DBUS_DISPLAY_ERROR, 135 DBUS_DISPLAY_ERROR_FAILED, 136 "Couldn't register FD!"); 137 close(fd); 138 return DBUS_METHOD_INVOCATION_HANDLED; 139 } 140 141 g_object_set(dc->iface, 142 "owner", g_dbus_method_invocation_get_sender(invocation), 143 NULL); 144 145 qemu_dbus_display1_chardev_complete_register(object, invocation, NULL); 146 return DBUS_METHOD_INVOCATION_HANDLED; 147 } 148 149 static gboolean 150 dbus_chr_send_break( 151 DBusChardev *dc, 152 GDBusMethodInvocation *invocation, 153 QemuDBusDisplay1Chardev *object) 154 { 155 qemu_chr_be_event(CHARDEV(dc), CHR_EVENT_BREAK); 156 157 qemu_dbus_display1_chardev_complete_send_break(object, invocation); 158 return DBUS_METHOD_INVOCATION_HANDLED; 159 } 160 161 static void 162 dbus_chr_open(Chardev *chr, ChardevBackend *backend, 163 bool *be_opened, Error **errp) 164 { 165 ERRP_GUARD(); 166 167 DBusChardev *dc = DBUS_CHARDEV(chr); 168 DBusDisplayEvent event = { 169 .type = DBUS_DISPLAY_CHARDEV_OPEN, 170 .chardev = dc, 171 }; 172 g_autoptr(ChardevBackend) be = NULL; 173 g_autoptr(QemuOpts) opts = NULL; 174 175 dc->iface = qemu_dbus_display1_chardev_skeleton_new(); 176 g_object_set(dc->iface, "name", backend->u.dbus.data->name, NULL); 177 g_object_connect(dc->iface, 178 "swapped-signal::handle-register", 179 dbus_chr_register, dc, 180 "swapped-signal::handle-send-break", 181 dbus_chr_send_break, dc, 182 NULL); 183 184 dbus_display_notify(&event); 185 186 be = g_new0(ChardevBackend, 1); 187 opts = qemu_opts_create(qemu_find_opts("chardev"), NULL, 0, &error_abort); 188 qemu_opt_set(opts, "server", "on", &error_abort); 189 qemu_opt_set(opts, "wait", "off", &error_abort); 190 CHARDEV_CLASS(object_class_by_name(TYPE_CHARDEV_SOCKET))->parse( 191 opts, be, errp); 192 if (*errp) { 193 return; 194 } 195 CHARDEV_CLASS(object_class_by_name(TYPE_CHARDEV_SOCKET))->open( 196 chr, be, be_opened, errp); 197 } 198 199 static void 200 dbus_chr_set_fe_open(Chardev *chr, int fe_open) 201 { 202 DBusChardev *dc = DBUS_CHARDEV(chr); 203 204 g_object_set(dc->iface, "feopened", fe_open, NULL); 205 } 206 207 static void 208 dbus_chr_set_echo(Chardev *chr, bool echo) 209 { 210 DBusChardev *dc = DBUS_CHARDEV(chr); 211 212 g_object_set(dc->iface, "echo", echo, NULL); 213 } 214 215 static void 216 dbus_chr_be_event(Chardev *chr, QEMUChrEvent event) 217 { 218 DBusChardev *dc = DBUS_CHARDEV(chr); 219 DBusChardevClass *klass = DBUS_CHARDEV_GET_CLASS(chr); 220 221 switch (event) { 222 case CHR_EVENT_CLOSED: 223 if (dc->iface) { 224 /* on finalize, iface is set to NULL */ 225 g_object_set(dc->iface, "owner", "", NULL); 226 } 227 break; 228 default: 229 break; 230 }; 231 232 klass->parent_chr_be_event(chr, event); 233 } 234 235 static void 236 dbus_chr_parse(QemuOpts *opts, ChardevBackend *backend, 237 Error **errp) 238 { 239 const char *name = qemu_opt_get(opts, "name"); 240 ChardevDBus *dbus; 241 242 if (name == NULL) { 243 error_setg(errp, "chardev: dbus: no name given"); 244 return; 245 } 246 247 backend->type = CHARDEV_BACKEND_KIND_DBUS; 248 dbus = backend->u.dbus.data = g_new0(ChardevDBus, 1); 249 qemu_chr_parse_common(opts, qapi_ChardevDBus_base(dbus)); 250 dbus->name = g_strdup(name); 251 } 252 253 static void 254 char_dbus_class_init(ObjectClass *oc, void *data) 255 { 256 DBusChardevClass *klass = DBUS_CHARDEV_CLASS(oc); 257 ChardevClass *cc = CHARDEV_CLASS(oc); 258 259 cc->parse = dbus_chr_parse; 260 cc->open = dbus_chr_open; 261 cc->chr_set_fe_open = dbus_chr_set_fe_open; 262 cc->chr_set_echo = dbus_chr_set_echo; 263 klass->parent_chr_be_event = cc->chr_be_event; 264 cc->chr_be_event = dbus_chr_be_event; 265 } 266 267 static void 268 char_dbus_finalize(Object *obj) 269 { 270 DBusChardev *dc = DBUS_CHARDEV(obj); 271 DBusDisplayEvent event = { 272 .type = DBUS_DISPLAY_CHARDEV_CLOSE, 273 .chardev = dc, 274 }; 275 276 dbus_display_notify(&event); 277 g_clear_object(&dc->iface); 278 } 279 280 static const TypeInfo char_dbus_type_info = { 281 .name = TYPE_CHARDEV_DBUS, 282 .parent = TYPE_CHARDEV_SOCKET, 283 .class_size = sizeof(DBusChardevClass), 284 .instance_size = sizeof(DBusChardev), 285 .instance_finalize = char_dbus_finalize, 286 .class_init = char_dbus_class_init, 287 }; 288 module_obj(TYPE_CHARDEV_DBUS); 289 290 static void 291 register_types(void) 292 { 293 type_register_static(&char_dbus_type_info); 294 } 295 296 type_init(register_types); 297