tests/tests/security/jni/android_security_cts_AudioFlingerBinderTest.cpp - platform/cts - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "AudioFlingerBinderTest-JNI"

 #include <jni.h>
 #include <binder/IServiceManager.h>
 #include <media/IAudioFlinger.h>
 #include <media/AudioSystem.h>
 #include <system/audio.h>
 #include <utils/Log.h>
 #include <utils/SystemClock.h>

 using namespace android;

 /*
  * Native methods used by
  * cts/tests/tests/security/src/android/security/cts/AudioFlingerBinderTest.java
  */

 #define TEST_ARRAY_SIZE 10000
 #define MAX_ARRAY_SIZE 1024
 #define TEST_PATTERN 0x55

 class MyDeathClient: public IBinder::DeathRecipient
 {
 public:
     MyDeathClient() :
         mAfIsDead(false) {
     }

     bool afIsDead() const { return mAfIsDead; }

     // DeathRecipient
     virtual void binderDied(const wp<IBinder>& who __unused) { mAfIsDead = true; }

 private:
     bool mAfIsDead;
 };


 static bool connectAudioFlinger(sp<IAudioFlinger>& af, sp<MyDeathClient> &dr)
 {
     int64_t startTime = 0;
     while (af == 0) {
         sp<IBinder> binder = defaultServiceManager()->checkService(String16("media.audio_flinger"));
         if (binder == 0) {
             if (startTime == 0) {
                 startTime = uptimeMillis();
             } else if ((uptimeMillis()-startTime) > 10000) {
                 ALOGE("timeout while getting audio flinger service");
                 return false;
             }
             sleep(1);
         } else {
             af = interface_cast<IAudioFlinger>(binder);
             dr = new MyDeathClient();
             binder->linkToDeath(dr);
         }
     }
     return true;
 }

 /*
  * Checks that AudioSystem::setMasterMute() does not crash mediaserver if a duplicated output
  * is opened.
  */
 jboolean android_security_cts_AudioFlinger_test_setMasterMute(JNIEnv* env __unused,
                                                            jobject thiz __unused)
 {
     sp<IAudioFlinger> af;
     sp<MyDeathClient> dr;

     if (!connectAudioFlinger(af, dr)) {
         return false;
     }

     // force opening of a duplicating output
     status_t status = AudioSystem::setDeviceConnectionState(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
                                           AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
                                           "0", "");
     if (status != NO_ERROR) {
         return false;
     }

     bool mute;
     status = AudioSystem::getMasterMute(&mute);
     if (status != NO_ERROR) {
         return false;
     }

     AudioSystem::setMasterMute(!mute);

     sleep(1);

     // Check that mediaserver did not crash
     if (dr->afIsDead()) {
         return false;
     }

     AudioSystem::setMasterMute(mute);

     AudioSystem::setDeviceConnectionState(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
                                           AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
                                           "0", "");

     AudioSystem::setMasterMute(false);

     return true;
 }

 jboolean android_security_cts_AudioFlinger_test_setMasterVolume(JNIEnv* env __unused,
                                                            jobject thiz __unused)
 {
     sp<IAudioFlinger> af;
     sp<MyDeathClient> dr;

     if (!connectAudioFlinger(af, dr)) {
         return false;
     }

     // force opening of a duplicating output
     status_t status = AudioSystem::setDeviceConnectionState(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
                                           AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
                                           "0", "");
     if (status != NO_ERROR) {
         return false;
     }

     float vol;
     status = AudioSystem::getMasterVolume(&vol);
     if (status != NO_ERROR) {
         return false;
     }

     AudioSystem::setMasterVolume(vol < 0.5 ? 1.0 : 0.0);

     sleep(1);

     // Check that mediaserver did not crash
     if (dr->afIsDead()) {
         return false;
     }

     AudioSystem::setMasterMute(vol);

     AudioSystem::setDeviceConnectionState(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
                                           AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
                                           "0", "");

     return true;
 }

 jboolean android_security_cts_AudioFlinger_test_listAudioPorts(JNIEnv* env __unused,
                                                            jobject thiz __unused)
 {
     sp<IAudioFlinger> af;
     sp<MyDeathClient> dr;

     if (!connectAudioFlinger(af, dr)) {
         return false;
     }

     unsigned int num_ports = TEST_ARRAY_SIZE;
     struct audio_port *ports =
             (struct audio_port *)calloc(TEST_ARRAY_SIZE, sizeof(struct audio_port));

     memset(ports, TEST_PATTERN, TEST_ARRAY_SIZE * sizeof(struct audio_port));

     status_t status = af->listAudioPorts(&num_ports, ports);

     sleep(1);

     // Check that the memory content above the max allowed array size was not changed
     char *ptr = (char *)(ports + MAX_ARRAY_SIZE);
     for (size_t i = 0; i < TEST_ARRAY_SIZE - MAX_ARRAY_SIZE; i++) {
         if (ptr[i * sizeof(struct audio_port)] != TEST_PATTERN) {
             free(ports);
             return false;
         }
     }

     free(ports);

     // Check that mediaserver did not crash
     if (dr->afIsDead()) {
         return false;
     }

     return true;
 }

 jboolean android_security_cts_AudioFlinger_test_listAudioPatches(JNIEnv* env __unused,
                                                            jobject thiz __unused)
 {
     sp<IAudioFlinger> af;
     sp<MyDeathClient> dr;

     if (!connectAudioFlinger(af, dr)) {
         return false;
     }

     unsigned int num_patches = TEST_ARRAY_SIZE;
     struct audio_patch *patches =
             (struct audio_patch *)calloc(TEST_ARRAY_SIZE, sizeof(struct audio_patch));

     memset(patches, TEST_PATTERN, TEST_ARRAY_SIZE * sizeof(struct audio_patch));

     status_t status = af->listAudioPatches(&num_patches, patches);

     sleep(1);

     // Check that the memory content above the max allowed array size was not changed
     char *ptr = (char *)(patches + MAX_ARRAY_SIZE);
     for (size_t i = 0; i < TEST_ARRAY_SIZE - MAX_ARRAY_SIZE; i++) {
         if (ptr[i * sizeof(struct audio_patch)] != TEST_PATTERN) {
             free(patches);
             return false;
         }
     }

     free(patches);

     // Check that mediaserver did not crash
     if (dr->afIsDead()) {
         return false;
     }

     return true;
 }

 jboolean android_security_cts_AudioFlinger_test_createEffect(JNIEnv* env __unused,
                                                              jobject thiz __unused)
 {
     sp<IAudioFlinger> af;
     sp<MyDeathClient> dr;

     if (!connectAudioFlinger(af, dr)) {
         return false;
     }

     for (int j = 0; j < 10; ++j) {
         Parcel data, reply;
         data.writeInterfaceToken(af->getInterfaceDescriptor());
         data.writeInt32((int32_t)j);
         status_t status = af->asBinder(af)->transact(40, data, &reply); // 40 is CREATE_EFFECT
         if (status != NO_ERROR) {
             return false;
         }

         status = (status_t)reply.readInt32();
         if (status == NO_ERROR) {
             continue;
         }

         int id = reply.readInt32();
         int enabled = reply.readInt32();
         sp<IEffect> effect = interface_cast<IEffect>(reply.readStrongBinder());
         effect_descriptor_t desc;
         effect_descriptor_t descTarget;
         memset(&desc, 0, sizeof(effect_descriptor_t));
         memset(&descTarget, 0, sizeof(effect_descriptor_t));
         reply.read(&desc, sizeof(effect_descriptor_t));
         if (id != 0 || enabled != 0 || memcmp(&desc, &descTarget, sizeof(effect_descriptor_t))) {
             return false;
         }
     }

     sleep(1);

     // Check that mediaserver did not crash
     if (dr->afIsDead()) {
         return false;
     }

     return true;
 }

 static JNINativeMethod gMethods[] = {
     {  "native_test_setMasterMute", "()Z",
             (void *) android_security_cts_AudioFlinger_test_setMasterMute },
     {  "native_test_setMasterVolume", "()Z",
             (void *) android_security_cts_AudioFlinger_test_setMasterVolume },
     {  "native_test_listAudioPorts", "()Z",
             (void *) android_security_cts_AudioFlinger_test_listAudioPorts },
     {  "native_test_listAudioPatches", "()Z",
             (void *) android_security_cts_AudioFlinger_test_listAudioPatches },
     {  "native_test_createEffect", "()Z",
             (void *) android_security_cts_AudioFlinger_test_createEffect },
 };

 int register_android_security_cts_AudioFlingerBinderTest(JNIEnv* env)
 {
     jclass clazz = env->FindClass("android/security/cts/AudioFlingerBinderTest");
     return env->RegisterNatives(clazz, gMethods,
             sizeof(gMethods) / sizeof(JNINativeMethod));
 }
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "AudioFlingerBinderTest-JNI"

	#include <jni.h>
	#include <binder/IServiceManager.h>
	#include <media/IAudioFlinger.h>
	#include <media/AudioSystem.h>
	#include <system/audio.h>
	#include <utils/Log.h>
	#include <utils/SystemClock.h>

	using namespace android;

	/*
	* Native methods used by
	* cts/tests/tests/security/src/android/security/cts/AudioFlingerBinderTest.java
	*/

	#define TEST_ARRAY_SIZE 10000
	#define MAX_ARRAY_SIZE 1024
	#define TEST_PATTERN 0x55

	class MyDeathClient: public IBinder::DeathRecipient
	{
	public:
	MyDeathClient() :
	mAfIsDead(false) {
	}

	bool afIsDead() const { return mAfIsDead; }

	// DeathRecipient
	virtual void binderDied(const wp<IBinder>& who __unused) { mAfIsDead = true; }

	private:
	bool mAfIsDead;
	};


	static bool connectAudioFlinger(sp<IAudioFlinger>& af, sp<MyDeathClient> &dr)
	{
	int64_t startTime = 0;
	while (af == 0) {
	sp<IBinder> binder = defaultServiceManager()->checkService(String16("media.audio_flinger"));
	if (binder == 0) {
	if (startTime == 0) {
	startTime = uptimeMillis();
	} else if ((uptimeMillis()-startTime) > 10000) {
	ALOGE("timeout while getting audio flinger service");
	return false;
	}
	sleep(1);
	} else {
	af = interface_cast<IAudioFlinger>(binder);
	dr = new MyDeathClient();
	binder->linkToDeath(dr);
	}
	}
	return true;
	}

	/*
	* Checks that AudioSystem::setMasterMute() does not crash mediaserver if a duplicated output
	* is opened.
	*/
	jboolean android_security_cts_AudioFlinger_test_setMasterMute(JNIEnv* env __unused,
	jobject thiz __unused)
	{
	sp<IAudioFlinger> af;
	sp<MyDeathClient> dr;

	if (!connectAudioFlinger(af, dr)) {
	return false;
	}

	// force opening of a duplicating output
	status_t status = AudioSystem::setDeviceConnectionState(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
	AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
	"0", "");
	if (status != NO_ERROR) {
	return false;
	}

	bool mute;
	status = AudioSystem::getMasterMute(&mute);
	if (status != NO_ERROR) {
	return false;
	}

	AudioSystem::setMasterMute(!mute);

	sleep(1);

	// Check that mediaserver did not crash
	if (dr->afIsDead()) {
	return false;
	}

	AudioSystem::setMasterMute(mute);

	AudioSystem::setDeviceConnectionState(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
	AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
	"0", "");

	AudioSystem::setMasterMute(false);

	return true;
	}

	jboolean android_security_cts_AudioFlinger_test_setMasterVolume(JNIEnv* env __unused,
	jobject thiz __unused)
	{
	sp<IAudioFlinger> af;
	sp<MyDeathClient> dr;

	if (!connectAudioFlinger(af, dr)) {
	return false;
	}

	// force opening of a duplicating output
	status_t status = AudioSystem::setDeviceConnectionState(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
	AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
	"0", "");
	if (status != NO_ERROR) {
	return false;
	}

	float vol;
	status = AudioSystem::getMasterVolume(&vol);
	if (status != NO_ERROR) {
	return false;
	}

	AudioSystem::setMasterVolume(vol < 0.5 ? 1.0 : 0.0);

	sleep(1);

	// Check that mediaserver did not crash
	if (dr->afIsDead()) {
	return false;
	}

	AudioSystem::setMasterMute(vol);

	AudioSystem::setDeviceConnectionState(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
	AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
	"0", "");

	return true;
	}

	jboolean android_security_cts_AudioFlinger_test_listAudioPorts(JNIEnv* env __unused,
	jobject thiz __unused)
	{
	sp<IAudioFlinger> af;
	sp<MyDeathClient> dr;

	if (!connectAudioFlinger(af, dr)) {
	return false;
	}

	unsigned int num_ports = TEST_ARRAY_SIZE;
	struct audio_port *ports =
	(struct audio_port *)calloc(TEST_ARRAY_SIZE, sizeof(struct audio_port));

	memset(ports, TEST_PATTERN, TEST_ARRAY_SIZE * sizeof(struct audio_port));

	status_t status = af->listAudioPorts(&num_ports, ports);

	sleep(1);

	// Check that the memory content above the max allowed array size was not changed
	char ptr = (char )(ports + MAX_ARRAY_SIZE);
	for (size_t i = 0; i < TEST_ARRAY_SIZE - MAX_ARRAY_SIZE; i++) {
	if (ptr[i * sizeof(struct audio_port)] != TEST_PATTERN) {
	free(ports);
	return false;
	}
	}

	free(ports);

	// Check that mediaserver did not crash
	if (dr->afIsDead()) {
	return false;
	}

	return true;
	}

	jboolean android_security_cts_AudioFlinger_test_listAudioPatches(JNIEnv* env __unused,
	jobject thiz __unused)
	{
	sp<IAudioFlinger> af;
	sp<MyDeathClient> dr;

	if (!connectAudioFlinger(af, dr)) {
	return false;
	}

	unsigned int num_patches = TEST_ARRAY_SIZE;
	struct audio_patch *patches =
	(struct audio_patch *)calloc(TEST_ARRAY_SIZE, sizeof(struct audio_patch));

	memset(patches, TEST_PATTERN, TEST_ARRAY_SIZE * sizeof(struct audio_patch));

	status_t status = af->listAudioPatches(&num_patches, patches);

	sleep(1);

	// Check that the memory content above the max allowed array size was not changed
	char ptr = (char )(patches + MAX_ARRAY_SIZE);
	for (size_t i = 0; i < TEST_ARRAY_SIZE - MAX_ARRAY_SIZE; i++) {
	if (ptr[i * sizeof(struct audio_patch)] != TEST_PATTERN) {
	free(patches);
	return false;
	}
	}

	free(patches);

	// Check that mediaserver did not crash
	if (dr->afIsDead()) {
	return false;
	}

	return true;
	}

	jboolean android_security_cts_AudioFlinger_test_createEffect(JNIEnv* env __unused,
	jobject thiz __unused)
	{
	sp<IAudioFlinger> af;
	sp<MyDeathClient> dr;

	if (!connectAudioFlinger(af, dr)) {
	return false;
	}

	for (int j = 0; j < 10; ++j) {
	Parcel data, reply;
	data.writeInterfaceToken(af->getInterfaceDescriptor());
	data.writeInt32((int32_t)j);
	status_t status = af->asBinder(af)->transact(40, data, &reply); // 40 is CREATE_EFFECT
	if (status != NO_ERROR) {
	return false;
	}

	status = (status_t)reply.readInt32();
	if (status == NO_ERROR) {
	continue;
	}

	int id = reply.readInt32();
	int enabled = reply.readInt32();
	sp<IEffect> effect = interface_cast<IEffect>(reply.readStrongBinder());
	effect_descriptor_t desc;
	effect_descriptor_t descTarget;
	memset(&desc, 0, sizeof(effect_descriptor_t));
	memset(&descTarget, 0, sizeof(effect_descriptor_t));
	reply.read(&desc, sizeof(effect_descriptor_t));
	if (id != 0 \|\| enabled != 0 \|\| memcmp(&desc, &descTarget, sizeof(effect_descriptor_t))) {
	return false;
	}
	}

	sleep(1);

	// Check that mediaserver did not crash
	if (dr->afIsDead()) {
	return false;
	}

	return true;
	}

	static JNINativeMethod gMethods[] = {
	{ "native_test_setMasterMute", "()Z",
	(void *) android_security_cts_AudioFlinger_test_setMasterMute },
	{ "native_test_setMasterVolume", "()Z",
	(void *) android_security_cts_AudioFlinger_test_setMasterVolume },
	{ "native_test_listAudioPorts", "()Z",
	(void *) android_security_cts_AudioFlinger_test_listAudioPorts },
	{ "native_test_listAudioPatches", "()Z",
	(void *) android_security_cts_AudioFlinger_test_listAudioPatches },
	{ "native_test_createEffect", "()Z",
	(void *) android_security_cts_AudioFlinger_test_createEffect },
	};

	int register_android_security_cts_AudioFlingerBinderTest(JNIEnv* env)
	{
	jclass clazz = env->FindClass("android/security/cts/AudioFlingerBinderTest");
	return env->RegisterNatives(clazz, gMethods,
	sizeof(gMethods) / sizeof(JNINativeMethod));
	}