diff options
Diffstat (limited to 'server')
-rw-r--r-- | server/red_channel.c | 16 | ||||
-rw-r--r-- | server/red_client_cache.h | 5 | ||||
-rw-r--r-- | server/red_client_shared_cache.h | 5 | ||||
-rw-r--r-- | server/red_common.h | 1 | ||||
-rw-r--r-- | server/red_dispatcher.c | 16 | ||||
-rw-r--r-- | server/red_tunnel_worker.c | 69 | ||||
-rw-r--r-- | server/red_worker.c | 160 | ||||
-rw-r--r-- | server/reds.c | 133 | ||||
-rw-r--r-- | server/snd_worker.c | 25 |
9 files changed, 102 insertions, 328 deletions
diff --git a/server/red_channel.c b/server/red_channel.c index d8ea49dc..9364904a 100644 --- a/server/red_channel.c +++ b/server/red_channel.c @@ -245,11 +245,7 @@ RedChannel *red_channel_create(int size, RedsStreamContext *peer, CoreInterface ASSERT(size >= sizeof(*channel)); ASSERT(config_socket && disconnect && handle_message && alloc_recv_buf && release_item); - if (!(channel = malloc(size))) { - red_printf("malloc failed"); - goto error1; - } - memset(channel, 0, size); + channel = spice_malloc0(size); channel->handle_acks = handle_acks; channel->disconnect = disconnect; @@ -282,7 +278,7 @@ RedChannel *red_channel_create(int size, RedsStreamContext *peer, CoreInterface channel->outgoing.on_msg_done = red_channel_peer_on_out_msg_done; if (!config_socket(channel)) { - goto error2; + goto error; } channel->core->set_file_handlers(channel->core, channel->peer->socket, @@ -290,9 +286,8 @@ RedChannel *red_channel_create(int size, RedsStreamContext *peer, CoreInterface return channel; -error2: +error: free(channel); -error1: peer->cb_free(peer); return NULL; @@ -480,10 +475,7 @@ void red_channel_pipe_add_tail(RedChannel *channel, PipeItem *item) void red_channel_pipe_add_type(RedChannel *channel, int pipe_item_type) { - PipeItem *item = malloc(sizeof(*item)); - if (!item) { - red_error("malloc failed"); - } + PipeItem *item = spice_new(PipeItem, 1); red_channel_pipe_item_init(channel, item, pipe_item_type); red_channel_pipe_add(channel, item); diff --git a/server/red_client_cache.h b/server/red_client_cache.h index 3db0ce9c..91eaf4e9 100644 --- a/server/red_client_cache.h +++ b/server/red_client_cache.h @@ -82,10 +82,7 @@ static int FUNC_NAME(add)(CHANNEL *channel, uint64_t id, size_t size) CacheItem *item; int key; - item = malloc(sizeof(*item)); - if (!item) { - return FALSE; - } + item = spice_new(CacheItem, 1); channel->VAR_NAME(available) -= size; while (channel->VAR_NAME(available) < 0) { diff --git a/server/red_client_shared_cache.h b/server/red_client_shared_cache.h index 141f1b11..b356fe01 100644 --- a/server/red_client_shared_cache.h +++ b/server/red_client_shared_cache.h @@ -68,10 +68,7 @@ static int FUNC_NAME(add)(CACHE *cache, uint64_t id, uint32_t size, CHANNEL *cha ASSERT(size > 0); - item = malloc(sizeof(*item)); - if (!item) { - return FALSE; - } + item = spice_new(NewCacheItem, 1); serial = channel_message_serial((RedChannel *)channel); pthread_mutex_lock(&cache->lock); diff --git a/server/red_common.h b/server/red_common.h index 7f6fdbc4..d59b04f3 100644 --- a/server/red_common.h +++ b/server/red_common.h @@ -22,6 +22,7 @@ #include <openssl/ssl.h> #include "spice.h" +#include "mem.h" #include <spice/protocol.h> #include <spice/macros.h> diff --git a/server/red_dispatcher.c b/server/red_dispatcher.c index 2eb510b7..17bf24cf 100644 --- a/server/red_dispatcher.c +++ b/server/red_dispatcher.c @@ -483,10 +483,7 @@ RedDispatcher *red_dispatcher_init(QXLInterface *qxl_interface) red_error("socketpair failed %s", strerror(errno)); } - if (!(dispatcher = malloc(sizeof(RedDispatcher)))) { - red_error("malloc failed"); - } - memset(dispatcher, 0, sizeof(RedDispatcher)); + dispatcher = spice_new0(RedDispatcher, 1); dispatcher->channel = channels[0]; init_data.qxl_interface = dispatcher->qxl_interface = qxl_interface; init_data.id = qxl_interface->base.id; @@ -540,10 +537,8 @@ RedDispatcher *red_dispatcher_init(QXLInterface *qxl_interface) read_message(dispatcher->channel, &message); ASSERT(message == RED_WORKER_MESSAGE_READY); - if (!(reds_channel = malloc(sizeof(Channel)))) { - red_error("reds channel malloc failed"); - } - memset(reds_channel, 0, sizeof(Channel)); + + reds_channel = spice_new0(Channel, 1); reds_channel->type = SPICE_CHANNEL_DISPLAY; reds_channel->id = qxl_interface->base.id; reds_channel->link = red_dispatcher_set_peer; @@ -552,10 +547,7 @@ RedDispatcher *red_dispatcher_init(QXLInterface *qxl_interface) reds_channel->data = dispatcher; reds_register_channel(reds_channel); - if (!(cursor_channel = malloc(sizeof(Channel)))) { - red_error("reds channel malloc failed"); - } - memset(cursor_channel, 0, sizeof(Channel)); + cursor_channel = spice_new0(Channel, 1); cursor_channel->type = SPICE_CHANNEL_CURSOR; cursor_channel->id = qxl_interface->base.id; cursor_channel->link = red_dispatcher_set_cursor_peer; diff --git a/server/red_tunnel_worker.c b/server/red_tunnel_worker.c index f3374de6..13921022 100644 --- a/server/red_tunnel_worker.c +++ b/server/red_tunnel_worker.c @@ -645,10 +645,7 @@ static inline RedSocketRawSndBuf *__tunnel_worker_alloc_socket_snd_buf(TunnelWor ret = worker->free_snd_buf; worker->free_snd_buf = (RedSocketRawSndBuf *)worker->free_snd_buf->base.next; } else { - ret = (RedSocketRawSndBuf *)malloc(sizeof(*ret)); - if (!ret) { - red_error("malloc of send buf failed"); - } + ret = spice_new(RedSocketRawSndBuf, 1); } ret->base.data = ret->buf; ret->base.size = 0; @@ -707,10 +704,7 @@ static inline RedSocketRawRcvBuf *__tunnel_worker_alloc_socket_rcv_buf(TunnelWor ret = worker->free_rcv_buf; worker->free_rcv_buf = (RedSocketRawRcvBuf *)worker->free_rcv_buf->base.next; } else { - ret = (RedSocketRawRcvBuf *)malloc(sizeof(*ret)); - if (!ret) { - red_error("malloc of send buf failed"); - } + ret = spice_new(RedSocketRawRcvBuf, 1); } ret->msg_info = (SpiceMsgcTunnelSocketData *)ret->buf; ret->base.usr_opaque = NULL; @@ -853,7 +847,7 @@ static void __ready_queue_push(ReadyTunneledChunkQueue *queue, ReadyTunneledChun static void ready_queue_add_orig_chunk(ReadyTunneledChunkQueue *queue, RawTunneledBuffer *origin, uint8_t *data, int size) { - ReadyTunneledChunk *chunk = malloc(sizeof(ReadyTunneledChunk)); + ReadyTunneledChunk *chunk = spice_new(ReadyTunneledChunk, 1); chunk->type = READY_TUNNELED_CHUNK_TYPE_ORIG; chunk->origin = tunneled_buffer_ref(origin); chunk->data = data; @@ -921,8 +915,7 @@ static inline TunneledBufferProcessQueue *__tunnel_socket_alloc_simple_process_q uint32_t service_type, uint32_t direction_type) { - TunneledBufferProcessQueue *ret_queue = malloc(sizeof(TunneledBufferProcessQueue)); - memset(ret_queue, 0, sizeof(TunneledBufferProcessQueue)); + TunneledBufferProcessQueue *ret_queue = spice_new0(TunneledBufferProcessQueue, 1); ret_queue->service_type = service_type; ret_queue->direction = direction_type; ret_queue->usr_opaque = sckt; @@ -979,12 +972,7 @@ static void tunnel_send_packet(void *opaque_tunnel, const uint8_t *pkt, int pkt_ void *red_tunnel_attach(CoreInterface *core_interface, NetWireInterface *vlan_interface) { - TunnelWorker *worker = (TunnelWorker *)malloc(sizeof(TunnelWorker)); - - if (!worker) { - red_error("malloc of tunnel worker failed"); - } - memset(worker, 0, sizeof(*worker)); + TunnelWorker *worker = spice_new0(TunnelWorker, 1); worker->core_interface = core_interface; worker->vlan_interface = vlan_interface; @@ -1056,12 +1044,7 @@ static inline TunnelService *__tunnel_worker_add_service(TunnelWorker *worker, u char *name, char *description, struct in_addr *virt_ip) { - TunnelService *new_service = malloc(size); - - if (!new_service) { - red_error("malloc of TunnelService failed"); - } - memset(new_service, 0, size); + TunnelService *new_service = spice_malloc0(size); if (!virt_ip) { TunnelService *service_of_same_group; @@ -1290,7 +1273,7 @@ static RedSocket *tunnel_worker_create_socket(TunnelWorker *worker, uint16_t loc new_socket = __tunnel_worker_find_free_socket(worker); if (!new_socket) { - red_error("malloc of RedSocket failed"); + red_error("creation of RedSocket failed"); } tunnel_worker_alloc_socket(worker, new_socket, local_port, far_service, slirp_s); @@ -1662,11 +1645,7 @@ static uint8_t *tunnel_channel_alloc_msg_rcv_buf(RedChannel *channel, SpiceDataH return (__tunnel_worker_alloc_socket_rcv_buf(tunnel_channel->worker)->buf); } else if ((msg_header->type == SPICE_MSGC_MIGRATE_DATA) || (msg_header->type == SPICE_MSGC_TUNNEL_SERVICE_ADD)) { - uint8_t *ret = malloc(msg_header->size); - if (!ret) { - red_error("failed allocating"); - } - return ret; + return spice_malloc(msg_header->size); } else { return (tunnel_channel->control_rcv_buf); } @@ -1771,13 +1750,7 @@ static int tunnel_channel_handle_migrate_mark(TunnelChannel *channel) return FALSE; } channel->expect_migrate_mark = FALSE; - migrate_item = (TunnelMigrateItem *)malloc(sizeof(*migrate_item)); - - if (!migrate_item) { - red_error("failed alloc TunnelMigrateItem"); - } - - memset(migrate_item, 0, sizeof(*migrate_item)); + migrate_item = spice_new0(TunnelMigrateItem, 1); migrate_item->base.type = PIPE_ITEM_TYPE_MIGRATE_DATA; migrate_item->slirp_state_size = net_slirp_state_export(&migrate_item->slirp_state); @@ -1789,19 +1762,12 @@ static int tunnel_channel_handle_migrate_mark(TunnelChannel *channel) migrate_item->services_list_size = sizeof(TunnelMigrateServicesList) + (sizeof(uint32_t)*channel->worker->num_services); migrate_item->services_list = - (TunnelMigrateServicesList *)malloc(migrate_item->services_list_size); - if (!migrate_item->services_list) { - red_error("failed alloc services list"); - } + (TunnelMigrateServicesList *)spice_malloc(migrate_item->services_list_size); migrate_item->services_list->num_services = channel->worker->num_services; - migrate_item->services = (TunnelMigrateServiceItem *)malloc( + migrate_item->services = (TunnelMigrateServiceItem *)spice_malloc( channel->worker->num_services * sizeof(TunnelMigrateServiceItem)); - if (!migrate_item->services) { - red_error("failed alloc services items"); - } - for (mig_service = migrate_item->services, service = (TunnelService *)ring_get_head(&channel->worker->services); service; @@ -1815,11 +1781,8 @@ static int tunnel_channel_handle_migrate_mark(TunnelChannel *channel) migrate_item->sockets_list_size = sizeof(TunnelMigrateSocketList) + (sizeof(uint32_t)*channel->worker->num_sockets); - migrate_item->sockets_list = (TunnelMigrateSocketList *)malloc( - migrate_item->sockets_list_size); - if (!migrate_item->sockets_list) { - red_error("failed alloc sockets list"); - } + migrate_item->sockets_list = + (TunnelMigrateSocketList *) spice_malloc(migrate_item->sockets_list_size); migrate_item->sockets_list->num_sockets = channel->worker->num_sockets; @@ -1918,11 +1881,7 @@ static void restore_tokens_buf_release(RawTunneledBuffer *buf) RawTunneledBuffer *__tunnel_socket_alloc_restore_tokens_buf(RedSocket *sckt, int num_tokens) { - RedSocketRestoreTokensBuf *buf = (RedSocketRestoreTokensBuf *)malloc(sizeof(*buf)); - if (!buf) { - red_error("failed alloc"); - } - memset(buf, 0, sizeof(*buf)); + RedSocketRestoreTokensBuf *buf = spice_new0(RedSocketRestoreTokensBuf, 1); buf->base.base.usr_opaque = sckt; buf->base.base.refs = 1; diff --git a/server/red_worker.c b/server/red_worker.c index 9e31f510..ae361c1d 100644 --- a/server/red_worker.c +++ b/server/red_worker.c @@ -1315,10 +1315,7 @@ static inline void red_pipe_add_tail(RedChannel *channel, PipeItem *item) static void red_pipe_add_verb(RedChannel* channel, uint16_t verb) { - VerbItem *item = malloc(sizeof(*item)); - if (!item) { - PANIC("malloc failed"); - } + VerbItem *item = spice_new(VerbItem, 1); red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_VERB); item->verb = verb; red_pipe_add(channel, &item->base); @@ -1326,10 +1323,7 @@ static void red_pipe_add_verb(RedChannel* channel, uint16_t verb) static void red_pipe_add_type(RedChannel* channel, int pipe_item_type) { - PipeItem *item = malloc(sizeof(*item)); - if (!item) { - PANIC("malloc failed"); - } + PipeItem *item = spice_new(PipeItem, 1); red_pipe_item_init(item, pipe_item_type); red_pipe_add(channel, item); } @@ -2048,10 +2042,7 @@ static void exclude_region(RedWorker *worker, Ring *ring, RingItem *ring_item, Q static inline Container *__new_container(RedWorker *worker, DrawItem *item) { - Container *container = malloc(sizeof(Container)); - if (!container) { - return NULL; - } + Container *container = spice_new(Container, 1); worker->containers_count++; #ifdef PIPE_DEBUG container->base.id = ++worker->last_id; @@ -2240,10 +2231,7 @@ static inline void red_detach_stream(RedWorker *worker, Stream *stream) static StreamClipItem *__new_stream_clip(DisplayChannel* channel, StreamAgent *agent) { - StreamClipItem *item = (StreamClipItem *)malloc(sizeof(*item)); - if (!item) { - PANIC("alloc failed"); - } + StreamClipItem *item = spice_new(StreamClipItem, 1); red_pipe_item_init((PipeItem *)item, PIPE_ITEM_TYPE_STREAM_CLIP); item->stream_agent = agent; @@ -2351,9 +2339,7 @@ static inline void red_detach_stream_gracefully(RedWorker *worker, Stream *strea if ((channel = worker->display_channel) && !pipe_item_is_linked(&stream->current->pipe_item)) { UpgradeItem *upgrade_item; - if (!(upgrade_item = (UpgradeItem *)malloc(sizeof(*upgrade_item)))) { - PANIC("malloc failed"); - } + upgrade_item = spice_new(UpgradeItem, 1); upgrade_item->refs = 1; red_pipe_item_init(&upgrade_item->base, PIPE_ITEM_TYPE_UPGRADE); upgrade_item->drawable = stream->current; @@ -2370,16 +2356,14 @@ static inline void red_stop_stream_gracefully(RedWorker *worker, Stream *stream) { ASSERT(stream->current); if (worker->display_channel && !pipe_item_is_linked(&stream->current->pipe_item)) { - UpgradeItem *item; - if ((item = (UpgradeItem *)malloc(sizeof(*item)))) { - item->refs = 1; - red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_UPGRADE); - item->drawable = stream->current; - item->drawable->refs++; - item->rects = region_dup_rects(&item->drawable->tree_item.base.rgn, - &item->n_rects); - red_pipe_add((RedChannel *)worker->display_channel, &item->base); - } + UpgradeItem *item = spice_new(UpgradeItem, 1); + item->refs = 1; + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_UPGRADE); + item->drawable = stream->current; + item->drawable->refs++; + item->rects = region_dup_rects(&item->drawable->tree_item.base.rgn, + &item->n_rects); + red_pipe_add((RedChannel *)worker->display_channel, &item->base); } red_stop_stream(worker, stream); } @@ -2643,9 +2627,7 @@ static void red_create_stream(RedWorker *worker, Drawable *drawable) goto error_3; } - if (!(frame_buf = malloc(pict_size))) { - goto error_3; - } + frame_buf = spice_malloc(pict_size); if (avpicture_fill((AVPicture *)frame, frame_buf, av_ctx->pix_fmt, stream_width, stream_height) < 0) { @@ -3390,10 +3372,7 @@ static inline Shadow *__new_shadow(RedWorker *worker, Drawable *item, SpicePoint return NULL; } - Shadow *shadow = malloc(sizeof(Shadow)); - if (!shadow) { - return NULL; - } + Shadow *shadow = spice_new(Shadow, 1); worker->shadows_count++; #ifdef PIPE_DEBUG shadow->base.id = ++worker->last_id; @@ -3560,10 +3539,7 @@ static inline int red_handle_self_bitmap(RedWorker *worker, Drawable *drawable) height = drawable->qxl_drawable->bbox.bottom - drawable->qxl_drawable->bbox.top; dest_stride = width * sizeof(uint32_t); - if (!(image = malloc(sizeof(QXLImage) + height * dest_stride))) { - red_printf("alloc failed"); - return FALSE; - } + image = spice_malloc_n_m(height, dest_stride, sizeof(QXLImage)); dest = (uint8_t *)(image + 1); image->descriptor.type = SPICE_IMAGE_TYPE_BITMAP; @@ -3700,8 +3676,7 @@ static void localize_path(RedWorker *worker, QXLPHYSICAL *in_path, uint32_t grou ASSERT(in_path && *in_path); path = (QXLPath *)get_virt(worker, *in_path, sizeof(QXLPath), group_id); - data = malloc(sizeof(uint32_t) + path->data_size); - ASSERT(data); + data = spice_malloc_n_m(1, path->data_size, sizeof(uint32_t)); *in_path = (QXLPHYSICAL)data; *(uint32_t *)data = path->data_size; data += sizeof(uint32_t); @@ -3733,8 +3708,7 @@ static void localize_str(RedWorker *worker, QXLPHYSICAL *in_str, uint32_t group_ int memslot_id = get_memslot_id(worker, *in_str); ASSERT(in_str); - str = malloc(sizeof(uint32_t) + qxl_str->data_size); - ASSERT(str); + str = spice_malloc_n_m(1, qxl_str->data_size, sizeof(uint32_t)); *in_str = (QXLPHYSICAL)str; str->length = qxl_str->length; str->flags = qxl_str->flags; @@ -3777,8 +3751,7 @@ static void localize_clip(RedWorker *worker, SpiceClip *clip, uint32_t group_id) clip_rects = (QXLClipRects *)get_virt(worker, clip->data, sizeof(QXLClipRects), group_id); chunk = &clip_rects->chunk; ASSERT(clip->data); - data = malloc(sizeof(uint32_t) + clip_rects->num_rects * sizeof(SpiceRect)); - ASSERT(data); + data = spice_malloc_n_m(clip_rects->num_rects, sizeof(SpiceRect), sizeof(uint32_t)); clip->data = (QXLPHYSICAL)data; *(uint32_t *)(data) = clip_rects->num_rects; data += sizeof(uint32_t); @@ -3887,9 +3860,7 @@ static void image_cache_put(SpiceImageCache *spice_cache, uint64_t id, pixman_im } #endif - if (!(item = (ImageCacheItem *)malloc(sizeof(ImageCacheItem)))) { - red_error("alloc failed"); - } + item = spice_new(ImageCacheItem, 1); item->id = id; #ifdef IMAGE_CACHE_AGE item->age = cache->age; @@ -3999,8 +3970,7 @@ static void localize_bitmap(RedWorker *worker, QXLPHYSICAL *in_bitmap, uint32_t } else { QXLPHYSICAL src_data; int size = image->bitmap.y * image->bitmap.stride; - uint8_t *data = malloc(size); - ASSERT(data); + uint8_t *data = spice_malloc_n(image->bitmap.y, image->bitmap.stride); local_image->bitmap.data = (QXLPHYSICAL)data; src_data = image->bitmap.data; @@ -4038,11 +4008,7 @@ static void localize_bitmap(RedWorker *worker, QXLPHYSICAL *in_bitmap, uint32_t validate_virt(worker, (unsigned long)ents, slot_id, (num_ents * sizeof(uint32_t)), group_id); - shadow_palette = (SpicePalette *)malloc(sizeof(SpicePalette) + num_ents * sizeof(uint32_t) + - sizeof(QXLPHYSICAL)); - if (!shadow_palette) { - PANIC("SpicePalette malloc failed"); - } + shadow_palette = (SpicePalette *)spice_malloc_n_m(num_ents, sizeof(uint32_t),sizeof(SpicePalette) + sizeof(QXLPHYSICAL)); memcpy(shadow_palette->ents, ents, num_ents * sizeof(uint32_t)); shadow_palette->num_ents = num_ents; @@ -4119,8 +4085,7 @@ static void localize_attr(RedWorker *worker, SpiceLineAttr *attr, uint32_t group ASSERT(attr->style); buf = (uint8_t *)get_virt(worker, attr->style, attr->style_nseg * sizeof(uint32_t), group_id); - data = malloc(attr->style_nseg * sizeof(uint32_t)); - ASSERT(data); + data = spice_malloc_n(attr->style_nseg, sizeof(uint32_t)); memcpy(data, buf, attr->style_nseg * sizeof(uint32_t)); attr->style = (QXLPHYSICAL)data; } @@ -4689,11 +4654,7 @@ static void red_add_screen_image(RedWorker *worker) } stride = worker->surface.context.width << 2; - if (!(item = (ImageItem *)malloc(sizeof(ImageItem) + - worker->surface.context.height * stride))) { - //warn - return; - } + item = (ImageItem *)spice_malloc_n_m(worker->surface.context.height, stride, sizeof(ImageItem)); red_pipe_item_init(&item->link, PIPE_ITEM_TYPE_IMAGE); @@ -4830,9 +4791,7 @@ static inline RedCompressBuf *red_display_alloc_compress_buf(DisplayChannel *dis ret = display_channel->send_data.free_compress_bufs; display_channel->send_data.free_compress_bufs = ret->next; } else { - if (!(ret = malloc(sizeof(*ret)))) { - return NULL; - } + ret = spice_new(RedCompressBuf, 1); } ret->next = display_channel->send_data.used_compress_bufs; @@ -4886,9 +4845,7 @@ static RedGlzDrawable *red_display_get_glz_drawable(DisplayChannel *channel, Dra return drawable->red_glz_drawable; } - if (!(ret = malloc(sizeof(*ret)))) { - PANIC("malloc failed"); - } + ret = spice_new(RedGlzDrawable, 1); ret->display_channel = channel; ret->qxl_drawable = drawable->qxl_drawable; @@ -5141,17 +5098,17 @@ static void glz_usr_warn(GlzEncoderUsrContext *usr, const char *fmt, ...) static void *quic_usr_malloc(QuicUsrContext *usr, int size) { - return malloc(size); + return spice_malloc(size); } static void *lz_usr_malloc(LzUsrContext *usr, int size) { - return malloc(size); + return spice_malloc(size); } static void *glz_usr_malloc(GlzEncoderUsrContext *usr, int size) { - return malloc(size); + return spice_malloc(size); } static void quic_usr_free(QuicUsrContext *usr, void *ptr) @@ -6444,10 +6401,7 @@ static void display_channel_push_release(DisplayChannel *channel, uint8_t type, if (free_list->res->count == free_list->res_size) { SpiceResorceList *new_list; - new_list = malloc(sizeof(*new_list) + free_list->res_size * sizeof(SpiceResorceID) * 2); - if (!new_list) { - PANIC("malloc failed"); - } + new_list = spice_malloc(sizeof(*new_list) + free_list->res_size * sizeof(SpiceResorceID) * 2); new_list->count = free_list->res->count; memcpy(new_list->resorces, free_list->res->resorces, new_list->count * sizeof(SpiceResorceID)); @@ -6652,9 +6606,7 @@ static inline int red_send_stream_data(DisplayChannel *display_channel, Drawable if (display_channel->send_data.stream_outbuf_size < min_buf_size) { uint8_t *new_buf; - if (!(new_buf = malloc(min_buf_size + FF_INPUT_BUFFER_PADDING_SIZE))) { - return FALSE; - } + new_buf = spice_malloc(min_buf_size + FF_INPUT_BUFFER_PADDING_SIZE); red_display_unshare_stream_buf(display_channel); free(display_channel->send_data.stream_outbuf); @@ -6694,9 +6646,7 @@ static inline int red_send_stream_data(DisplayChannel *display_channel, Drawable new_size = display_channel->send_data.stream_outbuf_size * 2; new_size = MIN(new_size, max_size); - if (!(new_buf = malloc(new_size + FF_INPUT_BUFFER_PADDING_SIZE))) { - return FALSE; - } + new_buf = spice_malloc(new_size + FF_INPUT_BUFFER_PADDING_SIZE); red_printf("new streaming video buf size %u", new_size); red_display_unshare_stream_buf(display_channel); free(display_channel->send_data.stream_outbuf); @@ -7725,12 +7675,7 @@ static GlzSharedDictionary *_red_create_glz_dictionary(DisplayChannel *display, uint8_t id, GlzEncDictContext *opaque_dict) { - GlzSharedDictionary *shared_dict = malloc(sizeof(*shared_dict)); - memset(shared_dict, 0, sizeof(*shared_dict)); // nullify the ring base - - if (!shared_dict) { - return NULL; - } + GlzSharedDictionary *shared_dict = spice_new0(GlzSharedDictionary, 1); shared_dict->dict = opaque_dict; shared_dict->id = id; shared_dict->refs = 1; @@ -7845,11 +7790,7 @@ static void red_release_glz(DisplayChannel *channel) static PixmapCache *red_create_pixmap_cache(uint8_t id, int64_t size) { - PixmapCache *cache = malloc(sizeof(*cache)); - if (!cache) { - return NULL; - } - memset(cache, 0, sizeof(*cache)); + PixmapCache *cache = spice_new0(PixmapCache, 1); ring_item_init(&cache->base); pthread_mutex_init(&cache->lock, NULL); cache->id = id; @@ -8105,11 +8046,7 @@ static RedChannel *__new_channel(RedWorker *worker, int size, RedsStreamContext } ASSERT(size >= sizeof(*channel)); - if (!(channel = malloc(size))) { - red_printf("malloc failed"); - goto error1; - } - memset(channel, 0, size); + channel = spice_malloc0(size); channel->id = worker->id; channel->listener.refs = 1; channel->listener.action = handler; @@ -8235,20 +8172,16 @@ static void handle_new_display_channel(RedWorker *worker, RedsStreamContext *pee red_display_init_streams(display_channel); stream_buf_size = FF_MIN_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE; - if (!(display_channel->send_data.stream_outbuf = malloc(stream_buf_size))) { - PANIC("alloc failed"); - } + display_channel->send_data.stream_outbuf = spice_malloc(stream_buf_size); display_channel->send_data.stream_outbuf_size = FF_MIN_BUFFER_SIZE; red_display_share_stream_buf(display_channel); red_display_init_glz_data(display_channel); worker->display_channel = display_channel; - if (!(display_channel->send_data.free_list.res = malloc(sizeof(SpiceResorceList) + - DISPLAY_FREE_LIST_DEFAULT_SIZE * - sizeof(SpiceResorceID)))) { - PANIC("free list alloc failed"); - } + display_channel->send_data.free_list.res = + spice_malloc(sizeof(SpiceResorceList) + + DISPLAY_FREE_LIST_DEFAULT_SIZE * sizeof(SpiceResorceID)); display_channel->send_data.free_list.res_size = DISPLAY_FREE_LIST_DEFAULT_SIZE; red_ref_channel((RedChannel*)display_channel); on_new_display_channel(worker); @@ -8348,8 +8281,7 @@ static void red_save_cursor(RedWorker *worker) local = (LocalCursor *)worker->cursor; size = sizeof(CursorData) + sizeof(SpiceCursor) + local->data_size; - cursor_data = malloc(size); - ASSERT(cursor_data); + cursor_data = spice_malloc(size); cursor_data->position = worker->cursor_position; cursor_data->visible = worker->cursor_visible; @@ -8365,10 +8297,7 @@ static LocalCursor *_new_local_cursor(SpiceCursorHeader *header, int data_size, { LocalCursor *local; - local = (LocalCursor *)malloc(sizeof(LocalCursor) + data_size); - if (!local) { - return NULL; - } + local = (LocalCursor *)spice_malloc(sizeof(LocalCursor) + data_size); red_pipe_item_init(&local->base.pipe_data, PIPE_ITEM_TYPE_LOCAL_CURSOR); local->base.refs = 1; @@ -8674,13 +8603,10 @@ static void inline red_create_mem_slots(RedWorker *worker) ASSERT(worker->num_memslots > 0); ASSERT(worker->num_memslots_groups > 0); - worker->mem_slots = (MemSlot **)malloc(sizeof(MemSlot *) * worker->num_memslots_groups); - PANIC_ON(!worker->mem_slots); + worker->mem_slots = spice_new(MemSlot *, worker->num_memslots_groups); for (i = 0; i < worker->num_memslots_groups; ++i) { - worker->mem_slots[i] = malloc(sizeof(MemSlot) * worker->num_memslots); - PANIC_ON(!worker->mem_slots[i]); - memset(worker->mem_slots[i], 0, sizeof(MemSlot) * worker->num_memslots); + worker->mem_slots[i] = spice_new0(MemSlot, worker->num_memslots); } worker->memslot_id_shift = 64 - worker->mem_slot_bits; diff --git a/server/reds.c b/server/reds.c index b7cef9fd..f8320fc9 100644 --- a/server/reds.c +++ b/server/reds.c @@ -536,11 +536,9 @@ static char *base64decode(const char *input, int length) BIO *b64; BIO *bmem; int n; - char *buffer = (char *)malloc(length); - memset(buffer, 0, length); + char *buffer = (char *)spice_malloc0(length); + char *inbuffer = (char *)spice_malloc0(length + 1); - char *inbuffer = (char *)malloc(length + 1); - memset(inbuffer, 0, length + 1); memcpy(inbuffer, input, length); inbuffer[length] = '\n'; @@ -1063,9 +1061,7 @@ static SimpleOutItem *new_simple_out_item(uint32_t type, int message_size) { SimpleOutItem *item; - if (!(item = (SimpleOutItem *)malloc(sizeof(*item) + message_size))) { - return NULL; - } + item = (SimpleOutItem *)spice_malloc(sizeof(*item) + message_size); ring_item_init(&item->base.link); item->base.prepare = reds_prepare_basic_out_item; item->base.release = reds_free_basic_out_item; @@ -1142,9 +1138,10 @@ static int send_ping(int size) struct timespec time_space; PingItem *item; - if (!reds->peer || !(item = (PingItem *)malloc(sizeof(*item)))) { + if (!reds->peer) { return FALSE; } + item = spice_new(PingItem, 1); ring_item_init(&item->base.link); item->base.prepare = reds_prepare_ping_item; item->base.release = reds_free_ping_item; @@ -1640,10 +1637,7 @@ static void main_channel_push_migrate_data_item() { SendMainMigrateItem *item; - if (!(item = (SendMainMigrateItem *)malloc(sizeof(*item)))) { - PANIC("malloc failed"); - } - memset(item, 0, sizeof(*item)); + item = spice_new0(SendMainMigrateItem, 1); ring_item_init(&item->base.link); item->base.prepare = main_channel_send_migrate_data_item; item->base.release = main_channelrelease_migrate_data_item; @@ -1770,11 +1764,7 @@ static int main_channel_restore_vdi_wqueue(MainMigrateData *data, uint8_t *pos, reds_disconnect(); return FALSE; } - if (!(buf = malloc(sizeof(VDInternalBuf)))) { - red_printf("no internal buff"); - reds_disconnect(); - return FALSE; - } + buf = spice_new(VDInternalBuf, 1); ring_item_init(&buf->base.link); buf->base.free = free_tmp_internal_buf; buf->base.now = (uint8_t *)&buf->base.chunk_header; @@ -2568,11 +2558,7 @@ static void inputs_link(Channel *channel, RedsStreamContext *peer, int migration red_printf(""); ASSERT(channel->data == NULL); - if (!(inputs_state = malloc(sizeof(InputsState)))) { - red_printf("alloc input state failed"); - close(peer->socket); - return; - } + inputs_state = spice_new0(InputsState, 1); delay_val = 1; if (setsockopt(peer->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) { @@ -2584,7 +2570,6 @@ static void inputs_link(Channel *channel, RedsStreamContext *peer, int migration red_printf("fcntl failed, %s", strerror(errno)); } - memset(inputs_state, 0, sizeof(*inputs_state)); inputs_state->peer = peer; inputs_state->end_pos = 0; inputs_state->channel = channel; @@ -2661,10 +2646,8 @@ static void openssl_init(RedLinkInfo *link) static void inputs_init() { Channel *channel; - if (!(channel = malloc(sizeof(Channel)))) { - red_error("alloc inputs chanel failed"); - } - memset(channel, 0, sizeof(Channel)); + + channel = spice_new0(Channel, 1); channel->type = SPICE_CHANNEL_INPUTS; channel->link = inputs_link; channel->shutdown = inputs_shutdown; @@ -2918,11 +2901,7 @@ static void reds_handle_read_header_done(void *opaque) return; } - if (!(link->link_mess = malloc(header->size))) { - red_printf("malloc failed %u", header->size); - reds_release_link(link); - return; - } + link->link_mess = spice_malloc(header->size); obj->now = (uint8_t *)link->link_mess; obj->end = obj->now + header->size; @@ -2975,40 +2954,27 @@ static RedLinkInfo *__reds_accept_connection(int listen_socket) if ((flags = fcntl(socket, F_GETFL)) == -1) { red_printf("accept failed, %s", strerror(errno)); - goto error1; + goto error; } if (fcntl(socket, F_SETFL, flags | O_NONBLOCK) == -1) { red_printf("accept failed, %s", strerror(errno)); - goto error1; + goto error; } if (setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) { red_printf("setsockopt failed, %s", strerror(errno)); } - if (!(link = malloc(sizeof(RedLinkInfo)))) { - red_printf("malloc failed"); - goto error1; - } - - if (!(peer = malloc(sizeof(RedsStreamContext)))) { - red_printf("malloc failed"); - goto error2; - } - - memset(link, 0, sizeof(RedLinkInfo)); - memset(peer, 0, sizeof(RedsStreamContext)); + link = spice_new0(RedLinkInfo, 1); + peer = spice_new0(RedsStreamContext, 1); link->peer = peer; peer->socket = socket; openssl_init(link); return link; -error2: - free(link); - -error1: +error: close(socket); return NULL; @@ -3469,8 +3435,7 @@ static void reds_do_set_ticket(const char *password, const char *args) int option; char *val; - in_args = local_args = malloc(strlen(args) + 1); - strcpy(local_args, args); + in_args = local_args = spice_strdup(args); do { switch (option = get_option(&in_args, &val, _spice_ticket_options, ',')) { case SPICE_TICKET_OPTION_EXPIRATION: { @@ -3836,10 +3801,7 @@ static void set_one_channel_security(int id, uint32_t security) security_options->options = security; return; } - security_options = (ChannelSecurityOptions *)malloc(sizeof(*security_options)); - if (!security_options) { - red_error("malloc failed"); - } + security_options = spice_new(ChannelSecurityOptions, 1); security_options->channel_id = id; security_options->options = security; security_options->next = channels_security; @@ -3848,17 +3810,14 @@ static void set_one_channel_security(int id, uint32_t security) static int set_channels_security(const char *channels, uint32_t security) { - char *local_str = malloc(strlen(channels) + 1); + char *local_str; int channel_name; char *str; char *val; int all = 0; int specific = 0; - if (!local_str) { - red_error("malloc failed"); - } - strcpy(local_str, channels); + local_str = spice_strdup(channels); str = local_str; do { switch (channel_name = get_option(&str, &val, _channel_map, '+')) { @@ -3928,8 +3887,7 @@ int __attribute__ ((visibility ("default"))) spice_parse_args(const char *in_arg memset(&ssl_parameters, 0, sizeof(ssl_parameters)); - local_args = malloc(strlen(in_args) + 1); - strcpy(local_args, in_args); + local_args = spice_strdup(in_args); args = local_args; do { @@ -4394,14 +4352,7 @@ static void reds_mig_send_ticket(RedsMigSpice *s) static void reds_mig_receive_cert_public_key(RedsMigSpice *s) { - s->cert_pub_key = malloc(s->cert_pub_key_len); - if (!s->cert_pub_key) { - red_printf("alloc failed"); - reds_mig_failed(s); - return; - } - - memcpy(s->cert_pub_key, s->read.buf, s->cert_pub_key_len); + s->cert_pub_key = spice_memdup(s->read.buf, s->cert_pub_key_len); s->read.size = SPICE_TICKET_PUBKEY_BYTES; s->read.end_pos = 0; @@ -4530,21 +4481,12 @@ static void reds_mig_started(void *opaque, const char *in_args) goto error; } - spice_migration = (RedsMigSpice *)malloc(sizeof(RedsMigSpice)); - if (!spice_migration) { - red_printf("Could not allocate memory for spice migration structure"); - goto error; - } - memset(spice_migration, 0, sizeof(RedsMigSpice)); + spice_migration = spice_new0(RedsMigSpice, 1); spice_migration->port = -1; spice_migration->sport = -1; - if (!(spice_migration->local_args = malloc(strlen(in_args) + 1))) { - red_printf("str malloc failed"); - goto error; - } + spice_migration->local_args = spice_strdup(in_args); - strcpy(spice_migration->local_args, in_args); args = spice_migration->local_args; do { switch (option = get_option(&args, &val, spice_mig_options, ',')) { @@ -5351,11 +5293,7 @@ static void init_vd_agent_resources() state->recive_len = sizeof(state->vdi_chunk_header); for (i = 0; i < REDS_AGENT_WINDOW_SIZE; i++) { - VDAgentExtBuf *buf = (VDAgentExtBuf *)malloc(sizeof(VDAgentExtBuf)); - if (!buf) { - PANIC("alloc failed"); - } - memset(buf, 0, sizeof(*buf)); + VDAgentExtBuf *buf = spice_new0(VDAgentExtBuf, 1); ring_item_init(&buf->base.link); buf->base.chunk_header.port = VDP_CLIENT_PORT; buf->base.free = free_external_agent_buff; @@ -5363,11 +5301,7 @@ static void init_vd_agent_resources() } for (i = 0; i < REDS_NUM_INTERNAL_AGENT_MESSAGES; i++) { - VDInternalBuf *buf = (VDInternalBuf *)malloc(sizeof(VDInternalBuf)); - if (!buf) { - PANIC("alloc failed"); - } - memset(buf, 0, sizeof(*buf)); + VDInternalBuf *buf = spice_new0(VDInternalBuf, 1); ring_item_init(&buf->base.link); buf->base.free = free_internal_agent_buff; buf->base.chunk_header.port = VDP_SERVER_PORT; @@ -5380,11 +5314,7 @@ static void init_vd_agent_resources() } for (i = 0; i < REDS_VDI_PORT_NUM_RECIVE_BUFFS; i++) { - VDIReadBuf *buf = (VDIReadBuf *)malloc(sizeof(VDIReadBuf)); - if (!buf) { - PANIC("alloc failed"); - } - memset(buf, 0, sizeof(*buf)); + VDIReadBuf *buf = spice_new0(VDIReadBuf, 1); buf->out_item.prepare = reds_prepare_read_buf; buf->out_item.release = reds_release_read_buf; buf->header.type = SPICE_MSG_MAIN_AGENT_DATA; @@ -5446,9 +5376,7 @@ static void do_spice_init(CoreInterface *core_interface) int shm_name_len = strlen(SPICE_STAT_SHM_NAME) + 20; int fd; - if (!(reds->stat_shm_name = (char *)malloc(shm_name_len))) { - red_error("stat_shm_name alloc failed"); - } + reds->stat_shm_name = (char *)spice_malloc(shm_name_len); snprintf(reds->stat_shm_name, shm_name_len, SPICE_STAT_SHM_NAME, getpid()); if ((fd = shm_open(reds->stat_shm_name, O_CREAT | O_RDWR, 0444)) == -1) { red_error("statistics shm_open failed, %s", strerror(errno)); @@ -5500,10 +5428,7 @@ SpiceServer *spice_server_new(void) /* we can't handle multiple instances (yet) */ ASSERT(reds == NULL); - if (!(reds = malloc(sizeof(RedsState)))) { - red_error("reds alloc failed"); - } - memset(reds, 0, sizeof(RedsState)); + reds = spice_new0(RedsState, 1); return reds; } diff --git a/server/snd_worker.c b/server/snd_worker.c index d9e5b625..aa61c4b4 100644 --- a/server/snd_worker.c +++ b/server/snd_worker.c @@ -795,11 +795,7 @@ static SndChannel *__new_channel(SndWorker *worker, int size, RedsStreamContext } ASSERT(size >= sizeof(*channel)); - if (!(channel = malloc(size))) { - red_printf("malloc failed"); - goto error1; - } - memset(channel, 0, size); + channel = spice_malloc0(size); channel->peer = peer; channel->worker = worker; channel->recive_data.message = (SpiceDataHeader *)channel->recive_data.buf; @@ -1201,10 +1197,7 @@ static SndWorker *find_worker(VDInterface *interface) void snd_attach_playback(PlaybackInterface *interface) { SndWorker *playback_worker; - if (!(playback_worker = (SndWorker *)malloc(sizeof(*playback_worker)))) { - red_error("playback channel malloc failed"); - } - memset(playback_worker, 0, sizeof(*playback_worker)); + playback_worker = spice_new0(SndWorker, 1); playback_worker->base.type = SPICE_CHANNEL_PLAYBACK; playback_worker->base.link = snd_set_playback_peer; playback_worker->base.shutdown = snd_shutdown; @@ -1213,9 +1206,7 @@ void snd_attach_playback(PlaybackInterface *interface) playback_worker->interface = &interface->base; playback_worker->base.num_caps = 1; - if (!(playback_worker->base.caps = malloc(sizeof(uint32_t)))) { - PANIC("malloc failed"); - } + playback_worker->base.caps = spice_new(uint32_t, 1); playback_worker->base.caps[0] = (1 << SPICE_PLAYBACK_CAP_CELT_0_5_1); add_worker(playback_worker); @@ -1225,11 +1216,7 @@ void snd_attach_playback(PlaybackInterface *interface) void snd_attach_record(RecordInterface *interface) { SndWorker *record_worker; - if (!(record_worker = (SndWorker *)malloc(sizeof(*record_worker)))) { - PANIC("malloc failed"); - } - - memset(record_worker, 0, sizeof(*record_worker)); + record_worker = spice_new0(SndWorker, 1); record_worker->base.type = SPICE_CHANNEL_RECORD; record_worker->base.link = snd_set_record_peer; record_worker->base.shutdown = snd_shutdown; @@ -1239,9 +1226,7 @@ void snd_attach_record(RecordInterface *interface) record_worker->interface = &interface->base; record_worker->base.num_caps = 1; - if (!(record_worker->base.caps = malloc(sizeof(uint32_t)))) { - PANIC("malloc failed"); - } + record_worker->base.caps = spice_new(uint32_t, 1); record_worker->base.caps[0] = (1 << SPICE_RECORD_CAP_CELT_0_5_1); add_worker(record_worker); reds_register_channel(&record_worker->base); |