static void test_clone_alternate(void) { AltEnumBool *b_src, *s_src, *b_dst, *s_dst; b_src = g_new0(AltEnumBool, 1); b_src->type = QTYPE_QBOOL; b_src->u.b = true; s_src = g_new0(AltEnumBool, 1); s_src->type = QTYPE_QSTRING; s_src->u.e = ENUM_ONE_VALUE1; b_dst = QAPI_CLONE(AltEnumBool, b_src); g_assert(b_dst); g_assert_cmpint(b_dst->type, ==, b_src->type); g_assert_cmpint(b_dst->u.b, ==, b_src->u.b); s_dst = QAPI_CLONE(AltEnumBool, s_src); g_assert(s_dst); g_assert_cmpint(s_dst->type, ==, s_src->type); g_assert_cmpint(s_dst->u.e, ==, s_src->u.e); qapi_free_AltEnumBool(b_src); qapi_free_AltEnumBool(s_src); qapi_free_AltEnumBool(b_dst); qapi_free_AltEnumBool(s_dst); }
SocketAddress *socket_address_crumple(SocketAddressFlat *addr_flat) { SocketAddress *addr = g_new(SocketAddress, 1); switch (addr_flat->type) { case SOCKET_ADDRESS_FLAT_TYPE_INET: addr->type = SOCKET_ADDRESS_KIND_INET; addr->u.inet.data = QAPI_CLONE(InetSocketAddress, &addr_flat->u.inet); break; case SOCKET_ADDRESS_FLAT_TYPE_UNIX: addr->type = SOCKET_ADDRESS_KIND_UNIX; addr->u.q_unix.data = QAPI_CLONE(UnixSocketAddress, &addr_flat->u.q_unix); break; case SOCKET_ADDRESS_FLAT_TYPE_VSOCK: addr->type = SOCKET_ADDRESS_KIND_VSOCK; addr->u.vsock.data = QAPI_CLONE(VsockSocketAddress, &addr_flat->u.vsock); break; case SOCKET_ADDRESS_FLAT_TYPE_FD: addr->type = SOCKET_ADDRESS_KIND_FD; addr->u.fd.data = QAPI_CLONE(String, &addr_flat->u.fd); break; default: abort(); } return addr; }
static void test_clone_native_list(void) { uint8List *src, *dst; uint8List *tmp = NULL; int i; /* Build list in reverse */ for (i = 10; i; i--) { src = g_new0(uint8List, 1); src->next = tmp; src->value = i; tmp = src; } dst = QAPI_CLONE(uint8List, src); for (tmp = dst, i = 1; i <= 10; i++) { g_assert(tmp); g_assert_cmpint(tmp->value, ==, i); tmp = tmp->next; } g_assert(!tmp); qapi_free_uint8List(src); qapi_free_uint8List(dst); }
static void test_clone_complex2(void) { WrapAlternate *src, *dst; src = g_new0(WrapAlternate, 1); src->alt = g_new(UserDefAlternate, 1); src->alt->type = QTYPE_QDICT; src->alt->u.udfu.integer = 42; /* Clone intentionally converts NULL into "" for strings */ src->alt->u.udfu.string = NULL; src->alt->u.udfu.enum1 = ENUM_ONE_VALUE3; src->alt->u.udfu.u.value3.intb = 99; src->alt->u.udfu.u.value3.has_a_b = true; src->alt->u.udfu.u.value3.a_b = true; dst = QAPI_CLONE(WrapAlternate, src); g_assert(dst); g_assert(dst->alt); g_assert_cmpint(dst->alt->type, ==, QTYPE_QDICT); g_assert_cmpint(dst->alt->u.udfu.integer, ==, 42); g_assert_cmpstr(dst->alt->u.udfu.string, ==, ""); g_assert_cmpint(dst->alt->u.udfu.enum1, ==, ENUM_ONE_VALUE3); g_assert_cmpint(dst->alt->u.udfu.u.value3.intb, ==, 99); g_assert_cmpint(dst->alt->u.udfu.u.value3.has_a_b, ==, true); g_assert_cmpint(dst->alt->u.udfu.u.value3.a_b, ==, true); qapi_free_WrapAlternate(src); qapi_free_WrapAlternate(dst); }
static TpmTypeOptions *tpm_emulator_get_tpm_options(TPMBackend *tb) { TPMEmulator *tpm_emu = TPM_EMULATOR(tb); TpmTypeOptions *options = g_new0(TpmTypeOptions, 1); options->type = TPM_TYPE_OPTIONS_KIND_EMULATOR; options->u.emulator.data = QAPI_CLONE(TPMEmulatorOptions, tpm_emu->options); return options; }
static void test_clone_empty(void) { Empty2 *src, *dst; src = g_new0(Empty2, 1); dst = QAPI_CLONE(Empty2, src); g_assert(dst); qapi_free_Empty2(src); qapi_free_Empty2(dst); }
void qio_channel_socket_dgram_async(QIOChannelSocket *ioc, SocketAddress *localAddr, SocketAddress *remoteAddr, QIOTaskFunc callback, gpointer opaque, GDestroyNotify destroy) { QIOTask *task = qio_task_new( OBJECT(ioc), callback, opaque, destroy); struct QIOChannelSocketDGramWorkerData *data = g_new0( struct QIOChannelSocketDGramWorkerData, 1); data->localAddr = QAPI_CLONE(SocketAddress, localAddr); data->remoteAddr = QAPI_CLONE(SocketAddress, remoteAddr); trace_qio_channel_socket_dgram_async(ioc, localAddr, remoteAddr); qio_task_run_in_thread(task, qio_channel_socket_dgram_worker, data, qio_channel_socket_dgram_worker_free); }
static void test_clone_complex1(void) { UserDefNativeListUnion *src, *dst; src = g_new0(UserDefNativeListUnion, 1); src->type = USER_DEF_NATIVE_LIST_UNION_KIND_STRING; dst = QAPI_CLONE(UserDefNativeListUnion, src); g_assert(dst); g_assert_cmpint(dst->type, ==, src->type); g_assert(!dst->u.string.data); qapi_free_UserDefNativeListUnion(src); qapi_free_UserDefNativeListUnion(dst); }
void qio_channel_socket_listen_async(QIOChannelSocket *ioc, SocketAddress *addr, QIOTaskFunc callback, gpointer opaque, GDestroyNotify destroy) { QIOTask *task = qio_task_new( OBJECT(ioc), callback, opaque, destroy); SocketAddress *addrCopy; addrCopy = QAPI_CLONE(SocketAddress, addr); /* socket_listen() blocks in DNS lookups, so we must use a thread */ trace_qio_channel_socket_listen_async(ioc, addr); qio_task_run_in_thread(task, qio_channel_socket_listen_worker, addrCopy, (GDestroyNotify)qapi_free_SocketAddress); }
static void test_clone_complex3(void) { __org_qemu_x_Struct2 *src, *dst; __org_qemu_x_Union1List *tmp; src = g_new0(__org_qemu_x_Struct2, 1); tmp = src->array = g_new0(__org_qemu_x_Union1List, 1); tmp->value = g_new0(__org_qemu_x_Union1, 1); tmp->value->type = ORG_QEMU_X_UNION1_KIND___ORG_QEMU_X_BRANCH; tmp->value->u.__org_qemu_x_branch.data = g_strdup("one"); tmp = tmp->next = g_new0(__org_qemu_x_Union1List, 1); tmp->value = g_new0(__org_qemu_x_Union1, 1); tmp->value->type = ORG_QEMU_X_UNION1_KIND___ORG_QEMU_X_BRANCH; tmp->value->u.__org_qemu_x_branch.data = g_strdup("two"); tmp = tmp->next = g_new0(__org_qemu_x_Union1List, 1); tmp->value = g_new0(__org_qemu_x_Union1, 1); tmp->value->type = ORG_QEMU_X_UNION1_KIND___ORG_QEMU_X_BRANCH; tmp->value->u.__org_qemu_x_branch.data = g_strdup("three"); dst = QAPI_CLONE(__org_qemu_x_Struct2, src); g_assert(dst); tmp = dst->array; g_assert(tmp); g_assert(tmp->value); g_assert_cmpstr(tmp->value->u.__org_qemu_x_branch.data, ==, "one"); tmp = tmp->next; g_assert(tmp); g_assert(tmp->value); g_assert_cmpstr(tmp->value->u.__org_qemu_x_branch.data, ==, "two"); tmp = tmp->next; g_assert(tmp); g_assert(tmp->value); g_assert_cmpstr(tmp->value->u.__org_qemu_x_branch.data, ==, "three"); tmp = tmp->next; g_assert(!tmp); qapi_free___org_qemu_x_Struct2(src); qapi_free___org_qemu_x_Struct2(dst); }
static void test_clone_struct(void) { UserDefOne *src, *dst; src = g_new0(UserDefOne, 1); src->integer = 42; src->string = g_strdup("Hello"); src->has_enum1 = false; src->enum1 = ENUM_ONE_VALUE2; dst = QAPI_CLONE(UserDefOne, src); g_assert(dst); g_assert_cmpint(dst->integer, ==, 42); g_assert(dst->string != src->string); g_assert_cmpstr(dst->string, ==, "Hello"); g_assert_cmpint(dst->has_enum1, ==, false); /* Our implementation does this, but it is not required: g_assert_cmpint(dst->enum1, ==, ENUM_ONE_VALUE2); */ qapi_free_UserDefOne(src); qapi_free_UserDefOne(dst); }
void qmp_blockdev_create(const char *job_id, BlockdevCreateOptions *options, Error **errp) { BlockdevCreateJob *s; const char *fmt = BlockdevDriver_str(options->driver); BlockDriver *drv = bdrv_find_format(fmt); /* If the driver is in the schema, we know that it exists. But it may not * be whitelisted. */ assert(drv); if (bdrv_uses_whitelist() && !bdrv_is_whitelisted(drv, false)) { error_setg(errp, "Driver is not whitelisted"); return; } /* Error out if the driver doesn't support .bdrv_co_create */ if (!drv->bdrv_co_create) { error_setg(errp, "Driver does not support blockdev-create"); return; } /* Create the block job */ /* TODO Running in the main context. Block drivers need to error out or add * locking when they use a BDS in a different AioContext. */ s = job_create(job_id, &blockdev_create_job_driver, NULL, qemu_get_aio_context(), JOB_DEFAULT | JOB_MANUAL_DISMISS, NULL, NULL, errp); if (!s) { return; } s->drv = drv, s->opts = QAPI_CLONE(BlockdevCreateOptions, options), job_start(&s->common); }
static void qmp_chardev_open_socket(Chardev *chr, ChardevBackend *backend, bool *be_opened, Error **errp) { SocketChardev *s = SOCKET_CHARDEV(chr); ChardevSocket *sock = backend->u.socket.data; SocketAddress *addr = sock->addr; bool do_nodelay = sock->has_nodelay ? sock->nodelay : false; bool is_listen = sock->has_server ? sock->server : true; bool is_telnet = sock->has_telnet ? sock->telnet : false; bool is_waitconnect = sock->has_wait ? sock->wait : false; int64_t reconnect = sock->has_reconnect ? sock->reconnect : 0; QIOChannelSocket *sioc = NULL; s->is_unix = addr->type == SOCKET_ADDRESS_KIND_UNIX; s->is_listen = is_listen; s->is_telnet = is_telnet; s->do_nodelay = do_nodelay; if (sock->tls_creds) { Object *creds; creds = object_resolve_path_component( object_get_objects_root(), sock->tls_creds); if (!creds) { error_setg(errp, "No TLS credentials with id '%s'", sock->tls_creds); goto error; } s->tls_creds = (QCryptoTLSCreds *) object_dynamic_cast(creds, TYPE_QCRYPTO_TLS_CREDS); if (!s->tls_creds) { error_setg(errp, "Object with id '%s' is not TLS credentials", sock->tls_creds); goto error; } object_ref(OBJECT(s->tls_creds)); if (is_listen) { if (s->tls_creds->endpoint != QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) { error_setg(errp, "%s", "Expected TLS credentials for server endpoint"); goto error; } } else { if (s->tls_creds->endpoint != QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT) { error_setg(errp, "%s", "Expected TLS credentials for client endpoint"); goto error; } } } s->addr = QAPI_CLONE(SocketAddress, sock->addr); qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_RECONNECTABLE); if (s->is_unix) { qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_FD_PASS); } /* be isn't opened until we get a connection */ *be_opened = false; chr->filename = SocketAddress_to_str("disconnected:", addr, is_listen, is_telnet); if (is_listen) { if (is_telnet) { s->do_telnetopt = 1; } } else if (reconnect > 0) { s->reconnect_time = reconnect; } if (s->reconnect_time) { sioc = qio_channel_socket_new(); tcp_chr_set_client_ioc_name(chr, sioc); qio_channel_socket_connect_async(sioc, s->addr, qemu_chr_socket_connected, chr, NULL); } else { if (s->is_listen) { char *name; sioc = qio_channel_socket_new(); name = g_strdup_printf("chardev-tcp-listener-%s", chr->label); qio_channel_set_name(QIO_CHANNEL(sioc), name); g_free(name); if (qio_channel_socket_listen_sync(sioc, s->addr, errp) < 0) { goto error; } s->listen_ioc = sioc; if (is_waitconnect && qemu_chr_wait_connected(chr, errp) < 0) { return; } if (!s->ioc) { s->listen_tag = qio_channel_add_watch( QIO_CHANNEL(s->listen_ioc), G_IO_IN, tcp_chr_accept, chr, NULL); } } else if (qemu_chr_wait_connected(chr, errp) < 0) { goto error; } } return; error: if (sioc) { object_unref(OBJECT(sioc)); } }