void remote_audio_mixer_get_item_info(
ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
{
audio_mixer_iface_t *mixer_iface = iface;
if (!mixer_iface->get_item_info) {
async_answer_0(callid, ENOTSUP);
return;
}
const unsigned item = DEV_IPC_GET_ARG1(*call);
const char *name = NULL;
unsigned values = 0;
const int ret = mixer_iface->get_item_info(fun, item, &name, &values);
const size_t name_size = name ? str_size(name) + 1 : 0;
async_answer_2(callid, ret, name_size, values);
/* Send the name. */
if (ret == EOK && name_size > 0) {
size_t size;
ipc_callid_t name_id;
if (!async_data_read_receive(&name_id, &size)) {
async_answer_0(name_id, EPARTY);
return;
}
if (size != name_size) {
async_answer_0(name_id, ELIMIT);
return;
}
async_data_read_finalize(name_id, name, name_size);
}
}
static void remote_ahci_get_num_blocks(ddf_fun_t *fun, void *iface,
ipc_callid_t callid, ipc_call_t *call)
{
const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
if (ahci_iface->get_num_blocks == NULL) {
async_answer_0(callid, ENOTSUP);
return;
}
uint64_t blocks;
const int ret = ahci_iface->get_num_blocks(fun, &blocks);
if (ret != EOK)
async_answer_0(callid, ret);
else
async_answer_2(callid, EOK, HI(blocks), LO(blocks));
}
static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
{
void *fs_va = NULL;
ipc_callid_t callid;
ipc_call_t call;
sysarg_t method;
size_t comm_size;
unsigned int flags;
int retval;
uint64_t ba;
size_t cnt;
/* Answer the IPC_M_CONNECT_ME_TO call. */
async_answer_0(iid, EOK);
if (!async_share_out_receive(&callid, &comm_size, &flags)) {
async_answer_0(callid, EHANGUP);
return;
}
(void) async_share_out_finalize(callid, &fs_va);
if (fs_va == AS_MAP_FAILED) {
async_answer_0(callid, EHANGUP);
return;
}
while (true) {
callid = async_get_call(&call);
method = IPC_GET_IMETHOD(call);
if (!method) {
/* The other side has hung up. */
async_answer_0(callid, EOK);
return;
}
switch (method) {
case BD_READ_BLOCKS:
ba = MERGE_LOUP32(IPC_GET_ARG1(call),
IPC_GET_ARG2(call));
cnt = IPC_GET_ARG3(call);
if (cnt * block_size > comm_size) {
retval = ELIMIT;
break;
}
retval = file_bd_read_blocks(ba, cnt, fs_va);
break;
case BD_WRITE_BLOCKS:
ba = MERGE_LOUP32(IPC_GET_ARG1(call),
IPC_GET_ARG2(call));
cnt = IPC_GET_ARG3(call);
if (cnt * block_size > comm_size) {
retval = ELIMIT;
break;
}
retval = file_bd_write_blocks(ba, cnt, fs_va);
break;
case BD_GET_BLOCK_SIZE:
async_answer_1(callid, EOK, block_size);
continue;
case BD_GET_NUM_BLOCKS:
async_answer_2(callid, EOK, LOWER32(num_blocks),
UPPER32(num_blocks));
continue;
default:
retval = EINVAL;
break;
}
async_answer_0(callid, retval);
}
}
static void tcp_sock_send(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
{
int socket_id;
int fragments;
int index;
socket_core_t *sock_core;
tcp_sockdata_t *socket;
ipc_call_t answer;
ipc_callid_t wcallid;
size_t length;
uint8_t buffer[TCP_SOCK_FRAGMENT_SIZE];
tcp_error_t trc;
int rc;
log_msg(LVL_DEBUG, "tcp_sock_send()");
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);
return;
}
socket = (tcp_sockdata_t *)sock_core->specific_data;
fibril_mutex_lock(&socket->lock);
if (socket->conn == NULL) {
fibril_mutex_unlock(&socket->lock);
async_answer_0(callid, ENOTCONN);
return;
}
for (index = 0; index < fragments; index++) {
if (!async_data_write_receive(&wcallid, &length)) {
fibril_mutex_unlock(&socket->lock);
async_answer_0(callid, EINVAL);
return;
}
if (length > TCP_SOCK_FRAGMENT_SIZE)
length = TCP_SOCK_FRAGMENT_SIZE;
rc = async_data_write_finalize(wcallid, buffer, length);
if (rc != EOK) {
fibril_mutex_unlock(&socket->lock);
async_answer_0(callid, rc);
return;
}
trc = tcp_uc_send(socket->conn, buffer, length, 0);
switch (trc) {
case TCP_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);
return;
}
}
IPC_SET_ARG1(answer, 0);
SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
async_answer_2(callid, EOK, IPC_GET_ARG1(answer),
IPC_GET_ARG2(answer));
fibril_mutex_unlock(&socket->lock);
}
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);
}
