int aeron_driver_receiver_add_pending_setup(
aeron_driver_receiver_t *receiver,
aeron_receive_channel_endpoint_t *endpoint,
int32_t session_id,
int32_t stream_id,
struct sockaddr_storage *control_addr)
{
int ensure_capacity_result = 0;
AERON_ARRAY_ENSURE_CAPACITY(
ensure_capacity_result, receiver->pending_setups, aeron_driver_receiver_pending_setup_entry_t);
if (ensure_capacity_result < 0)
{
int errcode = errno;
aeron_set_err(errcode, "receiver add_pending_setup: %s", strerror(errcode));
return ensure_capacity_result;
}
aeron_driver_receiver_pending_setup_entry_t *entry =
&receiver->pending_setups.array[receiver->pending_setups.length++];
entry->endpoint = endpoint;
entry->session_id = session_id;
entry->stream_id = stream_id;
entry->time_of_status_message_ns = receiver->context->nano_clock();
entry->is_periodic = false;
if (NULL != control_addr)
{
memcpy(&entry->control_addr, control_addr, sizeof(entry->control_addr));
entry->is_periodic = true;
}
return ensure_capacity_result;
}
int aeron_udp_transport_poller_add(aeron_udp_transport_poller_t *poller, aeron_udp_channel_transport_t *transport)
{
int ensure_capacity_result = 0;
size_t old_capacity = poller->transports.capacity, index = poller->transports.length;
AERON_ARRAY_ENSURE_CAPACITY(ensure_capacity_result, poller->transports, aeron_udp_channel_transport_entry_t);
if (ensure_capacity_result < 0)
{
return -1;
}
poller->transports.array[index].transport = transport;
#if defined(HAVE_EPOLL)
size_t new_capacity = poller->transports.capacity;
if (new_capacity > old_capacity)
{
if (aeron_array_ensure_capacity((uint8_t **)&poller->epoll_events, sizeof(struct epoll_event), old_capacity, new_capacity) < 0)
{
return -1;
}
}
struct epoll_event event;
event.data.fd = transport->fd;
event.data.ptr = transport;
event.events = EPOLLIN;
int result = epoll_ctl(poller->epoll_fd, EPOLL_CTL_ADD, transport->fd, &event);
if (result < 0)
{
aeron_set_err(errno, "epoll_ctl(EPOLL_CTL_ADD): %s", strerror(errno));
return -1;
}
#elif defined(HAVE_POLL)
size_t new_capacity = poller->transports.capacity;
if (new_capacity > old_capacity)
{
if (aeron_array_ensure_capacity((uint8_t **)&poller->pollfds, sizeof(struct pollfd), old_capacity, new_capacity) < 0)
{
return -1;
}
}
poller->pollfds[index].fd = transport->fd;
poller->pollfds[index].events = POLLIN;
poller->pollfds[index].revents = 0;
#endif
poller->transports.length++;
return 0;
}
int aeron_udp_destination_tracker_add_destination(
aeron_udp_destination_tracker_t *tracker, int64_t receiver_id, int64_t now_ns, struct sockaddr_storage *addr)
{
int result = 0;
AERON_ARRAY_ENSURE_CAPACITY(result, tracker->destinations, aeron_udp_destination_entry_t);
if (result >= 0)
{
aeron_udp_destination_entry_t *entry = &tracker->destinations.array[tracker->destinations.length++];
entry->receiver_id = receiver_id;
entry->time_of_last_activity_ns = now_ns;
memcpy(&entry->addr, addr, sizeof(struct sockaddr_storage));
}
return result;
}
void aeron_driver_receiver_on_add_publication_image(void *clientd, void *item)
{
aeron_driver_receiver_t *receiver = (aeron_driver_receiver_t *)clientd;
aeron_command_publication_image_t *cmd = (aeron_command_publication_image_t *)item;
aeron_receive_channel_endpoint_t *endpoint = (aeron_receive_channel_endpoint_t *)cmd->endpoint;
int ensure_capacity_result = 0;
AERON_ARRAY_ENSURE_CAPACITY(ensure_capacity_result, receiver->images, aeron_driver_receiver_image_entry_t);
if (aeron_receive_channel_endpoint_on_add_publication_image(endpoint, cmd->image) < 0 || ensure_capacity_result < 0)
{
AERON_DRIVER_RECEIVER_ERROR(receiver, "receiver on_add_publication_image: %s", aeron_errmsg());
}
receiver->images.array[receiver->images.length++].image = cmd->image;
aeron_driver_conductor_proxy_on_delete_cmd(receiver->context->conductor_proxy, item);
}
