virtual status_t onTransact(uint32_t code,
const Parcel& data, Parcel* reply,
uint32_t flags = 0) {
//printf("%s: code %d\n", __func__, code);
(void)flags;
if (getuid() != (uid_t)IPCThreadState::self()->getCallingUid()) {
return PERMISSION_DENIED;
}
switch (code) {
case BINDER_LIB_TEST_REGISTER_SERVER: {
int32_t id;
sp<IBinder> binder;
id = data.readInt32();
binder = data.readStrongBinder();
if (binder == NULL) {
return BAD_VALUE;
}
if (m_id != 0)
return INVALID_OPERATION;
pthread_mutex_lock(&m_serverWaitMutex);
if (m_serverStartRequested) {
m_serverStartRequested = false;
m_serverStarted = binder;
pthread_cond_signal(&m_serverWaitCond);
}
pthread_mutex_unlock(&m_serverWaitMutex);
return NO_ERROR;
}
case BINDER_LIB_TEST_ADD_SERVER: {
int ret;
uint8_t buf[1] = { 0 };
int serverid;
if (m_id != 0) {
return INVALID_OPERATION;
}
pthread_mutex_lock(&m_serverWaitMutex);
if (m_serverStartRequested) {
ret = -EBUSY;
} else {
serverid = m_nextServerId++;
m_serverStartRequested = true;
pthread_mutex_unlock(&m_serverWaitMutex);
ret = start_server_process(serverid);
pthread_mutex_lock(&m_serverWaitMutex);
}
if (ret > 0) {
if (m_serverStartRequested) {
#if defined(HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE)
ret = pthread_cond_timeout_np(&m_serverWaitCond, &m_serverWaitMutex, 5000);
#else
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_sec += 5;
ret = pthread_cond_timedwait(&m_serverWaitCond, &m_serverWaitMutex, &ts);
#endif
}
if (m_serverStartRequested) {
m_serverStartRequested = false;
ret = -ETIMEDOUT;
} else {
reply->writeStrongBinder(m_serverStarted);
reply->writeInt32(serverid);
m_serverStarted = NULL;
ret = NO_ERROR;
}
} else if (ret >= 0) {
m_serverStartRequested = false;
ret = UNKNOWN_ERROR;
}
pthread_mutex_unlock(&m_serverWaitMutex);
return ret;
}
case BINDER_LIB_TEST_NOP_TRANSACTION:
return NO_ERROR;
case BINDER_LIB_TEST_NOP_CALL_BACK: {
Parcel data2, reply2;
sp<IBinder> binder;
binder = data.readStrongBinder();
if (binder == NULL) {
return BAD_VALUE;
}
reply2.writeInt32(NO_ERROR);
binder->transact(BINDER_LIB_TEST_CALL_BACK, data2, &reply2);
return NO_ERROR;
}
case BINDER_LIB_TEST_GET_ID_TRANSACTION:
reply->writeInt32(m_id);
return NO_ERROR;
case BINDER_LIB_TEST_INDIRECT_TRANSACTION: {
int32_t count;
uint32_t indirect_code;
sp<IBinder> binder;
count = data.readInt32();
reply->writeInt32(m_id);
reply->writeInt32(count);
for (int i = 0; i < count; i++) {
binder = data.readStrongBinder();
if (binder == NULL) {
return BAD_VALUE;
}
indirect_code = data.readInt32();
BinderLibTestBundle data2(&data);
if (!data2.isValid()) {
return BAD_VALUE;
}
BinderLibTestBundle reply2;
binder->transact(indirect_code, data2, &reply2);
reply2.appendTo(reply);
}
return NO_ERROR;
}
case BINDER_LIB_TEST_SET_ERROR_TRANSACTION:
reply->setError(data.readInt32());
return NO_ERROR;
case BINDER_LIB_TEST_GET_PTR_SIZE_TRANSACTION:
reply->writeInt32(sizeof(void *));
return NO_ERROR;
case BINDER_LIB_TEST_GET_STATUS_TRANSACTION:
return NO_ERROR;
case BINDER_LIB_TEST_ADD_STRONG_REF_TRANSACTION:
m_strongRef = data.readStrongBinder();
return NO_ERROR;
case BINDER_LIB_TEST_LINK_DEATH_TRANSACTION: {
int ret;
Parcel data2, reply2;
sp<TestDeathRecipient> testDeathRecipient = new TestDeathRecipient();
sp<IBinder> target;
sp<IBinder> callback;
target = data.readStrongBinder();
if (target == NULL) {
return BAD_VALUE;
}
callback = data.readStrongBinder();run_server
if (callback == NULL) {
return BAD_VALUE;
}
ret = target->linkToDeath(testDeathRecipient);
if (ret == NO_ERROR)
ret = testDeathRecipient->waitEvent(5);
data2.writeInt32(ret);
callback->transact(BINDER_LIB_TEST_CALL_BACK, data2, &reply2);
return NO_ERROR;
}
case BINDER_LIB_TEST_WRITE_FILE_TRANSACTION: {
int ret;
int32_t size;
const void *buf;
int fd;
fd = data.readFileDescriptor();
if (fd < 0) {
return BAD_VALUE;
}
ret = data.readInt32(&size);
if (ret != NO_ERROR) {
return ret;
}
buf = data.readInplace(size);
if (buf == NULL) {
return BAD_VALUE;
}
ret = write(fd, buf, size);
if (ret != size)
return UNKNOWN_ERROR;
return NO_ERROR;
}
case BINDER_LIB_TEST_PROMOTE_WEAK_REF_TRANSACTION: {
int ret;
wp<IBinder> weak;
sp<IBinder> strong;
Parcel data2, reply2;
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> server = sm->getService(binderLibTestServiceName);
weak = data.readWeakBinder();
if (weak == NULL) {
return BAD_VALUE;
}
strong = weak.promote();
ret = server->transact(BINDER_LIB_TEST_NOP_TRANSACTION, data2, &reply2);
if (ret != NO_ERROR)
exit(EXIT_FAILURE);
if (strong == NULL) {
reply->setError(1);
}
return NO_ERROR;
}
case BINDER_LIB_TEST_DELAYED_EXIT_TRANSACTION:
alarm(10);
return NO_ERROR;
case BINDER_LIB_TEST_EXIT_TRANSACTION:
while (wait(NULL) != -1 || errno != ECHILD)
;
exit(EXIT_SUCCESS);
default:
return UNKNOWN_TRANSACTION;
};
}
