/** Receive a call setting arguments of the program to execute.
*
* @param rid
* @param request
*/
static void ldr_set_args(ipc_callid_t rid, ipc_call_t *request)
{
char *buf;
size_t buf_size;
int rc = async_data_write_accept((void **) &buf, true, 0, 0, 0, &buf_size);
if (rc == EOK) {
/*
* Count number of arguments
*/
char *cur = buf;
int count = 0;
while (cur < buf + buf_size) {
size_t arg_size = str_size(cur);
cur += arg_size + 1;
count++;
}
/*
* Allocate new argv
*/
char **_argv = (char **) malloc((count + 1) * sizeof(char *));
if (_argv == NULL) {
free(buf);
async_answer_0(rid, ENOMEM);
return;
}
/*
* Fill the new argv with argument pointers
*/
cur = buf;
count = 0;
while (cur < buf + buf_size) {
_argv[count] = cur;
size_t arg_size = str_size(cur);
cur += arg_size + 1;
count++;
}
_argv[count] = NULL;
/*
* Copy temporary data to global variables
*/
if (arg_buf != NULL)
free(arg_buf);
if (argv != NULL)
free(argv);
argc = count;
arg_buf = buf;
argv = _argv;
}
async_answer_0(rid, rc);
}
/** Receive a call setting pathname of the program to execute.
*
* @param rid
* @param request
*/
static void ldr_set_pathname(ipc_callid_t rid, ipc_call_t *request)
{
char *buf;
int rc = async_data_write_accept((void **) &buf, true, 0, 0, 0, NULL);
if (rc == EOK) {
if (pathname != NULL)
free(pathname);
pathname = buf;
}
async_answer_0(rid, rc);
}
/** Handle VHC request for control write to the device.
*
* @param dev Target virtual device.
* @param iid Caller id.
* @param icall The call with the request.
*/
static void ipc_control_write(usbvirt_device_t *dev,
ipc_callid_t iid, ipc_call_t *icall)
{
size_t data_buffer_len = IPC_GET_ARG1(*icall);
int rc;
void *setup_packet = NULL;
void *data_buffer = NULL;
size_t setup_packet_len = 0;
rc = async_data_write_accept(&setup_packet, false,
1, 0, 0, &setup_packet_len);
if (rc != EOK) {
async_answer_0(iid, rc);
return;
}
if (data_buffer_len > 0) {
rc = async_data_write_accept(&data_buffer, false,
1, 0, 0, &data_buffer_len);
if (rc != EOK) {
async_answer_0(iid, rc);
free(setup_packet);
return;
}
}
rc = usbvirt_control_write(dev, setup_packet, setup_packet_len,
data_buffer, data_buffer_len);
async_answer_0(iid, rc);
free(setup_packet);
if (data_buffer != NULL) {
free(data_buffer);
}
}
/** Handle VHC request for control read from the device.
*
* @param dev Target virtual device.
* @param iid Caller id.
* @param icall The call with the request.
*/
static void ipc_control_read(usbvirt_device_t *dev,
ipc_callid_t iid, ipc_call_t *icall)
{
int rc;
void *setup_packet = NULL;
size_t setup_packet_len = 0;
size_t data_len = 0;
rc = async_data_write_accept(&setup_packet, false,
1, 1024, 0, &setup_packet_len);
if (rc != EOK) {
async_answer_0(iid, rc);
return;
}
ipc_callid_t data_callid;
if (!async_data_read_receive(&data_callid, &data_len)) {
async_answer_0(iid, EPARTY);
free(setup_packet);
return;
}
void *buffer = malloc(data_len);
if (buffer == NULL) {
async_answer_0(iid, ENOMEM);
free(setup_packet);
return;
}
size_t actual_len;
rc = usbvirt_control_read(dev, setup_packet, setup_packet_len,
buffer, data_len, &actual_len);
if (rc != EOK) {
async_answer_0(data_callid, rc);
async_answer_0(iid, rc);
free(setup_packet);
free(buffer);
return;
}
async_data_read_finalize(data_callid, buffer, actual_len);
async_answer_0(iid, EOK);
free(setup_packet);
free(buffer);
}
static void inet_ev_recv(ipc_callid_t callid, ipc_call_t *call)
{
int rc;
inet_dgram_t dgram;
dgram.src.ipv4 = IPC_GET_ARG1(*call);
dgram.dest.ipv4 = IPC_GET_ARG2(*call);
dgram.tos = IPC_GET_ARG3(*call);
rc = async_data_write_accept(&dgram.data, false, 0, 0, 0, &dgram.size);
if (rc != EOK) {
async_answer_0(callid, rc);
return;
}
rc = inet_ev_ops->recv(&dgram);
async_answer_0(callid, rc);
}
static void iplink_send_srv(iplink_srv_t *srv, ipc_callid_t callid,
ipc_call_t *call)
{
iplink_srv_sdu_t sdu;
int rc;
sdu.lsrc.ipv4 = IPC_GET_ARG1(*call);
sdu.ldest.ipv4 = IPC_GET_ARG2(*call);
rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
if (rc != EOK) {
async_answer_0(callid, rc);
return;
}
rc = srv->ops->send(srv, &sdu);
free(sdu.data);
async_answer_0(callid, rc);
}
/** Handle VHC request for data write to the device (out transfer).
*
* @param dev Target virtual device.
* @param iid Caller id.
* @param icall The call with the request.
*/
static void ipc_data_out(usbvirt_device_t *dev,
usb_transfer_type_t transfer_type,
ipc_callid_t iid, ipc_call_t *icall)
{
usb_endpoint_t endpoint = IPC_GET_ARG1(*icall);
void *data_buffer = NULL;
size_t data_buffer_size = 0;
int rc = async_data_write_accept(&data_buffer, false,
1, 0, 0, &data_buffer_size);
if (rc != EOK) {
async_answer_0(iid, rc);
return;
}
rc = usbvirt_data_out(dev, transfer_type, endpoint,
data_buffer, data_buffer_size);
async_answer_0(iid, rc);
free(data_buffer);
}
static void tcp_sock_bind(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
{
int rc;
struct sockaddr *addr;
size_t addr_len;
socket_core_t *sock_core;
tcp_sockdata_t *socket;
log_msg(LVL_DEBUG, "tcp_sock_bind()");
log_msg(LVL_DEBUG, " - async_data_write_accept");
rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len);
if (rc != EOK) {
async_answer_0(callid, rc);
return;
}
log_msg(LVL_DEBUG, " - call socket_bind");
rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
addr, addr_len, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
last_used_port);
if (rc != EOK) {
async_answer_0(callid, rc);
return;
}
log_msg(LVL_DEBUG, " - call socket_cores_find");
sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
if (sock_core != NULL) {
socket = (tcp_sockdata_t *)sock_core->specific_data;
/* XXX Anything to do? */
(void) socket;
}
log_msg(LVL_DEBUG, " - success");
async_answer_0(callid, EOK);
}
/** VFS_REGISTER protocol function.
*
* @param rid Hash of the call with the request.
* @param request Call structure with the request.
*
*/
void vfs_register(ipc_callid_t rid, ipc_call_t *request)
{
dprintf("Processing VFS_REGISTER request received from %p.\n",
request->in_phone_hash);
vfs_info_t *vfs_info;
int rc = async_data_write_accept((void **) &vfs_info, false,
sizeof(vfs_info_t), sizeof(vfs_info_t), 0, NULL);
if (rc != EOK) {
dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n",
rc);
async_answer_0(rid, rc);
return;
}
/*
* Allocate and initialize a buffer for the fs_info structure.
*/
fs_info_t *fs_info = (fs_info_t *) malloc(sizeof(fs_info_t));
if (!fs_info) {
dprintf("Could not allocate memory for FS info.\n");
async_answer_0(rid, ENOMEM);
return;
}
link_initialize(&fs_info->fs_link);
fs_info->vfs_info = *vfs_info;
free(vfs_info);
dprintf("VFS info delivered.\n");
if (!vfs_info_sane(&fs_info->vfs_info)) {
free(fs_info);
async_answer_0(rid, EINVAL);
return;
}
fibril_mutex_lock(&fs_list_lock);
/*
* Check for duplicit registrations.
*/
if (fs_name_to_handle(fs_info->vfs_info.instance,
fs_info->vfs_info.name, false)) {
/*
* We already register a fs like this.
*/
dprintf("FS is already registered.\n");
fibril_mutex_unlock(&fs_list_lock);
free(fs_info);
async_answer_0(rid, EEXISTS);
return;
}
/*
* Add fs_info to the list of registered FS's.
*/
dprintf("Inserting FS into the list of registered file systems.\n");
list_append(&fs_info->fs_link, &fs_list);
/*
* Now we want the client to send us the IPC_M_CONNECT_TO_ME call so
* that a callback connection is created and we have a phone through
* which to forward VFS requests to it.
*/
fs_info->sess = async_callback_receive(EXCHANGE_PARALLEL);
if (!fs_info->sess) {
dprintf("Callback connection expected\n");
list_remove(&fs_info->fs_link);
fibril_mutex_unlock(&fs_list_lock);
free(fs_info);
async_answer_0(rid, EINVAL);
return;
}
dprintf("Callback connection to FS created.\n");
/*
* The client will want us to send him the address space area with PLB.
*/
size_t size;
ipc_callid_t callid;
if (!async_share_in_receive(&callid, &size)) {
dprintf("Unexpected call, method = %d\n", IPC_GET_IMETHOD(call));
list_remove(&fs_info->fs_link);
fibril_mutex_unlock(&fs_list_lock);
async_hangup(fs_info->sess);
free(fs_info);
async_answer_0(callid, EINVAL);
async_answer_0(rid, EINVAL);
return;
}
/*
* We can only send the client address space area PLB_SIZE bytes long.
*/
if (size != PLB_SIZE) {
dprintf("Client suggests wrong size of PFB, size = %d\n", size);
list_remove(&fs_info->fs_link);
fibril_mutex_unlock(&fs_list_lock);
async_hangup(fs_info->sess);
free(fs_info);
async_answer_0(callid, EINVAL);
async_answer_0(rid, EINVAL);
return;
}
/*
* Commit to read-only sharing the PLB with the client.
*/
(void) async_share_in_finalize(callid, plb,
AS_AREA_READ | AS_AREA_CACHEABLE);
dprintf("Sharing PLB.\n");
/*
* That was it. The FS has been registered.
* In reply to the VFS_REGISTER request, we assign the client file
* system a global file system handle.
*/
fs_info->fs_handle = (fs_handle_t) atomic_postinc(&fs_handle_next);
async_answer_1(rid, EOK, (sysarg_t) fs_info->fs_handle);
fibril_condvar_broadcast(&fs_list_cv);
fibril_mutex_unlock(&fs_list_lock);
dprintf("\"%.*s\" filesystem successfully registered, handle=%d.\n",
FS_NAME_MAXLEN, fs_info->vfs_info.name, fs_info->fs_handle);
}
static void tcp_sock_connect(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
{
int rc;
struct sockaddr_in *addr;
int socket_id;
size_t addr_len;
socket_core_t *sock_core;
tcp_sockdata_t *socket;
tcp_error_t trc;
tcp_sock_t lsocket;
tcp_sock_t fsocket;
log_msg(LVL_DEBUG, "tcp_sock_connect()");
rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len);
if (rc != EOK || addr_len != sizeof(struct sockaddr_in)) {
async_answer_0(callid, rc);
return;
}
socket_id = SOCKET_GET_SOCKET_ID(call);
sock_core = socket_cores_find(&client->sockets, socket_id);
if (sock_core == NULL) {
async_answer_0(callid, ENOTSOCK);
return;
}
socket = (tcp_sockdata_t *)sock_core->specific_data;
if (sock_core->port <= 0) {
rc = socket_bind_free_port(&gsock, sock_core,
TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
last_used_port);
if (rc != EOK) {
async_answer_0(callid, rc);
return;
}
last_used_port = sock_core->port;
}
fibril_mutex_lock(&socket->lock);
if (socket->laddr.ipv4 == TCP_IPV4_ANY) {
/* Determine local IP address */
inet_addr_t loc_addr, rem_addr;
rem_addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
if (rc != EOK) {
fibril_mutex_unlock(&socket->lock);
async_answer_0(callid, rc);
log_msg(LVL_DEBUG, "tcp_sock_connect: Failed to "
"determine local address.");
return;
}
socket->laddr.ipv4 = loc_addr.ipv4;
log_msg(LVL_DEBUG, "Local IP address is %x", socket->laddr.ipv4);
}
lsocket.addr.ipv4 = socket->laddr.ipv4;
lsocket.port = sock_core->port;
fsocket.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
fsocket.port = uint16_t_be2host(addr->sin_port);
trc = tcp_uc_open(&lsocket, &fsocket, ap_active, 0, &socket->conn);
if (socket->conn != NULL)
socket->conn->name = (char *)"C";
fibril_mutex_unlock(&socket->lock);
switch (trc) {
case TCP_EOK:
rc = EOK;
break;
case TCP_ERESET:
rc = ECONNREFUSED;
break;
default:
assert(false);
}
if (rc == EOK)
fibril_add_ready(socket->recv_fibril);
async_answer_0(callid, rc);
}
static void udp_sock_sendto(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
{
int socket_id;
int fragments;
int index;
struct sockaddr_in *addr;
size_t addr_size;
socket_core_t *sock_core;
udp_sockdata_t *socket;
udp_sock_t fsock, *fsockp;
ipc_call_t answer;
ipc_callid_t wcallid;
size_t length;
uint8_t buffer[UDP_FRAGMENT_SIZE];
udp_error_t urc;
int rc;
log_msg(LVL_DEBUG, "udp_sock_send()");
addr = NULL;
if (IPC_GET_IMETHOD(call) == NET_SOCKET_SENDTO) {
rc = async_data_write_accept((void **) &addr, false,
0, 0, 0, &addr_size);
if (rc != EOK) {
async_answer_0(callid, rc);
goto out;
}
if (addr_size != sizeof(struct sockaddr_in)) {
async_answer_0(callid, EINVAL);
goto out;
}
fsock.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
fsock.port = uint16_t_be2host(addr->sin_port);
fsockp = &fsock;
} else {
fsockp = NULL;
}
socket_id = SOCKET_GET_SOCKET_ID(call);
fragments = SOCKET_GET_DATA_FRAGMENTS(call);
SOCKET_GET_FLAGS(call);
sock_core = socket_cores_find(&client->sockets, socket_id);
if (sock_core == NULL) {
async_answer_0(callid, ENOTSOCK);
goto out;
}
if (sock_core->port == 0) {
/* Implicitly bind socket to port */
rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
addr, addr_size, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
last_used_port);
if (rc != EOK) {
async_answer_0(callid, rc);
goto out;
}
}
socket = (udp_sockdata_t *)sock_core->specific_data;
fibril_mutex_lock(&socket->lock);
if (socket->assoc->ident.local.addr.ipv4 == UDP_IPV4_ANY) {
/* Determine local IP address */
inet_addr_t loc_addr, rem_addr;
rem_addr.ipv4 = fsockp ? fsock.addr.ipv4 :
socket->assoc->ident.foreign.addr.ipv4;
rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
if (rc != EOK) {
fibril_mutex_unlock(&socket->lock);
async_answer_0(callid, rc);
log_msg(LVL_DEBUG, "udp_sock_sendto: Failed to "
"determine local address.");
return;
}
socket->assoc->ident.local.addr.ipv4 = loc_addr.ipv4;
log_msg(LVL_DEBUG, "Local IP address is %x",
socket->assoc->ident.local.addr.ipv4);
}
assert(socket->assoc != NULL);
for (index = 0; index < fragments; index++) {
if (!async_data_write_receive(&wcallid, &length)) {
fibril_mutex_unlock(&socket->lock);
async_answer_0(callid, EINVAL);
goto out;
}
if (length > UDP_FRAGMENT_SIZE)
length = UDP_FRAGMENT_SIZE;
rc = async_data_write_finalize(wcallid, buffer, length);
if (rc != EOK) {
fibril_mutex_unlock(&socket->lock);
async_answer_0(callid, rc);
goto out;
}
urc = udp_uc_send(socket->assoc, fsockp, buffer, length, 0);
switch (urc) {
case UDP_EOK:
rc = EOK;
break;
/* case TCP_ENOTEXIST:
rc = ENOTCONN;
break;
case TCP_ECLOSING:
rc = ENOTCONN;
break;
case TCP_ERESET:
rc = ECONNABORTED;
break;*/
default:
assert(false);
}
if (rc != EOK) {
fibril_mutex_unlock(&socket->lock);
async_answer_0(callid, rc);
goto out;
}
}
IPC_SET_ARG1(answer, 0);
SOCKET_SET_DATA_FRAGMENT_SIZE(answer, UDP_FRAGMENT_SIZE);
async_answer_2(callid, EOK, IPC_GET_ARG1(answer),
IPC_GET_ARG2(answer));
fibril_mutex_unlock(&socket->lock);
out:
if (addr != NULL)
free(addr);
}
static void udp_sock_bind(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
{
int rc;
struct sockaddr_in *addr;
size_t addr_size;
socket_core_t *sock_core;
udp_sockdata_t *socket;
udp_sock_t fsock;
udp_error_t urc;
log_msg(LVL_DEBUG, "udp_sock_bind()");
log_msg(LVL_DEBUG, " - async_data_write_accept");
addr = NULL;
rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_size);
if (rc != EOK) {
async_answer_0(callid, rc);
goto out;
}
log_msg(LVL_DEBUG, " - call socket_bind");
rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
addr, addr_size, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
last_used_port);
if (rc != EOK) {
async_answer_0(callid, rc);
goto out;
}
if (addr_size != sizeof(struct sockaddr_in)) {
async_answer_0(callid, EINVAL);
goto out;
}
log_msg(LVL_DEBUG, " - call socket_cores_find");
sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
if (sock_core == NULL) {
async_answer_0(callid, ENOENT);
goto out;
}
socket = (udp_sockdata_t *)sock_core->specific_data;
fsock.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
fsock.port = sock_core->port;
urc = udp_uc_set_local(socket->assoc, &fsock);
switch (urc) {
case UDP_EOK:
rc = EOK;
break;
/* case TCP_ENOTEXIST:
rc = ENOTCONN;
break;
case TCP_ECLOSING:
rc = ENOTCONN;
break;
case TCP_ERESET:
rc = ECONNABORTED;
break;*/
default:
assert(false);
}
log_msg(LVL_DEBUG, " - success");
async_answer_0(callid, rc);
out:
if (addr != NULL)
free(addr);
}
/**
* Server side implementation of the hound protocol. IPC connection handler.
* @param iid initial call id
* @param icall pointer to initial call structure.
* @param arg (unused)
*/
void hound_connection_handler(ipc_callid_t iid, ipc_call_t *icall, void *arg)
{
/* Accept connection if there is a valid iface*/
if (server_iface) {
async_answer_0(iid, EOK);
} else {
async_answer_0(iid, ENOTSUP);
return;
}
while (1) {
ipc_call_t call;
ipc_callid_t callid = async_get_call(&call);
switch (IPC_GET_IMETHOD(call)) {
case IPC_M_HOUND_CONTEXT_REGISTER: {
/* check interface functions */
if (!server_iface || !server_iface->add_context) {
async_answer_0(callid, ENOTSUP);
break;
}
bool record = IPC_GET_ARG1(call);
void *name;
/* Get context name */
int ret =
async_data_write_accept(&name, true, 0, 0, 0, 0);
if (ret != EOK) {
async_answer_0(callid, ret);
break;
}
hound_context_id_t id = 0;
ret = server_iface->add_context(server_iface->server,
&id, name, record);
/** new context should create a copy */
free(name);
if (ret != EOK) {
async_answer_0(callid, ret);
} else {
async_answer_1(callid, EOK, id);
}
break;
}
case IPC_M_HOUND_CONTEXT_UNREGISTER: {
/* check interface functions */
if (!server_iface || !server_iface->rem_context) {
async_answer_0(callid, ENOTSUP);
break;
}
/* get id, 1st param */
hound_context_id_t id = IPC_GET_ARG1(call);
const int ret =
server_iface->rem_context(server_iface->server, id);
async_answer_0(callid, ret);
break;
}
case IPC_M_HOUND_GET_LIST: {
/* check interface functions */
if (!server_iface || !server_iface->get_list) {
async_answer_0(callid, ENOTSUP);
break;
}
const char **list = NULL;
const int flags = IPC_GET_ARG1(call);
size_t count = IPC_GET_ARG2(call);
const bool conn = IPC_GET_ARG3(call);
char *conn_name = NULL;
int ret = EOK;
/* get connected actor name if provided */
if (conn)
ret = async_data_write_accept(
(void**)&conn_name, true, 0, 0, 0, 0);
if (ret == EOK)
ret = server_iface->get_list(
server_iface->server, &list, &count,
conn_name, flags);
free(conn_name);
/* Alloc string sizes array */
size_t *sizes = NULL;
if (count)
sizes = calloc(count, sizeof(size_t));
if (count && !sizes)
ret = ENOMEM;
async_answer_1(callid, ret, count);
/* We are done */
if (count == 0 || ret != EOK)
break;
/* Prepare sizes table */
for (unsigned i = 0; i < count; ++i)
sizes[i] = str_size(list[i]);
/* Send sizes table */
ipc_callid_t id;
if (async_data_read_receive(&id, NULL)) {
ret = async_data_read_finalize(id, sizes,
count * sizeof(size_t));
}
free(sizes);
/* Proceed to send names */
for (unsigned i = 0; i < count; ++i) {
size_t size = str_size(list[i]);
ipc_callid_t id;
if (ret == EOK &&
async_data_read_receive(&id, NULL)) {
ret = async_data_read_finalize(id,
list[i], size);
}
free(list[i]);
}
free(list);
break;
}
case IPC_M_HOUND_CONNECT: {
/* check interface functions */
if (!server_iface || !server_iface->connect) {
async_answer_0(callid, ENOTSUP);
break;
}
void *source = NULL;
void *sink = NULL;
/* read source name */
int ret =
async_data_write_accept(&source, true, 0, 0, 0, 0);
/* read sink name */
if (ret == EOK)
ret = async_data_write_accept(&sink,
true, 0, 0, 0, 0);
if (ret == EOK)
ret = server_iface->connect(
server_iface->server, source, sink);
free(source);
free(sink);
async_answer_0(callid, ret);
break;
}
case IPC_M_HOUND_DISCONNECT: {
/* check interface functions */
if (!server_iface || !server_iface->disconnect) {
async_answer_0(callid, ENOTSUP);
break;
}
void *source = NULL;
void *sink = NULL;
/* read source name */
int ret =
async_data_write_accept(&source, true, 0, 0, 0, 0);
/*read sink name */
if (ret == EOK)
ret = async_data_write_accept(&sink,
true, 0, 0, 0, 0);
if (ret == EOK)
ret = server_iface->connect(
server_iface->server, source, sink);
free(source);
free(sink);
async_answer_0(callid, ret);
break;
}
case IPC_M_HOUND_STREAM_ENTER: {
/* check interface functions */
if (!server_iface || !server_iface->is_record_context
|| !server_iface->add_stream
|| !server_iface->rem_stream) {
async_answer_0(callid, ENOTSUP);
break;
}
/* get parameters */
hound_context_id_t id = IPC_GET_ARG1(call);
const int flags = IPC_GET_ARG2(call);
const format_convert_t c = {.arg = IPC_GET_ARG3(call)};
const pcm_format_t f = {
.sampling_rate = c.f.rate * 100,
.channels = c.f.channels,
.sample_format = c.f.format,
};
size_t bsize = IPC_GET_ARG4(call);
void *stream;
int ret = server_iface->add_stream(server_iface->server,
id, flags, f, bsize, &stream);
if (ret != EOK) {
async_answer_0(callid, ret);
break;
}
const bool rec = server_iface->is_record_context(
server_iface->server, id);
if (rec) {
if(server_iface->stream_data_read) {
async_answer_0(callid, EOK);
/* start answering read calls */
hound_server_write_data(stream);
server_iface->rem_stream(
server_iface->server, stream);
} else {
async_answer_0(callid, ENOTSUP);
}
} else {
if (server_iface->stream_data_write) {
async_answer_0(callid, EOK);
/* accept write calls */
hound_server_read_data(stream);
server_iface->rem_stream(
server_iface->server, stream);
} else {
async_answer_0(callid, ENOTSUP);
}
}
break;
}
case IPC_M_HOUND_STREAM_EXIT:
case IPC_M_HOUND_STREAM_DRAIN:
/* Stream exit/drain is only allowed in stream context*/
async_answer_0(callid, EINVAL);
break;
default:
async_answer_0(callid, ENOTSUP);
return;
}
}
}
/**
* Read data and push it to the stream.
* @param stream target stream, will push data there.
*/
static void hound_server_read_data(void *stream)
{
ipc_callid_t callid;
ipc_call_t call;
size_t size = 0;
int ret_answer = EOK;
/* accept data write or drain */
while (async_data_write_receive_call(&callid, &call, &size)
|| (IPC_GET_IMETHOD(call) == IPC_M_HOUND_STREAM_DRAIN)) {
/* check drain first */
if (IPC_GET_IMETHOD(call) == IPC_M_HOUND_STREAM_DRAIN) {
int ret = ENOTSUP;
if (server_iface->drain_stream)
ret = server_iface->drain_stream(stream);
async_answer_0(callid, ret);
continue;
}
/* there was an error last time */
if (ret_answer != EOK) {
async_answer_0(callid, ret_answer);
continue;
}
char *buffer = malloc(size);
if (!buffer) {
async_answer_0(callid, ENOMEM);
continue;
}
const int ret = async_data_write_finalize(callid, buffer, size);
if (ret == EOK) {
/* push data to stream */
ret_answer = server_iface->stream_data_write(
stream, buffer, size);
}
}
const int ret = IPC_GET_IMETHOD(call) == IPC_M_HOUND_STREAM_EXIT
? EOK : EINVAL;
async_answer_0(callid, ret);
}
