/** Add new Wake-On-LAN virtue.
*
* @param[in] dev_sess
* @param[in] type Type of the virtue
* @param[in] data Data required for this virtue
* (depends on type)
* @param[in] length Length of the data
* @param[out] id Identifier of the new virtue
*
* @return EOK If the operation was successfully completed
*
*/
int nic_wol_virtue_add(async_sess_t *dev_sess, nic_wv_type_t type,
const void *data, size_t length, nic_wv_id_t *id)
{
assert(id);
bool send_data = ((data != NULL) && (length != 0));
async_exch_t *exch = async_exchange_begin(dev_sess);
ipc_call_t result;
aid_t message_id = async_send_3(exch, DEV_IFACE_ID(NIC_DEV_IFACE),
NIC_WOL_VIRTUE_ADD, (sysarg_t) type, send_data, &result);
sysarg_t res;
if (send_data) {
int rc = async_data_write_start(exch, data, length);
if (rc != EOK) {
async_exchange_end(exch);
async_wait_for(message_id, &res);
return rc;
}
}
async_exchange_end(exch);
async_wait_for(message_id, &res);
*id = IPC_GET_ARG1(result);
return (int) res;
}
/** Copy string to clipboard.
*
* Sets the clipboard contents to @a str. Passing an empty string or NULL
* makes the clipboard empty.
*
* @param str String to put to clipboard or NULL.
*
* @return Zero on success or negative error code.
*
*/
int clipboard_put_str(const char *str)
{
size_t size = str_size(str);
if (size == 0) {
async_exch_t *exch = clip_exchange_begin();
sysarg_t rc = async_req_1_0(exch, CLIPBOARD_PUT_DATA,
CLIPBOARD_TAG_NONE);
clip_exchange_end(exch);
return (int) rc;
} else {
async_exch_t *exch = clip_exchange_begin();
aid_t req = async_send_1(exch, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_DATA,
NULL);
sysarg_t rc = async_data_write_start(exch, (void *) str, size);
clip_exchange_end(exch);
if (rc != EOK) {
sysarg_t rc_orig;
async_wait_for(req, &rc_orig);
if (rc_orig == EOK)
return (int) rc;
else
return (int) rc_orig;
}
async_wait_for(req, &rc);
return (int) rc;
}
}
/** Connect to specified network.
*
* @param[in] dev_sess Device session.
* @param[in] ssid_start Network SSID prefix.
* @param[in] password Network password (pass empty string if not needed).
*
* @return EOK If the operation was successfully completed,
* negative error code otherwise.
*
*/
int ieee80211_connect(async_sess_t *dev_sess, char *ssid_start, char *password)
{
assert(ssid_start);
sysarg_t rc_orig;
async_exch_t *exch = async_exchange_begin(dev_sess);
aid_t aid = async_send_1(exch, DEV_IFACE_ID(IEEE80211_DEV_IFACE),
IEEE80211_CONNECT, NULL);
sysarg_t rc = async_data_write_start(exch, ssid_start,
str_size(ssid_start) + 1);
if (rc != EOK) {
async_exchange_end(exch);
async_wait_for(aid, &rc_orig);
if (rc_orig == EOK)
return (int) rc;
return (int) rc_orig;
}
// FIXME: Typecasting string literal
if (password == NULL)
password = (char *) "";
rc = async_data_write_start(exch, password, str_size(password) + 1);
if (rc != EOK) {
async_exchange_end(exch);
async_wait_for(aid, &rc_orig);
if (rc_orig == EOK)
return (int) rc;
return (int) rc_orig;
}
async_exchange_end(exch);
async_wait_for(aid, &rc);
if (rc != EOK)
return rc;
/* Send DHCP discover. */
nic_address_t wifi_mac;
rc = nic_get_address(dev_sess, &wifi_mac);
if (rc != EOK)
return rc;
sysarg_t link_id = get_link_id(wifi_mac.address);
if (link_id == ((sysarg_t) -1))
return EINVAL;
rc = dhcp_discover(link_id);
return (int) rc;
}
/** Register new service.
*
* The @p interface is used when forwarding connection to the server.
* If not 0, the first argument is the interface and the second argument
* is the service ID.
*
* When the interface is zero (default), the first argument is directly
* the handle (to ensure backward compatibility).
*
* @param fqsn Fully qualified service name
* @param[out] sid Service ID of new service
* @param interface Interface when forwarding
*
*/
int loc_service_register_with_iface(const char *fqsn,
service_id_t *sid, sysarg_t interface)
{
async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_SUPPLIER);
ipc_call_t answer;
aid_t req = async_send_2(exch, LOC_SERVICE_REGISTER, interface, 0,
&answer);
sysarg_t retval = async_data_write_start(exch, fqsn, str_size(fqsn));
loc_exchange_end(exch);
if (retval != EOK) {
async_forget(req);
return retval;
}
async_wait_for(req, &retval);
if (retval != EOK) {
if (sid != NULL)
*sid = -1;
return retval;
}
if (sid != NULL)
*sid = (service_id_t) IPC_GET_ARG1(answer);
return retval;
}
int iplink_ev_recv(iplink_srv_t *srv, iplink_srv_sdu_t *sdu)
{
if (srv->client_sess == NULL)
return EIO;
async_exch_t *exch = async_exchange_begin(srv->client_sess);
ipc_call_t answer;
aid_t req = async_send_2(exch, IPLINK_EV_RECV, sdu->lsrc.ipv4,
sdu->ldest.ipv4, &answer);
int rc = async_data_write_start(exch, sdu->data, sdu->size);
async_exchange_end(exch);
if (rc != EOK) {
async_forget(req);
return rc;
}
sysarg_t retval;
async_wait_for(req, &retval);
if (retval != EOK)
return retval;
return EOK;
}
static int loc_category_get_ids_once(sysarg_t method, sysarg_t arg1,
sysarg_t *id_buf, size_t buf_size, size_t *act_size)
{
async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
ipc_call_t answer;
aid_t req = async_send_1(exch, method, arg1, &answer);
int rc = async_data_read_start(exch, id_buf, buf_size);
loc_exchange_end(exch);
if (rc != EOK) {
async_forget(req);
return rc;
}
sysarg_t retval;
async_wait_for(req, &retval);
if (retval != EOK) {
return retval;
}
*act_size = IPC_GET_ARG1(answer);
return EOK;
}
/** Send formatted message to the logger service.
*
* @param session Initialized IPC session with the logger.
* @param log Log to use.
* @param level Verbosity level of the message.
* @param message The actual message.
* @return Error code of the conversion or EOK on success.
*/
static int logger_message(async_sess_t *session, log_t log, log_level_t level, char *message)
{
async_exch_t *exchange = async_exchange_begin(session);
if (exchange == NULL) {
return ENOMEM;
}
if (log == LOG_DEFAULT)
log = default_log_id;
// FIXME: remove when all USB drivers use libc logging explicitly
str_rtrim(message, '\n');
aid_t reg_msg = async_send_2(exchange, LOGGER_WRITER_MESSAGE,
log, level, NULL);
int rc = async_data_write_start(exchange, message, str_size(message));
sysarg_t reg_msg_rc;
async_wait_for(reg_msg, ®_msg_rc);
async_exchange_end(exchange);
/*
* Getting ENAK means no-one wants our message. That is not an
* error at all.
*/
if (rc == ENAK)
rc = EOK;
if (rc != EOK) {
return rc;
}
return reg_msg_rc;
}
/** Send message via UDP association.
*
* @param assoc Association
* @param dest Destination endpoint or @c NULL to use association's remote ep.
* @param data Message data
* @param bytes Message size in bytes
*
* @return EOK on success or negative error code
*/
int udp_assoc_send_msg(udp_assoc_t *assoc, inet_ep_t *dest, void *data,
size_t bytes)
{
async_exch_t *exch;
exch = async_exchange_begin(assoc->udp->sess);
aid_t req = async_send_1(exch, UDP_ASSOC_SEND_MSG, assoc->id, NULL);
sysarg_t rc = async_data_write_start(exch, (void *)dest,
sizeof(inet_ep_t));
if (rc != EOK) {
async_exchange_end(exch);
async_forget(req);
return rc;
}
rc = async_data_write_start(exch, data, bytes);
if (rc != EOK) {
async_forget(req);
return rc;
}
async_exchange_end(exch);
if (rc != EOK) {
async_forget(req);
return rc;
}
async_wait_for(req, &rc);
return rc;
}
/** Get list of IDs into a buffer of fixed size.
*
* @param vbd Virtual Block Device
* @param method IPC method
* @param arg1 First argument
* @param id_buf Buffer to store IDs
* @param buf_size Buffer size
* @param act_size Place to store actual size of complete data.
*
* @return EOK on success or negative error code.
*/
static int vbd_get_ids_once(vbd_t *vbd, sysarg_t method, sysarg_t arg1,
sysarg_t *id_buf, size_t buf_size, size_t *act_size)
{
async_exch_t *exch = async_exchange_begin(vbd->sess);
ipc_call_t answer;
aid_t req = async_send_1(exch, method, arg1, &answer);
int rc = async_data_read_start(exch, id_buf, buf_size);
async_exchange_end(exch);
if (rc != EOK) {
async_forget(req);
return rc;
}
sysarg_t retval;
async_wait_for(req, &retval);
if (retval != EOK) {
return retval;
}
*act_size = IPC_GET_ARG1(answer);
return EOK;
}
int vbd_part_create(vbd_t *vbd, service_id_t disk, vbd_part_spec_t *pspec,
vbd_part_id_t *rpart)
{
async_exch_t *exch;
sysarg_t retval;
ipc_call_t answer;
exch = async_exchange_begin(vbd->sess);
aid_t req = async_send_1(exch, VBD_PART_CREATE, disk, &answer);
int rc = async_data_write_start(exch, pspec, sizeof(vbd_part_spec_t));
async_exchange_end(exch);
if (rc != EOK) {
async_forget(req);
return EIO;
}
async_wait_for(req, &retval);
if (retval != EOK)
return EIO;
*rpart = (vbd_part_id_t)IPC_GET_ARG1(answer);
return EOK;
}
/** Set preset files for the program.
*
* Sets the vector of preset files to be passed to the loaded
* program. By convention, the first three files represent stdin,
* stdout and stderr respectively.
*
* @param ldr Loader connection structure.
* @param files NULL-terminated array of pointers to files.
*
* @return Zero on success or negative error code.
*
*/
int loader_set_files(loader_t *ldr, int * const files[])
{
/* Send serialized files to the loader */
async_exch_t *exch = async_exchange_begin(ldr->sess);
async_exch_t *vfs_exch = vfs_exchange_begin();
int i;
for (i = 0; files[i]; i++);
ipc_call_t answer;
aid_t req = async_send_1(exch, LOADER_SET_FILES, i, &answer);
sysarg_t rc = EOK;
for (i = 0; files[i]; i++) {
rc = async_state_change_start(exch, VFS_PASS_HANDLE, *files[i],
0, vfs_exch);
if (rc != EOK)
break;
}
vfs_exchange_end(vfs_exch);
async_exchange_end(exch);
if (rc != EOK) {
async_forget(req);
return (int) rc;
}
async_wait_for(req, &rc);
return (int) rc;
}
/** Set pathname of the program to load.
*
* Sets the name of the program file to load. The name can be relative
* to the current working directory (it will be absolutized before
* sending to the loader).
*
* @param ldr Loader connection structure.
* @param path Pathname of the program file.
*
* @return Zero on success or negative error code.
*
*/
int loader_set_pathname(loader_t *ldr, const char *path)
{
size_t pa_len;
char *pa = absolutize(path, &pa_len);
if (!pa)
return ENOMEM;
/* Send program pathname */
async_exch_t *exch = async_exchange_begin(ldr->sess);
ipc_call_t answer;
aid_t req = async_send_0(exch, LOADER_SET_PATHNAME, &answer);
sysarg_t rc = async_data_write_start(exch, (void *) pa, pa_len);
async_exchange_end(exch);
free(pa);
if (rc != EOK) {
async_forget(req);
return (int) rc;
}
async_wait_for(req, &rc);
return (int) rc;
}
/** Set which multicast frames are received.
*
* @param[in] dev_sess
* @param[in] mode Current operation mode
* @param[in] address_list The list of addresses. Can be NULL.
* @param[in] address_count Number of addresses in the list.
*
* @return EOK If the operation was successfully completed
*
*/
int nic_multicast_set_mode(async_sess_t *dev_sess, nic_multicast_mode_t mode,
const nic_address_t *address_list, size_t address_count)
{
if (address_list == NULL)
address_count = 0;
async_exch_t *exch = async_exchange_begin(dev_sess);
aid_t message_id = async_send_3(exch, DEV_IFACE_ID(NIC_DEV_IFACE),
NIC_MULTICAST_SET_MODE, (sysarg_t) mode, address_count, NULL);
int rc;
if (address_count)
rc = async_data_write_start(exch, address_list,
address_count * sizeof(nic_address_t));
else
rc = EOK;
async_exchange_end(exch);
sysarg_t res;
async_wait_for(message_id, &res);
if (rc != EOK)
return rc;
return (int) res;
}
/** Set current working directory for the loaded task.
*
* Sets the current working directory for the loaded task.
*
* @param ldr Loader connection structure.
*
* @return Zero on success or negative error code.
*
*/
int loader_set_cwd(loader_t *ldr)
{
char *cwd = (char *) malloc(MAX_PATH_LEN + 1);
if (!cwd)
return ENOMEM;
if (!getcwd(cwd, MAX_PATH_LEN + 1))
str_cpy(cwd, MAX_PATH_LEN + 1, "/");
size_t len = str_length(cwd);
async_exch_t *exch = async_exchange_begin(ldr->sess);
ipc_call_t answer;
aid_t req = async_send_0(exch, LOADER_SET_CWD, &answer);
sysarg_t rc = async_data_write_start(exch, cwd, len);
async_exchange_end(exch);
free(cwd);
if (rc != EOK) {
async_forget(req);
return (int) rc;
}
async_wait_for(req, &rc);
return (int) rc;
}
/** Set which source MACs are blocked
*
* @param[in] dev_sess
* @param[in] address_list The list of addresses. Can be NULL.
* @param[in] address_count Number of addresses in the list.
*
* @return EOK If the operation was successfully completed
*
*/
int nic_blocked_sources_set(async_sess_t *dev_sess,
const nic_address_t *address_list, size_t address_count)
{
if (address_list == NULL)
address_count = 0;
async_exch_t *exch = async_exchange_begin(dev_sess);
aid_t message_id = async_send_2(exch, DEV_IFACE_ID(NIC_DEV_IFACE),
NIC_BLOCKED_SOURCES_SET, address_count, NULL);
int rc;
if (address_count)
rc = async_data_write_start(exch, address_list,
address_count * sizeof(nic_address_t));
else
rc = EOK;
async_exchange_end(exch);
sysarg_t res;
async_wait_for(message_id, &res);
if (rc != EOK)
return rc;
return (int) res;
}
/** Get information about the next received message from UDP service.
*
* @param udp UDP client
* @param rmsg Place to store message information
*
* @return EOK on success or negative error code
*/
static int udp_rmsg_info(udp_t *udp, udp_rmsg_t *rmsg)
{
async_exch_t *exch;
inet_ep_t ep;
ipc_call_t answer;
exch = async_exchange_begin(udp->sess);
aid_t req = async_send_0(exch, UDP_RMSG_INFO, &answer);
int rc = async_data_read_start(exch, &ep, sizeof(inet_ep_t));
async_exchange_end(exch);
if (rc != EOK) {
async_forget(req);
return rc;
}
sysarg_t retval;
async_wait_for(req, &retval);
if (retval != EOK)
return retval;
rmsg->udp = udp;
rmsg->assoc_id = IPC_GET_ARG1(answer);
rmsg->size = IPC_GET_ARG2(answer);
rmsg->remote_ep = ep;
return EOK;
}
/** Create new UDP association.
*
* Create a UDP association that allows sending and receiving messages.
*
* @a epp may specify remote address and port, in which case only messages
* from that remote endpoint will be received. Also, that remote endpoint
* is used as default when @c NULL is passed as destination to
* udp_assoc_send_msg.
*
* @a epp may specify a local link or address. If it does not, the association
* will listen on all local links/addresses. If @a epp does not specify
* a local port number, a free dynamic port number will be allocated.
*
* The caller is informed about incoming data by invoking @a cb->recv_msg
*
* @param udp UDP client
* @param epp Internet endpoint pair
* @param cb Callbacks
* @param arg Argument to callbacks
* @param rassoc Place to store pointer to new association
*
* @return EOK on success or negative error code.
*/
int udp_assoc_create(udp_t *udp, inet_ep2_t *epp, udp_cb_t *cb, void *arg,
udp_assoc_t **rassoc)
{
async_exch_t *exch;
udp_assoc_t *assoc;
ipc_call_t answer;
assoc = calloc(1, sizeof(udp_assoc_t));
if (assoc == NULL)
return ENOMEM;
exch = async_exchange_begin(udp->sess);
aid_t req = async_send_0(exch, UDP_ASSOC_CREATE, &answer);
sysarg_t rc = async_data_write_start(exch, (void *)epp,
sizeof(inet_ep2_t));
async_exchange_end(exch);
if (rc != EOK) {
sysarg_t rc_orig;
async_wait_for(req, &rc_orig);
if (rc_orig != EOK)
rc = rc_orig;
goto error;
}
async_wait_for(req, &rc);
if (rc != EOK)
goto error;
assoc->udp = udp;
assoc->id = IPC_GET_ARG1(answer);
assoc->cb = cb;
assoc->cb_arg = arg;
list_append(&assoc->ludp, &udp->assoc);
*rassoc = assoc;
return EOK;
error:
free(assoc);
return (int) rc;
}
/** Get object name.
*
* Provided ID of an object, return its name.
*
* @param method IPC method
* @param id Object ID
* @param name Place to store pointer to new string. Caller should
* free it using free().
* @return EOK on success or negative error code
*/
static int loc_get_name_internal(sysarg_t method, sysarg_t id, char **name)
{
async_exch_t *exch;
char name_buf[LOC_NAME_MAXLEN + 1];
ipc_call_t dreply;
size_t act_size;
sysarg_t dretval;
*name = NULL;
exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
ipc_call_t answer;
aid_t req = async_send_1(exch, method, id, &answer);
aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN,
&dreply);
async_wait_for(dreq, &dretval);
loc_exchange_end(exch);
if (dretval != EOK) {
async_forget(req);
return dretval;
}
sysarg_t retval;
async_wait_for(req, &retval);
if (retval != EOK)
return retval;
act_size = IPC_GET_ARG2(dreply);
assert(act_size <= LOC_NAME_MAXLEN);
name_buf[act_size] = '\0';
*name = str_dup(name_buf);
if (*name == NULL)
return ENOMEM;
return EOK;
}
int led_dev_color_set(async_sess_t *sess, pixel_t pixel)
{
async_exch_t *exch = async_exchange_begin(sess);
aid_t req = async_send_2(exch, DEV_IFACE_ID(LED_DEV_IFACE),
LED_DEV_COLOR_SET, (sysarg_t) pixel, NULL);
async_exchange_end(exch);
sysarg_t rc;
async_wait_for(req, &rc);
return (int) rc;
}
/** Read to or write from device.
*
* Helper function to read to or write from a device
* using its character interface.
*
* @param sess Session to the device.
* @param buf Buffer for the data read from or written to the device.
* @param size Maximum size of data (in bytes) to be read or written.
* @param read Read from the device if true, write to it otherwise.
*
* @return Non-negative number of bytes actually read from or
* written to the device on success, negative error number
* otherwise.
*
*/
static ssize_t char_dev_rw(async_sess_t *sess, void *buf, size_t size, bool read)
{
ipc_call_t answer;
aid_t req;
int ret;
async_exch_t *exch = async_exchange_begin(sess);
if (read) {
req = async_send_1(exch, DEV_IFACE_ID(CHAR_DEV_IFACE),
CHAR_DEV_READ, &answer);
ret = async_data_read_start(exch, buf, size);
} else {
req = async_send_1(exch, DEV_IFACE_ID(CHAR_DEV_IFACE),
CHAR_DEV_WRITE, &answer);
ret = async_data_write_start(exch, buf, size);
}
async_exchange_end(exch);
sysarg_t rc;
if (ret != EOK) {
async_wait_for(req, &rc);
if (rc == EOK)
return (ssize_t) ret;
return (ssize_t) rc;
}
async_wait_for(req, &rc);
ret = (int) rc;
if (ret != EOK)
return (ssize_t) ret;
return (ssize_t) IPC_GET_ARG1(answer);
}
size_t loc_get_services(service_id_t ns_handle, loc_sdesc_t **data)
{
/* Loop until read is succesful */
while (true) {
async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
size_t count = loc_count_services_internal(exch, ns_handle);
loc_exchange_end(exch);
if (count == 0)
return 0;
loc_sdesc_t *devs = (loc_sdesc_t *) calloc(count, sizeof(loc_sdesc_t));
if (devs == NULL)
return 0;
exch = loc_exchange_begin(LOC_PORT_CONSUMER);
ipc_call_t answer;
aid_t req = async_send_1(exch, LOC_GET_SERVICES, ns_handle, &answer);
int rc = async_data_read_start(exch, devs, count * sizeof(loc_sdesc_t));
loc_exchange_end(exch);
if (rc == EOVERFLOW) {
/*
* Number of services has changed since
* the last call of LOC_GET_SERVICE_COUNT
*/
free(devs);
continue;
}
if (rc != EOK) {
async_forget(req);
free(devs);
return 0;
}
sysarg_t retval;
async_wait_for(req, &retval);
if (retval != EOK)
return 0;
*data = devs;
return count;
}
}
int ahci_get_sata_device_name(async_sess_t *sess, size_t sata_dev_name_length,
char *sata_dev_name)
{
async_exch_t *exch = async_exchange_begin(sess);
if (!exch)
return EINVAL;
aid_t req = async_send_2(exch, DEV_IFACE_ID(AHCI_DEV_IFACE),
IPC_M_AHCI_GET_SATA_DEVICE_NAME, sata_dev_name_length, NULL);
async_data_read_start(exch, sata_dev_name, sata_dev_name_length);
sysarg_t rc;
async_wait_for(req, &rc);
return rc;
}
/** Close the file in the endpoint FS server. */
static int vfs_file_close_remote(vfs_file_t *file)
{
assert(!file->refcnt);
async_exch_t *exch = vfs_exchange_grab(file->node->fs_handle);
ipc_call_t answer;
aid_t msg = async_send_2(exch, VFS_OUT_CLOSE, file->node->service_id,
file->node->index, &answer);
vfs_exchange_release(exch);
sysarg_t rc;
async_wait_for(msg, &rc);
return IPC_GET_ARG1(answer);
}
/** Set command-line arguments for the program.
*
* Sets the vector of command-line arguments to be passed to the loaded
* program. By convention, the very first argument is typically the same as
* the command used to execute the program.
*
* @param ldr Loader connection structure.
* @param argv NULL-terminated array of pointers to arguments.
*
* @return Zero on success or negative error code.
*
*/
int loader_set_args(loader_t *ldr, const char *const argv[])
{
/*
* Serialize the arguments into a single array. First
* compute size of the buffer needed.
*/
const char *const *ap = argv;
size_t buffer_size = 0;
while (*ap != NULL) {
buffer_size += str_size(*ap) + 1;
ap++;
}
char *arg_buf = malloc(buffer_size);
if (arg_buf == NULL)
return ENOMEM;
/* Now fill the buffer with null-terminated argument strings */
ap = argv;
char *dp = arg_buf;
while (*ap != NULL) {
str_cpy(dp, buffer_size - (dp - arg_buf), *ap);
dp += str_size(*ap) + 1;
ap++;
}
/* Send serialized arguments to the loader */
async_exch_t *exch = async_exchange_begin(ldr->sess);
ipc_call_t answer;
aid_t req = async_send_0(exch, LOADER_SET_ARGS, &answer);
sysarg_t rc = async_data_write_start(exch, (void *) arg_buf,
buffer_size);
async_exchange_end(exch);
free(arg_buf);
if (rc != EOK) {
async_forget(req);
return (int) rc;
}
async_wait_for(req, &rc);
return (int) rc;
}
static int inet_callback_create(void)
{
async_exch_t *exch = async_exchange_begin(inet_sess);
ipc_call_t answer;
aid_t req = async_send_0(exch, INET_CALLBACK_CREATE, &answer);
int rc = async_connect_to_me(exch, 0, 0, 0, inet_cb_conn, NULL);
async_exchange_end(exch);
if (rc != EOK)
return rc;
sysarg_t retval;
async_wait_for(req, &retval);
return retval;
}
/** Set the address of the device (e.g. MAC on Ethernet)
*
* @param[in] dev_sess
* @param[in] address Pointer to the address
*
* @return EOK If the operation was successfully completed
*
*/
int nic_set_address(async_sess_t *dev_sess, const nic_address_t *address)
{
assert(address);
async_exch_t *exch = async_exchange_begin(dev_sess);
aid_t aid = async_send_1(exch, DEV_IFACE_ID(NIC_DEV_IFACE),
NIC_SET_ADDRESS, NULL);
int rc = async_data_write_start(exch, address, sizeof(nic_address_t));
async_exchange_end(exch);
sysarg_t res;
async_wait_for(aid, &res);
if (rc != EOK)
return rc;
return (int) res;
}
/**
* Destroy an existing connection between a source and a sink.
* @param sess Valid audio session.
* @param source Source name, valid string.
* @param sink Sink name, valid string.
* @return Error code.
*/
int hound_service_disconnect_source_sink(hound_sess_t *sess, const char *source,
const char *sink)
{
assert(sess);
async_exch_t *exch = async_exchange_begin(sess);
if (!exch)
return ENOMEM;
ipc_call_t call;
aid_t id = async_send_0(exch, IPC_M_HOUND_DISCONNECT, &call);
int ret = id ? EOK : EPARTY;
if (ret == EOK)
ret = async_data_write_start(exch, source, str_size(source));
if (ret == EOK)
ret = async_data_write_start(exch, sink, str_size(sink));
async_wait_for(id, (sysarg_t*)&ret);
async_exchange_end(exch);
return ENOTSUP;
}
/** Get ID of the new task.
*
* Retrieves the ID of the new task from the loader.
*
* @param ldr Loader connection structure.
* @param task_id Points to a variable where the ID should be stored.
*
* @return Zero on success or negative error code.
*
*/
int loader_get_task_id(loader_t *ldr, task_id_t *task_id)
{
/* Get task ID. */
async_exch_t *exch = async_exchange_begin(ldr->sess);
ipc_call_t answer;
aid_t req = async_send_0(exch, LOADER_GET_TASKID, &answer);
sysarg_t rc = async_data_read_start(exch, task_id, sizeof(task_id_t));
async_exchange_end(exch);
if (rc != EOK) {
async_forget(req);
return (int) rc;
}
async_wait_for(req, &rc);
return (int) rc;
}
imagemap_handle_t fb_imagemap_create(async_sess_t *sess, imgmap_t *imgmap)
{
async_exch_t *exch = async_exchange_begin(sess);
ipc_call_t answer;
aid_t req = async_send_0(exch, FB_IMAGEMAP_CREATE, &answer);
int rc = async_share_out_start(exch, imgmap, AS_AREA_READ
| AS_AREA_WRITE | AS_AREA_CACHEABLE);
async_exchange_end(exch);
sysarg_t ret;
async_wait_for(req, &ret);
if ((rc != EOK) || (ret != EOK))
return 0;
return (imagemap_handle_t) IPC_GET_ARG1(answer);
}
/** Send frame from NIC
*
* @param[in] dev_sess
* @param[in] data Frame data
* @param[in] size Frame size in bytes
*
* @return EOK If the operation was successfully completed
*
*/
int nic_send_frame(async_sess_t *dev_sess, void *data, size_t size)
{
async_exch_t *exch = async_exchange_begin(dev_sess);
ipc_call_t answer;
aid_t req = async_send_1(exch, DEV_IFACE_ID(NIC_DEV_IFACE),
NIC_SEND_MESSAGE, &answer);
sysarg_t retval = async_data_write_start(exch, data, size);
async_exchange_end(exch);
if (retval != EOK) {
async_forget(req);
return retval;
}
async_wait_for(req, &retval);
return retval;
}
