int aa_move_mount(struct aa_label *label, const struct path *path,
const char *orig_name)
{
struct aa_profile *profile;
char *buffer = NULL, *old_buffer = NULL;
struct path old_path;
int error;
AA_BUG(!label);
AA_BUG(!path);
if (!orig_name || !*orig_name)
return -EINVAL;
error = kern_path(orig_name, LOOKUP_FOLLOW, &old_path);
if (error)
return error;
get_buffers(buffer, old_buffer);
error = fn_for_each_confined(label, profile,
match_mnt(profile, path, buffer, &old_path, old_buffer,
NULL, MS_MOVE, NULL, false));
put_buffers(buffer, old_buffer);
path_put(&old_path);
return error;
}
int aa_bind_mount(struct aa_label *label, const struct path *path,
const char *dev_name, unsigned long flags)
{
struct aa_profile *profile;
char *buffer = NULL, *old_buffer = NULL;
struct path old_path;
int error;
AA_BUG(!label);
AA_BUG(!path);
if (!dev_name || !*dev_name)
return -EINVAL;
flags &= MS_REC | MS_BIND;
error = kern_path(dev_name, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &old_path);
if (error)
return error;
get_buffers(buffer, old_buffer);
error = fn_for_each_confined(label, profile,
match_mnt(profile, path, buffer, &old_path, old_buffer,
NULL, flags, NULL, false));
put_buffers(buffer, old_buffer);
path_put(&old_path);
return error;
}
status_t
multi_audio_control(void* cookie, uint32 op, void* arg, size_t len)
{
switch(op) {
case B_MULTI_GET_DESCRIPTION: return get_description(cookie, arg);
case B_MULTI_GET_EVENT_INFO: return B_ERROR;
case B_MULTI_SET_EVENT_INFO: return B_ERROR;
case B_MULTI_GET_EVENT: return B_ERROR;
case B_MULTI_GET_ENABLED_CHANNELS: return get_enabled_channels(cookie, arg);
case B_MULTI_SET_ENABLED_CHANNELS: return B_OK;
case B_MULTI_GET_GLOBAL_FORMAT: return get_global_format(cookie, arg);
case B_MULTI_SET_GLOBAL_FORMAT: return set_global_format(cookie, arg);
case B_MULTI_GET_CHANNEL_FORMATS: return B_ERROR;
case B_MULTI_SET_CHANNEL_FORMATS: return B_ERROR;
case B_MULTI_GET_MIX: return B_ERROR;
case B_MULTI_SET_MIX: return B_ERROR;
case B_MULTI_LIST_MIX_CHANNELS: return list_mix_channels(cookie, arg);
case B_MULTI_LIST_MIX_CONTROLS: return list_mix_controls(cookie, arg);
case B_MULTI_LIST_MIX_CONNECTIONS: return list_mix_connections(cookie, arg);
case B_MULTI_GET_BUFFERS: return get_buffers(cookie, arg);
case B_MULTI_SET_BUFFERS: return B_ERROR;
case B_MULTI_SET_START_TIME: return B_ERROR;
case B_MULTI_BUFFER_EXCHANGE: return buffer_exchange(cookie, arg);
case B_MULTI_BUFFER_FORCE_STOP: return buffer_force_stop(cookie);
}
dprintf("null_audio: %s - unknown op\n" , __func__);
return B_BAD_VALUE;
}
int aa_new_mount(struct aa_label *label, const char *dev_name,
const struct path *path, const char *type, unsigned long flags,
void *data)
{
struct aa_profile *profile;
char *buffer = NULL, *dev_buffer = NULL;
bool binary = true;
int error;
int requires_dev = 0;
struct path tmp_path, *dev_path = NULL;
AA_BUG(!label);
AA_BUG(!path);
if (type) {
struct file_system_type *fstype;
fstype = get_fs_type(type);
if (!fstype)
return -ENODEV;
binary = fstype->fs_flags & FS_BINARY_MOUNTDATA;
requires_dev = fstype->fs_flags & FS_REQUIRES_DEV;
put_filesystem(fstype);
if (requires_dev) {
if (!dev_name || !*dev_name)
return -ENOENT;
error = kern_path(dev_name, LOOKUP_FOLLOW, &tmp_path);
if (error)
return error;
dev_path = &tmp_path;
}
}
get_buffers(buffer, dev_buffer);
if (dev_path) {
error = fn_for_each_confined(label, profile,
match_mnt(profile, path, buffer, dev_path, dev_buffer,
type, flags, data, binary));
} else {
error = fn_for_each_confined(label, profile,
match_mnt_path_str(profile, path, buffer, dev_name,
type, flags, data, binary, NULL));
}
put_buffers(buffer, dev_buffer);
if (dev_path)
path_put(dev_path);
return error;
}
int aa_remount(struct aa_label *label, const struct path *path,
unsigned long flags, void *data)
{
struct aa_profile *profile;
char *buffer = NULL;
bool binary;
int error;
AA_BUG(!label);
AA_BUG(!path);
binary = path->dentry->d_sb->s_type->fs_flags & FS_BINARY_MOUNTDATA;
get_buffers(buffer);
error = fn_for_each_confined(label, profile,
match_mnt(profile, path, buffer, NULL, NULL, NULL,
flags, data, binary));
put_buffers(buffer);
return error;
}
int aa_mount_change_type(struct aa_label *label, const struct path *path,
unsigned long flags)
{
struct aa_profile *profile;
char *buffer = NULL;
int error;
AA_BUG(!label);
AA_BUG(!path);
/* These are the flags allowed by do_change_type() */
flags &= (MS_REC | MS_SILENT | MS_SHARED | MS_PRIVATE | MS_SLAVE |
MS_UNBINDABLE);
get_buffers(buffer);
error = fn_for_each_confined(label, profile,
match_mnt(profile, path, buffer, NULL, NULL, NULL,
flags, NULL, false));
put_buffers(buffer);
return error;
}
int PluginArray::run_plugins()
{
// Length to write after process_loop
int64_t write_length;
done = 0; // for when done
error = 0;
if(plugin_server->realtime)
{
int64_t len;
MainProgressBar *progress;
char string[BCTEXTLEN], string2[BCTEXTLEN];
sprintf(string, _("%s..."), plugin_server->title);
progress = mwindow->mainprogress->start_progress(string, end - start);
for(int current_position = start;
current_position < end && !done && !error;
current_position += len)
{
len = buffer_size;
if(current_position + len > end) len = end - current_position;
// Process in plugin. This pulls data from the modules
get_buffers();
for(int i = 0; i < total; i++)
{
process_realtime(i, current_position, len);
}
// Write to file
error = write_buffers(len);
done = progress->update(current_position - start + len);
}
progress->get_time(string2);
progress->stop_progress();
delete progress;
sprintf(string, _("%s took %s"), plugin_server->title, string2);
mwindow->gui->lock_window();
mwindow->gui->show_message(string2);
mwindow->gui->unlock_window();
}
else
{
// Run main loop once for multichannel plugins.
// Run multiple times for single channel plugins.
// Each write to the file must contain all the channels
while(!done && !error)
{
for(int i = 0; i < total; i++)
{
write_length = 0;
done += process_loop(i, write_length);
}
if(write_length)
error = write_buffers(write_length);
}
}
return error;
}
static status_t
multi_audio_control_generic(cookie_type* cookie, uint32 op, void* arg, size_t len)
{
status_t status;
switch (op) {
case B_MULTI_GET_DESCRIPTION:
{
multi_description description;
multi_channel_info channels[16];
multi_channel_info* originalChannels;
if (user_memcpy(&description, arg, sizeof(multi_description))
!= B_OK)
return B_BAD_ADDRESS;
originalChannels = description.channels;
description.channels = channels;
if (description.request_channel_count > 16)
description.request_channel_count = 16;
status = get_description(cookie, &description);
if (status != B_OK)
return status;
description.channels = originalChannels;
if (user_memcpy(arg, &description, sizeof(multi_description))
!= B_OK)
return B_BAD_ADDRESS;
return user_memcpy(originalChannels, channels,
sizeof(multi_channel_info) * description.request_channel_count);
}
case B_MULTI_GET_ENABLED_CHANNELS:
{
multi_channel_enable* data = (multi_channel_enable*)arg;
multi_channel_enable enable;
uint32 enable_bits;
uchar* orig_enable_bits;
if (user_memcpy(&enable, data, sizeof(enable)) != B_OK
|| !IS_USER_ADDRESS(enable.enable_bits)) {
return B_BAD_ADDRESS;
}
orig_enable_bits = enable.enable_bits;
enable.enable_bits = (uchar*)&enable_bits;
status = get_enabled_channels(cookie, &enable);
if (status != B_OK)
return status;
enable.enable_bits = orig_enable_bits;
if (user_memcpy(enable.enable_bits, &enable_bits,
sizeof(enable_bits)) < B_OK
|| user_memcpy(arg, &enable, sizeof(multi_channel_enable)) < B_OK) {
return B_BAD_ADDRESS;
}
return B_OK;
}
case B_MULTI_SET_ENABLED_CHANNELS:
return B_OK;
case B_MULTI_GET_GLOBAL_FORMAT:
{
multi_format_info info;
if (user_memcpy(&info, arg, sizeof(multi_format_info)) != B_OK)
return B_BAD_ADDRESS;
status = get_global_format(cookie, &info);
if (status != B_OK)
return B_OK;
return user_memcpy(arg, &info, sizeof(multi_format_info));
}
case B_MULTI_SET_GLOBAL_FORMAT:
{
multi_format_info info;
if (user_memcpy(&info, arg, sizeof(multi_format_info)) != B_OK)
return B_BAD_ADDRESS;
status = set_global_format(cookie, &info);
if (status != B_OK)
return B_OK;
return user_memcpy(arg, &info, sizeof(multi_format_info));
}
case B_MULTI_LIST_MIX_CHANNELS:
return list_mix_channels(cookie, (multi_mix_channel_info*)arg);
case B_MULTI_LIST_MIX_CONTROLS:
{
multi_mix_control_info info;
multi_mix_control* original_controls;
size_t allocSize;
multi_mix_control *controls;
if (user_memcpy(&info, arg, sizeof(multi_mix_control_info)) != B_OK)
return B_BAD_ADDRESS;
original_controls = info.controls;
allocSize = sizeof(multi_mix_control) * info.control_count;
controls = (multi_mix_control *)malloc(allocSize);
if (controls == NULL)
return B_NO_MEMORY;
if (!IS_USER_ADDRESS(info.controls)
|| user_memcpy(controls, info.controls, allocSize) < B_OK) {
free(controls);
return B_BAD_ADDRESS;
}
info.controls = controls;
status = list_mix_controls(cookie, &info);
if (status != B_OK) {
free(controls);
return status;
}
info.controls = original_controls;
status = user_memcpy(info.controls, controls, allocSize);
if (status == B_OK)
status = user_memcpy(arg, &info, sizeof(multi_mix_control_info));
if (status != B_OK)
status = B_BAD_ADDRESS;
free(controls);
return status;
}
case B_MULTI_LIST_MIX_CONNECTIONS:
return list_mix_connections(cookie,
(multi_mix_connection_info*)arg);
case B_MULTI_GET_MIX:
{
multi_mix_value_info info;
multi_mix_value* original_values;
size_t allocSize;
multi_mix_value *values;
if (user_memcpy(&info, arg, sizeof(multi_mix_value_info)) != B_OK)
return B_BAD_ADDRESS;
original_values = info.values;
allocSize = sizeof(multi_mix_value) * info.item_count;
values = (multi_mix_value *)malloc(allocSize);
if (values == NULL)
return B_NO_MEMORY;
if (!IS_USER_ADDRESS(info.values)
|| user_memcpy(values, info.values, allocSize) < B_OK) {
free(values);
return B_BAD_ADDRESS;
}
info.values = values;
status = get_mix(cookie, &info);
if (status != B_OK) {
free(values);
return status;
}
info.values = original_values;
status = user_memcpy(info.values, values, allocSize);
if (status == B_OK)
status = user_memcpy(arg, &info, sizeof(multi_mix_value_info));
if (status != B_OK)
status = B_BAD_ADDRESS;
free(values);
return status;
}
case B_MULTI_SET_MIX:
{
multi_mix_value_info info;
multi_mix_value* original_values;
size_t allocSize;
multi_mix_value *values;
if (user_memcpy(&info, arg, sizeof(multi_mix_value_info)) != B_OK)
return B_BAD_ADDRESS;
original_values = info.values;
allocSize = sizeof(multi_mix_value) * info.item_count;
values = (multi_mix_value *)malloc(allocSize);
if (values == NULL)
return B_NO_MEMORY;
if (!IS_USER_ADDRESS(info.values)
|| user_memcpy(values, info.values, allocSize) < B_OK) {
free(values);
return B_BAD_ADDRESS;
}
info.values = values;
status = set_mix(cookie, &info);
if (status != B_OK) {
free(values);
return status;
}
info.values = original_values;
status = user_memcpy(info.values, values, allocSize);
if (status == B_OK)
status = user_memcpy(arg, &info, sizeof(multi_mix_value_info));
if (status != B_OK)
status = B_BAD_ADDRESS;
free(values);
return status;
}
case B_MULTI_GET_BUFFERS:
{
multi_buffer_list list;
if (user_memcpy(&list, arg, sizeof(multi_buffer_list)) != B_OK)
return B_BAD_ADDRESS;
{
buffer_desc **original_playback_descs = list.playback_buffers;
buffer_desc **original_record_descs = list.record_buffers;
buffer_desc *playback_descs[list.request_playback_buffers];
buffer_desc *record_descs[list.request_record_buffers];
if (!IS_USER_ADDRESS(list.playback_buffers)
|| user_memcpy(playback_descs, list.playback_buffers,
sizeof(buffer_desc*) * list.request_playback_buffers)
< B_OK
|| !IS_USER_ADDRESS(list.record_buffers)
|| user_memcpy(record_descs, list.record_buffers,
sizeof(buffer_desc*) * list.request_record_buffers)
< B_OK) {
return B_BAD_ADDRESS;
}
list.playback_buffers = playback_descs;
list.record_buffers = record_descs;
status = get_buffers(cookie, &list);
if (status != B_OK)
return status;
list.playback_buffers = original_playback_descs;
list.record_buffers = original_record_descs;
if (user_memcpy(arg, &list, sizeof(multi_buffer_list)) < B_OK
|| user_memcpy(original_playback_descs, playback_descs,
sizeof(buffer_desc*) * list.request_playback_buffers)
< B_OK
|| user_memcpy(original_record_descs, record_descs,
sizeof(buffer_desc*) * list.request_record_buffers)
< B_OK) {
status = B_BAD_ADDRESS;
}
}
return status;
}
case B_MULTI_BUFFER_EXCHANGE:
return buffer_exchange(cookie, (multi_buffer_info*)arg);
case B_MULTI_BUFFER_FORCE_STOP:
return buffer_force_stop(cookie);
case B_MULTI_GET_EVENT_INFO:
case B_MULTI_SET_EVENT_INFO:
case B_MULTI_GET_EVENT:
case B_MULTI_GET_CHANNEL_FORMATS:
case B_MULTI_SET_CHANNEL_FORMATS:
case B_MULTI_SET_BUFFERS:
case B_MULTI_SET_START_TIME:
return B_ERROR;
}
return B_BAD_VALUE;
}
int aa_umount(struct aa_label *label, struct vfsmount *mnt, int flags)
{
struct aa_profile *profile;
char *buffer = NULL;
int error;
struct path path = { .mnt = mnt, .dentry = mnt->mnt_root };
AA_BUG(!label);
AA_BUG(!mnt);
get_buffers(buffer);
error = fn_for_each_confined(label, profile,
profile_umount(profile, &path, buffer));
put_buffers(buffer);
return error;
}
/* helper fn for transition on pivotroot
*
* Returns: label for transition or ERR_PTR. Does not return NULL
*/
static struct aa_label *build_pivotroot(struct aa_profile *profile,
const struct path *new_path,
char *new_buffer,
const struct path *old_path,
char *old_buffer)
{
const char *old_name, *new_name = NULL, *info = NULL;
const char *trans_name = NULL;
struct aa_perms perms = { };
unsigned int state;
int error;
AA_BUG(!profile);
AA_BUG(!new_path);
AA_BUG(!old_path);
if (profile_unconfined(profile) ||
!PROFILE_MEDIATES(profile, AA_CLASS_MOUNT))
return aa_get_newest_label(&profile->label);
error = aa_path_name(old_path, path_flags(profile, old_path),
old_buffer, &old_name, &info,
profile->disconnected);
if (error)
goto audit;
error = aa_path_name(new_path, path_flags(profile, new_path),
new_buffer, &new_name, &info,
profile->disconnected);
if (error)
goto audit;
error = -EACCES;
state = aa_dfa_match(profile->policy.dfa,
profile->policy.start[AA_CLASS_MOUNT],
new_name);
state = aa_dfa_null_transition(profile->policy.dfa, state);
state = aa_dfa_match(profile->policy.dfa, state, old_name);
perms = compute_mnt_perms(profile->policy.dfa, state);
if (AA_MAY_PIVOTROOT & perms.allow)
error = 0;
audit:
error = audit_mount(profile, OP_PIVOTROOT, new_name, old_name,
NULL, trans_name, 0, NULL, AA_MAY_PIVOTROOT,
&perms, info, error);
if (error)
return ERR_PTR(error);
return aa_get_newest_label(&profile->label);
}
int aa_pivotroot(struct aa_label *label, const struct path *old_path,
const struct path *new_path)
{
struct aa_profile *profile;
struct aa_label *target = NULL;
char *old_buffer = NULL, *new_buffer = NULL, *info = NULL;
int error;
AA_BUG(!label);
AA_BUG(!old_path);
AA_BUG(!new_path);
get_buffers(old_buffer, new_buffer);
target = fn_label_build(label, profile, GFP_ATOMIC,
build_pivotroot(profile, new_path, new_buffer,
old_path, old_buffer));
if (!target) {
info = "label build failed";
error = -ENOMEM;
goto fail;
} else if (!IS_ERR(target)) {
error = aa_replace_current_label(target);
if (error) {
/* TODO: audit target */
aa_put_label(target);
goto out;
}
} else
/* already audited error */
error = PTR_ERR(target);
out:
put_buffers(old_buffer, new_buffer);
return error;
fail:
/* TODO: add back in auditing of new_name and old_name */
error = fn_for_each(label, profile,
audit_mount(profile, OP_PIVOTROOT, NULL /*new_name */,
NULL /* old_name */,
NULL, NULL,
0, NULL, AA_MAY_PIVOTROOT, &nullperms, info,
error));
goto out;
}
void
PortImpl::prepare_poly_buffers(BufferFactory& bufs)
{
if (_prepared_buffers)
get_buffers(bufs, _prepared_buffers, _prepared_buffers->size());
}
std::vector<RAPDU> ICard::transceive(const std::vector<CAPDU> &cmds)
{
return get_rapdus(m_subSystem->transceive(get_buffers(cmds)));
}
mem_buf_desc_t *buffer_pool::get_buffers_thread_safe(size_t count, uint32_t lkey)
{
auto_unlocker lock(m_lock_spin);
return get_buffers(count, lkey);
}
