Move 'core' into RedsState struct

Also add reds_get_core_interface() accessor for external use.

Acked-by: Frediano Ziglio <fziglio@redhat.com>

10 files changed, 74 insertions, 64 deletions

diff --git a/server/char-device.c b/server/char-device.c
index aa2eafd3..6093599b 100644
--- a/server/char-device.c
+++ b/server/char-device.c
@@ -156,7 +156,7 @@ static void spice_char_device_client_free(SpiceCharDeviceState *dev,
     RingItem *item, *next;
 
     if (dev_client->wait_for_tokens_timer) {
-        core->timer_remove(dev_client->wait_for_tokens_timer);
+        reds_get_core_interface(reds)->timer_remove(dev_client->wait_for_tokens_timer);
     }
 
     spice_char_device_client_send_queue_free(dev, dev_client);
@@ -262,8 +262,8 @@ static void spice_char_device_add_msg_to_client_queue(SpiceCharDeviceClientState
     ring_add(&dev_client->send_queue, &msg_item->link);
     dev_client->send_queue_size++;
     if (!dev_client->wait_for_tokens_started) {
-        core->timer_start(dev_client->wait_for_tokens_timer,
-                          SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
+        reds_get_core_interface(reds)->timer_start(dev_client->wait_for_tokens_timer,
+                                                   SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
         dev_client->wait_for_tokens_started = TRUE;
     }
 }
@@ -370,12 +370,12 @@ static void spice_char_device_send_to_client_tokens_absorb(SpiceCharDeviceClient
     }
 
     if (spice_char_device_can_send_to_client(dev_client)) {
-        core->timer_cancel(dev_client->wait_for_tokens_timer);
+        reds_get_core_interface(reds)->timer_cancel(dev_client->wait_for_tokens_timer);
         dev_client->wait_for_tokens_started = FALSE;
         spice_char_device_read_from_device(dev_client->dev);
     } else if (dev_client->send_queue_size) {
-        core->timer_start(dev_client->wait_for_tokens_timer,
-                          SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
+        reds_get_core_interface(reds)->timer_start(dev_client->wait_for_tokens_timer,
+                                                   SPICE_CHAR_DEVICE_WAIT_TOKENS_TIMEOUT);
         dev_client->wait_for_tokens_started = TRUE;
     }
 }
@@ -456,7 +456,7 @@ static int spice_char_device_write_to_device(SpiceCharDeviceState *dev)
     spice_char_device_state_ref(dev);
 
     if (dev->write_to_dev_timer) {
-        core->timer_cancel(dev->write_to_dev_timer);
+        reds_get_core_interface(reds)->timer_cancel(dev->write_to_dev_timer);
     }
 
     sif = SPICE_CONTAINEROF(dev->sin->base.sif, SpiceCharDeviceInterface, base);
@@ -498,8 +498,8 @@ static int spice_char_device_write_to_device(SpiceCharDeviceState *dev)
     if (dev->running) {
         if (dev->cur_write_buf) {
             if (dev->write_to_dev_timer) {
-                core->timer_start(dev->write_to_dev_timer,
-                                  CHAR_DEVICE_WRITE_TO_TIMEOUT);
+                reds_get_core_interface(reds)->timer_start(dev->write_to_dev_timer,
+                                                           CHAR_DEVICE_WRITE_TO_TIMEOUT);
             }
         } else {
             spice_assert(ring_is_empty(&dev->write_queue));
@@ -516,7 +516,7 @@ static void spice_char_dev_write_retry(void *opaque)
     SpiceCharDeviceState *dev = opaque;
 
     if (dev->write_to_dev_timer) {
-        core->timer_cancel(dev->write_to_dev_timer);
+        reds_get_core_interface(reds)->timer_cancel(dev->write_to_dev_timer);
     }
     spice_char_device_write_to_device(dev);
 }
@@ -695,7 +695,8 @@ SpiceCharDeviceState *spice_char_device_state_create(SpiceCharDeviceInstance *si
     sif = SPICE_CONTAINEROF(char_dev->sin->base.sif, SpiceCharDeviceInterface, base);
     if (sif->base.minor_version <= 2 ||
         !(sif->flags & SPICE_CHAR_DEVICE_NOTIFY_WRITABLE)) {
-        char_dev->write_to_dev_timer = core->timer_add(core, spice_char_dev_write_retry, char_dev);
+        char_dev->write_to_dev_timer = reds_get_core_interface(reds)->timer_add(reds_get_core_interface(reds),
+                                                                                spice_char_dev_write_retry, char_dev);
         if (!char_dev->write_to_dev_timer) {
             spice_error("failed creating char dev write timer");
         }
@@ -743,7 +744,7 @@ void spice_char_device_state_destroy(SpiceCharDeviceState *char_dev)
 {
     reds_on_char_device_state_destroy(reds, char_dev);
     if (char_dev->write_to_dev_timer) {
-        core->timer_remove(char_dev->write_to_dev_timer);
+        reds_get_core_interface(reds)->timer_remove(char_dev->write_to_dev_timer);
         char_dev->write_to_dev_timer = NULL;
     }
     write_buffers_queue_free(&char_dev->write_queue);
@@ -794,8 +795,9 @@ int spice_char_device_client_add(SpiceCharDeviceState *dev,
     dev_client->max_send_queue_size = max_send_queue_size;
     dev_client->do_flow_control = do_flow_control;
     if (do_flow_control) {
-        dev_client->wait_for_tokens_timer = core->timer_add(core, device_client_wait_for_tokens_timeout,
-                                                            dev_client);
+        dev_client->wait_for_tokens_timer = reds_get_core_interface(reds)->timer_add(reds_get_core_interface(reds),
+                                                                                     device_client_wait_for_tokens_timeout,
+                                                                                     dev_client);
         if (!dev_client->wait_for_tokens_timer) {
             spice_error("failed to create wait for tokens timer");
         }
@@ -860,7 +862,7 @@ void spice_char_device_stop(SpiceCharDeviceState *dev)
     dev->running = FALSE;
     dev->active = FALSE;
     if (dev->write_to_dev_timer) {
-        core->timer_cancel(dev->write_to_dev_timer);
+        reds_get_core_interface(reds)->timer_cancel(dev->write_to_dev_timer);
     }
 }
 
diff --git a/server/inputs-channel.c b/server/inputs-channel.c
index 319d26cb..5e884f47 100644
--- a/server/inputs-channel.c
+++ b/server/inputs-channel.c
@@ -186,7 +186,7 @@ static void inputs_channel_release_msg_rcv_buf(RedChannelClient *rcc,
 
 static void activate_modifiers_watch(void)
 {
-    core->timer_start(key_modifiers_timer, KEY_MODIFIERS_TTL);
+    reds_get_core_interface(reds)->timer_start(key_modifiers_timer, KEY_MODIFIERS_TTL);
 }
 
 static void kbd_push_scan(SpiceKbdInstance *sin, uint8_t scan)
@@ -628,7 +628,7 @@ InputsChannel* inputs_channel_new(void)
 
     inputs = (InputsChannel *)red_channel_create_parser(
                                     sizeof(InputsChannel),
-                                    core,
+                                    reds_get_core_interface(reds),
                                     SPICE_CHANNEL_INPUTS, 0,
                                     FALSE, /* handle_acks */
                                     spice_get_client_channel_parser(SPICE_CHANNEL_INPUTS, NULL),
@@ -647,7 +647,8 @@ InputsChannel* inputs_channel_new(void)
     red_channel_set_cap(&inputs->base, SPICE_INPUTS_CAP_KEY_SCANCODE);
     reds_register_channel(reds, &inputs->base);
 
-    if (!(key_modifiers_timer = core->timer_add(core, key_modifiers_sender, inputs))) {
+    if (!(key_modifiers_timer = reds_get_core_interface(reds)->timer_add(reds_get_core_interface(reds),
+                                                                         key_modifiers_sender, inputs))) {
         spice_error("key modifiers timer create failed");
     }
     return inputs;
diff --git a/server/main-channel.c b/server/main-channel.c
index aa2b03ca..c2a7b8bb 100644
--- a/server/main-channel.c
+++ b/server/main-channel.c
@@ -1052,9 +1052,9 @@ static void do_ping_client(MainChannelClient *mcc,
         if (has_interval && interval > 0) {
             mcc->ping_interval = interval * MSEC_PER_SEC;
         }
-        core->timer_start(mcc->ping_timer, mcc->ping_interval);
+        reds_get_core_interface(reds)->timer_start(mcc->ping_timer, mcc->ping_interval);
     } else if (!strcmp(opt, "off")) {
-        core->timer_cancel(mcc->ping_timer);
+        reds_get_core_interface(reds)->timer_cancel(mcc->ping_timer);
     } else {
         return;
     }
@@ -1066,11 +1066,11 @@ static void ping_timer_cb(void *opaque)
 
     if (!red_channel_client_is_connected(&mcc->base)) {
         spice_printerr("not connected to peer, ping off");
-        core->timer_cancel(mcc->ping_timer);
+        reds_get_core_interface(reds)->timer_cancel(mcc->ping_timer);
         return;
     }
     do_ping_client(mcc, NULL, 0, 0);
-    core->timer_start(mcc->ping_timer, mcc->ping_interval);
+    reds_get_core_interface(reds)->timer_start(mcc->ping_timer, mcc->ping_interval);
 }
 #endif /* RED_STATISTICS */
 
@@ -1087,7 +1087,8 @@ static MainChannelClient *main_channel_client_create(MainChannel *main_chan, Red
     mcc->connection_id = connection_id;
     mcc->bitrate_per_sec = ~0;
 #ifdef RED_STATISTICS
-    if (!(mcc->ping_timer = core->timer_add(core, ping_timer_cb, NULL))) {
+    if (!(mcc->ping_timer = reds_get_core_interface(reds)->timer_add(reds_get_core_interface(reds),
+                                                                     ping_timer_cb, NULL))) {
         spice_error("ping timer create failed");
     }
     mcc->ping_interval = PING_INTERVAL;
@@ -1178,7 +1179,7 @@ MainChannel* main_channel_new(void)
     channel_cbs.handle_migrate_data = main_channel_handle_migrate_data;
 
     // TODO: set the migration flag of the channel
-    channel = red_channel_create_parser(sizeof(MainChannel), core,
+    channel = red_channel_create_parser(sizeof(MainChannel), reds_get_core_interface(reds),
                                         SPICE_CHANNEL_MAIN, 0,
                                         FALSE, /* handle_acks */
                                         spice_get_client_channel_parser(SPICE_CHANNEL_MAIN, NULL),
diff --git a/server/reds-private.h b/server/reds-private.h
index bc086ba3..21dbe490 100644
--- a/server/reds-private.h
+++ b/server/reds-private.h
@@ -235,6 +235,8 @@ struct RedsState {
     gboolean exit_on_disconnect;
 
     RedSSLParameters ssl_parameters;
+    SpiceCoreInterfaceInternal *core;
+
 };
 
 #endif
diff --git a/server/reds-stream.c b/server/reds-stream.c
index 2b1c5b98..2eb8f896 100644
--- a/server/reds-stream.c
+++ b/server/reds-stream.c
@@ -22,6 +22,7 @@
 #include "main-dispatcher.h"
 #include "red-common.h"
 #include "reds-stream.h"
+#include "reds.h"
 #include "common/log.h"
 
 #include <errno.h>
@@ -44,8 +45,6 @@ struct AsyncRead {
 };
 typedef struct AsyncRead AsyncRead;
 
-extern SpiceCoreInterfaceInternal *core;
-
 #if HAVE_SASL
 #include <sasl/sasl.h>
 
@@ -168,7 +167,7 @@ static ssize_t stream_ssl_read_cb(RedsStream *s, void *buf, size_t size)
 void reds_stream_remove_watch(RedsStream* s)
 {
     if (s->watch) {
-        core->watch_remove(s->watch);
+        reds_get_core_interface(reds)->watch_remove(s->watch);
         s->watch = NULL;
     }
 }
@@ -497,9 +496,10 @@ static void async_read_handler(G_GNUC_UNUSED int fd,
                 switch (errno) {
                 case EAGAIN:
                     if (!async->stream->watch) {
-                        async->stream->watch = core->watch_add(core, async->stream->socket,
-                                                               SPICE_WATCH_EVENT_READ,
-                                                               async_read_handler, async);
+                        async->stream->watch = reds_get_core_interface(reds)->watch_add(reds_get_core_interface(reds),
+                                                                                        async->stream->socket,
+                                                                                        SPICE_WATCH_EVENT_READ,
+                                                                                        async_read_handler, async);
                     }
                     return;
                 case EINTR:
diff --git a/server/reds.c b/server/reds.c
index d7acab5c..58af7c48 100644
--- a/server/reds.c
+++ b/server/reds.c
@@ -72,8 +72,6 @@
 
 #include "reds-private.h"
 
-SpiceCoreInterfaceInternal *core = NULL;
-
 static SpiceCoreInterface *core_public = NULL;
 
 static SpiceTimer *adapter_timer_add(const SpiceCoreInterfaceInternal *iface, SpiceTimerFunc func, void *opaque)
@@ -189,7 +187,7 @@ static ChannelSecurityOptions *reds_find_channel_security(RedsState *reds, int i
 
 void reds_handle_channel_event(RedsState *reds, int event, SpiceChannelEventInfo *info)
 {
-    core->channel_event(event, info);
+    reds->core->channel_event(event, info);
 
     if (event == SPICE_CHANNEL_EVENT_DISCONNECTED) {
         free(info);
@@ -381,7 +379,7 @@ static void reds_mig_cleanup(RedsState *reds)
         reds->mig_inprogress = FALSE;
         reds->mig_wait_connect = FALSE;
         reds->mig_wait_disconnect = FALSE;
-        core->timer_cancel(reds->mig_timer);
+        reds->core->timer_cancel(reds->mig_timer);
         reds_mig_cleanup_wait_disconnect(reds);
     }
 }
@@ -2256,10 +2254,10 @@ static void reds_handle_ssl_accept(int fd, int event, void *data)
             reds_link_free(link);
             return;
         case REDS_STREAM_SSL_STATUS_WAIT_FOR_READ:
-            core->watch_update_mask(link->stream->watch, SPICE_WATCH_EVENT_READ);
+            reds->core->watch_update_mask(link->stream->watch, SPICE_WATCH_EVENT_READ);
             return;
         case REDS_STREAM_SSL_STATUS_WAIT_FOR_WRITE:
-            core->watch_update_mask(link->stream->watch, SPICE_WATCH_EVENT_WRITE);
+            reds->core->watch_update_mask(link->stream->watch, SPICE_WATCH_EVENT_WRITE);
             return;
         case REDS_STREAM_SSL_STATUS_OK:
             reds_stream_remove_watch(link->stream);
@@ -2337,12 +2335,12 @@ static RedLinkInfo *reds_init_client_ssl_connection(RedsState *reds, int socket)
         case REDS_STREAM_SSL_STATUS_ERROR:
             goto error;
         case REDS_STREAM_SSL_STATUS_WAIT_FOR_READ:
-            link->stream->watch = core->watch_add(core, link->stream->socket, SPICE_WATCH_EVENT_READ,
-                                            reds_handle_ssl_accept, link);
+            link->stream->watch = reds->core->watch_add(reds->core, link->stream->socket, SPICE_WATCH_EVENT_READ,
+                                                        reds_handle_ssl_accept, link);
             break;
         case REDS_STREAM_SSL_STATUS_WAIT_FOR_WRITE:
-            link->stream->watch = core->watch_add(core, link->stream->socket, SPICE_WATCH_EVENT_WRITE,
-                                                  reds_handle_ssl_accept, link);
+            link->stream->watch = reds->core->watch_add(reds->core, link->stream->socket, SPICE_WATCH_EVENT_WRITE,
+                                                        reds_handle_ssl_accept, link);
             break;
     }
     return link;
@@ -2536,9 +2534,9 @@ static int reds_init_net(RedsState *reds)
         if (-1 == reds->listen_socket) {
             return -1;
         }
-        reds->listen_watch = core->watch_add(core, reds->listen_socket,
-                                             SPICE_WATCH_EVENT_READ,
-                                             reds_accept, reds);
+        reds->listen_watch = reds->core->watch_add(reds->core, reds->listen_socket,
+                                                   SPICE_WATCH_EVENT_READ,
+                                                   reds_accept, reds);
         if (reds->listen_watch == NULL) {
             spice_warning("set fd handle failed");
             return -1;
@@ -2551,9 +2549,9 @@ static int reds_init_net(RedsState *reds)
         if (-1 == reds->secure_listen_socket) {
             return -1;
         }
-        reds->secure_listen_watch = core->watch_add(core, reds->secure_listen_socket,
-                                                    SPICE_WATCH_EVENT_READ,
-                                                    reds_accept_ssl_connection, reds);
+        reds->secure_listen_watch = reds->core->watch_add(reds->core, reds->secure_listen_socket,
+                                                          SPICE_WATCH_EVENT_READ,
+                                                          reds_accept_ssl_connection, reds);
         if (reds->secure_listen_watch == NULL) {
             spice_warning("set fd handle failed");
             return -1;
@@ -2562,9 +2560,9 @@ static int reds_init_net(RedsState *reds)
 
     if (reds->spice_listen_socket_fd != -1 ) {
         reds->listen_socket = reds->spice_listen_socket_fd;
-        reds->listen_watch = core->watch_add(core, reds->listen_socket,
-                                             SPICE_WATCH_EVENT_READ,
-                                             reds_accept, reds);
+        reds->listen_watch = reds->core->watch_add(reds->core, reds->listen_socket,
+                                                   SPICE_WATCH_EVENT_READ,
+                                                   reds_accept, reds);
         if (reds->listen_watch == NULL) {
             spice_warning("set fd handle failed");
             return -1;
@@ -2799,7 +2797,7 @@ static void reds_mig_started(RedsState *reds)
 
     reds->mig_inprogress = TRUE;
     reds->mig_wait_connect = TRUE;
-    core->timer_start(reds->mig_timer, MIGRATE_TIMEOUT);
+    reds->core->timer_start(reds->mig_timer, MIGRATE_TIMEOUT);
 }
 
 static void reds_mig_fill_wait_disconnect(RedsState *reds)
@@ -2818,7 +2816,7 @@ static void reds_mig_fill_wait_disconnect(RedsState *reds)
         ring_add(&reds->mig_wait_disconnect_clients, &wait_client->link);
     }
     reds->mig_wait_disconnect = TRUE;
-    core->timer_start(reds->mig_timer, MIGRATE_TIMEOUT);
+    reds->core->timer_start(reds->mig_timer, MIGRATE_TIMEOUT);
 }
 
 static void reds_mig_cleanup_wait_disconnect(RedsState *reds)
@@ -3314,20 +3312,20 @@ static int do_spice_init(RedsState *reds, SpiceCoreInterface *core_interface)
         goto err;
     }
     core_public = core_interface;
-    core = &core_interface_adapter;
+    reds->core = &core_interface_adapter;
     reds->listen_socket = -1;
     reds->secure_listen_socket = -1;
     reds_init_vd_agent_resources(reds);
     ring_init(&reds->clients);
     reds->num_clients = 0;
-    main_dispatcher_init(core);
+    main_dispatcher_init(reds->core);
     ring_init(&reds->channels);
     ring_init(&reds->mig_target_clients);
     ring_init(&reds->char_devs_states);
     ring_init(&reds->mig_wait_disconnect_clients);
     reds->vm_running = TRUE; /* for backward compatibility */
 
-    if (!(reds->mig_timer = core->timer_add(core, migrate_timeout, reds))) {
+    if (!(reds->mig_timer = reds->core->timer_add(reds->core, migrate_timeout, reds))) {
         spice_error("migration timer create failed");
     }
 
@@ -4025,3 +4023,8 @@ spice_wan_compression_t reds_get_zlib_glz_state(const RedsState *reds)
 {
     return reds->zlib_glz_state;
 }
+
+SpiceCoreInterfaceInternal* reds_get_core_interface(RedsState *reds)
+{
+    return reds->core;
+}
diff --git a/server/reds.h b/server/reds.h
index f1410430..d1a726f2 100644
--- a/server/reds.h
+++ b/server/reds.h
@@ -76,8 +76,6 @@ enum {
 extern uint32_t renderers[RED_RENDERER_LAST];
 extern uint32_t num_renderers;
 
-extern struct SpiceCoreInterfaceInternal *core;
-
 // Temporary measures to make splitting reds.c to inputs-channel.c easier
 
 /* should be called only from main_dispatcher */
@@ -116,5 +114,6 @@ void reds_set_client_mm_time_latency(RedsState *reds, RedClient *client, uint32_
 uint32_t reds_get_streaming_video(const RedsState *reds);
 spice_wan_compression_t reds_get_jpeg_state(const RedsState *reds);
 spice_wan_compression_t reds_get_zlib_glz_state(const RedsState *reds);
+SpiceCoreInterfaceInternal* reds_get_core_interface(RedsState *reds);
 
 #endif
diff --git a/server/smartcard.c b/server/smartcard.c
index 9b8f7c63..0be32357 100644
--- a/server/smartcard.c
+++ b/server/smartcard.c
@@ -848,7 +848,8 @@ static void smartcard_init(void)
     channel_cbs.handle_migrate_data = smartcard_channel_client_handle_migrate_data;
 
     g_smartcard_channel = (SmartCardChannel*)red_channel_create(sizeof(SmartCardChannel),
-                                             core, SPICE_CHANNEL_SMARTCARD, 0,
+                                             reds_get_core_interface(reds),
+                                             SPICE_CHANNEL_SMARTCARD, 0,
                                              FALSE /* handle_acks */,
                                              smartcard_channel_handle_message,
                                              &channel_cbs,
diff --git a/server/sound.c b/server/sound.c
index 0890a87d..3c77d77b 100644
--- a/server/sound.c
+++ b/server/sound.c
@@ -213,7 +213,7 @@ static void snd_disconnect_channel(SndChannel *channel)
     channel->cleanup(channel);
     red_channel_client_disconnect(worker->connection->channel_client);
     worker->connection->channel_client = NULL;
-    core->watch_remove(channel->stream->watch);
+    reds_get_core_interface(reds)->watch_remove(channel->stream->watch);
     channel->stream->watch = NULL;
     reds_stream_free(channel->stream);
     channel->stream = NULL;
@@ -266,7 +266,7 @@ static int snd_send_data(SndChannel *channel)
 
             if (channel->blocked) {
                 channel->blocked = FALSE;
-                core->watch_update_mask(channel->stream->watch, SPICE_WATCH_EVENT_READ);
+                reds_get_core_interface(reds)->watch_update_mask(channel->stream->watch, SPICE_WATCH_EVENT_READ);
             }
             break;
         }
@@ -278,8 +278,8 @@ static int snd_send_data(SndChannel *channel)
             switch (errno) {
             case EAGAIN:
                 channel->blocked = TRUE;
-                core->watch_update_mask(channel->stream->watch, SPICE_WATCH_EVENT_READ |
-                                        SPICE_WATCH_EVENT_WRITE);
+                reds_get_core_interface(reds)->watch_update_mask(channel->stream->watch, SPICE_WATCH_EVENT_READ |
+                                                                 SPICE_WATCH_EVENT_WRITE);
                 return FALSE;
             case EINTR:
                 break;
@@ -947,8 +947,9 @@ static SndChannel *__new_channel(SndWorker *worker, int size, uint32_t channel_i
     channel->receive_data.end = channel->receive_data.buf + sizeof(channel->receive_data.buf);
     channel->send_data.marshaller = spice_marshaller_new();
 
-    stream->watch = core->watch_add(core, stream->socket, SPICE_WATCH_EVENT_READ,
-                                  snd_event, channel);
+    stream->watch = reds_get_core_interface(reds)->watch_add(reds_get_core_interface(reds),
+                                                             stream->socket, SPICE_WATCH_EVENT_READ,
+                                                             snd_event, channel);
     if (stream->watch == NULL) {
         spice_printerr("watch_add failed, %s", strerror(errno));
         goto error2;
diff --git a/server/spicevmc.c b/server/spicevmc.c
index 28a65d72..95d840e9 100644
--- a/server/spicevmc.c
+++ b/server/spicevmc.c
@@ -524,7 +524,7 @@ SpiceCharDeviceState *spicevmc_device_connect(SpiceCharDeviceInstance *sin,
     channel_cbs.handle_migrate_data = spicevmc_channel_client_handle_migrate_data;
 
     state = (SpiceVmcState*)red_channel_create(sizeof(SpiceVmcState),
-                                   core, channel_type, id[channel_type]++,
+                                   reds_get_core_interface(reds), channel_type, id[channel_type]++,
                                    FALSE /* handle_acks */,
                                    spicevmc_red_channel_client_handle_message,
                                    &channel_cbs,