Switch media fw permissions checks to AttributionSource (av)
Attribution source is the abstraction to capture the data
flows for private data across apps. Checking permissions
for an attribution source does this for all apps in the
chain that would receive the data as well as the relevant
app ops are checked/noted/started as needed.
bug: 158792096
Test: atest CtsMediaTestCases
atest CtsPermissionTestCases
atest CtsPermission2TestCases
atest CtsPermission3TestCases
atest CtsPermission4TestCases
atest CtsPermission5TestCases
atest CtsAppOpsTestCases
atest CtsAppOps2TestCases
Merged-In: I1c5a4321dd3b2d458372058c99604a6ec208717c
Change-Id: I1c5a4321dd3b2d458372058c99604a6ec208717c
diff --git a/services/audioflinger/Android.bp b/services/audioflinger/Android.bp
index a7d47fb..b91f302 100644
--- a/services/audioflinger/Android.bp
+++ b/services/audioflinger/Android.bp
@@ -81,12 +81,12 @@
"libmedia_helper",
"libshmemcompat",
"libvibrator",
- "media_permission-aidl-cpp",
],
static_libs: [
"libcpustats",
"libsndfile",
+ "libpermission",
],
header_libs: [
@@ -97,7 +97,6 @@
export_shared_lib_headers: [
"libpermission",
- "media_permission-aidl-cpp",
],
cflags: [
diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp
index 00f423c..d4f9302 100644
--- a/services/audioflinger/AudioFlinger.cpp
+++ b/services/audioflinger/AudioFlinger.cpp
@@ -103,7 +103,7 @@
namespace android {
using media::IEffectClient;
-using media::permission::Identity;
+using android::content::AttributionSourceState;
static const char kDeadlockedString[] = "AudioFlinger may be deadlocked\n";
static const char kHardwareLockedString[] = "Hardware lock is taken\n";
@@ -163,31 +163,32 @@
}
};
-// TODO b/182392769: use identity util
+// TODO b/182392769: use attribution source util
/* static */
-media::permission::Identity AudioFlinger::checkIdentityPackage(
- const media::permission::Identity& identity) {
+AttributionSourceState AudioFlinger::checkAttributionSourcePackage(
+ const AttributionSourceState& attributionSource) {
Vector<String16> packages;
- PermissionController{}.getPackagesForUid(identity.uid, packages);
+ PermissionController{}.getPackagesForUid(attributionSource.uid, packages);
- Identity checkedIdentity = identity;
- if (!identity.packageName.has_value() || identity.packageName.value().size() == 0) {
+ AttributionSourceState checkedAttributionSource = attributionSource;
+ if (!attributionSource.packageName.has_value()
+ || attributionSource.packageName.value().size() == 0) {
if (!packages.isEmpty()) {
- checkedIdentity.packageName =
+ checkedAttributionSource.packageName =
std::move(legacy2aidl_String16_string(packages[0]).value());
}
} else {
String16 opPackageLegacy = VALUE_OR_FATAL(
- aidl2legacy_string_view_String16(identity.packageName.value_or("")));
+ aidl2legacy_string_view_String16(attributionSource.packageName.value_or("")));
if (std::find_if(packages.begin(), packages.end(),
[&opPackageLegacy](const auto& package) {
return opPackageLegacy == package; }) == packages.end()) {
ALOGW("The package name(%s) provided does not correspond to the uid %d",
- identity.packageName.value_or("").c_str(), identity.uid);
- checkedIdentity.packageName = std::optional<std::string>();
+ attributionSource.packageName.value_or("").c_str(), attributionSource.uid);
+ checkedAttributionSource.packageName = std::optional<std::string>();
}
}
- return checkedIdentity;
+ return checkedAttributionSource;
}
// ----------------------------------------------------------------------------
@@ -430,7 +431,7 @@
ret = AudioSystem::getOutputForAttr(&localAttr, &io,
actualSessionId,
- &streamType, client.identity,
+ &streamType, client.attributionSource,
&fullConfig,
(audio_output_flags_t)(AUDIO_OUTPUT_FLAG_MMAP_NOIRQ |
AUDIO_OUTPUT_FLAG_DIRECT),
@@ -441,7 +442,7 @@
ret = AudioSystem::getInputForAttr(&localAttr, &io,
RECORD_RIID_INVALID,
actualSessionId,
- client.identity,
+ client.attributionSource,
config,
AUDIO_INPUT_FLAG_MMAP_NOIRQ, deviceId, &portId);
}
@@ -847,21 +848,21 @@
// TODO b/182392553: refactor or make clearer
pid_t clientPid =
- VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(input.clientInfo.identity.pid));
+ VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(input.clientInfo.attributionSource.pid));
bool updatePid = (clientPid == (pid_t)-1);
const uid_t callingUid = IPCThreadState::self()->getCallingUid();
uid_t clientUid =
- VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_uid_t(input.clientInfo.identity.uid));
+ VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_uid_t(input.clientInfo.attributionSource.uid));
audio_io_handle_t effectThreadId = AUDIO_IO_HANDLE_NONE;
std::vector<int> effectIds;
audio_attributes_t localAttr = input.attr;
- Identity adjIdentity = input.clientInfo.identity;
+ AttributionSourceState adjAttributionSource = input.clientInfo.attributionSource;
if (!isAudioServerOrMediaServerUid(callingUid)) {
ALOGW_IF(clientUid != callingUid,
"%s uid %d tried to pass itself off as %d",
__FUNCTION__, callingUid, clientUid);
- adjIdentity.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
+ adjAttributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
clientUid = callingUid;
updatePid = true;
}
@@ -871,7 +872,7 @@
"%s uid %d pid %d tried to pass itself off as pid %d",
__func__, callingUid, callingPid, clientPid);
clientPid = callingPid;
- adjIdentity.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(callingPid));
+ adjAttributionSource.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(callingPid));
}
audio_session_t sessionId = input.sessionId;
@@ -886,7 +887,7 @@
output.outputId = AUDIO_IO_HANDLE_NONE;
output.selectedDeviceId = input.selectedDeviceId;
lStatus = AudioSystem::getOutputForAttr(&localAttr, &output.outputId, sessionId, &streamType,
- adjIdentity, &input.config, input.flags,
+ adjAttributionSource, &input.config, input.flags,
&output.selectedDeviceId, &portId, &secondaryOutputs);
if (lStatus != NO_ERROR || output.outputId == AUDIO_IO_HANDLE_NONE) {
@@ -951,7 +952,7 @@
&output.frameCount, &output.notificationFrameCount,
input.notificationsPerBuffer, input.speed,
input.sharedBuffer, sessionId, &output.flags,
- callingPid, adjIdentity, input.clientInfo.clientTid,
+ callingPid, adjAttributionSource, input.clientInfo.clientTid,
&lStatus, portId, input.audioTrackCallback);
LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (track == 0));
// we don't abort yet if lStatus != NO_ERROR; there is still work to be done regardless
@@ -2030,24 +2031,26 @@
output.inputId = AUDIO_IO_HANDLE_NONE;
// TODO b/182392553: refactor or clean up
- Identity adjIdentity = input.clientInfo.identity;
- bool updatePid = (adjIdentity.pid == -1);
+ AttributionSourceState adjAttributionSource = input.clientInfo.attributionSource;
+ bool updatePid = (adjAttributionSource.pid == -1);
const uid_t callingUid = IPCThreadState::self()->getCallingUid();
- const uid_t currentUid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(adjIdentity.uid));
+ const uid_t currentUid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(
+ adjAttributionSource.uid));
if (!isAudioServerOrMediaServerUid(callingUid)) {
ALOGW_IF(currentUid != callingUid,
"%s uid %d tried to pass itself off as %d",
__FUNCTION__, callingUid, currentUid);
- adjIdentity.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
+ adjAttributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
updatePid = true;
}
const pid_t callingPid = IPCThreadState::self()->getCallingPid();
- const pid_t currentPid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(adjIdentity.pid));
+ const pid_t currentPid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(
+ adjAttributionSource.pid));
if (updatePid) {
ALOGW_IF(currentPid != (pid_t)-1 && currentPid != callingPid,
"%s uid %d pid %d tried to pass itself off as pid %d",
__func__, callingUid, callingPid, currentPid);
- adjIdentity.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(callingPid));
+ adjAttributionSource.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(callingPid));
}
// we don't yet support anything other than linear PCM
@@ -2075,7 +2078,7 @@
output.selectedDeviceId = input.selectedDeviceId;
output.flags = input.flags;
- client = registerPid(VALUE_OR_FATAL(aidl2legacy_int32_t_pid_t(adjIdentity.pid)));
+ client = registerPid(VALUE_OR_FATAL(aidl2legacy_int32_t_pid_t(adjAttributionSource.pid)));
// Not a conventional loop, but a retry loop for at most two iterations total.
// Try first maybe with FAST flag then try again without FAST flag if that fails.
@@ -2095,7 +2098,7 @@
input.riid,
sessionId,
// FIXME compare to AudioTrack
- adjIdentity,
+ adjAttributionSource,
&input.config,
output.flags, &output.selectedDeviceId, &portId);
if (lStatus != NO_ERROR) {
@@ -2122,7 +2125,7 @@
input.config.format, input.config.channel_mask,
&output.frameCount, sessionId,
&output.notificationFrameCount,
- callingPid, adjIdentity, &output.flags,
+ callingPid, adjAttributionSource, &output.flags,
input.clientInfo.clientTid,
&lStatus, portId, input.maxSharedAudioHistoryMs);
LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (recordTrack == 0));
@@ -3605,7 +3608,7 @@
const int32_t priority = request.priority;
const AudioDeviceTypeAddr device = VALUE_OR_RETURN_STATUS(
aidl2legacy_AudioDeviceTypeAddress(request.device));
- Identity adjIdentity = request.identity;
+ AttributionSourceState adjAttributionSource = request.attributionSource;
const audio_session_t sessionId = VALUE_OR_RETURN_STATUS(
aidl2legacy_int32_t_audio_session_t(request.sessionId));
audio_io_handle_t io = VALUE_OR_RETURN_STATUS(
@@ -3623,19 +3626,20 @@
// TODO b/182392553: refactor or make clearer
const uid_t callingUid = IPCThreadState::self()->getCallingUid();
- adjIdentity.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
- pid_t currentPid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(adjIdentity.pid));
+ adjAttributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
+ pid_t currentPid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(adjAttributionSource.pid));
if (currentPid == -1 || !isAudioServerOrMediaServerUid(callingUid)) {
const pid_t callingPid = IPCThreadState::self()->getCallingPid();
ALOGW_IF(currentPid != -1 && currentPid != callingPid,
"%s uid %d pid %d tried to pass itself off as pid %d",
__func__, callingUid, callingPid, currentPid);
- adjIdentity.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(callingPid));
+ adjAttributionSource.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(callingPid));
currentPid = callingPid;
}
ALOGV("createEffect pid %d, effectClient %p, priority %d, sessionId %d, io %d, factory %p",
- adjIdentity.pid, effectClient.get(), priority, sessionId, io, mEffectsFactoryHal.get());
+ adjAttributionSource.pid, effectClient.get(), priority, sessionId, io,
+ mEffectsFactoryHal.get());
if (mEffectsFactoryHal == 0) {
ALOGE("%s: no effects factory hal", __func__);
@@ -3663,7 +3667,7 @@
goto Exit;
}
} else if (sessionId == AUDIO_SESSION_DEVICE) {
- if (!modifyDefaultAudioEffectsAllowed(adjIdentity)) {
+ if (!modifyDefaultAudioEffectsAllowed(adjAttributionSource)) {
ALOGE("%s: device effect permission denied for uid %d", __func__, callingUid);
lStatus = PERMISSION_DENIED;
goto Exit;
@@ -3708,7 +3712,7 @@
// check recording permission for visualizer
if ((memcmp(&descOut.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) &&
// TODO: Do we need to start/stop op - i.e. is there recording being performed?
- !recordingAllowed(adjIdentity)) {
+ !recordingAllowed(adjAttributionSource)) {
lStatus = PERMISSION_DENIED;
goto Exit;
}
diff --git a/services/audioflinger/AudioFlinger.h b/services/audioflinger/AudioFlinger.h
index b12f52e..fff61f8 100644
--- a/services/audioflinger/AudioFlinger.h
+++ b/services/audioflinger/AudioFlinger.h
@@ -37,6 +37,8 @@
#include <android/media/IAudioFlingerClient.h>
#include <android/media/IAudioTrackCallback.h>
#include <android/os/BnExternalVibrationController.h>
+#include <android/content/AttributionSourceState.h>
+
#include <android-base/macros.h>
#include <cutils/atomic.h>
@@ -124,13 +126,15 @@
#define INCLUDING_FROM_AUDIOFLINGER_H
+using android::content::AttributionSourceState;
+
class AudioFlinger : public AudioFlingerServerAdapter::Delegate
{
public:
static void instantiate() ANDROID_API;
- static media::permission::Identity checkIdentityPackage(
- const media::permission::Identity& identity);
+ static AttributionSourceState checkAttributionSourcePackage(
+ const AttributionSourceState& attributionSource);
status_t dump(int fd, const Vector<String16>& args) override;
diff --git a/services/audioflinger/MmapTracks.h b/services/audioflinger/MmapTracks.h
index ba868d7..eb640bb 100644
--- a/services/audioflinger/MmapTracks.h
+++ b/services/audioflinger/MmapTracks.h
@@ -29,7 +29,7 @@
audio_channel_mask_t channelMask,
audio_session_t sessionId,
bool isOut,
- const media::permission::Identity& identity,
+ const android::content::AttributionSourceState& attributionSource,
pid_t creatorPid,
audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
virtual ~MmapTrack();
diff --git a/services/audioflinger/PlaybackTracks.h b/services/audioflinger/PlaybackTracks.h
index 30a2432..51a41af 100644
--- a/services/audioflinger/PlaybackTracks.h
+++ b/services/audioflinger/PlaybackTracks.h
@@ -15,8 +15,6 @@
** limitations under the License.
*/
-#include <android/media/permission/Identity.h>
-
#ifndef INCLUDING_FROM_AUDIOFLINGER_H
#error This header file should only be included from AudioFlinger.h
#endif
@@ -28,12 +26,12 @@
bool hasOpPlayAudio() const;
static sp<OpPlayAudioMonitor> createIfNeeded(
- const android::media::permission::Identity& identity,
+ const AttributionSourceState& attributionSource,
const audio_attributes_t& attr, int id,
audio_stream_type_t streamType);
private:
- OpPlayAudioMonitor(const android::media::permission::Identity& identity,
+ OpPlayAudioMonitor(const AttributionSourceState& attributionSource,
audio_usage_t usage, int id);
void onFirstRef() override;
static void getPackagesForUid(uid_t uid, Vector<String16>& packages);
@@ -54,7 +52,7 @@
void checkPlayAudioForUsage();
std::atomic_bool mHasOpPlayAudio;
- const android::media::permission::Identity mIdentity;
+ const AttributionSourceState mAttributionSource;
const int32_t mUsage; // on purpose not audio_usage_t because always checked in appOps as int32_t
const int mId; // for logging purposes only
};
@@ -75,7 +73,7 @@
const sp<IMemory>& sharedBuffer,
audio_session_t sessionId,
pid_t creatorPid,
- const media::permission::Identity& identity,
+ const AttributionSourceState& attributionSource,
audio_output_flags_t flags,
track_type type,
audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE,
@@ -334,7 +332,7 @@
audio_format_t format,
audio_channel_mask_t channelMask,
size_t frameCount,
- const android::media::permission::Identity& identity);
+ const AttributionSourceState& attributionSource);
virtual ~OutputTrack();
virtual status_t start(AudioSystem::sync_event_t event =
diff --git a/services/audioflinger/RecordTracks.h b/services/audioflinger/RecordTracks.h
index a1c2de7..88aa7cb 100644
--- a/services/audioflinger/RecordTracks.h
+++ b/services/audioflinger/RecordTracks.h
@@ -15,6 +15,8 @@
** limitations under the License.
*/
+#include <android/content/AttributionSourceState.h>
+
#ifndef INCLUDING_FROM_AUDIOFLINGER_H
#error This header file should only be included from AudioFlinger.h
#endif
@@ -26,11 +28,12 @@
bool hasOp() const;
int32_t getOp() const { return mAppOp; }
- static sp<OpRecordAudioMonitor> createIfNeeded
- (const media::permission::Identity& identity, const audio_attributes_t& attr);
+ static sp<OpRecordAudioMonitor> createIfNeeded(const AttributionSourceState& attributionSource,
+ const audio_attributes_t& attr);
private:
- OpRecordAudioMonitor(const media::permission::Identity& identity, int32_t appOp);
+ OpRecordAudioMonitor(const AttributionSourceState& attributionSource, int32_t appOp);
+
void onFirstRef() override;
AppOpsManager mAppOpsManager;
@@ -50,7 +53,7 @@
void checkOp();
std::atomic_bool mHasOp;
- const media::permission::Identity mIdentity;
+ const AttributionSourceState mAttributionSource;
const int32_t mAppOp;
};
@@ -68,7 +71,7 @@
size_t bufferSize,
audio_session_t sessionId,
pid_t creatorPid,
- const media::permission::Identity& identity,
+ const AttributionSourceState& attributionSource,
audio_input_flags_t flags,
track_type type,
audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE,
diff --git a/services/audioflinger/Threads.cpp b/services/audioflinger/Threads.cpp
index 25a19a2..47b4b18 100644
--- a/services/audioflinger/Threads.cpp
+++ b/services/audioflinger/Threads.cpp
@@ -118,7 +118,7 @@
namespace android {
using media::IEffectClient;
-using media::permission::Identity;
+using content::AttributionSourceState;
// retry counts for buffer fill timeout
// 50 * ~20msecs = 1 second
@@ -2129,7 +2129,7 @@
audio_session_t sessionId,
audio_output_flags_t *flags,
pid_t creatorPid,
- const Identity& identity,
+ const AttributionSourceState& attributionSource,
pid_t tid,
status_t *status,
audio_port_handle_t portId,
@@ -2424,8 +2424,8 @@
track = new Track(this, client, streamType, attr, sampleRate, format,
channelMask, frameCount,
nullptr /* buffer */, (size_t)0 /* bufferSize */, sharedBuffer,
- sessionId, creatorPid, identity, trackFlags, TrackBase::TYPE_DEFAULT,
- portId, SIZE_MAX /*frameCountToBeReady*/, speed);
+ sessionId, creatorPid, attributionSource, trackFlags,
+ TrackBase::TYPE_DEFAULT, portId, SIZE_MAX /*frameCountToBeReady*/, speed);
lStatus = track != 0 ? track->initCheck() : (status_t) NO_MEMORY;
if (lStatus != NO_ERROR) {
@@ -6886,19 +6886,20 @@
// from different OutputTracks and their associated MixerThreads (e.g. one may
// nearly empty and the other may be dropping data).
- // TODO b/182392769: use identity util, move to server edge
- Identity identity = Identity();
- identity.uid = VALUE_OR_FATAL(legacy2aidl_uid_t_int32_t(
+ // TODO b/182392769: use attribution source util, move to server edge
+ AttributionSourceState attributionSource = AttributionSourceState();
+ attributionSource.uid = VALUE_OR_FATAL(legacy2aidl_uid_t_int32_t(
IPCThreadState::self()->getCallingUid()));
- identity.pid = VALUE_OR_FATAL(legacy2aidl_pid_t_int32_t(
+ attributionSource.pid = VALUE_OR_FATAL(legacy2aidl_pid_t_int32_t(
IPCThreadState::self()->getCallingPid()));
+ attributionSource.token = sp<BBinder>::make();
sp<OutputTrack> outputTrack = new OutputTrack(thread,
this,
mSampleRate,
mFormat,
mChannelMask,
frameCount,
- identity);
+ attributionSource);
status_t status = outputTrack != 0 ? outputTrack->initCheck() : (status_t) NO_MEMORY;
if (status != NO_ERROR) {
ALOGE("addOutputTrack() initCheck failed %d", status);
@@ -7822,7 +7823,7 @@
audio_session_t sessionId,
size_t *pNotificationFrameCount,
pid_t creatorPid,
- const Identity& identity,
+ const AttributionSourceState& attributionSource,
audio_input_flags_t *flags,
pid_t tid,
status_t *status,
@@ -7836,7 +7837,8 @@
audio_input_flags_t inputFlags = mInput->flags;
audio_input_flags_t requestedFlags = *flags;
uint32_t sampleRate;
- Identity checkedIdentity = AudioFlinger::checkIdentityPackage(identity);
+ AttributionSourceState checkedAttributionSource = AudioFlinger::checkAttributionSourcePackage(
+ attributionSource);
lStatus = initCheck();
if (lStatus != NO_ERROR) {
@@ -7851,7 +7853,7 @@
}
if (maxSharedAudioHistoryMs != 0) {
- if (!captureHotwordAllowed(checkedIdentity)) {
+ if (!captureHotwordAllowed(checkedAttributionSource)) {
lStatus = PERMISSION_DENIED;
goto Exit;
}
@@ -7973,16 +7975,17 @@
Mutex::Autolock _l(mLock);
int32_t startFrames = -1;
if (!mSharedAudioPackageName.empty()
- && mSharedAudioPackageName == checkedIdentity.packageName
+ && mSharedAudioPackageName == checkedAttributionSource.packageName
&& mSharedAudioSessionId == sessionId
- && captureHotwordAllowed(checkedIdentity)) {
+ && captureHotwordAllowed(checkedAttributionSource)) {
startFrames = mSharedAudioStartFrames;
}
track = new RecordTrack(this, client, attr, sampleRate,
format, channelMask, frameCount,
nullptr /* buffer */, (size_t)0 /* bufferSize */, sessionId, creatorPid,
- checkedIdentity, *flags, TrackBase::TYPE_DEFAULT, portId, startFrames);
+ checkedAttributionSource, *flags, TrackBase::TYPE_DEFAULT, portId,
+ startFrames);
lStatus = track->initCheck();
if (lStatus != NO_ERROR) {
@@ -9174,7 +9177,7 @@
audio_port_handle_t *handle)
{
ALOGV("%s clientUid %d mStandby %d mPortId %d *handle %d", __FUNCTION__,
- client.identity.uid, mStandby, mPortId, *handle);
+ client.attributionSource.uid, mStandby, mPortId, *handle);
if (mHalStream == 0) {
return NO_INIT;
}
@@ -9206,7 +9209,7 @@
ret = AudioSystem::getOutputForAttr(&mAttr, &io,
mSessionId,
&stream,
- client.identity,
+ client.attributionSource,
&config,
flags,
&deviceId,
@@ -9223,7 +9226,7 @@
ret = AudioSystem::getInputForAttr(&mAttr, &io,
RECORD_RIID_INVALID,
mSessionId,
- client.identity,
+ client.attributionSource,
&config,
AUDIO_INPUT_FLAG_MMAP_NOIRQ,
&deviceId,
@@ -9263,7 +9266,8 @@
// Given that MmapThread::mAttr is mutable, should a MmapTrack have attributes ?
sp<MmapTrack> track = new MmapTrack(this, attr == nullptr ? mAttr : *attr, mSampleRate, mFormat,
- mChannelMask, mSessionId, isOutput(), client.identity,
+ mChannelMask, mSessionId, isOutput(),
+ client.attributionSource,
IPCThreadState::self()->getCallingPid(), portId);
if (isOutput()) {
@@ -9271,7 +9275,7 @@
mHalVolFloat = -1.0f;
} else if (!track->isSilenced_l()) {
for (const sp<MmapTrack> &t : mActiveTracks) {
- if (t->isSilenced_l() && t->uid() != client.identity.uid)
+ if (t->isSilenced_l() && t->uid() != client.attributionSource.uid)
t->invalidate();
}
}
diff --git a/services/audioflinger/Threads.h b/services/audioflinger/Threads.h
index d4fb995..eee1f2b 100644
--- a/services/audioflinger/Threads.h
+++ b/services/audioflinger/Threads.h
@@ -918,7 +918,7 @@
audio_session_t sessionId,
audio_output_flags_t *flags,
pid_t creatorPid,
- const media::permission::Identity& identity,
+ const AttributionSourceState& attributionSource,
pid_t tid,
status_t *status /*non-NULL*/,
audio_port_handle_t portId,
@@ -1698,7 +1698,7 @@
audio_session_t sessionId,
size_t *pNotificationFrameCount,
pid_t creatorPid,
- const media::permission::Identity& identity,
+ const AttributionSourceState& attributionSource,
audio_input_flags_t *flags,
pid_t tid,
status_t *status /*non-NULL*/,
diff --git a/services/audioflinger/Tracks.cpp b/services/audioflinger/Tracks.cpp
index 09e5ec5..57ff0d7 100644
--- a/services/audioflinger/Tracks.cpp
+++ b/services/audioflinger/Tracks.cpp
@@ -65,7 +65,7 @@
using ::android::aidl_utils::binderStatusFromStatusT;
using binder::Status;
-using media::permission::Identity;
+using content::AttributionSourceState;
using media::VolumeShaper;
// ----------------------------------------------------------------------------
// TrackBase
@@ -238,12 +238,13 @@
}
}
-// TODO b/182392769: use identity util
-static Identity audioServerIdentity(pid_t pid) {
- Identity i{};
- i.uid = AID_AUDIOSERVER;
- i.pid = pid;
- return i;
+// TODO b/182392769: use attribution source util
+static AttributionSourceState audioServerAttributionSource(pid_t pid) {
+ AttributionSourceState attributionSource{};
+ attributionSource.uid = AID_AUDIOSERVER;
+ attributionSource.pid = pid;
+ attributionSource.token = sp<BBinder>::make();
+ return attributionSource;
}
status_t AudioFlinger::ThreadBase::TrackBase::initCheck() const
@@ -498,11 +499,11 @@
// static
sp<AudioFlinger::PlaybackThread::OpPlayAudioMonitor>
AudioFlinger::PlaybackThread::OpPlayAudioMonitor::createIfNeeded(
- const Identity& identity, const audio_attributes_t& attr, int id,
+ const AttributionSourceState& attributionSource, const audio_attributes_t& attr, int id,
audio_stream_type_t streamType)
{
Vector <String16> packages;
- uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(identity.uid));
+ uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid));
getPackagesForUid(uid, packages);
if (isServiceUid(uid)) {
if (packages.isEmpty()) {
@@ -525,13 +526,15 @@
return nullptr;
}
- Identity checkedIdentity = AudioFlinger::checkIdentityPackage(identity);
- return new OpPlayAudioMonitor(checkedIdentity, attr.usage, id);
+ AttributionSourceState checkedAttributionSource = AudioFlinger::checkAttributionSourcePackage(
+ attributionSource);
+ return new OpPlayAudioMonitor(checkedAttributionSource, attr.usage, id);
}
AudioFlinger::PlaybackThread::OpPlayAudioMonitor::OpPlayAudioMonitor(
- const Identity& identity, audio_usage_t usage, int id)
- : mHasOpPlayAudio(true), mIdentity(identity), mUsage((int32_t) usage), mId(id)
+ const AttributionSourceState& attributionSource, audio_usage_t usage, int id)
+ : mHasOpPlayAudio(true), mAttributionSource(attributionSource), mUsage((int32_t) usage),
+ mId(id)
{
}
@@ -546,10 +549,11 @@
void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::onFirstRef()
{
checkPlayAudioForUsage();
- if (mIdentity.packageName.has_value()) {
+ if (mAttributionSource.packageName.has_value()) {
mOpCallback = new PlayAudioOpCallback(this);
mAppOpsManager.startWatchingMode(AppOpsManager::OP_PLAY_AUDIO,
- VALUE_OR_FATAL(aidl2legacy_string_view_String16(mIdentity.packageName.value_or("")))
+ VALUE_OR_FATAL(aidl2legacy_string_view_String16(
+ mAttributionSource.packageName.value_or("")))
, mOpCallback);
}
}
@@ -563,12 +567,12 @@
// - not called from PlayAudioOpCallback because the callback is not installed in this case
void AudioFlinger::PlaybackThread::OpPlayAudioMonitor::checkPlayAudioForUsage()
{
- if (!mIdentity.packageName.has_value()) {
+ if (!mAttributionSource.packageName.has_value()) {
mHasOpPlayAudio.store(false);
} else {
- uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(mIdentity.uid));
+ uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(mAttributionSource.uid));
String16 packageName = VALUE_OR_FATAL(
- aidl2legacy_string_view_String16(mIdentity.packageName.value_or("")));
+ aidl2legacy_string_view_String16(mAttributionSource.packageName.value_or("")));
bool hasIt = mAppOpsManager.checkAudioOpNoThrow(AppOpsManager::OP_PLAY_AUDIO,
mUsage, uid, packageName) == AppOpsManager::MODE_ALLOWED;
ALOGD("OpPlayAudio: track:%d usage:%d %smuted", mId, mUsage, hasIt ? "not " : "");
@@ -620,7 +624,7 @@
const sp<IMemory>& sharedBuffer,
audio_session_t sessionId,
pid_t creatorPid,
- const Identity& identity,
+ const AttributionSourceState& attributionSource,
audio_output_flags_t flags,
track_type type,
audio_port_handle_t portId,
@@ -634,7 +638,7 @@
(sharedBuffer != 0) ? sharedBuffer->unsecurePointer() : buffer,
(sharedBuffer != 0) ? sharedBuffer->size() : bufferSize,
sessionId, creatorPid,
- VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(identity.uid)), true /*isOut*/,
+ VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid)), true /*isOut*/,
(type == TYPE_PATCH) ? ( buffer == NULL ? ALLOC_LOCAL : ALLOC_NONE) : ALLOC_CBLK,
type,
portId,
@@ -649,7 +653,7 @@
mPresentationCompleteFrames(0),
mFrameMap(16 /* sink-frame-to-track-frame map memory */),
mVolumeHandler(new media::VolumeHandler(sampleRate)),
- mOpPlayAudioMonitor(OpPlayAudioMonitor::createIfNeeded(identity, attr, id(),
+ mOpPlayAudioMonitor(OpPlayAudioMonitor::createIfNeeded(attributionSource, attr, id(),
streamType)),
// mSinkTimestamp
mFastIndex(-1),
@@ -672,7 +676,7 @@
return;
}
- uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(identity.uid));
+ uid_t uid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid));
if (!thread->isTrackAllowed_l(channelMask, format, sessionId, uid)) {
ALOGE("%s(%d): no more tracks available", __func__, mId);
releaseCblk(); // this makes the track invalid.
@@ -718,8 +722,8 @@
// HapticGenerator effect, which will generate haptic data, on the track. In that case,
// external vibration is always created for all tracks attached to haptic playback thread.
mAudioVibrationController = new AudioVibrationController(this);
- std::string packageName = identity.packageName.has_value() ?
- identity.packageName.value() : "";
+ std::string packageName = attributionSource.packageName.has_value() ?
+ attributionSource.packageName.value() : "";
mExternalVibration = new os::ExternalVibration(
mUid, packageName, mAttr, mAudioVibrationController);
}
@@ -1840,12 +1844,12 @@
audio_format_t format,
audio_channel_mask_t channelMask,
size_t frameCount,
- const Identity& identity)
+ const AttributionSourceState& attributionSource)
: Track(playbackThread, NULL, AUDIO_STREAM_PATCH,
audio_attributes_t{} /* currently unused for output track */,
sampleRate, format, channelMask, frameCount,
nullptr /* buffer */, (size_t)0 /* bufferSize */, nullptr /* sharedBuffer */,
- AUDIO_SESSION_NONE, getpid(), identity, AUDIO_OUTPUT_FLAG_NONE,
+ AUDIO_SESSION_NONE, getpid(), attributionSource, AUDIO_OUTPUT_FLAG_NONE,
TYPE_OUTPUT),
mActive(false), mSourceThread(sourceThread)
{
@@ -2075,7 +2079,7 @@
audio_attributes_t{} /* currently unused for patch track */,
sampleRate, format, channelMask, frameCount,
buffer, bufferSize, nullptr /* sharedBuffer */,
- AUDIO_SESSION_NONE, getpid(), audioServerIdentity(getpid()), flags,
+ AUDIO_SESSION_NONE, getpid(), audioServerAttributionSource(getpid()), flags,
TYPE_PATCH, AUDIO_PORT_HANDLE_NONE, frameCountToBeReady),
PatchTrackBase(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, true, true),
*playbackThread, timeout)
@@ -2213,32 +2217,33 @@
// static
sp<AudioFlinger::RecordThread::OpRecordAudioMonitor>
AudioFlinger::RecordThread::OpRecordAudioMonitor::createIfNeeded(
- const Identity& identity, const audio_attributes_t& attr)
+ const AttributionSourceState& attributionSource, const audio_attributes_t& attr)
{
- if (isServiceUid(identity.uid)) {
+ if (isServiceUid(attributionSource.uid)) {
ALOGV("not silencing record for service %s",
- identity.toString().c_str());
+ attributionSource.toString().c_str());
return nullptr;
}
// Capturing from FM TUNER output is not controlled by an app op
// because it does not affect users privacy as does capturing from an actual microphone.
if (attr.source == AUDIO_SOURCE_FM_TUNER) {
- ALOGV("not muting FM TUNER capture for uid %d", identity.uid);
+ ALOGV("not muting FM TUNER capture for uid %d", attributionSource.uid);
return nullptr;
}
- Identity checkedIdentity = AudioFlinger::checkIdentityPackage(identity);
- if (!checkedIdentity.packageName.has_value()
- || checkedIdentity.packageName.value().size() == 0) {
+ AttributionSourceState checkedAttributionSource = AudioFlinger::checkAttributionSourcePackage(
+ attributionSource);
+ if (!checkedAttributionSource.packageName.has_value()
+ || checkedAttributionSource.packageName.value().size() == 0) {
return nullptr;
}
- return new OpRecordAudioMonitor(checkedIdentity, getOpForSource(attr.source));
+ return new OpRecordAudioMonitor(checkedAttributionSource, getOpForSource(attr.source));
}
AudioFlinger::RecordThread::OpRecordAudioMonitor::OpRecordAudioMonitor(
- const Identity& identity, int32_t appOp)
- : mHasOp(true), mIdentity(identity), mAppOp(appOp)
+ const AttributionSourceState& attributionSource, int32_t appOp)
+ : mHasOp(true), mAttributionSource(attributionSource), mAppOp(appOp)
{
}
@@ -2254,9 +2259,11 @@
{
checkOp();
mOpCallback = new RecordAudioOpCallback(this);
- ALOGV("start watching op %d for %s", mAppOp, mIdentity.toString().c_str());
- mAppOpsManager.startWatchingMode(mAppOp,
- VALUE_OR_FATAL(aidl2legacy_string_view_String16(mIdentity.packageName.value_or(""))),
+ ALOGV("start watching op %d for %s", mAppOp, mAttributionSource.toString().c_str());
+ // TODO: We need to always watch AppOpsManager::OP_RECORD_AUDIO too
+ // since it controls the mic permission for legacy apps.
+ mAppOpsManager.startWatchingMode(mAppOp, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
+ mAttributionSource.packageName.value_or(""))),
mOpCallback);
}
@@ -2272,17 +2279,17 @@
// - not called from RecordAudioOpCallback because the callback is not installed in this case
void AudioFlinger::RecordThread::OpRecordAudioMonitor::checkOp()
{
-
+ // TODO: We need to always check AppOpsManager::OP_RECORD_AUDIO too
+ // since it controls the mic permission for legacy apps.
const int32_t mode = mAppOpsManager.checkOp(mAppOp,
- mIdentity.uid, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
- mIdentity.packageName.value_or(""))));
- const bool hasIt = (mode == AppOpsManager::MODE_ALLOWED);
+ mAttributionSource.uid, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
+ mAttributionSource.packageName.value_or(""))));
+ const bool hasIt = (mode == AppOpsManager::MODE_ALLOWED);
// verbose logging only log when appOp changed
ALOGI_IF(hasIt != mHasOp.load(),
"App op %d missing, %ssilencing record %s",
- mAppOp, hasIt ? "un" : "", mIdentity.toString().c_str());
+ mAppOp, hasIt ? "un" : "", mAttributionSource.toString().c_str());
mHasOp.store(hasIt);
-
}
AudioFlinger::RecordThread::OpRecordAudioMonitor::RecordAudioOpCallback::RecordAudioOpCallback(
@@ -2382,7 +2389,7 @@
size_t bufferSize,
audio_session_t sessionId,
pid_t creatorPid,
- const Identity& identity,
+ const AttributionSourceState& attributionSource,
audio_input_flags_t flags,
track_type type,
audio_port_handle_t portId,
@@ -2390,7 +2397,7 @@
: TrackBase(thread, client, attr, sampleRate, format,
channelMask, frameCount, buffer, bufferSize, sessionId,
creatorPid,
- VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(identity.uid)),
+ VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid)),
false /*isOut*/,
(type == TYPE_DEFAULT) ?
((flags & AUDIO_INPUT_FLAG_FAST) ? ALLOC_PIPE : ALLOC_CBLK) :
@@ -2403,7 +2410,7 @@
mRecordBufferConverter(NULL),
mFlags(flags),
mSilenced(false),
- mOpRecordAudioMonitor(OpRecordAudioMonitor::createIfNeeded(identity, attr)),
+ mOpRecordAudioMonitor(OpRecordAudioMonitor::createIfNeeded(attributionSource, attr)),
mStartFrames(startFrames)
{
if (mCblk == NULL) {
@@ -2712,10 +2719,11 @@
return PERMISSION_DENIED;
}
- Identity identity{};
- identity.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
- identity.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingPid));
- if (!captureHotwordAllowed(identity)) {
+ AttributionSourceState attributionSource{};
+ attributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
+ attributionSource.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingPid));
+ attributionSource.token = sp<BBinder>::make();
+ if (!captureHotwordAllowed(attributionSource)) {
return PERMISSION_DENIED;
}
@@ -2751,7 +2759,7 @@
audio_attributes_t{} /* currently unused for patch track */,
sampleRate, format, channelMask, frameCount,
buffer, bufferSize, AUDIO_SESSION_NONE, getpid(),
- audioServerIdentity(getpid()), flags, TYPE_PATCH),
+ audioServerAttributionSource(getpid()), flags, TYPE_PATCH),
PatchTrackBase(new ClientProxy(mCblk, mBuffer, frameCount, mFrameSize, false, true),
*recordThread, timeout)
{
@@ -3028,19 +3036,19 @@
audio_channel_mask_t channelMask,
audio_session_t sessionId,
bool isOut,
- const Identity& identity,
+ const AttributionSourceState& attributionSource,
pid_t creatorPid,
audio_port_handle_t portId)
: TrackBase(thread, NULL, attr, sampleRate, format,
channelMask, (size_t)0 /* frameCount */,
nullptr /* buffer */, (size_t)0 /* bufferSize */,
sessionId, creatorPid,
- VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(identity.uid)),
+ VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.uid)),
isOut,
ALLOC_NONE,
TYPE_DEFAULT, portId,
std::string(AMEDIAMETRICS_KEY_PREFIX_AUDIO_MMAP) + std::to_string(portId)),
- mPid(VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(identity.pid))),
+ mPid(VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(attributionSource.pid))),
mSilenced(false), mSilencedNotified(false)
{
// Once this item is logged by the server, the client can add properties.
diff --git a/services/audiopolicy/AudioPolicyInterface.h b/services/audiopolicy/AudioPolicyInterface.h
index a904321..2e49e71 100644
--- a/services/audiopolicy/AudioPolicyInterface.h
+++ b/services/audiopolicy/AudioPolicyInterface.h
@@ -22,11 +22,13 @@
#include <media/AudioSystem.h>
#include <media/AudioPolicy.h>
#include <media/DeviceDescriptorBase.h>
-#include <android/media/permission/Identity.h>
+#include <android/content/AttributionSourceState.h>
#include <utils/String8.h>
namespace android {
+using content::AttributionSourceState;
+
// ----------------------------------------------------------------------------
// The AudioPolicyInterface and AudioPolicyClientInterface classes define the communication interfaces
@@ -124,7 +126,7 @@
audio_io_handle_t *output,
audio_session_t session,
audio_stream_type_t *stream,
- const media::permission::Identity& identity,
+ const AttributionSourceState& attributionSouce,
const audio_config_t *config,
audio_output_flags_t *flags,
audio_port_handle_t *selectedDeviceId,
@@ -143,7 +145,7 @@
audio_io_handle_t *input,
audio_unique_id_t riid,
audio_session_t session,
- const media::permission::Identity& identity,
+ const AttributionSourceState& attributionSouce,
const audio_config_base_t *config,
audio_input_flags_t flags,
audio_port_handle_t *selectedDeviceId,
diff --git a/services/audiopolicy/fuzzer/Android.bp b/services/audiopolicy/fuzzer/Android.bp
index 38bdedc..faf15d6 100644
--- a/services/audiopolicy/fuzzer/Android.bp
+++ b/services/audiopolicy/fuzzer/Android.bp
@@ -50,7 +50,7 @@
"libbinder",
"libaudiopolicy",
"libaudiopolicymanagerdefault",
- "media_permission-aidl-cpp",
+ "framework-permission-aidl-cpp",
],
static_libs: [
"android.hardware.audio.common@7.0-enums",
diff --git a/services/audiopolicy/fuzzer/audiopolicy_fuzzer.cpp b/services/audiopolicy/fuzzer/audiopolicy_fuzzer.cpp
index 1177b95..7000cd9 100644
--- a/services/audiopolicy/fuzzer/audiopolicy_fuzzer.cpp
+++ b/services/audiopolicy/fuzzer/audiopolicy_fuzzer.cpp
@@ -26,7 +26,7 @@
#include <Serializer.h>
#include <android-base/file.h>
-#include <android/media/permission/Identity.h>
+#include <android/content/AttributionSourceState.h>
#include <libxml/parser.h>
#include <libxml/xinclude.h>
#include <media/AudioPolicy.h>
@@ -47,7 +47,7 @@
using namespace ::android::audio::policy::configuration::V7_0;
}
-using media::permission::Identity;
+using content::AttributionSourceState;
static const std::vector<audio_format_t> kAudioFormats = [] {
std::vector<audio_format_t> result;
@@ -249,11 +249,12 @@
*portId = AUDIO_PORT_HANDLE_NONE;
AudioPolicyInterface::output_type_t outputType;
- // TODO b/182392769: use identity util
- Identity i;
- i.uid = 0;
- if (mManager->getOutputForAttr(&attr, output, AUDIO_SESSION_NONE, &stream, i, &config,
- &flags, selectedDeviceId, portId, {}, &outputType) != OK) {
+ // TODO b/182392769: use attribution source util
+ AttributionSourceState attributionSource;
+ attributionSource.uid = 0;
+ attributionSource.token = sp<BBinder>::make();
+ if (mManager->getOutputForAttr(&attr, output, AUDIO_SESSION_NONE, &stream, attributionSource,
+ &config, &flags, selectedDeviceId, portId, {}, &outputType) != OK) {
return false;
}
if (*output == AUDIO_IO_HANDLE_NONE || *portId == AUDIO_PORT_HANDLE_NONE) {
@@ -276,10 +277,11 @@
*portId = AUDIO_PORT_HANDLE_NONE;
AudioPolicyInterface::input_type_t inputType;
- Identity i;
- i.uid = 0;
- if (mManager->getInputForAttr(&attr, &input, riid, AUDIO_SESSION_NONE, i, &config,
- flags, selectedDeviceId, &inputType, portId) != OK) {
+ AttributionSourceState attributionSource;
+ attributionSource.uid = 0;
+ attributionSource.token = sp<BBinder>::make();
+ if (mManager->getInputForAttr(&attr, &input, riid, AUDIO_SESSION_NONE, attributionSource,
+ &config, flags, selectedDeviceId, &inputType, portId) != OK) {
return false;
}
if (*portId == AUDIO_PORT_HANDLE_NONE || input == AUDIO_IO_HANDLE_NONE) {
diff --git a/services/audiopolicy/managerdefault/Android.bp b/services/audiopolicy/managerdefault/Android.bp
index b111db4..0165dc8 100644
--- a/services/audiopolicy/managerdefault/Android.bp
+++ b/services/audiopolicy/managerdefault/Android.bp
@@ -34,7 +34,7 @@
// a dependency on it in the device makefile. There will be no build time
// conflict with libaudiopolicyenginedefault.
"libaudiopolicyenginedefault",
- "media_permission-aidl-cpp",
+ "framework-permission-aidl-cpp",
"libaudioclient_aidl_conversion",
],
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
index c8ddbc6..2e866ff 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
@@ -53,7 +53,7 @@
namespace android {
-using media::permission::Identity;
+using content::AttributionSourceState;
//FIXME: workaround for truncated touch sounds
// to be removed when the problem is handled by system UI
@@ -1133,7 +1133,7 @@
audio_io_handle_t *output,
audio_session_t session,
audio_stream_type_t *stream,
- const Identity& identity,
+ const AttributionSourceState& attributionSource,
const audio_config_t *config,
audio_output_flags_t *flags,
audio_port_handle_t *selectedDeviceId,
@@ -1146,7 +1146,7 @@
return INVALID_OPERATION;
}
const uid_t uid = VALUE_OR_RETURN_STATUS(
- aidl2legacy_int32_t_uid_t(identity.uid));
+ aidl2legacy_int32_t_uid_t(attributionSource.uid));
const audio_port_handle_t requestedPortId = *selectedDeviceId;
audio_attributes_t resultAttr;
bool isRequestedDeviceForExclusiveUse = false;
@@ -2115,7 +2115,7 @@
audio_io_handle_t *input,
audio_unique_id_t riid,
audio_session_t session,
- const Identity& identity,
+ const AttributionSourceState& attributionSource,
const audio_config_base_t *config,
audio_input_flags_t flags,
audio_port_handle_t *selectedDeviceId,
@@ -2134,7 +2134,7 @@
sp<AudioInputDescriptor> inputDesc;
sp<RecordClientDescriptor> clientDesc;
audio_port_handle_t requestedDeviceId = *selectedDeviceId;
- uid_t uid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_uid_t(identity.uid));
+ uid_t uid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_uid_t(attributionSource.uid));
bool isSoundTrigger;
// The supplied portId must be AUDIO_PORT_HANDLE_NONE
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.h b/services/audiopolicy/managerdefault/AudioPolicyManager.h
index f5dd20c..98f96d1 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.h
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.h
@@ -52,6 +52,8 @@
namespace android {
+using content::AttributionSourceState;
+
// ----------------------------------------------------------------------------
// Attenuation applied to STRATEGY_SONIFICATION streams when a headset is connected: 6dB
@@ -116,7 +118,7 @@
audio_io_handle_t *output,
audio_session_t session,
audio_stream_type_t *stream,
- const media::permission::Identity& identity,
+ const AttributionSourceState& attributionSource,
const audio_config_t *config,
audio_output_flags_t *flags,
audio_port_handle_t *selectedDeviceId,
@@ -130,7 +132,7 @@
audio_io_handle_t *input,
audio_unique_id_t riid,
audio_session_t session,
- const media::permission::Identity& identity,
+ const AttributionSourceState& attributionSource,
const audio_config_base_t *config,
audio_input_flags_t flags,
audio_port_handle_t *selectedDeviceId,
diff --git a/services/audiopolicy/service/Android.bp b/services/audiopolicy/service/Android.bp
index 14be671..0273d29 100644
--- a/services/audiopolicy/service/Android.bp
+++ b/services/audiopolicy/service/Android.bp
@@ -45,12 +45,12 @@
"audiopolicy-aidl-cpp",
"audiopolicy-types-aidl-cpp",
"capture_state_listener-aidl-cpp",
- "media_permission-aidl-cpp",
+ "framework-permission-aidl-cpp",
],
static_libs: [
"libaudiopolicycomponents",
- "media_permission-aidl-cpp",
+ "framework-permission-aidl-cpp",
],
header_libs: [
@@ -70,6 +70,6 @@
export_shared_lib_headers: [
"libactivitymanager_aidl",
"libsensorprivacy",
- "media_permission-aidl-cpp",
+ "framework-permission-aidl-cpp",
],
}
diff --git a/services/audiopolicy/service/AudioPolicyEffects.cpp b/services/audiopolicy/service/AudioPolicyEffects.cpp
index 8426a77..3f01de9 100644
--- a/services/audiopolicy/service/AudioPolicyEffects.cpp
+++ b/services/audiopolicy/service/AudioPolicyEffects.cpp
@@ -35,7 +35,7 @@
namespace android {
-using media::permission::Identity;
+using content::AttributionSourceState;
// ----------------------------------------------------------------------------
// AudioPolicyEffects Implementation
@@ -123,9 +123,10 @@
Vector <EffectDesc *> effects = mInputSources.valueAt(index)->mEffects;
for (size_t i = 0; i < effects.size(); i++) {
EffectDesc *effect = effects[i];
- Identity identity;
- identity.packageName = "android";
- sp<AudioEffect> fx = new AudioEffect(identity);
+ AttributionSourceState attributionSource;
+ attributionSource.packageName = "android";
+ attributionSource.token = sp<BBinder>::make();
+ sp<AudioEffect> fx = new AudioEffect(attributionSource);
fx->set(NULL, &effect->mUuid, -1, 0, 0, audioSession, input);
status_t status = fx->initCheck();
if (status != NO_ERROR && status != ALREADY_EXISTS) {
@@ -274,9 +275,10 @@
Vector <EffectDesc *> effects = mOutputStreams.valueAt(index)->mEffects;
for (size_t i = 0; i < effects.size(); i++) {
EffectDesc *effect = effects[i];
- Identity identity;
- identity.packageName = "android";
- sp<AudioEffect> fx = new AudioEffect(identity);
+ AttributionSourceState attributionSource;
+ attributionSource.packageName = "android";
+ attributionSource.token = sp<BBinder>::make();
+ sp<AudioEffect> fx = new AudioEffect(attributionSource);
fx->set(NULL, &effect->mUuid, 0, 0, 0, audioSession, output);
status_t status = fx->initCheck();
if (status != NO_ERROR && status != ALREADY_EXISTS) {
@@ -976,9 +978,10 @@
for (const auto& deviceEffectsIter : mDeviceEffects) {
const auto& deviceEffects = deviceEffectsIter.second;
for (const auto& effectDesc : deviceEffects->mEffectDescriptors->mEffects) {
- Identity identity;
- identity.packageName = "android";
- sp<AudioEffect> fx = new AudioEffect(identity);
+ AttributionSourceState attributionSource;
+ attributionSource.packageName = "android";
+ attributionSource.token = sp<BBinder>::make();
+ sp<AudioEffect> fx = new AudioEffect(attributionSource);
fx->set(EFFECT_UUID_NULL, &effectDesc->mUuid, 0, nullptr,
nullptr, AUDIO_SESSION_DEVICE, AUDIO_IO_HANDLE_NONE,
AudioDeviceTypeAddr{deviceEffects->getDeviceType(),
diff --git a/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp b/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
index b9c715e..3298f6b 100644
--- a/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
+++ b/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
@@ -25,7 +25,7 @@
#include <media/MediaMetricsItem.h>
#include <media/PolicyAidlConversion.h>
#include <utils/Log.h>
-#include <android/media/permission/Identity.h>
+#include <android/content/AttributionSourceState.h>
#define VALUE_OR_RETURN_BINDER_STATUS(x) \
({ auto _tmp = (x); \
@@ -43,7 +43,7 @@
namespace android {
using binder::Status;
using aidl_utils::binderStatusFromStatusT;
-using media::permission::Identity;
+using content::AttributionSourceState;
const std::vector<audio_usage_t>& SYSTEM_USAGES = {
AUDIO_USAGE_CALL_ASSISTANT,
@@ -64,15 +64,16 @@
}
status_t AudioPolicyService::validateUsage(audio_usage_t usage) {
- return validateUsage(usage, getCallingIdentity());
+ return validateUsage(usage, getCallingAttributionSource());
}
-status_t AudioPolicyService::validateUsage(audio_usage_t usage, const Identity& identity) {
+status_t AudioPolicyService::validateUsage(audio_usage_t usage,
+ const AttributionSourceState& attributionSource) {
if (isSystemUsage(usage)) {
if (isSupportedSystemUsage(usage)) {
- if (!modifyAudioRoutingAllowed(identity)) {
+ if (!modifyAudioRoutingAllowed(attributionSource)) {
ALOGE(("permission denied: modify audio routing not allowed "
- "for identity %s"), identity.toString().c_str());
+ "for attributionSource %s"), attributionSource.toString().c_str());
return PERMISSION_DENIED;
}
} else {
@@ -279,7 +280,7 @@
Status AudioPolicyService::getOutputForAttr(const media::AudioAttributesInternal& attrAidl,
int32_t sessionAidl,
- const Identity& identity,
+ const AttributionSourceState& attributionSource,
const media::AudioConfig& configAidl,
int32_t flagsAidl,
int32_t selectedDeviceIdAidl,
@@ -307,28 +308,28 @@
RETURN_IF_BINDER_ERROR(
binderStatusFromStatusT(AudioValidator::validateAudioAttributes(attr, "68953950")));
- RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attr.usage, identity)));
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attr.usage, attributionSource)));
ALOGV("%s()", __func__);
Mutex::Autolock _l(mLock);
// TODO b/182392553: refactor or remove
- Identity adjIdentity = identity;
+ AttributionSourceState adjAttributionSource = attributionSource;
const uid_t callingUid = IPCThreadState::self()->getCallingUid();
- if (!isAudioServerOrMediaServerUid(callingUid) || identity.uid == -1) {
+ if (!isAudioServerOrMediaServerUid(callingUid) || attributionSource.uid == -1) {
int32_t callingUidAidl = VALUE_OR_RETURN_BINDER_STATUS(
legacy2aidl_uid_t_int32_t(callingUid));
- ALOGW_IF(identity.uid != -1 && identity.uid != callingUidAidl,
+ ALOGW_IF(attributionSource.uid != -1 && attributionSource.uid != callingUidAidl,
"%s uid %d tried to pass itself off as %d", __func__,
- callingUidAidl, identity.uid);
- adjIdentity.uid = callingUidAidl;
+ callingUidAidl, attributionSource.uid);
+ adjAttributionSource.uid = callingUidAidl;
}
if (!mPackageManager.allowPlaybackCapture(VALUE_OR_RETURN_BINDER_STATUS(
- aidl2legacy_int32_t_uid_t(adjIdentity.uid)))) {
+ aidl2legacy_int32_t_uid_t(adjAttributionSource.uid)))) {
attr.flags = static_cast<audio_flags_mask_t>(attr.flags | AUDIO_FLAG_NO_MEDIA_PROJECTION);
}
if (((attr.flags & (AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE)) != 0)
- && !bypassInterruptionPolicyAllowed(identity)) {
+ && !bypassInterruptionPolicyAllowed(adjAttributionSource)) {
attr.flags = static_cast<audio_flags_mask_t>(
attr.flags & ~(AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE));
}
@@ -336,7 +337,7 @@
AudioPolicyInterface::output_type_t outputType;
status_t result = mAudioPolicyManager->getOutputForAttr(&attr, &output, session,
&stream,
- adjIdentity,
+ adjAttributionSource,
&config,
&flags, &selectedDeviceId, &portId,
&secondaryOutputs,
@@ -349,16 +350,16 @@
case AudioPolicyInterface::API_OUTPUT_LEGACY:
break;
case AudioPolicyInterface::API_OUTPUT_TELEPHONY_TX:
- if (!modifyPhoneStateAllowed(adjIdentity)) {
+ if (!modifyPhoneStateAllowed(adjAttributionSource)) {
ALOGE("%s() permission denied: modify phone state not allowed for uid %d",
- __func__, adjIdentity.uid);
+ __func__, adjAttributionSource.uid);
result = PERMISSION_DENIED;
}
break;
case AudioPolicyInterface::API_OUT_MIX_PLAYBACK:
- if (!modifyAudioRoutingAllowed(adjIdentity)) {
+ if (!modifyAudioRoutingAllowed(adjAttributionSource)) {
ALOGE("%s() permission denied: modify audio routing not allowed for uid %d",
- __func__, adjIdentity.uid);
+ __func__, adjAttributionSource.uid);
result = PERMISSION_DENIED;
}
break;
@@ -371,7 +372,7 @@
if (result == NO_ERROR) {
sp<AudioPlaybackClient> client =
- new AudioPlaybackClient(attr, output, adjIdentity, session,
+ new AudioPlaybackClient(attr, output, adjAttributionSource, session,
portId, selectedDeviceId, stream);
mAudioPlaybackClients.add(portId, client);
@@ -508,7 +509,7 @@
int32_t inputAidl,
int32_t riidAidl,
int32_t sessionAidl,
- const Identity& identity,
+ const AttributionSourceState& attributionSource,
const media::AudioConfigBase& configAidl,
int32_t flagsAidl,
int32_t selectedDeviceIdAidl,
@@ -551,42 +552,46 @@
return binderStatusFromStatusT(BAD_VALUE);
}
- // Make sure identity represents the current caller
- Identity adjIdentity = identity;
+ // Make sure attribution source represents the current caller
+ AttributionSourceState adjAttributionSource = attributionSource;
// TODO b/182392553: refactor or remove
- bool updatePid = (identity.pid == -1);
+ bool updatePid = (attributionSource.pid == -1);
const uid_t callingUid =IPCThreadState::self()->getCallingUid();
- const uid_t currentUid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(identity.uid));
+ const uid_t currentUid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(
+ attributionSource.uid));
if (!isAudioServerOrMediaServerUid(callingUid)) {
ALOGW_IF(currentUid != (uid_t)-1 && currentUid != callingUid,
"%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid,
currentUid);
- adjIdentity.uid = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
+ adjAttributionSource.uid = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_uid_t_int32_t(
+ callingUid));
updatePid = true;
}
if (updatePid) {
const int32_t callingPid = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_pid_t_int32_t(
IPCThreadState::self()->getCallingPid()));
- ALOGW_IF(identity.pid != -1 && identity.pid != callingPid,
+ ALOGW_IF(attributionSource.pid != -1 && attributionSource.pid != callingPid,
"%s uid %d pid %d tried to pass itself off as pid %d",
- __func__, adjIdentity.uid, callingPid, identity.pid);
- adjIdentity.pid = callingPid;
+ __func__, adjAttributionSource.uid, callingPid, attributionSource.pid);
+ adjAttributionSource.pid = callingPid;
}
- RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attr.usage, adjIdentity)));
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attr.usage,
+ adjAttributionSource)));
// check calling permissions.
// Capturing from FM_TUNER source is controlled by captureTunerAudioInputAllowed() and
// captureAudioOutputAllowed() (deprecated) as this does not affect users privacy
// as does capturing from an actual microphone.
- if (!(recordingAllowed(adjIdentity, attr.source) || attr.source == AUDIO_SOURCE_FM_TUNER)) {
+ if (!(recordingAllowed(adjAttributionSource, attr.source)
+ || attr.source == AUDIO_SOURCE_FM_TUNER)) {
ALOGE("%s permission denied: recording not allowed for %s",
- __func__, adjIdentity.toString().c_str());
+ __func__, adjAttributionSource.toString().c_str());
return binderStatusFromStatusT(PERMISSION_DENIED);
}
- bool canCaptureOutput = captureAudioOutputAllowed(adjIdentity);
+ bool canCaptureOutput = captureAudioOutputAllowed(adjAttributionSource);
if ((inputSource == AUDIO_SOURCE_VOICE_UPLINK ||
inputSource == AUDIO_SOURCE_VOICE_DOWNLINK ||
inputSource == AUDIO_SOURCE_VOICE_CALL ||
@@ -596,12 +601,12 @@
}
if (inputSource == AUDIO_SOURCE_FM_TUNER
- && !captureTunerAudioInputAllowed(adjIdentity)
+ && !captureTunerAudioInputAllowed(adjAttributionSource)
&& !canCaptureOutput) {
return binderStatusFromStatusT(PERMISSION_DENIED);
}
- bool canCaptureHotword = captureHotwordAllowed(adjIdentity);
+ bool canCaptureHotword = captureHotwordAllowed(adjAttributionSource);
if ((inputSource == AUDIO_SOURCE_HOTWORD) && !canCaptureHotword) {
return binderStatusFromStatusT(PERMISSION_DENIED);
}
@@ -609,7 +614,7 @@
if (((flags & AUDIO_INPUT_FLAG_HW_HOTWORD) != 0)
&& !canCaptureHotword) {
ALOGE("%s: permission denied: hotword mode not allowed"
- " for uid %d pid %d", __func__, adjIdentity.uid, adjIdentity.pid);
+ " for uid %d pid %d", __func__, adjAttributionSource.uid, adjAttributionSource.pid);
return binderStatusFromStatusT(PERMISSION_DENIED);
}
@@ -623,7 +628,7 @@
AutoCallerClear acc;
// the audio_in_acoustics_t parameter is ignored by get_input()
status = mAudioPolicyManager->getInputForAttr(&attr, &input, riid, session,
- adjIdentity, &config,
+ adjAttributionSource, &config,
flags, &selectedDeviceId,
&inputType, &portId);
@@ -647,7 +652,7 @@
}
break;
case AudioPolicyInterface::API_INPUT_MIX_EXT_POLICY_REROUTE:
- if (!modifyAudioRoutingAllowed(adjIdentity)) {
+ if (!modifyAudioRoutingAllowed(adjAttributionSource)) {
ALOGE("getInputForAttr() permission denied: modify audio routing not allowed");
status = PERMISSION_DENIED;
}
@@ -668,7 +673,7 @@
}
sp<AudioRecordClient> client = new AudioRecordClient(attr, input, session, portId,
- selectedDeviceId, adjIdentity,
+ selectedDeviceId, adjAttributionSource,
canCaptureOutput, canCaptureHotword);
mAudioRecordClients.add(portId, client);
}
@@ -723,11 +728,11 @@
msg << "Audio recording on session " << client->session;
// check calling permissions
- if (!(startRecording(client->identity, String16(msg.str().c_str()),
+ if (!(startRecording(client->attributionSource, String16(msg.str().c_str()),
client->attributes.source)
|| client->attributes.source == AUDIO_SOURCE_FM_TUNER)) {
- ALOGE("%s permission denied: recording not allowed for identity %s",
- __func__, client->identity.toString().c_str());
+ ALOGE("%s permission denied: recording not allowed for attribution source %s",
+ __func__, client->attributionSource.toString().c_str());
return binderStatusFromStatusT(PERMISSION_DENIED);
}
@@ -771,13 +776,13 @@
item->setCString(kAudioPolicyRqstSrc,
toString(client->attributes.source).c_str());
item->setInt32(kAudioPolicyRqstSession, client->session);
- if (client->identity.packageName.has_value() &&
- client->identity.packageName.value().size() != 0) {
+ if (client->attributionSource.packageName.has_value() &&
+ client->attributionSource.packageName.value().size() != 0) {
item->setCString(kAudioPolicyRqstPkg,
- client->identity.packageName.value().c_str());
+ client->attributionSource.packageName.value().c_str());
} else {
item->setCString(kAudioPolicyRqstPkg,
- std::to_string(client->identity.uid).c_str());
+ std::to_string(client->attributionSource.uid).c_str());
}
item->setCString(
kAudioPolicyRqstDevice, getDeviceTypeStrForPortId(client->deviceId).c_str());
@@ -793,13 +798,13 @@
item->setCString(kAudioPolicyActiveSrc,
toString(other->attributes.source).c_str());
item->setInt32(kAudioPolicyActiveSession, other->session);
- if (other->identity.packageName.has_value() &&
- other->identity.packageName.value().size() != 0) {
+ if (other->attributionSource.packageName.has_value() &&
+ other->attributionSource.packageName.value().size() != 0) {
item->setCString(kAudioPolicyActivePkg,
- other->identity.packageName.value().c_str());
+ other->attributionSource.packageName.value().c_str());
} else {
item->setCString(kAudioPolicyRqstPkg, std::to_string(
- other->identity.uid).c_str());
+ other->attributionSource.uid).c_str());
}
item->setCString(kAudioPolicyActiveDevice,
getDeviceTypeStrForPortId(other->deviceId).c_str());
@@ -815,7 +820,7 @@
client->active = false;
client->startTimeNs = 0;
updateUidStates_l();
- finishRecording(client->identity, client->attributes.source);
+ finishRecording(client->attributionSource, client->attributes.source);
}
return binderStatusFromStatusT(status);
@@ -844,7 +849,7 @@
updateUidStates_l();
// finish the recording app op
- finishRecording(client->identity, client->attributes.source);
+ finishRecording(client->attributionSource, client->attributes.source);
AutoCallerClear acc;
return binderStatusFromStatusT(mAudioPolicyManager->stopInput(portId));
}
@@ -1641,15 +1646,15 @@
bool needCaptureMediaOutput = std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
return mix.mAllowPrivilegedMediaPlaybackCapture; });
- const Identity identity = getCallingIdentity();
+ const AttributionSourceState attributionSource = getCallingAttributionSource();
- if (needCaptureMediaOutput && !captureMediaOutputAllowed(identity)) {
+ if (needCaptureMediaOutput && !captureMediaOutputAllowed(attributionSource)) {
return binderStatusFromStatusT(PERMISSION_DENIED);
}
if (needCaptureVoiceCommunicationOutput &&
- !captureVoiceCommunicationOutputAllowed(identity)) {
+ !captureVoiceCommunicationOutputAllowed(attributionSource)) {
return binderStatusFromStatusT(PERMISSION_DENIED);
}
diff --git a/services/audiopolicy/service/AudioPolicyService.cpp b/services/audiopolicy/service/AudioPolicyService.cpp
index fb38e3d..cd50e21 100644
--- a/services/audiopolicy/service/AudioPolicyService.cpp
+++ b/services/audiopolicy/service/AudioPolicyService.cpp
@@ -594,7 +594,8 @@
for (size_t i =0; i < mAudioRecordClients.size(); i++) {
sp<AudioRecordClient> current = mAudioRecordClients[i];
- uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(current->identity.uid));
+ uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
+ current->attributionSource.uid));
if (!current->active) {
continue;
}
@@ -641,7 +642,7 @@
|| (isInCommunication && currentUid == mPhoneStateOwnerUid)) {
if (!isInCommunication || latestSensitiveActiveOrComm == nullptr
|| VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
- latestSensitiveActiveOrComm->identity.uid))
+ latestSensitiveActiveOrComm->attributionSource.uid))
!= mPhoneStateOwnerUid) {
latestSensitiveActiveOrComm = current;
latestSensitiveStartNs = current->startTimeNs;
@@ -676,7 +677,7 @@
// if audio mode is IN_COMMUNICATION, favor audio mode owner over an app with
// foreground UI in case both are capturing with privacy sensitive flag.
uid_t latestActiveUid = VALUE_OR_FATAL(
- aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->identity.uid));
+ aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->attributionSource.uid));
if (isInCommunication && latestActiveUid == mPhoneStateOwnerUid) {
topSensitiveActive = latestSensitiveActiveOrComm;
topSensitiveStartNs = latestSensitiveStartNs;
@@ -696,20 +697,20 @@
for (size_t i =0; i < mAudioRecordClients.size(); i++) {
sp<AudioRecordClient> current = mAudioRecordClients[i];
uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
- current->identity.uid));
+ current->attributionSource.uid));
if (!current->active) {
continue;
}
audio_source_t source = current->attributes.source;
bool isTopOrLatestActive = topActive == nullptr ? false :
- current->identity.uid == topActive->identity.uid;
+ current->attributionSource.uid == topActive->attributionSource.uid;
bool isTopOrLatestSensitive = topSensitiveActive == nullptr ? false :
- current->identity.uid == topSensitiveActive->identity.uid;
+ current->attributionSource.uid == topSensitiveActive->attributionSource.uid;
auto canCaptureIfInCallOrCommunication = [&](const auto &recordClient) REQUIRES(mLock) {
uid_t recordUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
- recordClient->identity.uid));
+ recordClient->attributionSource.uid));
bool canCaptureCall = recordClient->canCaptureOutput;
bool canCaptureCommunication = recordClient->canCaptureOutput
|| !isPhoneStateOwnerActive
diff --git a/services/audiopolicy/service/AudioPolicyService.h b/services/audiopolicy/service/AudioPolicyService.h
index 6eb33f6..48da40c 100644
--- a/services/audiopolicy/service/AudioPolicyService.h
+++ b/services/audiopolicy/service/AudioPolicyService.h
@@ -1,3 +1,4 @@
+
/*
* Copyright (C) 2009 The Android Open Source Project
*
@@ -38,12 +39,14 @@
#include "CaptureStateNotifier.h"
#include <AudioPolicyInterface.h>
#include <android/hardware/BnSensorPrivacyListener.h>
-#include <android/media/permission/Identity.h>
+#include <android/content/AttributionSourceState.h>
#include <unordered_map>
namespace android {
+using content::AttributionSourceState;
+
// ----------------------------------------------------------------------------
class AudioPolicyService :
@@ -81,7 +84,7 @@
media::AudioPolicyForcedConfig* _aidl_return) override;
binder::Status getOutput(media::AudioStreamType stream, int32_t* _aidl_return) override;
binder::Status getOutputForAttr(const media::AudioAttributesInternal& attr, int32_t session,
- const media::permission::Identity &identity,
+ const AttributionSourceState &attributionSource,
const media::AudioConfig& config,
int32_t flags, int32_t selectedDeviceId,
media::GetOutputForAttrResponse* _aidl_return) override;
@@ -90,7 +93,7 @@
binder::Status releaseOutput(int32_t portId) override;
binder::Status getInputForAttr(const media::AudioAttributesInternal& attr, int32_t input,
int32_t riid, int32_t session,
- const media::permission::Identity &identity,
+ const AttributionSourceState &attributionSource,
const media::AudioConfigBase& config, int32_t flags,
int32_t selectedDeviceId,
media::GetInputForAttrResponse* _aidl_return) override;
@@ -344,7 +347,7 @@
bool isSupportedSystemUsage(audio_usage_t usage);
status_t validateUsage(audio_usage_t usage);
- status_t validateUsage(audio_usage_t usage, const media::permission::Identity& identity);
+ status_t validateUsage(audio_usage_t usage, const AttributionSourceState& attributionSource);
void updateUidStates();
void updateUidStates_l() REQUIRES(mLock);
@@ -791,17 +794,18 @@
public:
AudioClient(const audio_attributes_t attributes,
const audio_io_handle_t io,
- const media::permission::Identity& identity,
+ const AttributionSourceState& attributionSource,
const audio_session_t session, audio_port_handle_t portId,
const audio_port_handle_t deviceId) :
- attributes(attributes), io(io), identity(identity),
- session(session), portId(portId), deviceId(deviceId), active(false) {}
+ attributes(attributes), io(io), attributionSource(
+ attributionSource), session(session), portId(portId),
+ deviceId(deviceId), active(false) {}
~AudioClient() override = default;
const audio_attributes_t attributes; // source, flags ...
const audio_io_handle_t io; // audio HAL stream IO handle
- const media::permission::Identity& identity; //client identity
+ const AttributionSourceState& attributionSource; //client attributionsource
const audio_session_t session; // audio session ID
const audio_port_handle_t portId;
const audio_port_handle_t deviceId; // selected input device port ID
@@ -817,14 +821,15 @@
const audio_io_handle_t io,
const audio_session_t session, audio_port_handle_t portId,
const audio_port_handle_t deviceId,
- const media::permission::Identity& identity,
+ const AttributionSourceState& attributionSource,
bool canCaptureOutput, bool canCaptureHotword) :
- AudioClient(attributes, io, identity,
- session, portId, deviceId), identity(identity), startTimeNs(0),
- canCaptureOutput(canCaptureOutput), canCaptureHotword(canCaptureHotword) {}
+ AudioClient(attributes, io, attributionSource,
+ session, portId, deviceId), attributionSource(attributionSource),
+ startTimeNs(0), canCaptureOutput(canCaptureOutput),
+ canCaptureHotword(canCaptureHotword) {}
~AudioRecordClient() override = default;
- const media::permission::Identity identity; // identity of client
+ const AttributionSourceState attributionSource; // attribution source of client
nsecs_t startTimeNs;
const bool canCaptureOutput;
const bool canCaptureHotword;
@@ -836,10 +841,10 @@
class AudioPlaybackClient : public AudioClient {
public:
AudioPlaybackClient(const audio_attributes_t attributes,
- const audio_io_handle_t io, media::permission::Identity identity,
+ const audio_io_handle_t io, AttributionSourceState attributionSource,
const audio_session_t session, audio_port_handle_t portId,
audio_port_handle_t deviceId, audio_stream_type_t stream) :
- AudioClient(attributes, io, identity, session, portId,
+ AudioClient(attributes, io, attributionSource, session, portId,
deviceId), stream(stream) {}
~AudioPlaybackClient() override = default;
diff --git a/services/audiopolicy/tests/Android.bp b/services/audiopolicy/tests/Android.bp
index f480210..b296fb0 100644
--- a/services/audiopolicy/tests/Android.bp
+++ b/services/audiopolicy/tests/Android.bp
@@ -25,7 +25,8 @@
"libmedia_helper",
"libutils",
"libxml2",
- "media_permission-aidl-cpp",
+ "libpermission",
+ "libbinder",
],
static_libs: [
diff --git a/services/audiopolicy/tests/audiopolicymanager_tests.cpp b/services/audiopolicy/tests/audiopolicymanager_tests.cpp
index 8f12ecf..a16ab7d 100644
--- a/services/audiopolicy/tests/audiopolicymanager_tests.cpp
+++ b/services/audiopolicy/tests/audiopolicymanager_tests.cpp
@@ -25,7 +25,7 @@
#define LOG_TAG "APM_Test"
#include <Serializer.h>
#include <android-base/file.h>
-#include <android/media/permission/Identity.h>
+#include <android/content/AttributionSourceState.h>
#include <media/AudioPolicy.h>
#include <media/PatchBuilder.h>
#include <media/RecordingActivityTracker.h>
@@ -40,7 +40,7 @@
using namespace android;
using testing::UnorderedElementsAre;
-using media::permission::Identity;
+using android::content::AttributionSourceState;
TEST(AudioPolicyManagerTestInit, EngineFailure) {
AudioPolicyTestClient client;
@@ -216,11 +216,12 @@
if (!portId) portId = &localPortId;
*portId = AUDIO_PORT_HANDLE_NONE;
AudioPolicyInterface::output_type_t outputType;
- // TODO b/182392769: use identity util
- Identity i = Identity();
- i.uid = 0;
+ // TODO b/182392769: use attribution source util
+ AttributionSourceState attributionSource = AttributionSourceState();
+ attributionSource.uid = 0;
+ attributionSource.token = sp<BBinder>::make();
ASSERT_EQ(OK, mManager->getOutputForAttr(
- &attr, output, AUDIO_SESSION_NONE, &stream, i, &config, &flags,
+ &attr, output, AUDIO_SESSION_NONE, &stream, attributionSource, &config, &flags,
selectedDeviceId, portId, {}, &outputType));
ASSERT_NE(AUDIO_PORT_HANDLE_NONE, *portId);
ASSERT_NE(AUDIO_IO_HANDLE_NONE, *output);
@@ -244,11 +245,12 @@
if (!portId) portId = &localPortId;
*portId = AUDIO_PORT_HANDLE_NONE;
AudioPolicyInterface::input_type_t inputType;
- // TODO b/182392769: use identity util
- Identity i = Identity();
- i.uid = 0;
+ // TODO b/182392769: use attribution source util
+ AttributionSourceState attributionSource = AttributionSourceState();
+ attributionSource.uid = 0;
+ attributionSource.token = sp<BBinder>::make();
ASSERT_EQ(OK, mManager->getInputForAttr(
- &attr, &input, riid, AUDIO_SESSION_NONE, i, &config, flags,
+ &attr, &input, riid, AUDIO_SESSION_NONE, attributionSource, &config, flags,
selectedDeviceId, &inputType, portId));
ASSERT_NE(AUDIO_PORT_HANDLE_NONE, *portId);
}
diff --git a/services/oboeservice/AAudioEndpointManager.cpp b/services/oboeservice/AAudioEndpointManager.cpp
index 3224cfc..20e4cc5 100644
--- a/services/oboeservice/AAudioEndpointManager.cpp
+++ b/services/oboeservice/AAudioEndpointManager.cpp
@@ -184,7 +184,7 @@
// An app can avoid having this happen by closing their streams when
// the app is paused.
pid_t pid = VALUE_OR_FATAL(
- aidl2legacy_int32_t_pid_t(request.getIdentity().pid));
+ aidl2legacy_int32_t_pid_t(request.getAttributionSource().pid));
AAudioClientTracker::getInstance().setExclusiveEnabled(pid, false);
endpointToSteal = endpoint; // return it to caller
}
diff --git a/services/oboeservice/AAudioService.cpp b/services/oboeservice/AAudioService.cpp
index 0b69bf6..40a664e 100644
--- a/services/oboeservice/AAudioService.cpp
+++ b/services/oboeservice/AAudioService.cpp
@@ -22,7 +22,7 @@
#include <iostream>
#include <sstream>
-#include <android/media/permission/Identity.h>
+#include <android/content/AttributionSourceState.h>
#include <aaudio/AAudio.h>
#include <media/AidlConversion.h>
#include <mediautils/ServiceUtilities.h>
@@ -47,18 +47,18 @@
std::move(_tmp.value()); })
using android::AAudioService;
-using android::media::permission::Identity;
+using android::content::AttributionSourceState;
using binder::Status;
android::AAudioService::AAudioService()
: BnAAudioService(),
mAdapter(this) {
// TODO consider using geteuid()
- // TODO b/182392769: use identity util
- mAudioClient.identity.uid = VALUE_OR_FATAL(legacy2aidl_uid_t_int32_t(getuid()));
- mAudioClient.identity.pid = VALUE_OR_FATAL(legacy2aidl_pid_t_int32_t(getpid()));
- mAudioClient.identity.packageName = std::nullopt;
- mAudioClient.identity.attributionTag = std::nullopt;
+ // TODO b/182392769: use attribution source util
+ mAudioClient.attributionSource.uid = VALUE_OR_FATAL(legacy2aidl_uid_t_int32_t(getuid()));
+ mAudioClient.attributionSource.pid = VALUE_OR_FATAL(legacy2aidl_pid_t_int32_t(getpid()));
+ mAudioClient.attributionSource.packageName = std::nullopt;
+ mAudioClient.attributionSource.attributionTag = std::nullopt;
AAudioClientTracker::getInstance().setAAudioService(this);
}
@@ -115,13 +115,14 @@
aaudio_sharing_mode_t sharingMode = configurationInput.getSharingMode();
// Enforce limit on client processes.
- Identity callingIdentity = request.getIdentity();
+ AttributionSourceState attributionSource = request.getAttributionSource();
pid_t pid = IPCThreadState::self()->getCallingPid();
- callingIdentity.pid = VALUE_OR_RETURN_ILLEGAL_ARG_STATUS(
+ attributionSource.pid = VALUE_OR_RETURN_ILLEGAL_ARG_STATUS(
legacy2aidl_pid_t_int32_t(pid));
- callingIdentity.uid = VALUE_OR_RETURN_ILLEGAL_ARG_STATUS(
+ attributionSource.uid = VALUE_OR_RETURN_ILLEGAL_ARG_STATUS(
legacy2aidl_uid_t_int32_t(IPCThreadState::self()->getCallingUid()));
- if (callingIdentity.pid != mAudioClient.identity.pid) {
+ attributionSource.token = sp<BBinder>::make();
+ if (attributionSource.pid != mAudioClient.attributionSource.pid) {
int32_t count = AAudioClientTracker::getInstance().getStreamCount(pid);
if (count >= MAX_STREAMS_PER_PROCESS) {
ALOGE("openStream(): exceeded max streams per process %d >= %d",
@@ -280,8 +281,8 @@
}
bool AAudioService::isCallerInService() {
- pid_t clientPid = VALUE_OR_FATAL(aidl2legacy_int32_t_pid_t(mAudioClient.identity.pid));
- uid_t clientUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(mAudioClient.identity.uid));
+ pid_t clientPid = VALUE_OR_FATAL(aidl2legacy_int32_t_pid_t(mAudioClient.attributionSource.pid));
+ uid_t clientUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(mAudioClient.attributionSource.uid));
return clientPid == IPCThreadState::self()->getCallingPid() &&
clientUid == IPCThreadState::self()->getCallingUid();
}
@@ -307,7 +308,7 @@
const uid_t callingUserId = IPCThreadState::self()->getCallingUid();
const uid_t ownerUserId = serviceStream->getOwnerUserId();
const uid_t clientUid = VALUE_OR_FATAL(
- aidl2legacy_int32_t_uid_t(mAudioClient.identity.uid));
+ aidl2legacy_int32_t_uid_t(mAudioClient.attributionSource.uid));
bool callerOwnsIt = callingUserId == ownerUserId;
bool serverCalling = callingUserId == clientUid;
bool serverOwnsIt = ownerUserId == clientUid;
diff --git a/services/oboeservice/AAudioServiceEndpointMMAP.cpp b/services/oboeservice/AAudioServiceEndpointMMAP.cpp
index b4efd1a..117218a 100644
--- a/services/oboeservice/AAudioServiceEndpointMMAP.cpp
+++ b/services/oboeservice/AAudioServiceEndpointMMAP.cpp
@@ -71,11 +71,11 @@
aaudio_result_t AAudioServiceEndpointMMAP::open(const aaudio::AAudioStreamRequest &request) {
aaudio_result_t result = AAUDIO_OK;
copyFrom(request.getConstantConfiguration());
- mMmapClient.identity = request.getIdentity();
- // TODO b/182392769: use identity util
- mMmapClient.identity.uid = VALUE_OR_FATAL(
+ mMmapClient.attributionSource = request.getAttributionSource();
+ // TODO b/182392769: use attribution source util
+ mMmapClient.attributionSource.uid = VALUE_OR_FATAL(
legacy2aidl_uid_t_int32_t(IPCThreadState::self()->getCallingUid()));
- mMmapClient.identity.pid = VALUE_OR_FATAL(
+ mMmapClient.attributionSource.pid = VALUE_OR_FATAL(
legacy2aidl_pid_t_int32_t(IPCThreadState::self()->getCallingPid()));
audio_format_t audioFormat = getFormat();
@@ -165,8 +165,8 @@
this, // callback
mMmapStream,
&mPortHandle);
- ALOGD("%s() mMapClient.identity = %s => portHandle = %d\n",
- __func__, mMmapClient.identity.toString().c_str(), mPortHandle);
+ ALOGD("%s() mMapClient.attributionSource = %s => portHandle = %d\n",
+ __func__, mMmapClient.attributionSource.toString().c_str(), mPortHandle);
if (status != OK) {
// This can happen if the resource is busy or the config does
// not match the hardware.
@@ -216,7 +216,7 @@
// Exclusive mode can only be used by the service because the FD cannot be shared.
int32_t audioServiceUid =
VALUE_OR_FATAL(legacy2aidl_uid_t_int32_t(getuid()));
- if ((mMmapClient.identity.uid != audioServiceUid) &&
+ if ((mMmapClient.attributionSource.uid != audioServiceUid) &&
getSharingMode() == AAUDIO_SHARING_MODE_EXCLUSIVE) {
ALOGW("%s() - exclusive FD cannot be used by client", __func__);
result = AAUDIO_ERROR_UNAVAILABLE;
diff --git a/services/oboeservice/AAudioServiceStreamBase.cpp b/services/oboeservice/AAudioServiceStreamBase.cpp
index dbacd75..34ddd4d 100644
--- a/services/oboeservice/AAudioServiceStreamBase.cpp
+++ b/services/oboeservice/AAudioServiceStreamBase.cpp
@@ -39,7 +39,7 @@
using namespace android; // TODO just import names needed
using namespace aaudio; // TODO just import names needed
-using media::permission::Identity;
+using content::AttributionSourceState;
/**
* Base class for streams in the service.
@@ -50,7 +50,7 @@
: mTimestampThread("AATime")
, mAtomicStreamTimestamp()
, mAudioService(audioService) {
- mMmapClient.identity = Identity();
+ mMmapClient.attributionSource = AttributionSourceState();
}
AAudioServiceStreamBase::~AAudioServiceStreamBase() {
@@ -81,7 +81,7 @@
result << " 0x" << std::setfill('0') << std::setw(8) << std::hex << mHandle
<< std::dec << std::setfill(' ') ;
- result << std::setw(6) << mMmapClient.identity.uid;
+ result << std::setw(6) << mMmapClient.attributionSource.uid;
result << std::setw(7) << mClientHandle;
result << std::setw(4) << (isRunning() ? "yes" : " no");
result << std::setw(6) << getState();
@@ -127,11 +127,11 @@
AAudioEndpointManager &mEndpointManager = AAudioEndpointManager::getInstance();
aaudio_result_t result = AAUDIO_OK;
- mMmapClient.identity = request.getIdentity();
- // TODO b/182392769: use identity util
- mMmapClient.identity.uid = VALUE_OR_FATAL(
+ mMmapClient.attributionSource = request.getAttributionSource();
+ // TODO b/182392769: use attribution source util
+ mMmapClient.attributionSource.uid = VALUE_OR_FATAL(
legacy2aidl_uid_t_int32_t(IPCThreadState::self()->getCallingUid()));
- mMmapClient.identity.pid = VALUE_OR_FATAL(
+ mMmapClient.attributionSource.pid = VALUE_OR_FATAL(
legacy2aidl_pid_t_int32_t(IPCThreadState::self()->getCallingPid()));
// Limit scope of lock to avoid recursive lock in close().
diff --git a/services/oboeservice/AAudioServiceStreamBase.h b/services/oboeservice/AAudioServiceStreamBase.h
index c42df0f..976996d 100644
--- a/services/oboeservice/AAudioServiceStreamBase.h
+++ b/services/oboeservice/AAudioServiceStreamBase.h
@@ -160,11 +160,13 @@
}
uid_t getOwnerUserId() const {
- return VALUE_OR_FATAL(android::aidl2legacy_int32_t_uid_t(mMmapClient.identity.uid));
+ return VALUE_OR_FATAL(android::aidl2legacy_int32_t_uid_t(
+ mMmapClient.attributionSource.uid));
}
pid_t getOwnerProcessId() const {
- return VALUE_OR_FATAL(android::aidl2legacy_int32_t_pid_t(mMmapClient.identity.pid));
+ return VALUE_OR_FATAL(android::aidl2legacy_int32_t_pid_t(
+ mMmapClient.attributionSource.pid));
}
aaudio_handle_t getHandle() const {
diff --git a/services/oboeservice/Android.bp b/services/oboeservice/Android.bp
index a419dd5..4c58040 100644
--- a/services/oboeservice/Android.bp
+++ b/services/oboeservice/Android.bp
@@ -66,13 +66,13 @@
"liblog",
"libutils",
"aaudio-aidl-cpp",
- "media_permission-aidl-cpp",
+ "framework-permission-aidl-cpp",
"libaudioclient_aidl_conversion",
],
export_shared_lib_headers: [
"libaaudio_internal",
- "media_permission-aidl-cpp",
+ "framework-permission-aidl-cpp",
],
header_libs: [
diff --git a/services/oboeservice/fuzzer/Android.bp b/services/oboeservice/fuzzer/Android.bp
index f4e8a81..605ac01 100644
--- a/services/oboeservice/fuzzer/Android.bp
+++ b/services/oboeservice/fuzzer/Android.bp
@@ -46,7 +46,7 @@
"liblog",
"libutils",
"aaudio-aidl-cpp",
- "media_permission-aidl-cpp",
+ "framework-permission-aidl-cpp",
"libaudioclient_aidl_conversion",
],
static_libs: [
diff --git a/services/oboeservice/fuzzer/oboeservice_fuzzer.cpp b/services/oboeservice/fuzzer/oboeservice_fuzzer.cpp
index 8e508d3..4bc661c 100644
--- a/services/oboeservice/fuzzer/oboeservice_fuzzer.cpp
+++ b/services/oboeservice/fuzzer/oboeservice_fuzzer.cpp
@@ -23,7 +23,7 @@
#include <AAudioService.h>
#include <aaudio/AAudio.h>
#include "aaudio/BnAAudioClient.h"
-#include <android/media/permission/Identity.h>
+#include <android/content/AttributionSourceState.h>
#define UNUSED_PARAM __attribute__((unused))
@@ -295,11 +295,12 @@
? fdp.ConsumeIntegral<int32_t>()
: kAAudioFormats[fdp.ConsumeIntegralInRange<int32_t>(0, kNumAAudioFormats - 1)]));
- // TODO b/182392769: use identity util
- media::permission::Identity identity;
- identity.uid = getuid();
- identity.pid = getpid();
- request.setIdentity(identity);
+ // TODO b/182392769: use attribution source util
+ android::content::AttributionSourceState attributionSource;
+ attributionSource.uid = getuid();
+ attributionSource.pid = getpid();
+ attributionSource.token = sp<BBinder>::make();
+ request.setAttributionSource(attributionSource);
request.setInService(fdp.ConsumeBool());
request.getConfiguration().setDeviceId(fdp.ConsumeIntegral<int32_t>());